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 }