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 }