Add API Framework Revel Source Files
[iec.git] / src / foundation / api / revel / utils / simplestack_test.go
1 package utils
2
3 import (
4         "testing"
5 )
6
7 type SimpleStackTest struct {
8         index int
9 }
10
11 func TestUnique(b *testing.T) {
12         stack := NewStackLock(10, 40, func() interface{} {
13                 newone := &SimpleStackTest{}
14                 return newone
15         })
16         values := []interface{}{}
17         for x := 0; x < 10; x++ {
18                 values = append(values, stack.Pop())
19         }
20         if stack.active != 10 {
21                 b.Errorf("Failed to match 10 active %v ", stack.active)
22         }
23         value1 := stack.Pop().(*SimpleStackTest)
24         value1.index = stack.active
25         value2 := stack.Pop().(*SimpleStackTest)
26         value2.index = stack.active
27         value3 := stack.Pop().(*SimpleStackTest)
28         value3.index = stack.active
29
30         if !isDifferent(value1, value2, value3) {
31                 b.Errorf("Failed to get unique values")
32         }
33
34         if stack.active != 13 {
35                 b.Errorf("Failed to match 13 active %v ", stack.active)
36         }
37
38         for _, v := range values {
39                 stack.Push(v)
40         }
41         if stack.len != 10 {
42                 b.Errorf("Failed to match 10 len %v ", stack.len)
43         }
44         if stack.capacity != 10 {
45                 b.Errorf("Failed to capacity 10 len %v ", stack.capacity)
46         }
47
48         stack.Push(value1)
49         stack.Push(value2)
50         stack.Push(value3)
51         if stack.capacity != 13 {
52                 b.Errorf("Failed to capacity 13 len %v ", stack.capacity)
53         }
54
55         value1 = stack.Pop().(*SimpleStackTest)
56         value2 = stack.Pop().(*SimpleStackTest)
57         value3 = stack.Pop().(*SimpleStackTest)
58         println(value1, value2, value3)
59         if !isDifferent(value1, value2, value3) {
60                 b.Errorf("Failed to get unique values")
61         }
62
63 }
64 func TestLimits(b *testing.T) {
65         stack := NewStackLock(10, 20, func() interface{} {
66                 newone := &SimpleStackTest{}
67                 return newone
68         })
69         values := []interface{}{}
70         for x := 0; x < 50; x++ {
71                 values = append(values, stack.Pop())
72         }
73         if stack.active != 50 {
74                 b.Errorf("Failed to match 50 active %v ", stack.active)
75         }
76         for _, v := range values {
77                 stack.Push(v)
78         }
79         if stack.Capacity() != 20 {
80                 b.Errorf("Failed to match 20 capcity %v ", stack.Capacity())
81         }
82
83 }
84 func isDifferent(values ...*SimpleStackTest) bool {
85         if len(values) == 2 {
86                 return values[0] != values[1]
87         }
88         for _, v := range values[1:] {
89                 if values[0] == v {
90                         return false
91                 }
92         }
93         return isDifferent(values[1:]...)
94 }
95
96 func BenchmarkCreateWrite(b *testing.B) {
97         stack := NewStackLock(0, 40, func() interface{} { return &SimpleStackTest{} })
98         for x := 0; x < b.N; x++ {
99                 stack.Push(x)
100         }
101 }
102 func BenchmarkAllocWrite(b *testing.B) {
103         stack := NewStackLock(b.N, b.N+100, func() interface{} { return &SimpleStackTest{} })
104         for x := 0; x < b.N; x++ {
105                 stack.Push(x)
106         }
107 }
108 func BenchmarkCreate(b *testing.B) {
109         NewStackLock(b.N, b.N+100, func() interface{} { return &SimpleStackTest{} })
110 }
111 func BenchmarkParrallel(b *testing.B) {
112         stack := NewStackLock(b.N, b.N+100, func() interface{} { return &SimpleStackTest{} })
113         b.RunParallel(func(pb *testing.PB) {
114                 for pb.Next() {
115                         for x := 0; x < 50000; x++ {
116                                 stack.Push(x)
117                         }
118                 }
119         })
120         b.RunParallel(func(pb *testing.PB) {
121                 for pb.Next() {
122                         for x := 0; x < 50000; x++ {
123                                 stack.Pop()
124                         }
125                 }
126         })
127 }