rescript/linkedlist_test.go at master · akeil/rescript · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
package rescript

import (
	"testing"

	"github.com/stretchr/testify/assert"
)

func TestHeadTail(t *testing.T) {
	assert := assert.New(t)

	start, middle, end := sampleList()

	assert.False(start.IsHead())
	assert.True(start.IsTail())

	assert.False(middle.IsHead())
	assert.False(middle.IsTail())

	assert.True(end.IsHead())
	assert.False(end.IsTail())
}

func TestRemove(t *testing.T) {
	assert := assert.New(t)

	start, middle, end := sampleList()

	middle.Remove()
	assert.Equal(start.Next(), end)
	assert.Equal(end.Prev(), start)
}

func TestUpdate(t *testing.T) {
	assert := assert.New(t)

	start, middle, end := sampleList()

	middle.Update(NewToken("replaced"))
	assert.Equal("replaced", start.Next().Token().String())
	assert.Equal("replaced", end.Prev().Token().String())
}

func TestInsert(t *testing.T) {
	assert := assert.New(t)

	start, middle, end := sampleList()

	a := NewNode(NewToken("a"))
	b := NewNode(NewToken("b"))

	assert.Equal("middle", start.Next().Token().String())

	middle.InsertBefore(a)
	assert.Equal("a", start.Next().Token().String())
	assert.Equal("start", a.Prev().Token().String())
	assert.Equal("middle", a.Next().Token().String())
	assert.Equal("a", middle.Prev().Token().String())

	middle.InsertAfter(b)
	assert.Equal("b", end.Prev().Token().String())
	assert.Equal("middle", b.Prev().Token().String())
	assert.Equal("end", b.Next().Token().String())
	assert.Equal("b", end.Prev().Token().String())
}

func TestAhead(t *testing.T) {
	assert := assert.New(t)

	start, middle, end := sampleList()

	assert.Equal(start.Ahead(1).Token().String(), middle.Token().String())
	assert.Equal(start.Ahead(2).Token().String(), end.Token().String())
	assert.Nil(start.Ahead(3))
	assert.Nil(start.Ahead(4))
	assert.Nil(start.Behind(1))
}

func TestBehind(t *testing.T) {
	assert := assert.New(t)

	start, middle, end := sampleList()
	assert.Equal(end.Behind(1).Token().String(), middle.Token().String())
	assert.Equal(end.Behind(2).Token().String(), start.Token().String())
	assert.Nil(end.Behind(3))
	assert.Nil(end.Behind(4))
	assert.Nil(end.Ahead(1))
}

func sampleList() (*Node, *Node, *Node) {
	start := NewNode(NewToken("start"))
	middle := NewNode(NewToken("middle"))
	end := NewNode(NewToken("end"))

	start.InsertAfter(middle)
	middle.InsertAfter(end)

	return start, middle, end
}