vendor/github.com/syndtr/goleveldb/leveldb/table/table_test.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 table
   8
   9 import (
  10         "bytes"
  11
  12         . "github.com/onsi/ginkgo"
  13         . "github.com/onsi/gomega"
  14
  15         "github.com/syndtr/goleveldb/leveldb/iterator"
  16         "github.com/syndtr/goleveldb/leveldb/opt"
  17         "github.com/syndtr/goleveldb/leveldb/storage"
  18         "github.com/syndtr/goleveldb/leveldb/testutil"
  19         "github.com/syndtr/goleveldb/leveldb/util"
  20 )
  21
  22 type tableWrapper struct {
  23         *Reader
  24 }
  25
  26 func (t tableWrapper) TestFind(key []byte) (rkey, rvalue []byte, err error) {
  27         return t.Reader.Find(key, false, nil)
  28 }
  29
  30 func (t tableWrapper) TestGet(key []byte) (value []byte, err error) {
  31         return t.Reader.Get(key, nil)
  32 }
  33
  34 func (t tableWrapper) TestNewIterator(slice *util.Range) iterator.Iterator {
  35         return t.Reader.NewIterator(slice, nil)
  36 }
  37
  38 var _ = testutil.Defer(func() {
  39         Describe("Table", func() {
  40                 Describe("approximate offset test", func() {
  41                         var (
  42                                 buf = &bytes.Buffer{}
  43                                 o   = &opt.Options{
  44                                         BlockSize:   1024,
  45                                         Compression: opt.NoCompression,
  46                                 }
  47                         )
  48
  49                         // Building the table.
  50                         tw := NewWriter(buf, o)
  51                         tw.Append([]byte("k01"), []byte("hello"))
  52                         tw.Append([]byte("k02"), []byte("hello2"))
  53                         tw.Append([]byte("k03"), bytes.Repeat([]byte{'x'}, 10000))
  54                         tw.Append([]byte("k04"), bytes.Repeat([]byte{'x'}, 200000))
  55                         tw.Append([]byte("k05"), bytes.Repeat([]byte{'x'}, 300000))
  56                         tw.Append([]byte("k06"), []byte("hello3"))
  57                         tw.Append([]byte("k07"), bytes.Repeat([]byte{'x'}, 100000))
  58                         err := tw.Close()
  59
  60                         It("Should be able to approximate offset of a key correctly", func() {
  61                                 Expect(err).ShouldNot(HaveOccurred())
  62
  63                                 tr, err := NewReader(bytes.NewReader(buf.Bytes()), int64(buf.Len()), storage.FileDesc{}, nil, nil, o)
  64                                 Expect(err).ShouldNot(HaveOccurred())
  65                                 CheckOffset := func(key string, expect, threshold int) {
  66                                         offset, err := tr.OffsetOf([]byte(key))
  67                                         Expect(err).ShouldNot(HaveOccurred())
  68                                         Expect(offset).Should(BeNumerically("~", expect, threshold), "Offset of key %q", key)
  69                                 }
  70
  71                                 CheckOffset("k0", 0, 0)
  72                                 CheckOffset("k01a", 0, 0)
  73                                 CheckOffset("k02", 0, 0)
  74                                 CheckOffset("k03", 0, 0)
  75                                 CheckOffset("k04", 10000, 1000)
  76                                 CheckOffset("k04a", 210000, 1000)
  77                                 CheckOffset("k05", 210000, 1000)
  78                                 CheckOffset("k06", 510000, 1000)
  79                                 CheckOffset("k07", 510000, 1000)
  80                                 CheckOffset("xyz", 610000, 2000)
  81                         })
  82                 })
  83
  84                 Describe("read test", func() {
  85                         Build := func(kv testutil.KeyValue) testutil.DB {
  86                                 o := &opt.Options{
  87                                         BlockSize:            512,
  88                                         BlockRestartInterval: 3,
  89                                 }
  90                                 buf := &bytes.Buffer{}
  91
  92                                 // Building the table.
  93                                 tw := NewWriter(buf, o)
  94                                 kv.Iterate(func(i int, key, value []byte) {
  95                                         tw.Append(key, value)
  96                                 })
  97                                 tw.Close()
  98
  99                                 // Opening the table.
 100                                 tr, _ := NewReader(bytes.NewReader(buf.Bytes()), int64(buf.Len()), storage.FileDesc{}, nil, nil, o)
 101                                 return tableWrapper{tr}
 102                         }
 103                         Test := func(kv *testutil.KeyValue, body func(r *Reader)) func() {
 104                                 return func() {
 105                                         db := Build(*kv)
 106                                         if body != nil {
 107                                                 body(db.(tableWrapper).Reader)
 108                                         }
 109                                         testutil.KeyValueTesting(nil, *kv, db, nil, nil)
 110                                 }
 111                         }
 112
 113                         testutil.AllKeyValueTesting(nil, Build, nil, nil)
 114                         Describe("with one key per block", Test(testutil.KeyValue_Generate(nil, 9, 1, 1, 10, 512, 512), func(r *Reader) {
 115                                 It("should have correct blocks number", func() {
 116                                         indexBlock, err := r.readBlock(r.indexBH, true)
 117                                         Expect(err).To(BeNil())
 118                                         Expect(indexBlock.restartsLen).Should(Equal(9))
 119                                 })
 120                         }))
 121                 })
 122         })
 123 })