github.com/alexandrestein/gods@v1.0.1/sets/hashset/hashset_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 hashset
     6  
     7  import (
     8  	"testing"
     9  )
    10  
    11  func TestSetAdd(t *testing.T) {
    12  	set := New()
    13  	set.Add()
    14  	set.Add(1)
    15  	set.Add(2)
    16  	set.Add(2, 3)
    17  	set.Add()
    18  	if actualValue := set.Empty(); actualValue != false {
    19  		t.Errorf("Got %v expected %v", actualValue, false)
    20  	}
    21  	if actualValue := set.Size(); actualValue != 3 {
    22  		t.Errorf("Got %v expected %v", actualValue, 3)
    23  	}
    24  }
    25  
    26  func TestSetContains(t *testing.T) {
    27  	set := New()
    28  	set.Add(3, 1, 2)
    29  	set.Add(2, 3)
    30  	set.Add()
    31  	if actualValue := set.Contains(); actualValue != true {
    32  		t.Errorf("Got %v expected %v", actualValue, true)
    33  	}
    34  	if actualValue := set.Contains(1); actualValue != true {
    35  		t.Errorf("Got %v expected %v", actualValue, true)
    36  	}
    37  	if actualValue := set.Contains(1, 2, 3); actualValue != true {
    38  		t.Errorf("Got %v expected %v", actualValue, true)
    39  	}
    40  	if actualValue := set.Contains(1, 2, 3, 4); actualValue != false {
    41  		t.Errorf("Got %v expected %v", actualValue, false)
    42  	}
    43  }
    44  
    45  func TestSetRemove(t *testing.T) {
    46  	set := New()
    47  	set.Add(3, 1, 2)
    48  	set.Remove()
    49  	if actualValue := set.Size(); actualValue != 3 {
    50  		t.Errorf("Got %v expected %v", actualValue, 3)
    51  	}
    52  	set.Remove(1)
    53  	if actualValue := set.Size(); actualValue != 2 {
    54  		t.Errorf("Got %v expected %v", actualValue, 2)
    55  	}
    56  	set.Remove(3)
    57  	set.Remove(3)
    58  	set.Remove()
    59  	set.Remove(2)
    60  	if actualValue := set.Size(); actualValue != 0 {
    61  		t.Errorf("Got %v expected %v", actualValue, 0)
    62  	}
    63  }
    64  
    65  func TestSetSerialization(t *testing.T) {
    66  	set := New()
    67  	set.Add("a", "b", "c")
    68  
    69  	var err error
    70  	assert := func() {
    71  		if actualValue, expectedValue := set.Size(), 3; actualValue != expectedValue {
    72  			t.Errorf("Got %v expected %v", actualValue, expectedValue)
    73  		}
    74  		if actualValue := set.Contains("a", "b", "c"); actualValue != true {
    75  			t.Errorf("Got %v expected %v", actualValue, true)
    76  		}
    77  		if err != nil {
    78  			t.Errorf("Got error %v", err)
    79  		}
    80  	}
    81  
    82  	assert()
    83  
    84  	json, err := set.ToJSON()
    85  	assert()
    86  
    87  	err = set.FromJSON(json)
    88  	assert()
    89  }
    90  
    91  func benchmarkContains(b *testing.B, set *Set, size int) {
    92  	for i := 0; i < b.N; i++ {
    93  		for n := 0; n < size; n++ {
    94  			set.Contains(n)
    95  		}
    96  	}
    97  }
    98  
    99  func benchmarkAdd(b *testing.B, set *Set, size int) {
   100  	for i := 0; i < b.N; i++ {
   101  		for n := 0; n < size; n++ {
   102  			set.Add(n)
   103  		}
   104  	}
   105  }
   106  
   107  func benchmarkRemove(b *testing.B, set *Set, size int) {
   108  	for i := 0; i < b.N; i++ {
   109  		for n := 0; n < size; n++ {
   110  			set.Remove(n)
   111  		}
   112  	}
   113  }
   114  
   115  func BenchmarkHashSetContains100(b *testing.B) {
   116  	b.StopTimer()
   117  	size := 100
   118  	set := New()
   119  	for n := 0; n < size; n++ {
   120  		set.Add(n)
   121  	}
   122  	b.StartTimer()
   123  	benchmarkContains(b, set, size)
   124  }
   125  
   126  func BenchmarkHashSetContains1000(b *testing.B) {
   127  	b.StopTimer()
   128  	size := 1000
   129  	set := New()
   130  	for n := 0; n < size; n++ {
   131  		set.Add(n)
   132  	}
   133  	b.StartTimer()
   134  	benchmarkContains(b, set, size)
   135  }
   136  
   137  func BenchmarkHashSetContains10000(b *testing.B) {
   138  	b.StopTimer()
   139  	size := 10000
   140  	set := New()
   141  	for n := 0; n < size; n++ {
   142  		set.Add(n)
   143  	}
   144  	b.StartTimer()
   145  	benchmarkContains(b, set, size)
   146  }
   147  
   148  func BenchmarkHashSetContains100000(b *testing.B) {
   149  	b.StopTimer()
   150  	size := 100000
   151  	set := New()
   152  	for n := 0; n < size; n++ {
   153  		set.Add(n)
   154  	}
   155  	b.StartTimer()
   156  	benchmarkContains(b, set, size)
   157  }
   158  
   159  func BenchmarkHashSetAdd100(b *testing.B) {
   160  	b.StopTimer()
   161  	size := 100
   162  	set := New()
   163  	b.StartTimer()
   164  	benchmarkAdd(b, set, size)
   165  }
   166  
   167  func BenchmarkHashSetAdd1000(b *testing.B) {
   168  	b.StopTimer()
   169  	size := 1000
   170  	set := New()
   171  	for n := 0; n < size; n++ {
   172  		set.Add(n)
   173  	}
   174  	b.StartTimer()
   175  	benchmarkAdd(b, set, size)
   176  }
   177  
   178  func BenchmarkHashSetAdd10000(b *testing.B) {
   179  	b.StopTimer()
   180  	size := 10000
   181  	set := New()
   182  	for n := 0; n < size; n++ {
   183  		set.Add(n)
   184  	}
   185  	b.StartTimer()
   186  	benchmarkAdd(b, set, size)
   187  }
   188  
   189  func BenchmarkHashSetAdd100000(b *testing.B) {
   190  	b.StopTimer()
   191  	size := 100000
   192  	set := New()
   193  	for n := 0; n < size; n++ {
   194  		set.Add(n)
   195  	}
   196  	b.StartTimer()
   197  	benchmarkAdd(b, set, size)
   198  }
   199  
   200  func BenchmarkHashSetRemove100(b *testing.B) {
   201  	b.StopTimer()
   202  	size := 100
   203  	set := New()
   204  	for n := 0; n < size; n++ {
   205  		set.Add(n)
   206  	}
   207  	b.StartTimer()
   208  	benchmarkRemove(b, set, size)
   209  }
   210  
   211  func BenchmarkHashSetRemove1000(b *testing.B) {
   212  	b.StopTimer()
   213  	size := 1000
   214  	set := New()
   215  	for n := 0; n < size; n++ {
   216  		set.Add(n)
   217  	}
   218  	b.StartTimer()
   219  	benchmarkRemove(b, set, size)
   220  }
   221  
   222  func BenchmarkHashSetRemove10000(b *testing.B) {
   223  	b.StopTimer()
   224  	size := 10000
   225  	set := New()
   226  	for n := 0; n < size; n++ {
   227  		set.Add(n)
   228  	}
   229  	b.StartTimer()
   230  	benchmarkRemove(b, set, size)
   231  }
   232  
   233  func BenchmarkHashSetRemove100000(b *testing.B) {
   234  	b.StopTimer()
   235  	size := 100000
   236  	set := New()
   237  	for n := 0; n < size; n++ {
   238  		set.Add(n)
   239  	}
   240  	b.StartTimer()
   241  	benchmarkRemove(b, set, size)
   242  }