Add API Framework Revel Source Files

[iec.git] / src / foundation / api / revel / utils / simplestack_test.go

diff --git a/src/foundation/api/revel/utils/simplestack_test.go b/src/foundation/api/revel/utils/simplestack_test.go
new file mode 100644 (file)
index 0000000..3a93740
--- /dev/null
+++ b/src/foundation/api/revel/utils/simplestack_test.go
@@ -0,0 +1,127 @@
+package utils
+
+import (
+       "testing"
+)
+
+type SimpleStackTest struct {
+       index int
+}
+
+func TestUnique(b *testing.T) {
+       stack := NewStackLock(10, 40, func() interface{} {
+               newone := &SimpleStackTest{}
+               return newone
+       })
+       values := []interface{}{}
+       for x := 0; x < 10; x++ {
+               values = append(values, stack.Pop())
+       }
+       if stack.active != 10 {
+               b.Errorf("Failed to match 10 active %v ", stack.active)
+       }
+       value1 := stack.Pop().(*SimpleStackTest)
+       value1.index = stack.active
+       value2 := stack.Pop().(*SimpleStackTest)
+       value2.index = stack.active
+       value3 := stack.Pop().(*SimpleStackTest)
+       value3.index = stack.active
+
+       if !isDifferent(value1, value2, value3) {
+               b.Errorf("Failed to get unique values")
+       }
+
+       if stack.active != 13 {
+               b.Errorf("Failed to match 13 active %v ", stack.active)
+       }
+
+       for _, v := range values {
+               stack.Push(v)
+       }
+       if stack.len != 10 {
+               b.Errorf("Failed to match 10 len %v ", stack.len)
+       }
+       if stack.capacity != 10 {
+               b.Errorf("Failed to capacity 10 len %v ", stack.capacity)
+       }
+
+       stack.Push(value1)
+       stack.Push(value2)
+       stack.Push(value3)
+       if stack.capacity != 13 {
+               b.Errorf("Failed to capacity 13 len %v ", stack.capacity)
+       }
+
+       value1 = stack.Pop().(*SimpleStackTest)
+       value2 = stack.Pop().(*SimpleStackTest)
+       value3 = stack.Pop().(*SimpleStackTest)
+       println(value1, value2, value3)
+       if !isDifferent(value1, value2, value3) {
+               b.Errorf("Failed to get unique values")
+       }
+
+}
+func TestLimits(b *testing.T) {
+       stack := NewStackLock(10, 20, func() interface{} {
+               newone := &SimpleStackTest{}
+               return newone
+       })
+       values := []interface{}{}
+       for x := 0; x < 50; x++ {
+               values = append(values, stack.Pop())
+       }
+       if stack.active != 50 {
+               b.Errorf("Failed to match 50 active %v ", stack.active)
+       }
+       for _, v := range values {
+               stack.Push(v)
+       }
+       if stack.Capacity() != 20 {
+               b.Errorf("Failed to match 20 capcity %v ", stack.Capacity())
+       }
+
+}
+func isDifferent(values ...*SimpleStackTest) bool {
+       if len(values) == 2 {
+               return values[0] != values[1]
+       }
+       for _, v := range values[1:] {
+               if values[0] == v {
+                       return false
+               }
+       }
+       return isDifferent(values[1:]...)
+}
+
+func BenchmarkCreateWrite(b *testing.B) {
+       stack := NewStackLock(0, 40, func() interface{} { return &SimpleStackTest{} })
+       for x := 0; x < b.N; x++ {
+               stack.Push(x)
+       }
+}
+func BenchmarkAllocWrite(b *testing.B) {
+       stack := NewStackLock(b.N, b.N+100, func() interface{} { return &SimpleStackTest{} })
+       for x := 0; x < b.N; x++ {
+               stack.Push(x)
+       }
+}
+func BenchmarkCreate(b *testing.B) {
+       NewStackLock(b.N, b.N+100, func() interface{} { return &SimpleStackTest{} })
+}
+func BenchmarkParrallel(b *testing.B) {
+       stack := NewStackLock(b.N, b.N+100, func() interface{} { return &SimpleStackTest{} })
+       b.RunParallel(func(pb *testing.PB) {
+               for pb.Next() {
+                       for x := 0; x < 50000; x++ {
+                               stack.Push(x)
+                       }
+               }
+       })
+       b.RunParallel(func(pb *testing.PB) {
+               for pb.Next() {
+                       for x := 0; x < 50000; x++ {
+                               stack.Pop()
+                       }
+               }
+       })
+}