github.com/alexandrestein/gods@v1.0.1/sets/treeset/treeset_test.go (about)

     1  // Copyright (c) 2015, Emir Pasic. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package treeset
     6  
     7  import (
     8  	"fmt"
     9  	"testing"
    10  )
    11  
    12  func TestSetAdd(t *testing.T) {
    13  	set := NewWithIntComparator()
    14  	set.Add()
    15  	set.Add(1)
    16  	set.Add(2)
    17  	set.Add(2, 3)
    18  	set.Add()
    19  	if actualValue := set.Empty(); actualValue != false {
    20  		t.Errorf("Got %v expected %v", actualValue, false)
    21  	}
    22  	if actualValue := set.Size(); actualValue != 3 {
    23  		t.Errorf("Got %v expected %v", actualValue, 3)
    24  	}
    25  	if actualValue, expectedValue := fmt.Sprintf("%d%d%d", set.Values()...), "123"; actualValue != expectedValue {
    26  		t.Errorf("Got %v expected %v", actualValue, expectedValue)
    27  	}
    28  }
    29  
    30  func TestSetContains(t *testing.T) {
    31  	set := NewWithIntComparator()
    32  	set.Add(3, 1, 2)
    33  	if actualValue := set.Contains(); actualValue != true {
    34  		t.Errorf("Got %v expected %v", actualValue, true)
    35  	}
    36  	if actualValue := set.Contains(1); actualValue != true {
    37  		t.Errorf("Got %v expected %v", actualValue, true)
    38  	}
    39  	if actualValue := set.Contains(1, 2, 3); actualValue != true {
    40  		t.Errorf("Got %v expected %v", actualValue, true)
    41  	}
    42  	if actualValue := set.Contains(1, 2, 3, 4); actualValue != false {
    43  		t.Errorf("Got %v expected %v", actualValue, false)
    44  	}
    45  }
    46  
    47  func TestSetRemove(t *testing.T) {
    48  	set := NewWithIntComparator()
    49  	set.Add(3, 1, 2)
    50  	set.Remove()
    51  	if actualValue := set.Size(); actualValue != 3 {
    52  		t.Errorf("Got %v expected %v", actualValue, 3)
    53  	}
    54  	set.Remove(1)
    55  	if actualValue := set.Size(); actualValue != 2 {
    56  		t.Errorf("Got %v expected %v", actualValue, 2)
    57  	}
    58  	set.Remove(3)
    59  	set.Remove(3)
    60  	set.Remove()
    61  	set.Remove(2)
    62  	if actualValue := set.Size(); actualValue != 0 {
    63  		t.Errorf("Got %v expected %v", actualValue, 0)
    64  	}
    65  }
    66  
    67  func TestSetEach(t *testing.T) {
    68  	set := NewWithStringComparator()
    69  	set.Add("c", "a", "b")
    70  	set.Each(func(index int, value interface{}) {
    71  		switch index {
    72  		case 0:
    73  			if actualValue, expectedValue := value, "a"; actualValue != expectedValue {
    74  				t.Errorf("Got %v expected %v", actualValue, expectedValue)
    75  			}
    76  		case 1:
    77  			if actualValue, expectedValue := value, "b"; actualValue != expectedValue {
    78  				t.Errorf("Got %v expected %v", actualValue, expectedValue)
    79  			}
    80  		case 2:
    81  			if actualValue, expectedValue := value, "c"; actualValue != expectedValue {
    82  				t.Errorf("Got %v expected %v", actualValue, expectedValue)
    83  			}
    84  		default:
    85  			t.Errorf("Too many")
    86  		}
    87  	})
    88  }
    89  
    90  func TestSetMap(t *testing.T) {
    91  	set := NewWithStringComparator()
    92  	set.Add("c", "a", "b")
    93  	mappedSet := set.Map(func(index int, value interface{}) interface{} {
    94  		return "mapped: " + value.(string)
    95  	})
    96  	if actualValue, expectedValue := mappedSet.Contains("mapped: a", "mapped: b", "mapped: c"), true; actualValue != expectedValue {
    97  		t.Errorf("Got %v expected %v", actualValue, expectedValue)
    98  	}
    99  	if actualValue, expectedValue := mappedSet.Contains("mapped: a", "mapped: b", "mapped: x"), false; actualValue != expectedValue {
   100  		t.Errorf("Got %v expected %v", actualValue, expectedValue)
   101  	}
   102  	if mappedSet.Size() != 3 {
   103  		t.Errorf("Got %v expected %v", mappedSet.Size(), 3)
   104  	}
   105  }
   106  
   107  func TestSetSelect(t *testing.T) {
   108  	set := NewWithStringComparator()
   109  	set.Add("c", "a", "b")
   110  	selectedSet := set.Select(func(index int, value interface{}) bool {
   111  		return value.(string) >= "a" && value.(string) <= "b"
   112  	})
   113  	if actualValue, expectedValue := selectedSet.Contains("a", "b"), true; actualValue != expectedValue {
   114  		fmt.Println("A: ", selectedSet.Contains("b"))
   115  		t.Errorf("Got %v (%v) expected %v (%v)", actualValue, selectedSet.Values(), expectedValue, "[a b]")
   116  	}
   117  	if actualValue, expectedValue := selectedSet.Contains("a", "b", "c"), false; actualValue != expectedValue {
   118  		t.Errorf("Got %v (%v) expected %v (%v)", actualValue, selectedSet.Values(), expectedValue, "[a b]")
   119  	}
   120  	if selectedSet.Size() != 2 {
   121  		t.Errorf("Got %v expected %v", selectedSet.Size(), 3)
   122  	}
   123  }
   124  
   125  func TestSetAny(t *testing.T) {
   126  	set := NewWithStringComparator()
   127  	set.Add("c", "a", "b")
   128  	any := set.Any(func(index int, value interface{}) bool {
   129  		return value.(string) == "c"
   130  	})
   131  	if any != true {
   132  		t.Errorf("Got %v expected %v", any, true)
   133  	}
   134  	any = set.Any(func(index int, value interface{}) bool {
   135  		return value.(string) == "x"
   136  	})
   137  	if any != false {
   138  		t.Errorf("Got %v expected %v", any, false)
   139  	}
   140  }
   141  
   142  func TestSetAll(t *testing.T) {
   143  	set := NewWithStringComparator()
   144  	set.Add("c", "a", "b")
   145  	all := set.All(func(index int, value interface{}) bool {
   146  		return value.(string) >= "a" && value.(string) <= "c"
   147  	})
   148  	if all != true {
   149  		t.Errorf("Got %v expected %v", all, true)
   150  	}
   151  	all = set.All(func(index int, value interface{}) bool {
   152  		return value.(string) >= "a" && value.(string) <= "b"
   153  	})
   154  	if all != false {
   155  		t.Errorf("Got %v expected %v", all, false)
   156  	}
   157  }
   158  
   159  func TestSetFind(t *testing.T) {
   160  	set := NewWithStringComparator()
   161  	set.Add("c", "a", "b")
   162  	foundIndex, foundValue := set.Find(func(index int, value interface{}) bool {
   163  		return value.(string) == "c"
   164  	})
   165  	if foundValue != "c" || foundIndex != 2 {
   166  		t.Errorf("Got %v at %v expected %v at %v", foundValue, foundIndex, "c", 2)
   167  	}
   168  	foundIndex, foundValue = set.Find(func(index int, value interface{}) bool {
   169  		return value.(string) == "x"
   170  	})
   171  	if foundValue != nil || foundIndex != -1 {
   172  		t.Errorf("Got %v at %v expected %v at %v", foundValue, foundIndex, nil, nil)
   173  	}
   174  }
   175  
   176  func TestSetChaining(t *testing.T) {
   177  	set := NewWithStringComparator()
   178  	set.Add("c", "a", "b")
   179  }
   180  
   181  func TestSetIteratorNextOnEmpty(t *testing.T) {
   182  	set := NewWithStringComparator()
   183  	it := set.Iterator()
   184  	for it.Next() {
   185  		t.Errorf("Shouldn't iterate on empty set")
   186  	}
   187  }
   188  
   189  func TestSetIteratorPrevOnEmpty(t *testing.T) {
   190  	set := NewWithStringComparator()
   191  	it := set.Iterator()
   192  	for it.Prev() {
   193  		t.Errorf("Shouldn't iterate on empty set")
   194  	}
   195  }
   196  
   197  func TestSetIteratorNext(t *testing.T) {
   198  	set := NewWithStringComparator()
   199  	set.Add("c", "a", "b")
   200  	it := set.Iterator()
   201  	count := 0
   202  	for it.Next() {
   203  		count++
   204  		index := it.Index()
   205  		value := it.Value()
   206  		switch index {
   207  		case 0:
   208  			if actualValue, expectedValue := value, "a"; actualValue != expectedValue {
   209  				t.Errorf("Got %v expected %v", actualValue, expectedValue)
   210  			}
   211  		case 1:
   212  			if actualValue, expectedValue := value, "b"; actualValue != expectedValue {
   213  				t.Errorf("Got %v expected %v", actualValue, expectedValue)
   214  			}
   215  		case 2:
   216  			if actualValue, expectedValue := value, "c"; actualValue != expectedValue {
   217  				t.Errorf("Got %v expected %v", actualValue, expectedValue)
   218  			}
   219  		default:
   220  			t.Errorf("Too many")
   221  		}
   222  		if actualValue, expectedValue := index, count-1; actualValue != expectedValue {
   223  			t.Errorf("Got %v expected %v", actualValue, expectedValue)
   224  		}
   225  	}
   226  	if actualValue, expectedValue := count, 3; actualValue != expectedValue {
   227  		t.Errorf("Got %v expected %v", actualValue, expectedValue)
   228  	}
   229  }
   230  
   231  func TestSetIteratorPrev(t *testing.T) {
   232  	set := NewWithStringComparator()
   233  	set.Add("c", "a", "b")
   234  	it := set.Iterator()
   235  	for it.Prev() {
   236  	}
   237  	count := 0
   238  	for it.Next() {
   239  		count++
   240  		index := it.Index()
   241  		value := it.Value()
   242  		switch index {
   243  		case 0:
   244  			if actualValue, expectedValue := value, "a"; actualValue != expectedValue {
   245  				t.Errorf("Got %v expected %v", actualValue, expectedValue)
   246  			}
   247  		case 1:
   248  			if actualValue, expectedValue := value, "b"; actualValue != expectedValue {
   249  				t.Errorf("Got %v expected %v", actualValue, expectedValue)
   250  			}
   251  		case 2:
   252  			if actualValue, expectedValue := value, "c"; actualValue != expectedValue {
   253  				t.Errorf("Got %v expected %v", actualValue, expectedValue)
   254  			}
   255  		default:
   256  			t.Errorf("Too many")
   257  		}
   258  		if actualValue, expectedValue := index, count-1; actualValue != expectedValue {
   259  			t.Errorf("Got %v expected %v", actualValue, expectedValue)
   260  		}
   261  	}
   262  	if actualValue, expectedValue := count, 3; actualValue != expectedValue {
   263  		t.Errorf("Got %v expected %v", actualValue, expectedValue)
   264  	}
   265  }
   266  
   267  func TestSetIteratorBegin(t *testing.T) {
   268  	m := NewWithStringComparator()
   269  	it := m.Iterator()
   270  	it.Begin()
   271  	m.Add("a", "b", "c")
   272  	for it.Next() {
   273  	}
   274  	it.Begin()
   275  	it.Next()
   276  	if index, value := it.Index(), it.Value(); index != 0 || value != "a" {
   277  		t.Errorf("Got %v,%v expected %v,%v", index, value, 0, "a")
   278  	}
   279  }
   280  
   281  func TestSetIteratorEnd(t *testing.T) {
   282  	set := NewWithStringComparator()
   283  	it := set.Iterator()
   284  
   285  	if index := it.Index(); index != -1 {
   286  		t.Errorf("Got %v expected %v", index, -1)
   287  	}
   288  
   289  	it.End()
   290  	if index := it.Index(); index != 0 {
   291  		t.Errorf("Got %v expected %v", index, 0)
   292  	}
   293  
   294  	set.Add("a", "b", "c")
   295  	it.End()
   296  	if index := it.Index(); index != set.Size() {
   297  		t.Errorf("Got %v expected %v", index, set.Size())
   298  	}
   299  
   300  	it.Prev()
   301  	if index, value := it.Index(), it.Value(); index != set.Size()-1 || value != "c" {
   302  		t.Errorf("Got %v,%v expected %v,%v", index, value, set.Size()-1, "c")
   303  	}
   304  }
   305  
   306  func TestSetIteratorFirst(t *testing.T) {
   307  	set := NewWithStringComparator()
   308  	set.Add("a", "b", "c")
   309  	it := set.Iterator()
   310  	if actualValue, expectedValue := it.First(), true; actualValue != expectedValue {
   311  		t.Errorf("Got %v expected %v", actualValue, expectedValue)
   312  	}
   313  	if index, value := it.Index(), it.Value(); index != 0 || value != "a" {
   314  		t.Errorf("Got %v,%v expected %v,%v", index, value, 0, "a")
   315  	}
   316  }
   317  
   318  func TestSetIteratorLast(t *testing.T) {
   319  	set := NewWithStringComparator()
   320  	set.Add("a", "b", "c")
   321  	it := set.Iterator()
   322  	if actualValue, expectedValue := it.Last(), true; actualValue != expectedValue {
   323  		t.Errorf("Got %v expected %v", actualValue, expectedValue)
   324  	}
   325  	if index, value := it.Index(), it.Value(); index != 3 || value != "c" {
   326  		t.Errorf("Got %v,%v expected %v,%v", index, value, 3, "c")
   327  	}
   328  }
   329  
   330  func TestSetSerialization(t *testing.T) {
   331  	set := NewWithStringComparator()
   332  	set.Add("a", "b", "c")
   333  
   334  	var err error
   335  	assert := func() {
   336  		if actualValue, expectedValue := set.Size(), 3; actualValue != expectedValue {
   337  			t.Errorf("Got %v expected %v", actualValue, expectedValue)
   338  		}
   339  		if actualValue := set.Contains("a", "b", "c"); actualValue != true {
   340  			t.Errorf("Got %v expected %v", actualValue, true)
   341  		}
   342  		if err != nil {
   343  			t.Errorf("Got error %v", err)
   344  		}
   345  	}
   346  
   347  	assert()
   348  
   349  	json, err := set.ToJSON()
   350  	assert()
   351  
   352  	err = set.FromJSON(json)
   353  	assert()
   354  }
   355  
   356  func benchmarkContains(b *testing.B, set *Set, size int) {
   357  	for i := 0; i < b.N; i++ {
   358  		for n := 0; n < size; n++ {
   359  			set.Contains(n)
   360  		}
   361  	}
   362  }
   363  
   364  func benchmarkAdd(b *testing.B, set *Set, size int) {
   365  	for i := 0; i < b.N; i++ {
   366  		for n := 0; n < size; n++ {
   367  			set.Add(n)
   368  		}
   369  	}
   370  }
   371  
   372  func benchmarkRemove(b *testing.B, set *Set, size int) {
   373  	for i := 0; i < b.N; i++ {
   374  		for n := 0; n < size; n++ {
   375  			set.Remove(n)
   376  		}
   377  	}
   378  }
   379  
   380  func BenchmarkTreeSetContains100(b *testing.B) {
   381  	b.StopTimer()
   382  	size := 100
   383  	set := NewWithIntComparator()
   384  	for n := 0; n < size; n++ {
   385  		set.Add(n)
   386  	}
   387  	b.StartTimer()
   388  	benchmarkContains(b, set, size)
   389  }
   390  
   391  func BenchmarkTreeSetContains1000(b *testing.B) {
   392  	b.StopTimer()
   393  	size := 1000
   394  	set := NewWithIntComparator()
   395  	for n := 0; n < size; n++ {
   396  		set.Add(n)
   397  	}
   398  	b.StartTimer()
   399  	benchmarkContains(b, set, size)
   400  }
   401  
   402  func BenchmarkTreeSetContains10000(b *testing.B) {
   403  	b.StopTimer()
   404  	size := 10000
   405  	set := NewWithIntComparator()
   406  	for n := 0; n < size; n++ {
   407  		set.Add(n)
   408  	}
   409  	b.StartTimer()
   410  	benchmarkContains(b, set, size)
   411  }
   412  
   413  func BenchmarkTreeSetContains100000(b *testing.B) {
   414  	b.StopTimer()
   415  	size := 100000
   416  	set := NewWithIntComparator()
   417  	for n := 0; n < size; n++ {
   418  		set.Add(n)
   419  	}
   420  	b.StartTimer()
   421  	benchmarkContains(b, set, size)
   422  }
   423  
   424  func BenchmarkTreeSetAdd100(b *testing.B) {
   425  	b.StopTimer()
   426  	size := 100
   427  	set := NewWithIntComparator()
   428  	b.StartTimer()
   429  	benchmarkAdd(b, set, size)
   430  }
   431  
   432  func BenchmarkTreeSetAdd1000(b *testing.B) {
   433  	b.StopTimer()
   434  	size := 1000
   435  	set := NewWithIntComparator()
   436  	for n := 0; n < size; n++ {
   437  		set.Add(n)
   438  	}
   439  	b.StartTimer()
   440  	benchmarkAdd(b, set, size)
   441  }
   442  
   443  func BenchmarkTreeSetAdd10000(b *testing.B) {
   444  	b.StopTimer()
   445  	size := 10000
   446  	set := NewWithIntComparator()
   447  	for n := 0; n < size; n++ {
   448  		set.Add(n)
   449  	}
   450  	b.StartTimer()
   451  	benchmarkAdd(b, set, size)
   452  }
   453  
   454  func BenchmarkTreeSetAdd100000(b *testing.B) {
   455  	b.StopTimer()
   456  	size := 100000
   457  	set := NewWithIntComparator()
   458  	for n := 0; n < size; n++ {
   459  		set.Add(n)
   460  	}
   461  	b.StartTimer()
   462  	benchmarkAdd(b, set, size)
   463  }
   464  
   465  func BenchmarkTreeSetRemove100(b *testing.B) {
   466  	b.StopTimer()
   467  	size := 100
   468  	set := NewWithIntComparator()
   469  	for n := 0; n < size; n++ {
   470  		set.Add(n)
   471  	}
   472  	b.StartTimer()
   473  	benchmarkRemove(b, set, size)
   474  }
   475  
   476  func BenchmarkTreeSetRemove1000(b *testing.B) {
   477  	b.StopTimer()
   478  	size := 1000
   479  	set := NewWithIntComparator()
   480  	for n := 0; n < size; n++ {
   481  		set.Add(n)
   482  	}
   483  	b.StartTimer()
   484  	benchmarkRemove(b, set, size)
   485  }
   486  
   487  func BenchmarkTreeSetRemove10000(b *testing.B) {
   488  	b.StopTimer()
   489  	size := 10000
   490  	set := NewWithIntComparator()
   491  	for n := 0; n < size; n++ {
   492  		set.Add(n)
   493  	}
   494  	b.StartTimer()
   495  	benchmarkRemove(b, set, size)
   496  }
   497  
   498  func BenchmarkTreeSetRemove100000(b *testing.B) {
   499  	b.StopTimer()
   500  	size := 100000
   501  	set := NewWithIntComparator()
   502  	for n := 0; n < size; n++ {
   503  		set.Add(n)
   504  	}
   505  	b.StartTimer()
   506  	benchmarkRemove(b, set, size)
   507  }