vendor/github.com/syndtr/goleveldb/leveldb/testutil/util.go

   1 // Copyright (c) 2014, Suryandaru Triandana <syndtr@gmail.com>
   2 // All rights reserved.
   3 //
   4 // Use of this source code is governed by a BSD-style license that can be
   5 // found in the LICENSE file.
   6
   7 package testutil
   8
   9 import (
  10         "bytes"
  11         "flag"
  12         "math/rand"
  13         "reflect"
  14         "sync"
  15
  16         "github.com/onsi/ginkgo/config"
  17
  18         "github.com/syndtr/goleveldb/leveldb/comparer"
  19 )
  20
  21 var (
  22         runfn = make(map[string][]func())
  23         runmu sync.Mutex
  24 )
  25
  26 func Defer(args ...interface{}) bool {
  27         var (
  28                 group string
  29                 fn    func()
  30         )
  31         for _, arg := range args {
  32                 v := reflect.ValueOf(arg)
  33                 switch v.Kind() {
  34                 case reflect.String:
  35                         group = v.String()
  36                 case reflect.Func:
  37                         r := reflect.ValueOf(&fn).Elem()
  38                         r.Set(v)
  39                 }
  40         }
  41         if fn != nil {
  42                 runmu.Lock()
  43                 runfn[group] = append(runfn[group], fn)
  44                 runmu.Unlock()
  45         }
  46         return true
  47 }
  48
  49 func RunDefer(groups ...string) bool {
  50         if len(groups) == 0 {
  51                 groups = append(groups, "")
  52         }
  53         runmu.Lock()
  54         var runfn_ []func()
  55         for _, group := range groups {
  56                 runfn_ = append(runfn_, runfn[group]...)
  57                 delete(runfn, group)
  58         }
  59         runmu.Unlock()
  60         for _, fn := range runfn_ {
  61                 fn()
  62         }
  63         return runfn_ != nil
  64 }
  65
  66 func RandomSeed() int64 {
  67         if !flag.Parsed() {
  68                 panic("random seed not initialized")
  69         }
  70         return config.GinkgoConfig.RandomSeed
  71 }
  72
  73 func NewRand() *rand.Rand {
  74         return rand.New(rand.NewSource(RandomSeed()))
  75 }
  76
  77 var cmp = comparer.DefaultComparer
  78
  79 func BytesSeparator(a, b []byte) []byte {
  80         if bytes.Equal(a, b) {
  81                 return b
  82         }
  83         i, n := 0, len(a)
  84         if n > len(b) {
  85                 n = len(b)
  86         }
  87         for ; i < n && (a[i] == b[i]); i++ {
  88         }
  89         x := append([]byte{}, a[:i]...)
  90         if i < n {
  91                 if c := a[i] + 1; c < b[i] {
  92                         return append(x, c)
  93                 }
  94                 x = append(x, a[i])
  95                 i++
  96         }
  97         for ; i < len(a); i++ {
  98                 if c := a[i]; c < 0xff {
  99                         return append(x, c+1)
 100                 } else {
 101                         x = append(x, c)
 102                 }
 103         }
 104         if len(b) > i && b[i] > 0 {
 105                 return append(x, b[i]-1)
 106         }
 107         return append(x, 'x')
 108 }
 109
 110 func BytesAfter(b []byte) []byte {
 111         var x []byte
 112         for _, c := range b {
 113                 if c < 0xff {
 114                         return append(x, c+1)
 115                 } else {
 116                         x = append(x, c)
 117                 }
 118         }
 119         return append(x, 'x')
 120 }
 121
 122 func RandomIndex(rnd *rand.Rand, n, round int, fn func(i int)) {
 123         if rnd == nil {
 124                 rnd = NewRand()
 125         }
 126         for x := 0; x < round; x++ {
 127                 fn(rnd.Intn(n))
 128         }
 129         return
 130 }
 131
 132 func ShuffledIndex(rnd *rand.Rand, n, round int, fn func(i int)) {
 133         if rnd == nil {
 134                 rnd = NewRand()
 135         }
 136         for x := 0; x < round; x++ {
 137                 for _, i := range rnd.Perm(n) {
 138                         fn(i)
 139                 }
 140         }
 141         return
 142 }
 143
 144 func RandomRange(rnd *rand.Rand, n, round int, fn func(start, limit int)) {
 145         if rnd == nil {
 146                 rnd = NewRand()
 147         }
 148         for x := 0; x < round; x++ {
 149                 start := rnd.Intn(n)
 150                 length := 0
 151                 if j := n - start; j > 0 {
 152                         length = rnd.Intn(j)
 153                 }
 154                 fn(start, start+length)
 155         }
 156         return
 157 }
 158
 159 func Max(x, y int) int {
 160         if x > y {
 161                 return x
 162         }
 163         return y
 164 }
 165
 166 func Min(x, y int) int {
 167         if x < y {
 168                 return x
 169         }
 170         return y
 171 }