vendor/github.com/syndtr/goleveldb/leveldb/storage/file_storage_test.go

   1 // Copyright (c) 2012, 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 storage
   8
   9 import (
  10         "fmt"
  11         "os"
  12         "path/filepath"
  13         "testing"
  14 )
  15
  16 var cases = []struct {
  17         oldName []string
  18         name    string
  19         ftype   FileType
  20         num     int64
  21 }{
  22         {nil, "000100.log", TypeJournal, 100},
  23         {nil, "000000.log", TypeJournal, 0},
  24         {[]string{"000000.sst"}, "000000.ldb", TypeTable, 0},
  25         {nil, "MANIFEST-000002", TypeManifest, 2},
  26         {nil, "MANIFEST-000007", TypeManifest, 7},
  27         {nil, "9223372036854775807.log", TypeJournal, 9223372036854775807},
  28         {nil, "000100.tmp", TypeTemp, 100},
  29 }
  30
  31 var invalidCases = []string{
  32         "",
  33         "foo",
  34         "foo-dx-100.log",
  35         ".log",
  36         "",
  37         "manifest",
  38         "CURREN",
  39         "CURRENTX",
  40         "MANIFES",
  41         "MANIFEST",
  42         "MANIFEST-",
  43         "XMANIFEST-3",
  44         "MANIFEST-3x",
  45         "LOC",
  46         "LOCKx",
  47         "LO",
  48         "LOGx",
  49         "18446744073709551616.log",
  50         "184467440737095516150.log",
  51         "100",
  52         "100.",
  53         "100.lop",
  54 }
  55
  56 func TestFileStorage_CreateFileName(t *testing.T) {
  57         for _, c := range cases {
  58                 if name := fsGenName(FileDesc{c.ftype, c.num}); name != c.name {
  59                         t.Errorf("invalid filename got '%s', want '%s'", name, c.name)
  60                 }
  61         }
  62 }
  63
  64 func TestFileStorage_ParseFileName(t *testing.T) {
  65         for _, c := range cases {
  66                 for _, name := range append([]string{c.name}, c.oldName...) {
  67                         fd, ok := fsParseName(name)
  68                         if !ok {
  69                                 t.Errorf("cannot parse filename '%s'", name)
  70                                 continue
  71                         }
  72                         if fd.Type != c.ftype {
  73                                 t.Errorf("filename '%s' invalid type got '%d', want '%d'", name, fd.Type, c.ftype)
  74                         }
  75                         if fd.Num != c.num {
  76                                 t.Errorf("filename '%s' invalid number got '%d', want '%d'", name, fd.Num, c.num)
  77                         }
  78                 }
  79         }
  80 }
  81
  82 func TestFileStorage_InvalidFileName(t *testing.T) {
  83         for _, name := range invalidCases {
  84                 if fsParseNamePtr(name, nil) {
  85                         t.Errorf("filename '%s' should be invalid", name)
  86                 }
  87         }
  88 }
  89
  90 func TestFileStorage_Locking(t *testing.T) {
  91         path := filepath.Join(os.TempDir(), fmt.Sprintf("goleveldb-testrwlock-%d", os.Getuid()))
  92         if err := os.RemoveAll(path); err != nil && !os.IsNotExist(err) {
  93                 t.Fatal("RemoveAll: got error: ", err)
  94         }
  95         defer os.RemoveAll(path)
  96
  97         p1, err := OpenFile(path, false)
  98         if err != nil {
  99                 t.Fatal("OpenFile(1): got error: ", err)
 100         }
 101
 102         p2, err := OpenFile(path, false)
 103         if err != nil {
 104                 t.Logf("OpenFile(2): got error: %s (expected)", err)
 105         } else {
 106                 p2.Close()
 107                 p1.Close()
 108                 t.Fatal("OpenFile(2): expect error")
 109         }
 110
 111         p1.Close()
 112
 113         p3, err := OpenFile(path, false)
 114         if err != nil {
 115                 t.Fatal("OpenFile(3): got error: ", err)
 116         }
 117         defer p3.Close()
 118
 119         l, err := p3.Lock()
 120         if err != nil {
 121                 t.Fatal("storage lock failed(1): ", err)
 122         }
 123         _, err = p3.Lock()
 124         if err == nil {
 125                 t.Fatal("expect error for second storage lock attempt")
 126         } else {
 127                 t.Logf("storage lock got error: %s (expected)", err)
 128         }
 129         l.Unlock()
 130         _, err = p3.Lock()
 131         if err != nil {
 132                 t.Fatal("storage lock failed(2): ", err)
 133         }
 134 }
 135
 136 func TestFileStorage_ReadOnlyLocking(t *testing.T) {
 137         path := filepath.Join(os.TempDir(), fmt.Sprintf("goleveldb-testrolock-%d", os.Getuid()))
 138         if err := os.RemoveAll(path); err != nil && !os.IsNotExist(err) {
 139                 t.Fatal("RemoveAll: got error: ", err)
 140         }
 141         defer os.RemoveAll(path)
 142
 143         p1, err := OpenFile(path, false)
 144         if err != nil {
 145                 t.Fatal("OpenFile(1): got error: ", err)
 146         }
 147
 148         _, err = OpenFile(path, true)
 149         if err != nil {
 150                 t.Logf("OpenFile(2): got error: %s (expected)", err)
 151         } else {
 152                 t.Fatal("OpenFile(2): expect error")
 153         }
 154
 155         p1.Close()
 156
 157         p3, err := OpenFile(path, true)
 158         if err != nil {
 159                 t.Fatal("OpenFile(3): got error: ", err)
 160         }
 161
 162         p4, err := OpenFile(path, true)
 163         if err != nil {
 164                 t.Fatal("OpenFile(4): got error: ", err)
 165         }
 166
 167         _, err = OpenFile(path, false)
 168         if err != nil {
 169                 t.Logf("OpenFile(5): got error: %s (expected)", err)
 170         } else {
 171                 t.Fatal("OpenFile(2): expect error")
 172         }
 173
 174         p3.Close()
 175         p4.Close()
 176 }