2015-03-10 03:14:40 +00:00
|
|
|
/*
|
|
|
|
Copyright (c) 2015, Emir Pasic
|
|
|
|
All rights reserved.
|
|
|
|
|
|
|
|
Redistribution and use in source and binary forms, with or without
|
|
|
|
modification, are permitted provided that the following conditions are met:
|
|
|
|
|
|
|
|
* Redistributions of source code must retain the above copyright notice, this
|
|
|
|
list of conditions and the following disclaimer.
|
|
|
|
|
|
|
|
* Redistributions in binary form must reproduce the above copyright notice,
|
|
|
|
this list of conditions and the following disclaimer in the documentation
|
|
|
|
and/or other materials provided with the distribution.
|
|
|
|
|
|
|
|
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
|
|
|
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
|
|
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
|
|
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
|
|
|
|
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
|
|
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
|
|
|
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
|
|
|
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
|
|
|
|
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
|
|
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
*/
|
|
|
|
|
|
|
|
package singlylinkedlist
|
|
|
|
|
|
|
|
import (
|
2016-06-21 01:15:02 +00:00
|
|
|
"fmt"
|
2015-03-10 03:14:40 +00:00
|
|
|
"github.com/emirpasic/gods/utils"
|
|
|
|
"testing"
|
|
|
|
)
|
|
|
|
|
|
|
|
func TestSinglyLinkedList(t *testing.T) {
|
|
|
|
|
|
|
|
list := New()
|
|
|
|
|
|
|
|
list.Sort(utils.StringComparator)
|
|
|
|
|
2015-03-13 23:36:10 +00:00
|
|
|
list.Add("e", "f", "g", "a", "b", "c", "d")
|
2015-03-10 03:14:40 +00:00
|
|
|
|
|
|
|
list.Sort(utils.StringComparator)
|
|
|
|
for i := 1; i < list.Size(); i++ {
|
|
|
|
a, _ := list.Get(i - 1)
|
|
|
|
b, _ := list.Get(i)
|
|
|
|
if a.(string) > b.(string) {
|
|
|
|
t.Errorf("Not sorted! %s > %s", a, b)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
list.Clear()
|
|
|
|
|
|
|
|
if actualValue := list.Empty(); actualValue != true {
|
|
|
|
t.Errorf("Got %v expected %v", actualValue, true)
|
|
|
|
}
|
|
|
|
|
|
|
|
if actualValue := list.Size(); actualValue != 0 {
|
|
|
|
t.Errorf("Got %v expected %v", actualValue, 0)
|
|
|
|
}
|
|
|
|
|
|
|
|
list.Add("a")
|
|
|
|
list.Add("b", "c")
|
|
|
|
|
|
|
|
if actualValue := list.Empty(); actualValue != false {
|
|
|
|
t.Errorf("Got %v expected %v", actualValue, false)
|
|
|
|
}
|
|
|
|
|
|
|
|
if actualValue := list.Size(); actualValue != 3 {
|
|
|
|
t.Errorf("Got %v expected %v", actualValue, 3)
|
|
|
|
}
|
|
|
|
|
|
|
|
if actualValue, ok := list.Get(2); actualValue != "c" || !ok {
|
|
|
|
t.Errorf("Got %v expected %v", actualValue, "c")
|
|
|
|
}
|
|
|
|
|
2015-03-13 23:36:10 +00:00
|
|
|
list.Swap(0, 2)
|
|
|
|
list.Swap(0, 2)
|
|
|
|
list.Swap(0, 1)
|
|
|
|
|
|
|
|
if actualValue, ok := list.Get(0); actualValue != "b" || !ok {
|
|
|
|
t.Errorf("Got %v expected %v", actualValue, "c")
|
|
|
|
}
|
|
|
|
|
2015-03-10 03:14:40 +00:00
|
|
|
list.Remove(2)
|
|
|
|
|
|
|
|
if actualValue, ok := list.Get(2); actualValue != nil || ok {
|
|
|
|
t.Errorf("Got %v expected %v", actualValue, nil)
|
|
|
|
}
|
|
|
|
|
|
|
|
list.Remove(1)
|
|
|
|
list.Remove(0)
|
|
|
|
|
|
|
|
if actualValue := list.Empty(); actualValue != true {
|
|
|
|
t.Errorf("Got %v expected %v", actualValue, true)
|
|
|
|
}
|
|
|
|
|
|
|
|
if actualValue := list.Size(); actualValue != 0 {
|
|
|
|
t.Errorf("Got %v expected %v", actualValue, 0)
|
|
|
|
}
|
|
|
|
|
|
|
|
list.Add("a", "b", "c")
|
|
|
|
|
2015-03-13 23:36:10 +00:00
|
|
|
if actualValue := list.Contains("a", "b", "c"); actualValue != true {
|
|
|
|
t.Errorf("Got %v expected %v", actualValue, true)
|
|
|
|
}
|
2015-03-10 03:14:40 +00:00
|
|
|
|
|
|
|
if actualValue := list.Contains("a", "b", "c", "d"); actualValue != false {
|
|
|
|
t.Errorf("Got %v expected %v", actualValue, false)
|
|
|
|
}
|
|
|
|
|
|
|
|
list.Clear()
|
|
|
|
|
2015-03-13 23:36:10 +00:00
|
|
|
if actualValue := list.Contains("a"); actualValue != false {
|
|
|
|
t.Errorf("Got %v expected %v", actualValue, false)
|
|
|
|
}
|
2015-03-10 03:14:40 +00:00
|
|
|
|
|
|
|
if actualValue, ok := list.Get(0); actualValue != nil || ok {
|
|
|
|
t.Errorf("Got %v expected %v", actualValue, false)
|
|
|
|
}
|
|
|
|
|
|
|
|
if actualValue := list.Empty(); actualValue != true {
|
|
|
|
t.Errorf("Got %v expected %v", actualValue, true)
|
|
|
|
}
|
|
|
|
|
2016-06-21 01:15:02 +00:00
|
|
|
list.Insert(0, "h")
|
|
|
|
list.Insert(0, "e")
|
|
|
|
list.Insert(1, "f")
|
|
|
|
list.Insert(2, "g")
|
|
|
|
list.Insert(4, "i")
|
|
|
|
list.Insert(0, "a", "b")
|
|
|
|
list.Insert(list.Size(), "j", "k")
|
|
|
|
list.Insert(2, "c", "d")
|
|
|
|
|
|
|
|
if actualValue, expectedValue := fmt.Sprintf("%s%s%s%s%s%s%s%s%s%s%s", list.Values()...), "abcdefghijk"; actualValue != expectedValue {
|
|
|
|
t.Errorf("Got %v expected %v", actualValue, expectedValue)
|
|
|
|
}
|
2016-06-22 03:29:21 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func TestSinglyLinkedListEnumerableAndIterator(t *testing.T) {
|
|
|
|
list := New()
|
|
|
|
list.Add("a", "b", "c")
|
|
|
|
|
|
|
|
// Each
|
2016-06-22 19:03:51 +00:00
|
|
|
list.Each(func(index int, value interface{}) {
|
2016-06-22 03:29:21 +00:00
|
|
|
switch index {
|
|
|
|
case 0:
|
|
|
|
if actualValue, expectedValue := value, "a"; actualValue != expectedValue {
|
|
|
|
t.Errorf("Got %v expected %v", actualValue, expectedValue)
|
|
|
|
}
|
|
|
|
case 1:
|
|
|
|
if actualValue, expectedValue := value, "b"; actualValue != expectedValue {
|
|
|
|
t.Errorf("Got %v expected %v", actualValue, expectedValue)
|
|
|
|
}
|
|
|
|
case 2:
|
|
|
|
if actualValue, expectedValue := value, "c"; actualValue != expectedValue {
|
|
|
|
t.Errorf("Got %v expected %v", actualValue, expectedValue)
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
t.Errorf("Too many")
|
|
|
|
}
|
|
|
|
})
|
|
|
|
|
|
|
|
// Map
|
2016-06-22 19:03:51 +00:00
|
|
|
mappedList := list.Map(func(index int, value interface{}) interface{} {
|
2016-06-22 03:29:21 +00:00
|
|
|
return "mapped: " + value.(string)
|
2016-06-24 04:20:24 +00:00
|
|
|
})
|
2016-06-22 03:29:21 +00:00
|
|
|
if actualValue, _ := mappedList.Get(0); actualValue != "mapped: a" {
|
|
|
|
t.Errorf("Got %v expected %v", actualValue, "mapped: a")
|
|
|
|
}
|
|
|
|
if actualValue, _ := mappedList.Get(1); actualValue != "mapped: b" {
|
|
|
|
t.Errorf("Got %v expected %v", actualValue, "mapped: b")
|
|
|
|
}
|
|
|
|
if actualValue, _ := mappedList.Get(2); actualValue != "mapped: c" {
|
|
|
|
t.Errorf("Got %v expected %v", actualValue, "mapped: c")
|
|
|
|
}
|
|
|
|
if mappedList.Size() != 3 {
|
|
|
|
t.Errorf("Got %v expected %v", mappedList.Size(), 3)
|
|
|
|
}
|
|
|
|
|
|
|
|
// Select
|
2016-06-22 19:03:51 +00:00
|
|
|
selectedList := list.Select(func(index int, value interface{}) bool {
|
2016-06-22 03:29:21 +00:00
|
|
|
return value.(string) >= "a" && value.(string) <= "b"
|
2016-06-24 04:20:24 +00:00
|
|
|
})
|
2016-06-22 03:29:21 +00:00
|
|
|
if actualValue, _ := selectedList.Get(0); actualValue != "a" {
|
|
|
|
t.Errorf("Got %v expected %v", actualValue, "value: a")
|
|
|
|
}
|
|
|
|
if actualValue, _ := selectedList.Get(1); actualValue != "b" {
|
|
|
|
t.Errorf("Got %v expected %v", actualValue, "value: b")
|
|
|
|
}
|
|
|
|
if selectedList.Size() != 2 {
|
|
|
|
t.Errorf("Got %v expected %v", selectedList.Size(), 3)
|
|
|
|
}
|
2016-06-21 01:15:02 +00:00
|
|
|
|
2016-06-22 03:29:21 +00:00
|
|
|
// Any
|
2016-06-22 19:03:51 +00:00
|
|
|
any := list.Any(func(index int, value interface{}) bool {
|
2016-06-22 03:29:21 +00:00
|
|
|
return value.(string) == "c"
|
|
|
|
})
|
|
|
|
if any != true {
|
|
|
|
t.Errorf("Got %v expected %v", any, true)
|
|
|
|
}
|
2016-06-22 19:03:51 +00:00
|
|
|
any = list.Any(func(index int, value interface{}) bool {
|
2016-06-22 03:29:21 +00:00
|
|
|
return value.(string) == "x"
|
|
|
|
})
|
|
|
|
if any != false {
|
|
|
|
t.Errorf("Got %v expected %v", any, false)
|
|
|
|
}
|
|
|
|
|
|
|
|
// All
|
2016-06-22 19:03:51 +00:00
|
|
|
all := list.All(func(index int, value interface{}) bool {
|
2016-06-22 03:29:21 +00:00
|
|
|
return value.(string) >= "a" && value.(string) <= "c"
|
|
|
|
})
|
|
|
|
if all != true {
|
|
|
|
t.Errorf("Got %v expected %v", all, true)
|
|
|
|
}
|
2016-06-22 19:03:51 +00:00
|
|
|
all = list.All(func(index int, value interface{}) bool {
|
2016-06-22 03:29:21 +00:00
|
|
|
return value.(string) >= "a" && value.(string) <= "b"
|
|
|
|
})
|
|
|
|
if all != false {
|
|
|
|
t.Errorf("Got %v expected %v", all, false)
|
|
|
|
}
|
|
|
|
|
|
|
|
// Find
|
2016-06-22 19:03:51 +00:00
|
|
|
foundIndex, foundValue := list.Find(func(index int, value interface{}) bool {
|
2016-06-22 03:29:21 +00:00
|
|
|
return value.(string) == "c"
|
|
|
|
})
|
|
|
|
if foundValue != "c" || foundIndex != 2 {
|
|
|
|
t.Errorf("Got %v at %v expected %v at %v", foundValue, foundIndex, "c", 2)
|
|
|
|
}
|
2016-06-22 19:03:51 +00:00
|
|
|
foundIndex, foundValue = list.Find(func(index int, value interface{}) bool {
|
2016-06-22 03:29:21 +00:00
|
|
|
return value.(string) == "x"
|
|
|
|
})
|
2016-06-22 19:03:51 +00:00
|
|
|
if foundValue != nil || foundIndex != -1 {
|
2016-06-22 03:29:21 +00:00
|
|
|
t.Errorf("Got %v at %v expected %v at %v", foundValue, foundIndex, nil, nil)
|
|
|
|
}
|
|
|
|
|
|
|
|
// Iterator
|
|
|
|
it := list.Iterator()
|
|
|
|
for it.Next() {
|
|
|
|
index := it.Index()
|
|
|
|
value := it.Value()
|
|
|
|
switch index {
|
|
|
|
case 0:
|
|
|
|
if actualValue, expectedValue := value, "a"; actualValue != expectedValue {
|
|
|
|
t.Errorf("Got %v expected %v", actualValue, expectedValue)
|
|
|
|
}
|
|
|
|
case 1:
|
|
|
|
if actualValue, expectedValue := value, "b"; actualValue != expectedValue {
|
|
|
|
t.Errorf("Got %v expected %v", actualValue, expectedValue)
|
|
|
|
}
|
|
|
|
case 2:
|
|
|
|
if actualValue, expectedValue := value, "c"; actualValue != expectedValue {
|
|
|
|
t.Errorf("Got %v expected %v", actualValue, expectedValue)
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
t.Errorf("Too many")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
list.Clear()
|
|
|
|
it = list.Iterator()
|
|
|
|
for it.Next() {
|
|
|
|
t.Errorf("Shouldn't iterate on empty list")
|
|
|
|
}
|
2015-03-10 03:14:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func BenchmarkSinglyLinkedList(b *testing.B) {
|
|
|
|
for i := 0; i < b.N; i++ {
|
|
|
|
list := New()
|
|
|
|
for n := 0; n < 1000; n++ {
|
|
|
|
list.Add(i)
|
|
|
|
}
|
|
|
|
for !list.Empty() {
|
|
|
|
list.Remove(0)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|