~rbn/fit

ref: be89c47f35a510556bf10a989ba06db073c166f8 fit/strategy_test.go -rw-r--r-- 1.9 KiB View raw
be89c47fRuben Schuller rename item field Path to Data and change type to []byte 1 year, 5 months ago
                                                                                
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
package fit

import (
	"bytes"
	"testing"
)

type strategyTest struct {
	item Item
	bin  int
	pos  int
}

var firstTests = []strategyTest{
	{
		item: Item{Data: []byte("a"), Size: 8},
		bin:  0,
		pos:  0,
	},
	{
		item: Item{Data: []byte("b"), Size: 1},
		bin:  0,
		pos:  1,
	},
	{
		item: Item{Data: []byte("c"), Size: 3},
		bin:  1,
		pos:  0,
	},
	{
		item: Item{Data: []byte("d"), Size: 1},
		bin:  0,
		pos:  2,
	},
	{
		item: Item{Data: []byte("e"), Size: 4},
		bin:  1,
		pos:  1,
	},
}

// one must swap the bins in head, as they are sorted in place. this isn't nice.
var bestTests = []strategyTest{
	{
		item: Item{Data: []byte("a"), Size: 6},
		bin:  0,
		pos:  0,
	},
	{
		item: Item{Data: []byte("b"), Size: 8},
		bin:  1,
		pos:  0,
	},
	{
		item: Item{Data: []byte("c"), Size: 1},
		bin:  0,
		pos:  1,
	},
	{
		item: Item{Data: []byte("d"), Size: 2},
		bin:  1,
		pos:  1,
	},
	{
		item: Item{Data: []byte("e"), Size: 1},
		bin:  0,
		pos:  2,
	},
}

var worstTests = []strategyTest{
	{
		item: Item{Data: []byte("a"), Size: 6},
		bin:  0,
		pos:  0,
	},
	{
		item: Item{Data: []byte("b"), Size: 8},
		bin:  1,
		pos:  0,
	},
	{
		item: Item{Data: []byte("c"), Size: 1},
		bin:  0,
		pos:  1,
	},
	{
		item: Item{Data: []byte("d"), Size: 2},
		bin:  0,
		pos:  2,
	},
	{
		item: Item{Data: []byte("e"), Size: 1},
		bin:  0,
		pos:  1,
	},
}

func testStrategy(t *testing.T, strategy StrategyFunc, tests []strategyTest) {
	bins := []Bin{}

	for _, test := range tests {
		bins = strategy(bins, 10, test.item)
		t.Logf("%#v",bins)

		binItem := bins[test.bin].Items()[test.pos]
		if !bytes.Equal(binItem.Data, test.item.Data) || binItem.Size != test.item.Size {
			t.Logf("items differ: %+v %+v", binItem, test.item)
			t.Fail()
		}
	}
}

func TestFirst(t *testing.T) {
	testStrategy(t, First, firstTests)
}

func TestBest(t *testing.T) {
	testStrategy(t, Best, bestTests)
}

func TestWorst(t *testing.T) {
	testStrategy(t, Worst, worstTests)
}