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 }