go-hash/hashtable_test.go at master · IrfanFaizullabhoy/go-hash · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
package hashtable

import (
	"github.com/stretchr/testify/assert"
	"strconv"
	"testing"
)

// Test basic add
// with load checks
func TestSetAndGet(t *testing.T) {
	h := NewHashMap(100)
	h.Set("key", "value")

	assert.Equal(t, h.Get("key"), "value", "Checking set & get")
	assert.Equal(t, h.Load(), float32(0.01))
}

func TestDelete(t *testing.T) {
	h := NewHashMap(100)
	h.Set("key", "value")
	h.Delete("key")

	assert.Equal(t, h.Get("key"), nil, "Checking set & delete")
	assert.Equal(t, h.Load(), float32(0))
}

// Test Deleting key that doesn't exist
func TestDeleteNonexistant(t *testing.T) {
	h := NewHashMap(100)
	h.Delete("key")

	assert.Equal(t, h.Delete("key"), nil, "Checking delete of nonexistant value")
	assert.Equal(t, h.Load(), float32(0))
}

// Test deleting twice
// Test Deleting key that doesn't exist
func TestDeleteTwice(t *testing.T) {
	h := NewHashMap(100)
	h.Set("key", "value")
	h.Delete("key")

	assert.Equal(t, h.Delete("key"), nil, "Checking delete of nonexistant value")
	assert.Equal(t, h.Load(), float32(0))
}

// Test add then add again, same key
// with load checks
func TestSetAndGetAndSet(t *testing.T) {
	h := NewHashMap(100)
	h.Set("key", "value")
	h.Set("key", "valueUpdated")

	assert.Equal(t, h.Get("key"), "valueUpdated", "Checking set & set again")
	assert.Equal(t, h.Load(), float32(0.01))
}

// Test add delete add
// with load checks
func TestSetDeleteSet(t *testing.T) {
	h := NewHashMap(100)
	h.Set("key", "value")
	h.Delete("key")
	h.Set("key", "valueUpdated")

	assert.Equal(t, h.Get("key"), "valueUpdated", "Checking set & delete & set & get")
	assert.Equal(t, h.Load(), float32(0.01))
}

// Test add update delete
// with load checks
func TestSetUpdateDeleteSet(t *testing.T) {
	h := NewHashMap(100)
	h.Set("key", "value")
	h.Set("key", "valueUpdated")
	h.Delete("key")

	assert.Equal(t, h.Get("key"), nil, "Checking set, set, delete")
	assert.Equal(t, h.Load(), float32(0.00))
}

// Test adding entries > 1x size
// with load checks

func TestSet100(t *testing.T) {
	h := NewHashMap(100)
	for i := 0; i < 100; i++ {
		key := "key" + strconv.Itoa(i)
		value := "value" + strconv.Itoa(i)
		h.Set(key, value)
	}
	for i := 0; i < 100; i++ {
		key := "key" + strconv.Itoa(i)
		value := "value" + strconv.Itoa(i)
		assert.Equal(t, h.Get(key), value, "Checking batch Set & Get")
	}
	assert.Equal(t, h.Load(), float32(1.00))
}

// Test adding entries > 10x size
// with load checks

func TestSet1000(t *testing.T) {
	h := NewHashMap(100)
	for i := 0; i < 1000; i++ {
		key := "key" + strconv.Itoa(i)
		value := "value" + strconv.Itoa(i)
		h.Set(key, value)
	}
	for i := 0; i < 1000; i++ {
		key := "key" + strconv.Itoa(i)
		value := "value" + strconv.Itoa(i)
		assert.Equal(t, h.Get(key), value, "Checking batch Set & Get")
	}
	assert.Equal(t, h.Load(), float32(10.00))
}

// Test adding entries > 10x size and deleting
// with load checks

func TestSet1000Delete(t *testing.T) {
	h := NewHashMap(100)
	for i := 0; i < 1000; i++ {
		key := "key" + strconv.Itoa(i)
		value := "value" + strconv.Itoa(i)
		h.Set(key, value)
	}
	for i := 0; i < 1000; i++ {
		key := "key" + strconv.Itoa(i)
		h.Delete(key)
	}
	for i := 0; i < 1000; i++ {
		key := "key" + strconv.Itoa(i)
		assert.Equal(t, h.Get(key), nil, "Checking batch Set & Delete")
	}
	assert.Equal(t, h.Load(), float32(0.00))
}

// Test constructorZero zero

func TestZeroMap(t *testing.T) {
	assert.Panics(t, func() { NewHashMap(0) }, "should panic")
}