463 lines
8.4 KiB
Go
463 lines
8.4 KiB
Go
package linkedlist
|
|
|
|
import (
|
|
"testing"
|
|
|
|
"github.com/Pallinder/go-randomdata"
|
|
"github.com/davecgh/go-spew/spew"
|
|
)
|
|
|
|
func TestPushFront(t *testing.T) {
|
|
l := New()
|
|
for i := 0; i < 5; i++ {
|
|
l.PushFront(i)
|
|
}
|
|
var result string
|
|
result = spew.Sprint(l.Values())
|
|
if result != "[4 3 2 1 0]" {
|
|
t.Error(result)
|
|
}
|
|
|
|
l.PushFront(0)
|
|
result = spew.Sprint(l.Values())
|
|
if result != "[0 4 3 2 1 0]" {
|
|
t.Error(result)
|
|
}
|
|
}
|
|
|
|
func TestPushBack(t *testing.T) {
|
|
l := New()
|
|
for i := 0; i < 5; i++ {
|
|
l.PushBack(i)
|
|
}
|
|
var result string
|
|
result = spew.Sprint(l.Values())
|
|
if result != "[0 1 2 3 4]" {
|
|
t.Error(result)
|
|
}
|
|
|
|
l.PushBack(0)
|
|
result = spew.Sprint(l.Values())
|
|
if result != "[0 1 2 3 4 0]" {
|
|
t.Error(result)
|
|
}
|
|
}
|
|
|
|
func TestPopFront(t *testing.T) {
|
|
l := New()
|
|
// "[4 3 2 1 0]"
|
|
for i := 0; i < 5; i++ {
|
|
l.PushFront(i)
|
|
}
|
|
// var result string
|
|
|
|
for i := 4; i >= 0; i-- {
|
|
if v, ok := l.PopFront(); ok {
|
|
if v != i {
|
|
t.Error("[4 3 2 1 0] PopFront value should be ", i, ", but is ", v)
|
|
}
|
|
} else {
|
|
t.Error("PopFront is not ok")
|
|
}
|
|
|
|
if l.Size() != uint(i) {
|
|
t.Error("l.Size() is error, is", l.Size())
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestPopBack(t *testing.T) {
|
|
l := New()
|
|
// "[4 3 2 1 0]"
|
|
for i := 0; i < 5; i++ {
|
|
l.PushFront(i)
|
|
}
|
|
// var result string
|
|
|
|
for i := 0; i < 5; i++ {
|
|
if v, ok := l.PopBack(); ok {
|
|
if v != i {
|
|
t.Error("[4 3 2 1 0] PopFront value should be ", i, ", but is ", v)
|
|
}
|
|
} else {
|
|
t.Error("PopFront is not ok")
|
|
}
|
|
|
|
if l.Size() != uint(5-i-1) {
|
|
t.Error("l.Size() is error, is", l.Size())
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
func TestInsert(t *testing.T) {
|
|
l1 := New()
|
|
l2 := New()
|
|
// "[4 3 2 1 0]"
|
|
for i := 0; i < 5; i++ {
|
|
l1.Insert(0, i)
|
|
l2.PushFront(i)
|
|
}
|
|
|
|
var result1, result2 string
|
|
result1 = spew.Sprint(l1.Values())
|
|
result2 = spew.Sprint(l2.Values())
|
|
if result1 != result2 {
|
|
t.Error(result1, result2)
|
|
}
|
|
|
|
for i := 0; i < 5; i++ {
|
|
l1.Insert(l1.Size(), i)
|
|
l2.PushBack(i)
|
|
// t.Error(l1.Values(), l2.Values())
|
|
}
|
|
|
|
result1 = spew.Sprint(l1.Values())
|
|
result2 = spew.Sprint(l2.Values())
|
|
if result1 != result2 {
|
|
t.Error(result1, result2)
|
|
}
|
|
|
|
if result1 != "[4 3 2 1 0 0 1 2 3 4]" {
|
|
t.Error("result should be [4 3 2 1 0 0 1 2 3 4]\n but result is", result1)
|
|
}
|
|
|
|
l1.Insert(1, 99)
|
|
result1 = spew.Sprint(l1.Values())
|
|
if result1 != "[4 99 3 2 1 0 0 1 2 3 4]" {
|
|
t.Error("[4 3 2 1 0 0 1 2 3 4] insert with index 1, should be [4 99 3 2 1 0 0 1 2 3 4]\n but result is", result1)
|
|
}
|
|
|
|
l1.Insert(9, 99)
|
|
result1 = spew.Sprint(l1.Values())
|
|
if result1 != "[4 99 3 2 1 0 0 1 2 99 3 4]" {
|
|
t.Error("[4 99 3 2 1 0 0 1 2 3 4] insert with index 9, should be [4 99 3 2 1 0 0 1 2 99 3 4]\n but result is", result1)
|
|
}
|
|
|
|
l1.Insert(12, 99)
|
|
result1 = spew.Sprint(l1.Values())
|
|
if result1 != "[4 99 3 2 1 0 0 1 2 99 3 4 99]" {
|
|
t.Error("[4 99 3 2 1 0 0 1 2 99 3 4] insert with index 12, should be [4 99 3 2 1 0 0 1 2 99 3 4 99]\n but result is", result1)
|
|
}
|
|
}
|
|
|
|
func TestInsertIf(t *testing.T) {
|
|
l := New()
|
|
|
|
// "[4 3 2 1 0]"
|
|
for i := 0; i < 5; i++ {
|
|
l.Insert(0, i)
|
|
}
|
|
|
|
// "[4 3 2 1 0]"
|
|
for i := 0; i < 2; i++ {
|
|
l.InsertIf(func(idx uint, value interface{}) int {
|
|
if value == 3 {
|
|
return 1
|
|
}
|
|
return 0
|
|
}, 11)
|
|
}
|
|
|
|
var result string
|
|
|
|
result = spew.Sprint(l.Values())
|
|
if result != "[4 3 11 11 2 1 0]" {
|
|
t.Error("result should be [4 3 11 11 2 1 0], reuslt is", result)
|
|
}
|
|
|
|
// "[4 3 2 1 0]"
|
|
for i := 0; i < 2; i++ {
|
|
l.InsertIf(func(idx uint, value interface{}) int {
|
|
if value == 0 {
|
|
return -1
|
|
}
|
|
return 0
|
|
}, 11)
|
|
}
|
|
|
|
result = spew.Sprint(l.Values())
|
|
if result != "[4 3 11 11 2 1 11 11 0]" {
|
|
t.Error("result should be [4 3 11 11 2 1 11 11 0], reuslt is", result)
|
|
}
|
|
|
|
// "[4 3 2 1 0]"
|
|
for i := 0; i < 2; i++ {
|
|
l.InsertIf(func(idx uint, value interface{}) int {
|
|
if value == 0 {
|
|
return 1
|
|
}
|
|
return 0
|
|
}, 11)
|
|
}
|
|
|
|
result = spew.Sprint(l.Values())
|
|
if result != "[4 3 11 11 2 1 11 11 0 11 11]" {
|
|
t.Error("result should be [4 3 11 11 2 1 11 11 0 11 11], reuslt is", result)
|
|
}
|
|
|
|
// t.Error(l.Values())
|
|
}
|
|
|
|
func TestIndex(t *testing.T) {
|
|
l := New()
|
|
// "[4 3 2 1 0]"
|
|
for i := 0; i < 5; i++ {
|
|
l.PushFront(i)
|
|
}
|
|
|
|
if v, ok := l.Index(4); ok {
|
|
if v != 0 {
|
|
t.Error("[4 3 2 1 0] Index 4 value is 0, but v is ", v)
|
|
}
|
|
} else {
|
|
t.Error("not ok is error")
|
|
}
|
|
|
|
if v, ok := l.Index(1); ok {
|
|
if v != 3 {
|
|
t.Error("[4 3 2 1 0] Index 1 value is 3, but v is ", v)
|
|
}
|
|
} else {
|
|
t.Error("not ok is error")
|
|
}
|
|
|
|
if v, ok := l.Index(0); ok {
|
|
if v != 4 {
|
|
t.Error("[4 3 2 1 0] Index 1 value is 4, but v is ", v)
|
|
}
|
|
} else {
|
|
t.Error("not ok is error")
|
|
}
|
|
|
|
if _, ok := l.Index(5); ok {
|
|
t.Error("[4 3 2 1 0] Index 5, out of range,ok = true is error")
|
|
}
|
|
|
|
}
|
|
|
|
func TestRemove(t *testing.T) {
|
|
l := New()
|
|
// "[4 3 2 1 0]"
|
|
for i := 0; i < 5; i++ {
|
|
l.PushFront(i)
|
|
}
|
|
|
|
l.Remove(0)
|
|
var result string
|
|
result = spew.Sprint(l.Values())
|
|
if result != "[3 2 1 0]" {
|
|
t.Error("should be [3 2 1 0] but result is", result)
|
|
}
|
|
|
|
l.Remove(3)
|
|
result = spew.Sprint(l.Values())
|
|
if result != "[3 2 1]" {
|
|
t.Error("should be [3 2 1] but result is", result)
|
|
}
|
|
|
|
l.Remove(2)
|
|
result = spew.Sprint(l.Values())
|
|
if result != "[3 2]" {
|
|
t.Error("should be [3 2 1] but result is", result)
|
|
}
|
|
|
|
l.Remove(1)
|
|
result = spew.Sprint(l.Values())
|
|
if result != "[3]" {
|
|
t.Error("should be [3 2 1] but result is", result)
|
|
}
|
|
|
|
l.Remove(0)
|
|
result = spew.Sprint(l.Values())
|
|
if result != "<nil>" && l.Size() == 0 && len(l.Values()) == 0 {
|
|
t.Error("should be [3 2 1] but result is", result, "Size is", l.Size())
|
|
}
|
|
|
|
defer func() {
|
|
if err := recover(); err == nil {
|
|
t.Error("should be out of range but is not")
|
|
}
|
|
}()
|
|
|
|
l.Remove(3)
|
|
}
|
|
|
|
func TestRemoveIf(t *testing.T) {
|
|
l := New()
|
|
// "[4 3 2 1 0]"
|
|
for i := 0; i < 5; i++ {
|
|
l.PushFront(i)
|
|
}
|
|
|
|
if r, ok := l.RemoveIf(func(value interface{}) bool {
|
|
if value == 0 {
|
|
return true
|
|
}
|
|
return false
|
|
}); ok {
|
|
if r != 0 {
|
|
t.Error("result should is", 0)
|
|
}
|
|
} else {
|
|
t.Error("should be ok")
|
|
}
|
|
|
|
if r, ok := l.RemoveIf(func(value interface{}) bool {
|
|
if value == 4 {
|
|
return true
|
|
}
|
|
return false
|
|
}); ok {
|
|
if r != 4 {
|
|
t.Error("result should is", 4)
|
|
}
|
|
} else {
|
|
t.Error("should be ok")
|
|
}
|
|
|
|
var result string
|
|
result = spew.Sprint(l.Values())
|
|
if result != "[3 2 1]" {
|
|
t.Error("should be [3 2 1] but result is", result)
|
|
}
|
|
|
|
if r, ok := l.RemoveIf(func(value interface{}) bool {
|
|
if value == 4 {
|
|
return true
|
|
}
|
|
return false
|
|
}); ok {
|
|
t.Error("should not be ok and result is nil")
|
|
} else {
|
|
if r != nil {
|
|
t.Error("should be nil")
|
|
}
|
|
}
|
|
|
|
result = spew.Sprint(l.Values())
|
|
if result != "[3 2 1]" {
|
|
t.Error("should be [3 2 1] but result is", result)
|
|
}
|
|
|
|
for _, v := range l.Values() {
|
|
l.RemoveIf(func(value interface{}) bool {
|
|
if value == v {
|
|
return true
|
|
}
|
|
return false
|
|
})
|
|
}
|
|
|
|
result = spew.Sprint(l.Values())
|
|
if result != "<nil>" {
|
|
t.Error("result should be <nil>, but now result is", result)
|
|
}
|
|
}
|
|
|
|
func BenchmarkPushBack(b *testing.B) {
|
|
|
|
ec := 5
|
|
cs := 2000000
|
|
b.N = cs * ec
|
|
|
|
for c := 0; c < ec; c++ {
|
|
l := New()
|
|
for i := 0; i < cs; i++ {
|
|
l.PushBack(i)
|
|
}
|
|
}
|
|
}
|
|
|
|
func BenchmarkPushFront(b *testing.B) {
|
|
|
|
ec := 5
|
|
cs := 2000000
|
|
b.N = cs * ec
|
|
|
|
for c := 0; c < ec; c++ {
|
|
l := New()
|
|
for i := 0; i < cs; i++ {
|
|
l.PushFront(i)
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
func BenchmarkInsert(b *testing.B) {
|
|
|
|
ec := 10
|
|
cs := 1000
|
|
b.N = cs * ec
|
|
|
|
for c := 0; c < ec; c++ {
|
|
l := New()
|
|
for i := 0; i < cs; i++ {
|
|
ridx := randomdata.Number(0, int(l.Size())+1)
|
|
l.Insert(uint(ridx), i)
|
|
}
|
|
}
|
|
}
|
|
|
|
// func TestPop(t *testing.T) {
|
|
// l := New()
|
|
// for i := 0; i < 5; i++ {
|
|
// l.Push(i)
|
|
// }
|
|
|
|
// if v, ok := l.Pop(); ok {
|
|
// if v != 4 {
|
|
// t.Error(v)
|
|
// }
|
|
// } else {
|
|
// t.Error("Pop should ok, but is not ok")
|
|
// }
|
|
|
|
// var result string
|
|
// result = spew.Sprint(l.Values())
|
|
// if result != "[3 2 1 0]" {
|
|
// t.Error(result)
|
|
// }
|
|
|
|
// for i := 3; l.Size() != 0; i-- {
|
|
// if v, ok := l.Pop(); ok {
|
|
// if v != i {
|
|
// t.Error(i, v, "is not equals")
|
|
// }
|
|
// } else {
|
|
// t.Error("Pop should ok, but is not ok", i)
|
|
// }
|
|
// }
|
|
|
|
// l.Push(0)
|
|
// result = spew.Sprint(l.Values())
|
|
// if result != "[0]" {
|
|
// t.Error(result)
|
|
// }
|
|
|
|
// if l.Size() != 1 {
|
|
// t.Error("l.Size() == 1, but is error, size = ", l.Size())
|
|
// }
|
|
// }
|
|
|
|
// func TestRemove(t *testing.T) {
|
|
// l := New()
|
|
// for i := 0; i < 5; i++ {
|
|
// l.Push(i)
|
|
// }
|
|
|
|
// for i := 0; i < 5; i++ {
|
|
// l.Remove(0)
|
|
// if l.head != nil {
|
|
// if l.head.Value() != 4-i-1 {
|
|
// t.Error("l.head is error")
|
|
// }
|
|
// }
|
|
// t.Error(l.Size())
|
|
// }
|
|
|
|
// if l.Size() != 0 {
|
|
// t.Error("l.Size() == 0, but is error, size = ", l.Size())
|
|
// }
|
|
// }
|