vendor/github.com/syndtr/goleveldb/leveldb/version_test.go

   1 package leveldb
   2
   3 import (
   4         "encoding/binary"
   5         "reflect"
   6         "testing"
   7
   8         "github.com/onsi/gomega"
   9
  10         "github.com/syndtr/goleveldb/leveldb/testutil"
  11 )
  12
  13 type testFileRec struct {
  14         level int
  15         num   int64
  16 }
  17
  18 func TestVersionStaging(t *testing.T) {
  19         gomega.RegisterTestingT(t)
  20         stor := testutil.NewStorage()
  21         defer stor.Close()
  22         s, err := newSession(stor, nil)
  23         if err != nil {
  24                 t.Fatal(err)
  25         }
  26
  27         v := newVersion(s)
  28         v.newStaging()
  29
  30         tmp := make([]byte, 4)
  31         mik := func(i uint64) []byte {
  32                 binary.BigEndian.PutUint32(tmp, uint32(i))
  33                 return []byte(makeInternalKey(nil, tmp, 0, keyTypeVal))
  34         }
  35
  36         for i, x := range []struct {
  37                 add, del []testFileRec
  38                 levels   [][]int64
  39         }{
  40                 {
  41                         add: []testFileRec{
  42                                 {1, 1},
  43                         },
  44                         levels: [][]int64{
  45                                 {},
  46                                 {1},
  47                         },
  48                 },
  49                 {
  50                         add: []testFileRec{
  51                                 {1, 1},
  52                         },
  53                         levels: [][]int64{
  54                                 {},
  55                                 {1},
  56                         },
  57                 },
  58                 {
  59                         del: []testFileRec{
  60                                 {1, 1},
  61                         },
  62                         levels: [][]int64{},
  63                 },
  64                 {
  65                         add: []testFileRec{
  66                                 {0, 1},
  67                                 {0, 3},
  68                                 {0, 2},
  69                                 {2, 5},
  70                                 {1, 4},
  71                         },
  72                         levels: [][]int64{
  73                                 {3, 2, 1},
  74                                 {4},
  75                                 {5},
  76                         },
  77                 },
  78                 {
  79                         add: []testFileRec{
  80                                 {1, 6},
  81                                 {2, 5},
  82                         },
  83                         del: []testFileRec{
  84                                 {0, 1},
  85                                 {0, 4},
  86                         },
  87                         levels: [][]int64{
  88                                 {3, 2},
  89                                 {4, 6},
  90                                 {5},
  91                         },
  92                 },
  93                 {
  94                         del: []testFileRec{
  95                                 {0, 3},
  96                                 {0, 2},
  97                                 {1, 4},
  98                                 {1, 6},
  99                                 {2, 5},
 100                         },
 101                         levels: [][]int64{},
 102                 },
 103                 {
 104                         add: []testFileRec{
 105                                 {0, 1},
 106                         },
 107                         levels: [][]int64{
 108                                 {1},
 109                         },
 110                 },
 111                 {
 112                         add: []testFileRec{
 113                                 {1, 2},
 114                         },
 115                         levels: [][]int64{
 116                                 {1},
 117                                 {2},
 118                         },
 119                 },
 120                 {
 121                         add: []testFileRec{
 122                                 {0, 3},
 123                         },
 124                         levels: [][]int64{
 125                                 {3, 1},
 126                                 {2},
 127                         },
 128                 },
 129                 {
 130                         add: []testFileRec{
 131                                 {6, 9},
 132                         },
 133                         levels: [][]int64{
 134                                 {3, 1},
 135                                 {2},
 136                                 {},
 137                                 {},
 138                                 {},
 139                                 {},
 140                                 {9},
 141                         },
 142                 },
 143                 {
 144                         del: []testFileRec{
 145                                 {6, 9},
 146                         },
 147                         levels: [][]int64{
 148                                 {3, 1},
 149                                 {2},
 150                         },
 151                 },
 152         } {
 153                 rec := &sessionRecord{}
 154                 for _, f := range x.add {
 155                         ik := mik(uint64(f.num))
 156                         rec.addTable(f.level, f.num, 1, ik, ik)
 157                 }
 158                 for _, f := range x.del {
 159                         rec.delTable(f.level, f.num)
 160                 }
 161                 vs := v.newStaging()
 162                 vs.commit(rec)
 163                 v = vs.finish()
 164                 if len(v.levels) != len(x.levels) {
 165                         t.Fatalf("#%d: invalid level count: want=%d got=%d", i, len(x.levels), len(v.levels))
 166                 }
 167                 for j, want := range x.levels {
 168                         tables := v.levels[j]
 169                         if len(want) != len(tables) {
 170                                 t.Fatalf("#%d.%d: invalid tables count: want=%d got=%d", i, j, len(want), len(tables))
 171                         }
 172                         got := make([]int64, len(tables))
 173                         for k, t := range tables {
 174                                 got[k] = t.fd.Num
 175                         }
 176                         if !reflect.DeepEqual(want, got) {
 177                                 t.Fatalf("#%d.%d: invalid tables: want=%v got=%v", i, j, want, got)
 178                         }
 179                 }
 180         }
 181 }