aboutsummaryrefslogtreecommitdiff
path: root/bucket_test.go
diff options
context:
space:
mode:
Diffstat (limited to 'bucket_test.go')
-rw-r--r--bucket_test.go1794
1 files changed, 1226 insertions, 568 deletions
diff --git a/bucket_test.go b/bucket_test.go
index 57b1d12..480ed08 100644
--- a/bucket_test.go
+++ b/bucket_test.go
@@ -5,6 +5,7 @@ import (
"encoding/binary"
"errors"
"fmt"
+ "log"
"math/rand"
"os"
"strconv"
@@ -17,94 +18,150 @@ import (
// Ensure that a bucket that gets a non-existent key returns nil.
func TestBucket_Get_NonExistent(t *testing.T) {
- db := NewTestDB()
- defer db.Close()
- db.Update(func(tx *bolt.Tx) error {
- tx.CreateBucket([]byte("widgets"))
- value := tx.Bucket([]byte("widgets")).Get([]byte("foo"))
- assert(t, value == nil, "")
+ db := MustOpenDB()
+ defer db.MustClose()
+
+ if err := db.Update(func(tx *bolt.Tx) error {
+ b, err := tx.CreateBucket([]byte("widgets"))
+ if err != nil {
+ t.Fatal(err)
+ }
+ if v := b.Get([]byte("foo")); v != nil {
+ t.Fatal("expected nil value")
+ }
return nil
- })
+ }); err != nil {
+ t.Fatal(err)
+ }
}
// Ensure that a bucket can read a value that is not flushed yet.
func TestBucket_Get_FromNode(t *testing.T) {
- db := NewTestDB()
- defer db.Close()
- db.Update(func(tx *bolt.Tx) error {
- tx.CreateBucket([]byte("widgets"))
- b := tx.Bucket([]byte("widgets"))
- b.Put([]byte("foo"), []byte("bar"))
- value := b.Get([]byte("foo"))
- equals(t, []byte("bar"), value)
+ db := MustOpenDB()
+ defer db.MustClose()
+
+ if err := db.Update(func(tx *bolt.Tx) error {
+ b, err := tx.CreateBucket([]byte("widgets"))
+ if err != nil {
+ t.Fatal(err)
+ }
+ if err := b.Put([]byte("foo"), []byte("bar")); err != nil {
+ t.Fatal(err)
+ }
+ if v := b.Get([]byte("foo")); !bytes.Equal(v, []byte("bar")) {
+ t.Fatalf("unexpected value: %v", v)
+ }
return nil
- })
+ }); err != nil {
+ t.Fatal(err)
+ }
}
// Ensure that a bucket retrieved via Get() returns a nil.
func TestBucket_Get_IncompatibleValue(t *testing.T) {
- db := NewTestDB()
- defer db.Close()
- db.Update(func(tx *bolt.Tx) error {
- tx.CreateBucket([]byte("widgets"))
- _, err := tx.Bucket([]byte("widgets")).CreateBucket([]byte("foo"))
- ok(t, err)
- assert(t, tx.Bucket([]byte("widgets")).Get([]byte("foo")) == nil, "")
+ db := MustOpenDB()
+ defer db.MustClose()
+ if err := db.Update(func(tx *bolt.Tx) error {
+ _, err := tx.CreateBucket([]byte("widgets"))
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ if _, err := tx.Bucket([]byte("widgets")).CreateBucket([]byte("foo")); err != nil {
+ t.Fatal(err)
+ }
+
+ if tx.Bucket([]byte("widgets")).Get([]byte("foo")) != nil {
+ t.Fatal("expected nil value")
+ }
return nil
- })
+ }); err != nil {
+ t.Fatal(err)
+ }
}
// Ensure that a bucket can write a key/value.
func TestBucket_Put(t *testing.T) {
- db := NewTestDB()
- defer db.Close()
- db.Update(func(tx *bolt.Tx) error {
- tx.CreateBucket([]byte("widgets"))
- err := tx.Bucket([]byte("widgets")).Put([]byte("foo"), []byte("bar"))
- ok(t, err)
- value := tx.Bucket([]byte("widgets")).Get([]byte("foo"))
- equals(t, value, []byte("bar"))
+ db := MustOpenDB()
+ defer db.MustClose()
+ if err := db.Update(func(tx *bolt.Tx) error {
+ b, err := tx.CreateBucket([]byte("widgets"))
+ if err != nil {
+ t.Fatal(err)
+ }
+ if err := b.Put([]byte("foo"), []byte("bar")); err != nil {
+ t.Fatal(err)
+ }
+
+ v := tx.Bucket([]byte("widgets")).Get([]byte("foo"))
+ if !bytes.Equal([]byte("bar"), v) {
+ t.Fatalf("unexpected value: %v", v)
+ }
return nil
- })
+ }); err != nil {
+ t.Fatal(err)
+ }
}
// Ensure that a bucket can rewrite a key in the same transaction.
func TestBucket_Put_Repeat(t *testing.T) {
- db := NewTestDB()
- defer db.Close()
- db.Update(func(tx *bolt.Tx) error {
- tx.CreateBucket([]byte("widgets"))
- b := tx.Bucket([]byte("widgets"))
- ok(t, b.Put([]byte("foo"), []byte("bar")))
- ok(t, b.Put([]byte("foo"), []byte("baz")))
+ db := MustOpenDB()
+ defer db.MustClose()
+ if err := db.Update(func(tx *bolt.Tx) error {
+ b, err := tx.CreateBucket([]byte("widgets"))
+ if err != nil {
+ t.Fatal(err)
+ }
+ if err := b.Put([]byte("foo"), []byte("bar")); err != nil {
+ t.Fatal(err)
+ }
+ if err := b.Put([]byte("foo"), []byte("baz")); err != nil {
+ t.Fatal(err)
+ }
+
value := tx.Bucket([]byte("widgets")).Get([]byte("foo"))
- equals(t, value, []byte("baz"))
+ if !bytes.Equal([]byte("baz"), value) {
+ t.Fatalf("unexpected value: %v", value)
+ }
return nil
- })
+ }); err != nil {
+ t.Fatal(err)
+ }
}
// Ensure that a bucket can write a bunch of large values.
func TestBucket_Put_Large(t *testing.T) {
- db := NewTestDB()
- defer db.Close()
+ db := MustOpenDB()
+ defer db.MustClose()
count, factor := 100, 200
- db.Update(func(tx *bolt.Tx) error {
- tx.CreateBucket([]byte("widgets"))
- b := tx.Bucket([]byte("widgets"))
+ if err := db.Update(func(tx *bolt.Tx) error {
+ b, err := tx.CreateBucket([]byte("widgets"))
+ if err != nil {
+ t.Fatal(err)
+ }
for i := 1; i < count; i++ {
- ok(t, b.Put([]byte(strings.Repeat("0", i*factor)), []byte(strings.Repeat("X", (count-i)*factor))))
+ if err := b.Put([]byte(strings.Repeat("0", i*factor)), []byte(strings.Repeat("X", (count-i)*factor))); err != nil {
+ t.Fatal(err)
+ }
}
return nil
- })
- db.View(func(tx *bolt.Tx) error {
+ }); err != nil {
+ t.Fatal(err)
+ }
+
+ if err := db.View(func(tx *bolt.Tx) error {
b := tx.Bucket([]byte("widgets"))
for i := 1; i < count; i++ {
value := b.Get([]byte(strings.Repeat("0", i*factor)))
- equals(t, []byte(strings.Repeat("X", (count-i)*factor)), value)
+ if !bytes.Equal(value, []byte(strings.Repeat("X", (count-i)*factor))) {
+ t.Fatalf("unexpected value: %v", value)
+ }
}
return nil
- })
+ }); err != nil {
+ t.Fatal(err)
+ }
}
// Ensure that a database can perform multiple large appends safely.
@@ -116,104 +173,170 @@ func TestDB_Put_VeryLarge(t *testing.T) {
n, batchN := 400000, 200000
ksize, vsize := 8, 500
- db := NewTestDB()
- defer db.Close()
+ db := MustOpenDB()
+ defer db.MustClose()
for i := 0; i < n; i += batchN {
- err := db.Update(func(tx *bolt.Tx) error {
- b, _ := tx.CreateBucketIfNotExists([]byte("widgets"))
+ if err := db.Update(func(tx *bolt.Tx) error {
+ b, err := tx.CreateBucketIfNotExists([]byte("widgets"))
+ if err != nil {
+ t.Fatal(err)
+ }
for j := 0; j < batchN; j++ {
k, v := make([]byte, ksize), make([]byte, vsize)
binary.BigEndian.PutUint32(k, uint32(i+j))
- ok(t, b.Put(k, v))
+ if err := b.Put(k, v); err != nil {
+ t.Fatal(err)
+ }
}
return nil
- })
- ok(t, err)
+ }); err != nil {
+ t.Fatal(err)
+ }
}
}
// Ensure that a setting a value on a key with a bucket value returns an error.
func TestBucket_Put_IncompatibleValue(t *testing.T) {
- db := NewTestDB()
- defer db.Close()
- db.Update(func(tx *bolt.Tx) error {
- tx.CreateBucket([]byte("widgets"))
- _, err := tx.Bucket([]byte("widgets")).CreateBucket([]byte("foo"))
- ok(t, err)
- equals(t, bolt.ErrIncompatibleValue, tx.Bucket([]byte("widgets")).Put([]byte("foo"), []byte("bar")))
+ db := MustOpenDB()
+ defer db.MustClose()
+
+ if err := db.Update(func(tx *bolt.Tx) error {
+ b0, err := tx.CreateBucket([]byte("widgets"))
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ if _, err := tx.Bucket([]byte("widgets")).CreateBucket([]byte("foo")); err != nil {
+ t.Fatal(err)
+ }
+ if err := b0.Put([]byte("foo"), []byte("bar")); err != bolt.ErrIncompatibleValue {
+ t.Fatalf("unexpected error: %s", err)
+ }
return nil
- })
+ }); err != nil {
+ t.Fatal(err)
+ }
}
// Ensure that a setting a value while the transaction is closed returns an error.
func TestBucket_Put_Closed(t *testing.T) {
- db := NewTestDB()
- defer db.Close()
- tx, _ := db.Begin(true)
- tx.CreateBucket([]byte("widgets"))
- b := tx.Bucket([]byte("widgets"))
- tx.Rollback()
- equals(t, bolt.ErrTxClosed, b.Put([]byte("foo"), []byte("bar")))
+ db := MustOpenDB()
+ defer db.MustClose()
+ tx, err := db.Begin(true)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ b, err := tx.CreateBucket([]byte("widgets"))
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ if err := tx.Rollback(); err != nil {
+ t.Fatal(err)
+ }
+
+ if err := b.Put([]byte("foo"), []byte("bar")); err != bolt.ErrTxClosed {
+ t.Fatalf("unexpected error: %s", err)
+ }
}
// Ensure that setting a value on a read-only bucket returns an error.
func TestBucket_Put_ReadOnly(t *testing.T) {
- db := NewTestDB()
- defer db.Close()
- db.Update(func(tx *bolt.Tx) error {
- _, err := tx.CreateBucket([]byte("widgets"))
- ok(t, err)
+ db := MustOpenDB()
+ defer db.MustClose()
+
+ if err := db.Update(func(tx *bolt.Tx) error {
+ if _, err := tx.CreateBucket([]byte("widgets")); err != nil {
+ t.Fatal(err)
+ }
return nil
- })
- db.View(func(tx *bolt.Tx) error {
+ }); err != nil {
+ t.Fatal(err)
+ }
+
+ if err := db.View(func(tx *bolt.Tx) error {
b := tx.Bucket([]byte("widgets"))
- err := b.Put([]byte("foo"), []byte("bar"))
- equals(t, err, bolt.ErrTxNotWritable)
+ if err := b.Put([]byte("foo"), []byte("bar")); err != bolt.ErrTxNotWritable {
+ t.Fatalf("unexpected error: %s", err)
+ }
return nil
- })
+ }); err != nil {
+ t.Fatal(err)
+ }
}
// Ensure that a bucket can delete an existing key.
func TestBucket_Delete(t *testing.T) {
- db := NewTestDB()
- defer db.Close()
- db.Update(func(tx *bolt.Tx) error {
- tx.CreateBucket([]byte("widgets"))
- tx.Bucket([]byte("widgets")).Put([]byte("foo"), []byte("bar"))
- err := tx.Bucket([]byte("widgets")).Delete([]byte("foo"))
- ok(t, err)
- value := tx.Bucket([]byte("widgets")).Get([]byte("foo"))
- assert(t, value == nil, "")
+ db := MustOpenDB()
+ defer db.MustClose()
+
+ if err := db.Update(func(tx *bolt.Tx) error {
+ b, err := tx.CreateBucket([]byte("widgets"))
+ if err != nil {
+ t.Fatal(err)
+ }
+ if err := b.Put([]byte("foo"), []byte("bar")); err != nil {
+ t.Fatal(err)
+ }
+ if err := b.Delete([]byte("foo")); err != nil {
+ t.Fatal(err)
+ }
+ if v := b.Get([]byte("foo")); v != nil {
+ t.Fatalf("unexpected value: %v", v)
+ }
return nil
- })
+ }); err != nil {
+ t.Fatal(err)
+ }
}
// Ensure that deleting a large set of keys will work correctly.
func TestBucket_Delete_Large(t *testing.T) {
- db := NewTestDB()
- defer db.Close()
- db.Update(func(tx *bolt.Tx) error {
- var b, _ = tx.CreateBucket([]byte("widgets"))
+ db := MustOpenDB()
+ defer db.MustClose()
+
+ if err := db.Update(func(tx *bolt.Tx) error {
+ b, err := tx.CreateBucket([]byte("widgets"))
+ if err != nil {
+ t.Fatal(err)
+ }
+
for i := 0; i < 100; i++ {
- ok(t, b.Put([]byte(strconv.Itoa(i)), []byte(strings.Repeat("*", 1024))))
+ if err := b.Put([]byte(strconv.Itoa(i)), []byte(strings.Repeat("*", 1024))); err != nil {
+ t.Fatal(err)
+ }
}
+
return nil
- })
- db.Update(func(tx *bolt.Tx) error {
- var b = tx.Bucket([]byte("widgets"))
+ }); err != nil {
+ t.Fatal(err)
+ }
+
+ if err := db.Update(func(tx *bolt.Tx) error {
+ b := tx.Bucket([]byte("widgets"))
for i := 0; i < 100; i++ {
- ok(t, b.Delete([]byte(strconv.Itoa(i))))
+ if err := b.Delete([]byte(strconv.Itoa(i))); err != nil {
+ t.Fatal(err)
+ }
}
return nil
- })
- db.View(func(tx *bolt.Tx) error {
- var b = tx.Bucket([]byte("widgets"))
+ }); err != nil {
+ t.Fatal(err)
+ }
+
+ if err := db.View(func(tx *bolt.Tx) error {
+ b := tx.Bucket([]byte("widgets"))
for i := 0; i < 100; i++ {
- assert(t, b.Get([]byte(strconv.Itoa(i))) == nil, "")
+ if v := b.Get([]byte(strconv.Itoa(i))); v != nil {
+ t.Fatalf("unexpected value: %v, i=%d", v, i)
+ }
}
return nil
- })
+ }); err != nil {
+ t.Fatal(err)
+ }
}
// Deleting a very large list of keys will cause the freelist to use overflow.
@@ -222,11 +345,12 @@ func TestBucket_Delete_FreelistOverflow(t *testing.T) {
t.Skip("skipping test in short mode.")
}
- db := NewTestDB()
- defer db.Close()
+ db := MustOpenDB()
+ defer db.MustClose()
+
k := make([]byte, 16)
for i := uint64(0); i < 10000; i++ {
- err := db.Update(func(tx *bolt.Tx) error {
+ if err := db.Update(func(tx *bolt.Tx) error {
b, err := tx.CreateBucketIfNotExists([]byte("0"))
if err != nil {
t.Fatalf("bucket error: %s", err)
@@ -241,272 +365,450 @@ func TestBucket_Delete_FreelistOverflow(t *testing.T) {
}
return nil
- })
-
- if err != nil {
- t.Fatalf("update error: %s", err)
+ }); err != nil {
+ t.Fatal(err)
}
}
// Delete all of them in one large transaction
- err := db.Update(func(tx *bolt.Tx) error {
+ if err := db.Update(func(tx *bolt.Tx) error {
b := tx.Bucket([]byte("0"))
c := b.Cursor()
for k, _ := c.First(); k != nil; k, _ = c.Next() {
- c.Delete()
+ if err := c.Delete(); err != nil {
+ t.Fatal(err)
+ }
}
return nil
- })
-
- // Check that a freelist overflow occurred.
- ok(t, err)
+ }); err != nil {
+ t.Fatal(err)
+ }
}
// Ensure that accessing and updating nested buckets is ok across transactions.
func TestBucket_Nested(t *testing.T) {
- db := NewTestDB()
- defer db.Close()
- db.Update(func(tx *bolt.Tx) error {
+ db := MustOpenDB()
+ defer db.MustClose()
+
+ if err := db.Update(func(tx *bolt.Tx) error {
// Create a widgets bucket.
b, err := tx.CreateBucket([]byte("widgets"))
- ok(t, err)
+ if err != nil {
+ t.Fatal(err)
+ }
// Create a widgets/foo bucket.
_, err = b.CreateBucket([]byte("foo"))
- ok(t, err)
+ if err != nil {
+ t.Fatal(err)
+ }
// Create a widgets/bar key.
- ok(t, b.Put([]byte("bar"), []byte("0000")))
+ if err := b.Put([]byte("bar"), []byte("0000")); err != nil {
+ t.Fatal(err)
+ }
return nil
- })
+ }); err != nil {
+ t.Fatal(err)
+ }
db.MustCheck()
// Update widgets/bar.
- db.Update(func(tx *bolt.Tx) error {
- var b = tx.Bucket([]byte("widgets"))
- ok(t, b.Put([]byte("bar"), []byte("xxxx")))
+ if err := db.Update(func(tx *bolt.Tx) error {
+ b := tx.Bucket([]byte("widgets"))
+ if err := b.Put([]byte("bar"), []byte("xxxx")); err != nil {
+ t.Fatal(err)
+ }
return nil
- })
+ }); err != nil {
+ t.Fatal(err)
+ }
db.MustCheck()
// Cause a split.
- db.Update(func(tx *bolt.Tx) error {
+ if err := db.Update(func(tx *bolt.Tx) error {
var b = tx.Bucket([]byte("widgets"))
for i := 0; i < 10000; i++ {
- ok(t, b.Put([]byte(strconv.Itoa(i)), []byte(strconv.Itoa(i))))
+ if err := b.Put([]byte(strconv.Itoa(i)), []byte(strconv.Itoa(i))); err != nil {
+ t.Fatal(err)
+ }
}
return nil
- })
+ }); err != nil {
+ t.Fatal(err)
+ }
db.MustCheck()
// Insert into widgets/foo/baz.
- db.Update(func(tx *bolt.Tx) error {
+ if err := db.Update(func(tx *bolt.Tx) error {
var b = tx.Bucket([]byte("widgets"))
- ok(t, b.Bucket([]byte("foo")).Put([]byte("baz"), []byte("yyyy")))
+ if err := b.Bucket([]byte("foo")).Put([]byte("baz"), []byte("yyyy")); err != nil {
+ t.Fatal(err)
+ }
return nil
- })
+ }); err != nil {
+ t.Fatal(err)
+ }
db.MustCheck()
// Verify.
- db.View(func(tx *bolt.Tx) error {
+ if err := db.View(func(tx *bolt.Tx) error {
var b = tx.Bucket([]byte("widgets"))
- equals(t, []byte("yyyy"), b.Bucket([]byte("foo")).Get([]byte("baz")))
- equals(t, []byte("xxxx"), b.Get([]byte("bar")))
+ if v := b.Bucket([]byte("foo")).Get([]byte("baz")); !bytes.Equal(v, []byte("yyyy")) {
+ t.Fatalf("unexpected value: %v")
+ }
+ if !bytes.Equal(b.Get([]byte("bar")), []byte("xxxx")) {
+ t.Fatalf("unexpected value: %v")
+ }
for i := 0; i < 10000; i++ {
- equals(t, []byte(strconv.Itoa(i)), b.Get([]byte(strconv.Itoa(i))))
+ if v := b.Get([]byte(strconv.Itoa(i))); !bytes.Equal(v, []byte(strconv.Itoa(i))) {
+ t.Fatalf("unexpected value: %v", v)
+ }
}
return nil
- })
+ }); err != nil {
+ t.Fatal(err)
+ }
}
// Ensure that deleting a bucket using Delete() returns an error.
func TestBucket_Delete_Bucket(t *testing.T) {
- db := NewTestDB()
- defer db.Close()
- db.Update(func(tx *bolt.Tx) error {
- tx.CreateBucket([]byte("widgets"))
- b := tx.Bucket([]byte("widgets"))
- _, err := b.CreateBucket([]byte("foo"))
- ok(t, err)
- equals(t, bolt.ErrIncompatibleValue, b.Delete([]byte("foo")))
+ db := MustOpenDB()
+ defer db.MustClose()
+ if err := db.Update(func(tx *bolt.Tx) error {
+ b, err := tx.CreateBucket([]byte("widgets"))
+ if err != nil {
+ t.Fatal(err)
+ }
+ if _, err := b.CreateBucket([]byte("foo")); err != nil {
+ t.Fatal(err)
+ }
+ if err := b.Delete([]byte("foo")); err != bolt.ErrIncompatibleValue {
+ t.Fatalf("unexpected error: %s", err)
+ }
return nil
- })
+ }); err != nil {
+ t.Fatal(err)
+ }
}
// Ensure that deleting a key on a read-only bucket returns an error.
func TestBucket_Delete_ReadOnly(t *testing.T) {
- db := NewTestDB()
- defer db.Close()
- db.Update(func(tx *bolt.Tx) error {
- tx.CreateBucket([]byte("widgets"))
+ db := MustOpenDB()
+ defer db.MustClose()
+
+ if err := db.Update(func(tx *bolt.Tx) error {
+ if _, err := tx.CreateBucket([]byte("widgets")); err != nil {
+ t.Fatal(err)
+ }
return nil
- })
- db.View(func(tx *bolt.Tx) error {
- b := tx.Bucket([]byte("widgets"))
- err := b.Delete([]byte("foo"))
- equals(t, err, bolt.ErrTxNotWritable)
+ }); err != nil {
+ t.Fatal(err)
+ }
+
+ if err := db.View(func(tx *bolt.Tx) error {
+ if err := tx.Bucket([]byte("widgets")).Delete([]byte("foo")); err != bolt.ErrTxNotWritable {
+ t.Fatalf("unexpected error: %s", err)
+ }
return nil
- })
+ }); err != nil {
+ t.Fatal(err)
+ }
}
// Ensure that a deleting value while the transaction is closed returns an error.
func TestBucket_Delete_Closed(t *testing.T) {
- db := NewTestDB()
- defer db.Close()
- tx, _ := db.Begin(true)
- tx.CreateBucket([]byte("widgets"))
- b := tx.Bucket([]byte("widgets"))
- tx.Rollback()
- equals(t, bolt.ErrTxClosed, b.Delete([]byte("foo")))
+ db := MustOpenDB()
+ defer db.MustClose()
+
+ tx, err := db.Begin(true)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ b, err := tx.CreateBucket([]byte("widgets"))
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ if err := tx.Rollback(); err != nil {
+ t.Fatal(err)
+ }
+ if err := b.Delete([]byte("foo")); err != bolt.ErrTxClosed {
+ t.Fatalf("unexpected error: %s", err)
+ }
}
// Ensure that deleting a bucket causes nested buckets to be deleted.
func TestBucket_DeleteBucket_Nested(t *testing.T) {
- db := NewTestDB()
- defer db.Close()
- db.Update(func(tx *bolt.Tx) error {
- tx.CreateBucket([]byte("widgets"))
- _, err := tx.Bucket([]byte("widgets")).CreateBucket([]byte("foo"))
- ok(t, err)
- _, err = tx.Bucket([]byte("widgets")).Bucket([]byte("foo")).CreateBucket([]byte("bar"))
- ok(t, err)
- ok(t, tx.Bucket([]byte("widgets")).Bucket([]byte("foo")).Bucket([]byte("bar")).Put([]byte("baz"), []byte("bat")))
- ok(t, tx.Bucket([]byte("widgets")).DeleteBucket([]byte("foo")))
+ db := MustOpenDB()
+ defer db.MustClose()
+
+ if err := db.Update(func(tx *bolt.Tx) error {
+ widgets, err := tx.CreateBucket([]byte("widgets"))
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ foo, err := widgets.CreateBucket([]byte("foo"))
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ bar, err := foo.CreateBucket([]byte("bar"))
+ if err != nil {
+ t.Fatal(err)
+ }
+ if err := bar.Put([]byte("baz"), []byte("bat")); err != nil {
+ t.Fatal(err)
+ }
+ if err := tx.Bucket([]byte("widgets")).DeleteBucket([]byte("foo")); err != nil {
+ t.Fatal(err)
+ }
return nil
- })
+ }); err != nil {
+ t.Fatal(err)
+ }
}
// Ensure that deleting a bucket causes nested buckets to be deleted after they have been committed.
func TestBucket_DeleteBucket_Nested2(t *testing.T) {
- db := NewTestDB()
- defer db.Close()
- db.Update(func(tx *bolt.Tx) error {
- tx.CreateBucket([]byte("widgets"))
- _, err := tx.Bucket([]byte("widgets")).CreateBucket([]byte("foo"))
- ok(t, err)
- _, err = tx.Bucket([]byte("widgets")).Bucket([]byte("foo")).CreateBucket([]byte("bar"))
- ok(t, err)
- ok(t, tx.Bucket([]byte("widgets")).Bucket([]byte("foo")).Bucket([]byte("bar")).Put([]byte("baz"), []byte("bat")))
+ db := MustOpenDB()
+ defer db.MustClose()
+
+ if err := db.Update(func(tx *bolt.Tx) error {
+ widgets, err := tx.CreateBucket([]byte("widgets"))
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ foo, err := widgets.CreateBucket([]byte("foo"))
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ bar, err := foo.CreateBucket([]byte("bar"))
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ if err := bar.Put([]byte("baz"), []byte("bat")); err != nil {
+ t.Fatal(err)
+ }
return nil
- })
- db.Update(func(tx *bolt.Tx) error {
- assert(t, tx.Bucket([]byte("widgets")) != nil, "")
- assert(t, tx.Bucket([]byte("widgets")).Bucket([]byte("foo")) != nil, "")
- assert(t, tx.Bucket([]byte("widgets")).Bucket([]byte("foo")).Bucket([]byte("bar")) != nil, "")
- equals(t, []byte("bat"), tx.Bucket([]byte("widgets")).Bucket([]byte("foo")).Bucket([]byte("bar")).Get([]byte("baz")))
- ok(t, tx.DeleteBucket([]byte("widgets")))
+ }); err != nil {
+ t.Fatal(err)
+ }
+
+ if err := db.Update(func(tx *bolt.Tx) error {
+ widgets := tx.Bucket([]byte("widgets"))
+ if widgets == nil {
+ t.Fatal("expected widgets bucket")
+ }
+
+ foo := widgets.Bucket([]byte("foo"))
+ if foo == nil {
+ t.Fatal("expected foo bucket")
+ }
+
+ bar := foo.Bucket([]byte("bar"))
+ if bar == nil {
+ t.Fatal("expected bar bucket")
+ }
+
+ if v := bar.Get([]byte("baz")); !bytes.Equal(v, []byte("bat")) {
+ t.Fatalf("unexpected value: %v", v)
+ }
+ if err := tx.DeleteBucket([]byte("widgets")); err != nil {
+ t.Fatal(err)
+ }
return nil
- })
- db.View(func(tx *bolt.Tx) error {
- assert(t, tx.Bucket([]byte("widgets")) == nil, "")
+ }); err != nil {
+ t.Fatal(err)
+ }
+
+ if err := db.View(func(tx *bolt.Tx) error {
+ if tx.Bucket([]byte("widgets")) != nil {
+ t.Fatal("expected bucket to be deleted")
+ }
return nil
- })
+ }); err != nil {
+ t.Fatal(err)
+ }
}
// Ensure that deleting a child bucket with multiple pages causes all pages to get collected.
+// NOTE: Consistency check in bolt_test.DB.Close() will panic if pages not freed properly.
func TestBucket_DeleteBucket_Large(t *testing.T) {
- db := NewTestDB()
- defer db.Close()
- db.Update(func(tx *bolt.Tx) error {
- _, err := tx.CreateBucket([]byte("widgets"))
- ok(t, err)
- _, err = tx.Bucket([]byte("widgets")).CreateBucket([]byte("foo"))
- ok(t, err)
- b := tx.Bucket([]byte("widgets")).Bucket([]byte("foo"))
+ db := MustOpenDB()
+ defer db.MustClose()
+
+ if err := db.Update(func(tx *bolt.Tx) error {
+ widgets, err := tx.CreateBucket([]byte("widgets"))
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ foo, err := widgets.CreateBucket([]byte("foo"))
+ if err != nil {
+ t.Fatal(err)
+ }
+
for i := 0; i < 1000; i++ {
- ok(t, b.Put([]byte(fmt.Sprintf("%d", i)), []byte(fmt.Sprintf("%0100d", i))))
+ if err := foo.Put([]byte(fmt.Sprintf("%d", i)), []byte(fmt.Sprintf("%0100d", i))); err != nil {
+ t.Fatal(err)
+ }
}
return nil
- })
- db.Update(func(tx *bolt.Tx) error {
- ok(t, tx.DeleteBucket([]byte("widgets")))
- return nil
- })
+ }); err != nil {
+ t.Fatal(err)
+ }
- // NOTE: Consistency check in TestDB.Close() will panic if pages not freed properly.
+ if err := db.Update(func(tx *bolt.Tx) error {
+ if err := tx.DeleteBucket([]byte("widgets")); err != nil {
+ t.Fatal(err)
+ }
+ return nil
+ }); err != nil {
+ t.Fatal(err)
+ }
}
// Ensure that a simple value retrieved via Bucket() returns a nil.
func TestBucket_Bucket_IncompatibleValue(t *testing.T) {
- db := NewTestDB()
- defer db.Close()
- db.Update(func(tx *bolt.Tx) error {
- tx.CreateBucket([]byte("widgets"))
- ok(t, tx.Bucket([]byte("widgets")).Put([]byte("foo"), []byte("bar")))
- assert(t, tx.Bucket([]byte("widgets")).Bucket([]byte("foo")) == nil, "")
+ db := MustOpenDB()
+ defer db.MustClose()
+
+ if err := db.Update(func(tx *bolt.Tx) error {
+ widgets, err := tx.CreateBucket([]byte("widgets"))
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ if err := widgets.Put([]byte("foo"), []byte("bar")); err != nil {
+ t.Fatal(err)
+ }
+ if b := tx.Bucket([]byte("widgets")).Bucket([]byte("foo")); b != nil {
+ t.Fatal("expected nil bucket")
+ }
return nil
- })
+ }); err != nil {
+ t.Fatal(err)
+ }
}
// Ensure that creating a bucket on an existing non-bucket key returns an error.
func TestBucket_CreateBucket_IncompatibleValue(t *testing.T) {
- db := NewTestDB()
- defer db.Close()
- db.Update(func(tx *bolt.Tx) error {
- _, err := tx.CreateBucket([]byte("widgets"))
- ok(t, err)
- ok(t, tx.Bucket([]byte("widgets")).Put([]byte("foo"), []byte("bar")))
- _, err = tx.Bucket([]byte("widgets")).CreateBucket([]byte("foo"))
- equals(t, bolt.ErrIncompatibleValue, err)
+ db := MustOpenDB()
+ defer db.MustClose()
+ if err := db.Update(func(tx *bolt.Tx) error {
+ widgets, err := tx.CreateBucket([]byte("widgets"))
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ if err := widgets.Put([]byte("foo"), []byte("bar")); err != nil {
+ t.Fatal(err)
+ }
+ if _, err := widgets.CreateBucket([]byte("foo")); err != bolt.ErrIncompatibleValue {
+ t.Fatalf("unexpected error: %s", err)
+ }
return nil
- })
+ }); err != nil {
+ t.Fatal(err)
+ }
}
// Ensure that deleting a bucket on an existing non-bucket key returns an error.
func TestBucket_DeleteBucket_IncompatibleValue(t *testing.T) {
- db := NewTestDB()
- defer db.Close()
- db.Update(func(tx *bolt.Tx) error {
- _, err := tx.CreateBucket([]byte("widgets"))
- ok(t, err)
- ok(t, tx.Bucket([]byte("widgets")).Put([]byte("foo"), []byte("bar")))
- equals(t, bolt.ErrIncompatibleValue, tx.Bucket([]byte("widgets")).DeleteBucket([]byte("foo")))
+ db := MustOpenDB()
+ defer db.MustClose()
+
+ if err := db.Update(func(tx *bolt.Tx) error {
+ widgets, err := tx.CreateBucket([]byte("widgets"))
+ if err != nil {
+ t.Fatal(err)
+ }
+ if err := widgets.Put([]byte("foo"), []byte("bar")); err != nil {
+ t.Fatal(err)
+ }
+ if err := tx.Bucket([]byte("widgets")).DeleteBucket([]byte("foo")); err != bolt.ErrIncompatibleValue {
+ t.Fatalf("unexpected error: %s", err)
+ }
return nil
- })
+ }); err != nil {
+ t.Fatal(err)
+ }
}
// Ensure that a bucket can return an autoincrementing sequence.
func TestBucket_NextSequence(t *testing.T) {
- db := NewTestDB()
- defer db.Close()
- db.Update(func(tx *bolt.Tx) error {
- tx.CreateBucket([]byte("widgets"))
- tx.CreateBucket([]byte("woojits"))
+ db := MustOpenDB()
+ defer db.MustClose()
+
+ if err := db.Update(func(tx *bolt.Tx) error {
+ widgets, err := tx.CreateBucket([]byte("widgets"))
+ if err != nil {
+ t.Fatal(err)
+ }
+ woojits, err := tx.CreateBucket([]byte("woojits"))
+ if err != nil {
+ t.Fatal(err)
+ }
// Make sure sequence increments.
- seq, err := tx.Bucket([]byte("widgets")).NextSequence()
- ok(t, err)
- equals(t, seq, uint64(1))
- seq, err = tx.Bucket([]byte("widgets")).NextSequence()
- ok(t, err)
- equals(t, seq, uint64(2))
+ if seq, err := widgets.NextSequence(); err != nil {
+ t.Fatal(err)
+ } else if seq != 1 {
+ t.Fatalf("unexpecte sequence: %d", seq)
+ }
+
+ if seq, err := widgets.NextSequence(); err != nil {
+ t.Fatal(err)
+ } else if seq != 2 {
+ t.Fatalf("unexpected sequence: %d", seq)
+ }
// Buckets should be separate.
- seq, err = tx.Bucket([]byte("woojits")).NextSequence()
- ok(t, err)
- equals(t, seq, uint64(1))
+ if seq, err := woojits.NextSequence(); err != nil {
+ t.Fatal(err)
+ } else if seq != 1 {
+ t.Fatalf("unexpected sequence: %d", 1)
+ }
+
return nil
- })
+ }); err != nil {
+ t.Fatal(err)
+ }
}
// Ensure that a bucket will persist an autoincrementing sequence even if its
// the only thing updated on the bucket.
// https://github.com/boltdb/bolt/issues/296
func TestBucket_NextSequence_Persist(t *testing.T) {
- db := NewTestDB()
- defer db.Close()
- db.Update(func(tx *bolt.Tx) error {
- _, _ = tx.CreateBucket([]byte("widgets"))
+ db := MustOpenDB()
+ defer db.MustClose()
+
+ if err := db.Update(func(tx *bolt.Tx) error {
+ if _, err := tx.CreateBucket([]byte("widgets")); err != nil {
+ t.Fatal(err)
+ }
return nil
- })
+ }); err != nil {
+ t.Fatal(err)
+ }
- db.Update(func(tx *bolt.Tx) error {
- _, _ = tx.Bucket([]byte("widgets")).NextSequence()
+ if err := db.Update(func(tx *bolt.Tx) error {
+ if _, err := tx.Bucket([]byte("widgets")).NextSequence(); err != nil {
+ t.Fatal(err)
+ }
return nil
- })
+ }); err != nil {
+ t.Fatal(err)
+ }
- db.Update(func(tx *bolt.Tx) error {
+ if err := db.Update(func(tx *bolt.Tx) error {
seq, err := tx.Bucket([]byte("widgets")).NextSequence()
if err != nil {
t.Fatalf("unexpected error: %s", err)
@@ -514,199 +816,326 @@ func TestBucket_NextSequence_Persist(t *testing.T) {
t.Fatalf("unexpected sequence: %d", seq)
}
return nil
- })
+ }); err != nil {
+ t.Fatal(err)
+ }
}
// Ensure that retrieving the next sequence on a read-only bucket returns an error.
func TestBucket_NextSequence_ReadOnly(t *testing.T) {
- db := NewTestDB()
- defer db.Close()
- db.Update(func(tx *bolt.Tx) error {
- tx.CreateBucket([]byte("widgets"))
+ db := MustOpenDB()
+ defer db.MustClose()
+
+ if err := db.Update(func(tx *bolt.Tx) error {
+ if _, err := tx.CreateBucket([]byte("widgets")); err != nil {
+ t.Fatal(err)
+ }
return nil
- })
- db.View(func(tx *bolt.Tx) error {
- b := tx.Bucket([]byte("widgets"))
- i, err := b.NextSequence()
- equals(t, i, uint64(0))
- equals(t, err, bolt.ErrTxNotWritable)
+ }); err != nil {
+ t.Fatal(err)
+ }
+
+ if err := db.View(func(tx *bolt.Tx) error {
+ _, err := tx.Bucket([]byte("widgets")).NextSequence()
+ if err != bolt.ErrTxNotWritable {
+ t.Fatalf("unexpected error: %s", err)
+ }
return nil
- })
+ }); err != nil {
+ t.Fatal(err)
+ }
}
// Ensure that retrieving the next sequence for a bucket on a closed database return an error.
func TestBucket_NextSequence_Closed(t *testing.T) {
- db := NewTestDB()
- defer db.Close()
- tx, _ := db.Begin(true)
- tx.CreateBucket([]byte("widgets"))
- b := tx.Bucket([]byte("widgets"))
- tx.Rollback()
- _, err := b.NextSequence()
- equals(t, bolt.ErrTxClosed, err)
+ db := MustOpenDB()
+ defer db.MustClose()
+ tx, err := db.Begin(true)
+ if err != nil {
+ t.Fatal(err)
+ }
+ b, err := tx.CreateBucket([]byte("widgets"))
+ if err != nil {
+ t.Fatal(err)
+ }
+ if err := tx.Rollback(); err != nil {
+ t.Fatal(err)
+ }
+ if _, err := b.NextSequence(); err != bolt.ErrTxClosed {
+ t.Fatal(err)
+ }
}
// Ensure a user can loop over all key/value pairs in a bucket.
func TestBucket_ForEach(t *testing.T) {
- db := NewTestDB()
- defer db.Close()
- db.Update(func(tx *bolt.Tx) error {
- tx.CreateBucket([]byte("widgets"))
- tx.Bucket([]byte("widgets")).Put([]byte("foo"), []byte("0000"))
- tx.Bucket([]byte("widgets")).Put([]byte("baz"), []byte("0001"))
- tx.Bucket([]byte("widgets")).Put([]byte("bar"), []byte("0002"))
+ db := MustOpenDB()
+ defer db.MustClose()
+
+ if err := db.Update(func(tx *bolt.Tx) error {
+ b, err := tx.CreateBucket([]byte("widgets"))
+ if err != nil {
+ t.Fatal(err)
+ }
+ if err := b.Put([]byte("foo"), []byte("0000")); err != nil {
+ t.Fatal(err)
+ }
+ if err := b.Put([]byte("baz"), []byte("0001")); err != nil {
+ t.Fatal(err)
+ }
+ if err := b.Put([]byte("bar"), []byte("0002")); err != nil {
+ t.Fatal(err)
+ }
var index int
- err := tx.Bucket([]byte("widgets")).ForEach(func(k, v []byte) error {
+ if err := b.ForEach(func(k, v []byte) error {
switch index {
case 0:
- equals(t, k, []byte("bar"))
- equals(t, v, []byte("0002"))
+ if !bytes.Equal(k, []byte("bar")) {
+ t.Fatalf("unexpected key: %v", k)
+ } else if !bytes.Equal(v, []byte("0002")) {
+ t.Fatalf("unexpected value: %v", v)
+ }
case 1:
- equals(t, k, []byte("baz"))
- equals(t, v, []byte("0001"))
+ if !bytes.Equal(k, []byte("baz")) {
+ t.Fatalf("unexpected key: %v", k)
+ } else if !bytes.Equal(v, []byte("0001")) {
+ t.Fatalf("unexpected value: %v", v)
+ }
case 2:
- equals(t, k, []byte("foo"))
- equals(t, v, []byte("0000"))
+ if !bytes.Equal(k, []byte("foo")) {
+ t.Fatalf("unexpected key: %v", k)
+ } else if !bytes.Equal(v, []byte("0000")) {
+ t.Fatalf("unexpected value: %v", v)
+ }
}
index++
return nil
- })
- ok(t, err)
- equals(t, index, 3)
+ }); err != nil {
+ t.Fatal(err)
+ }
+
+ if index != 3 {
+ t.Fatalf("unexpected index: %d", index)
+ }
+
return nil
- })
+ }); err != nil {
+ t.Fatal(err)
+ }
}
// Ensure a database can stop iteration early.
func TestBucket_ForEach_ShortCircuit(t *testing.T) {
- db := NewTestDB()
- defer db.Close()
- db.Update(func(tx *bolt.Tx) error {
- tx.CreateBucket([]byte("widgets"))
- tx.Bucket([]byte("widgets")).Put([]byte("bar"), []byte("0000"))
- tx.Bucket([]byte("widgets")).Put([]byte("baz"), []byte("0000"))
- tx.Bucket([]byte("widgets")).Put([]byte("foo"), []byte("0000"))
+ db := MustOpenDB()
+ defer db.MustClose()
+ if err := db.Update(func(tx *bolt.Tx) error {
+ b, err := tx.CreateBucket([]byte("widgets"))
+ if err != nil {
+ t.Fatal(err)
+ }
+ if err := b.Put([]byte("bar"), []byte("0000")); err != nil {
+ t.Fatal(err)
+ }
+ if err := b.Put([]byte("baz"), []byte("0000")); err != nil {
+ t.Fatal(err)
+ }
+ if err := b.Put([]byte("foo"), []byte("0000")); err != nil {
+ t.Fatal(err)
+ }
var index int
- err := tx.Bucket([]byte("widgets")).ForEach(func(k, v []byte) error {
+ if err := tx.Bucket([]byte("widgets")).ForEach(func(k, v []byte) error {
index++
if bytes.Equal(k, []byte("baz")) {
return errors.New("marker")
}
return nil
- })
- equals(t, errors.New("marker"), err)
- equals(t, 2, index)
+ }); err == nil || err.Error() != "marker" {
+ t.Fatalf("unexpected error: %s", err)
+ }
+ if index != 2 {
+ t.Fatalf("unexpected index: %d", index)
+ }
+
return nil
- })
+ }); err != nil {
+ t.Fatal(err)
+ }
}
// Ensure that looping over a bucket on a closed database returns an error.
func TestBucket_ForEach_Closed(t *testing.T) {
- db := NewTestDB()
- defer db.Close()
- tx, _ := db.Begin(true)
- tx.CreateBucket([]byte("widgets"))
- b := tx.Bucket([]byte("widgets"))
- tx.Rollback()
- err := b.ForEach(func(k, v []byte) error { return nil })
- equals(t, bolt.ErrTxClosed, err)
+ db := MustOpenDB()
+ defer db.MustClose()
+
+ tx, err := db.Begin(true)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ b, err := tx.CreateBucket([]byte("widgets"))
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ if err := tx.Rollback(); err != nil {
+ t.Fatal(err)
+ }
+
+ if err := b.ForEach(func(k, v []byte) error { return nil }); err != bolt.ErrTxClosed {
+ t.Fatalf("unexpected error: %s", err)
+ }
}
// Ensure that an error is returned when inserting with an empty key.
func TestBucket_Put_EmptyKey(t *testing.T) {
- db := NewTestDB()
- defer db.Close()
- db.Update(func(tx *bolt.Tx) error {
- tx.CreateBucket([]byte("widgets"))
- err := tx.Bucket([]byte("widgets")).Put([]byte(""), []byte("bar"))
- equals(t, err, bolt.ErrKeyRequired)
- err = tx.Bucket([]byte("widgets")).Put(nil, []byte("bar"))
- equals(t, err, bolt.ErrKeyRequired)
+ db := MustOpenDB()
+ defer db.MustClose()
+
+ if err := db.Update(func(tx *bolt.Tx) error {
+ b, err := tx.CreateBucket([]byte("widgets"))
+ if err != nil {
+ t.Fatal(err)
+ }
+ if err := b.Put([]byte(""), []byte("bar")); err != bolt.ErrKeyRequired {
+ t.Fatalf("unexpected error: %s", err)
+ }
+ if err := b.Put(nil, []byte("bar")); err != bolt.ErrKeyRequired {
+ t.Fatalf("unexpected error: %s", err)
+ }
return nil
- })
+ }); err != nil {
+ t.Fatal(err)
+ }
}
// Ensure that an error is returned when inserting with a key that's too large.
func TestBucket_Put_KeyTooLarge(t *testing.T) {
- db := NewTestDB()
- defer db.Close()
- db.Update(func(tx *bolt.Tx) error {
- tx.CreateBucket([]byte("widgets"))
- err := tx.Bucket([]byte("widgets")).Put(make([]byte, 32769), []byte("bar"))
- equals(t, err, bolt.ErrKeyTooLarge)
+ db := MustOpenDB()
+ defer db.MustClose()
+ if err := db.Update(func(tx *bolt.Tx) error {
+ b, err := tx.CreateBucket([]byte("widgets"))
+ if err != nil {
+ t.Fatal(err)
+ }
+ if err := b.Put(make([]byte, 32769), []byte("bar")); err != bolt.ErrKeyTooLarge {
+ t.Fatalf("unexpected error: %s", err)
+ }
return nil
- })
+ }); err != nil {
+ t.Fatal(err)
+ }
}
// Ensure that an error is returned when inserting a value that's too large.
func TestBucket_Put_ValueTooLarge(t *testing.T) {
+ // Skip this test on DroneCI because the machine is resource constrained.
if os.Getenv("DRONE") == "true" {
t.Skip("not enough RAM for test")
}
- db := NewTestDB()
- defer db.Close()
- db.Update(func(tx *bolt.Tx) error {
- tx.CreateBucket([]byte("widgets"))
- err := tx.Bucket([]byte("widgets")).Put([]byte("foo"), make([]byte, bolt.MaxValueSize+1))
- equals(t, err, bolt.ErrValueTooLarge)
+ db := MustOpenDB()
+ defer db.MustClose()
+
+ if err := db.Update(func(tx *bolt.Tx) error {
+ b, err := tx.CreateBucket([]byte("widgets"))
+ if err != nil {
+ t.Fatal(err)
+ }
+ if err := b.Put([]byte("foo"), make([]byte, bolt.MaxValueSize+1)); err != bolt.ErrValueTooLarge {
+ t.Fatalf("unexpected error: %s", err)
+ }
return nil
- })
+ }); err != nil {
+ t.Fatal(err)
+ }
}
// Ensure a bucket can calculate stats.
func TestBucket_Stats(t *testing.T) {
- db := NewTestDB()
- defer db.Close()
+ db := MustOpenDB()
+ defer db.MustClose()
// Add bucket with fewer keys but one big value.
- big_key := []byte("really-big-value")
+ bigKey := []byte("really-big-value")
for i := 0; i < 500; i++ {
- db.Update(func(tx *bolt.Tx) error {
- b, _ := tx.CreateBucketIfNotExists([]byte("woojits"))
- return b.Put([]byte(fmt.Sprintf("%03d", i)), []byte(strconv.Itoa(i)))
- })
+ if err := db.Update(func(tx *bolt.Tx) error {
+ b, err := tx.CreateBucketIfNotExists([]byte("woojits"))
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ if err := b.Put([]byte(fmt.Sprintf("%03d", i)), []byte(strconv.Itoa(i))); err != nil {
+ t.Fatal(err)
+ }
+ return nil
+ }); err != nil {
+ t.Fatal(err)
+ }
+ }
+ if err := db.Update(func(tx *bolt.Tx) error {
+ if err := tx.Bucket([]byte("woojits")).Put(bigKey, []byte(strings.Repeat("*", 10000))); err != nil {
+ t.Fatal(err)
+ }
+ return nil
+ }); err != nil {
+ t.Fatal(err)
}
- db.Update(func(tx *bolt.Tx) error {
- b, _ := tx.CreateBucketIfNotExists([]byte("woojits"))
- return b.Put(big_key, []byte(strings.Repeat("*", 10000)))
- })
db.MustCheck()
- db.View(func(tx *bolt.Tx) error {
- b := tx.Bucket([]byte("woojits"))
- stats := b.Stats()
- equals(t, 1, stats.BranchPageN)
- equals(t, 0, stats.BranchOverflowN)
- equals(t, 7, stats.LeafPageN)
- equals(t, 2, stats.LeafOverflowN)
- equals(t, 501, stats.KeyN)
- equals(t, 2, stats.Depth)
+
+ if err := db.View(func(tx *bolt.Tx) error {
+ stats := tx.Bucket([]byte("woojits")).Stats()
+ if stats.BranchPageN != 1 {
+ t.Fatalf("unexpected BranchPageN: %d", stats.BranchPageN)
+ } else if stats.BranchOverflowN != 0 {
+ t.Fatalf("unexpected BranchOverflowN: %d", stats.BranchOverflowN)
+ } else if stats.LeafPageN != 7 {
+ t.Fatalf("unexpected LeafPageN: %d", stats.LeafPageN)
+ } else if stats.LeafOverflowN != 2 {
+ t.Fatalf("unexpected LeafOverflowN: %d", stats.LeafOverflowN)
+ } else if stats.KeyN != 501 {
+ t.Fatalf("unexpected KeyN: %d", stats.KeyN)
+ } else if stats.Depth != 2 {
+ t.Fatalf("unexpected Depth: %d", stats.Depth)
+ }
branchInuse := 16 // branch page header
branchInuse += 7 * 16 // branch elements
branchInuse += 7 * 3 // branch keys (6 3-byte keys)
- equals(t, branchInuse, stats.BranchInuse)
+ if stats.BranchInuse != branchInuse {
+ t.Fatalf("unexpected BranchInuse: %d", stats.BranchInuse)
+ }
leafInuse := 7 * 16 // leaf page header
leafInuse += 501 * 16 // leaf elements
- leafInuse += 500*3 + len(big_key) // leaf keys
+ leafInuse += 500*3 + len(bigKey) // leaf keys
leafInuse += 1*10 + 2*90 + 3*400 + 10000 // leaf values
- equals(t, leafInuse, stats.LeafInuse)
+ if stats.LeafInuse != leafInuse {
+ t.Fatalf("unexpected LeafInuse: %d", stats.LeafInuse)
+ }
+ // Only check allocations for 4KB pages.
if os.Getpagesize() == 4096 {
- // Incompatible page size
- equals(t, 4096, stats.BranchAlloc)
- equals(t, 36864, stats.LeafAlloc)
+ if stats.BranchAlloc != 4096 {
+ t.Fatalf("unexpected BranchAlloc:", stats.BranchAlloc)
+ } else if stats.LeafAlloc != 36864 {
+ t.Fatalf("unexpected LeafAlloc:", stats.LeafAlloc)
+ }
+ }
+
+ if stats.BucketN != 1 {
+ t.Fatalf("unexpected BucketN:", stats.BucketN)
+ } else if stats.InlineBucketN != 0 {
+ t.Fatalf("unexpected InlineBucketN:", stats.InlineBucketN)
+ } else if stats.InlineBucketInuse != 0 {
+ t.Fatalf("unexpected InlineBucketInuse:", stats.InlineBucketInuse)
}
- equals(t, 1, stats.BucketN)
- equals(t, 0, stats.InlineBucketN)
- equals(t, 0, stats.InlineBucketInuse)
return nil
- })
+ }); err != nil {
+ t.Fatal(err)
+ }
}
// Ensure a bucket with random insertion utilizes fill percentage correctly.
@@ -717,150 +1146,251 @@ func TestBucket_Stats_RandomFill(t *testing.T) {
t.Skip("invalid page size for test")
}
- db := NewTestDB()
- defer db.Close()
+ db := MustOpenDB()
+ defer db.MustClose()
// Add a set of values in random order. It will be the same random
// order so we can maintain consistency between test runs.
var count int
- r := rand.New(rand.NewSource(42))
- for _, i := range r.Perm(1000) {
- db.Update(func(tx *bolt.Tx) error {
- b, _ := tx.CreateBucketIfNotExists([]byte("woojits"))
+ rand := rand.New(rand.NewSource(42))
+ for _, i := range rand.Perm(1000) {
+ if err := db.Update(func(tx *bolt.Tx) error {
+ b, err := tx.CreateBucketIfNotExists([]byte("woojits"))
+ if err != nil {
+ t.Fatal(err)
+ }
b.FillPercent = 0.9
- for _, j := range r.Perm(100) {
+ for _, j := range rand.Perm(100) {
index := (j * 10000) + i
- b.Put([]byte(fmt.Sprintf("%d000000000000000", index)), []byte("0000000000"))
+ if err := b.Put([]byte(fmt.Sprintf("%d000000000000000", index)), []byte("0000000000")); err != nil {
+ t.Fatal(err)
+ }
count++
}
return nil
- })
+ }); err != nil {
+ t.Fatal(err)
+ }
}
+
db.MustCheck()
- db.View(func(tx *bolt.Tx) error {
- s := tx.Bucket([]byte("woojits")).Stats()
- equals(t, 100000, s.KeyN)
+ if err := db.View(func(tx *bolt.Tx) error {
+ stats := tx.Bucket([]byte("woojits")).Stats()
+ if stats.KeyN != 100000 {
+ t.Fatalf("unexpected KeyN", stats.KeyN)
+ }
- equals(t, 98, s.BranchPageN)
- equals(t, 0, s.BranchOverflowN)
- equals(t, 130984, s.BranchInuse)
- equals(t, 401408, s.BranchAlloc)
+ if stats.BranchPageN != 98 {
+ t.Fatalf("unexpected BranchPageN", stats.BranchPageN)
+ } else if stats.BranchOverflowN != 0 {
+ t.Fatalf("unexpected BranchOverflowN", stats.BranchOverflowN)
+ } else if stats.BranchInuse != 130984 {
+ t.Fatalf("unexpected BranchInuse", stats.BranchInuse)
+ } else if stats.BranchAlloc != 401408 {
+ t.Fatalf("unexpected BranchAlloc", stats.BranchAlloc)
+ }
- equals(t, 3412, s.LeafPageN)
- equals(t, 0, s.LeafOverflowN)
- equals(t, 4742482, s.LeafInuse)
- equals(t, 13975552, s.LeafAlloc)
+ if stats.LeafPageN != 3412 {
+ t.Fatalf("unexpected LeafPageN", stats.LeafPageN)
+ } else if stats.LeafOverflowN != 0 {
+ t.Fatalf("unexpected LeafOverflowN", stats.LeafOverflowN)
+ } else if stats.LeafInuse != 4742482 {
+ t.Fatalf("unexpected LeafInuse", stats.LeafInuse)
+ } else if stats.LeafAlloc != 13975552 {
+ t.Fatalf("unexpected LeafAlloc", stats.LeafAlloc)
+ }
return nil
- })
+ }); err != nil {
+ t.Fatal(err)
+ }
}
// Ensure a bucket can calculate stats.
func TestBucket_Stats_Small(t *testing.T) {
- db := NewTestDB()
- defer db.Close()
- db.Update(func(tx *bolt.Tx) error {
+ db := MustOpenDB()
+ defer db.MustClose()
+
+ if err := db.Update(func(tx *bolt.Tx) error {
// Add a bucket that fits on a single root leaf.
b, err := tx.CreateBucket([]byte("whozawhats"))
- ok(t, err)
- b.Put([]byte("foo"), []byte("bar"))
+ if err != nil {
+ t.Fatal(err)
+ }
+ if err := b.Put([]byte("foo"), []byte("bar")); err != nil {
+ t.Fatal(err)
+ }
return nil
- })
+ }); err != nil {
+ t.Fatal(err)
+ }
+
db.MustCheck()
- db.View(func(tx *bolt.Tx) error {
+
+ if err := db.View(func(tx *bolt.Tx) error {
b := tx.Bucket([]byte("whozawhats"))
stats := b.Stats()
- equals(t, 0, stats.BranchPageN)
- equals(t, 0, stats.BranchOverflowN)
- equals(t, 0, stats.LeafPageN)
- equals(t, 0, stats.LeafOverflowN)
- equals(t, 1, stats.KeyN)
- equals(t, 1, stats.Depth)
- equals(t, 0, stats.BranchInuse)
- equals(t, 0, stats.LeafInuse)
+ if stats.BranchPageN != 0 {
+ t.Fatalf("unexpected BranchPageN: ", stats.BranchPageN)
+ } else if stats.BranchOverflowN != 0 {
+ t.Fatalf("unexpected BranchOverflowN: ", stats.BranchOverflowN)
+ } else if stats.LeafPageN != 0 {
+ t.Fatalf("unexpected LeafPageN: ", stats.LeafPageN)
+ } else if stats.LeafOverflowN != 0 {
+ t.Fatalf("unexpected LeafOverflowN: ", stats.LeafOverflowN)
+ } else if stats.KeyN != 1 {
+ t.Fatalf("unexpected KeyN: ", stats.KeyN)
+ } else if stats.Depth != 1 {
+ t.Fatalf("unexpected Depth: ", stats.Depth)
+ } else if stats.BranchInuse != 0 {
+ t.Fatalf("unexpected BranchInuse: ", stats.BranchInuse)
+ } else if stats.LeafInuse != 0 {
+ t.Fatalf("unexpected LeafInuse: ", stats.LeafInuse)
+ }
+
if os.Getpagesize() == 4096 {
- // Incompatible page size
- equals(t, 0, stats.BranchAlloc)
- equals(t, 0, stats.LeafAlloc)
+ if stats.BranchAlloc != 0 {
+ t.Fatalf("unexpected BranchAlloc: ", stats.BranchAlloc)
+ } else if stats.LeafAlloc != 0 {
+ t.Fatalf("unexpected LeafAlloc: ", stats.LeafAlloc)
+ }
+ }
+
+ if stats.BucketN != 1 {
+ t.Fatalf("unexpected BucketN: ", stats.BucketN)
+ } else if stats.InlineBucketN != 1 {
+ t.Fatalf("unexpected InlineBucketN: ", stats.InlineBucketN)
+ } else if stats.InlineBucketInuse != 16+16+6 {
+ t.Fatalf("unexpected InlineBucketInuse: ", stats.InlineBucketInuse)
}
- equals(t, 1, stats.BucketN)
- equals(t, 1, stats.InlineBucketN)
- equals(t, 16+16+6, stats.InlineBucketInuse)
+
return nil
- })
+ }); err != nil {
+ t.Fatal(err)
+ }
}
func TestBucket_Stats_EmptyBucket(t *testing.T) {
- db := NewTestDB()
- defer db.Close()
+ db := MustOpenDB()
+ defer db.MustClose()
- db.Update(func(tx *bolt.Tx) error {
+ if err := db.Update(func(tx *bolt.Tx) error {
// Add a bucket that fits on a single root leaf.
- _, err := tx.CreateBucket([]byte("whozawhats"))
- ok(t, err)
+ if _, err := tx.CreateBucket([]byte("whozawhats")); err != nil {
+ t.Fatal(err)
+ }
return nil
- })
+ }); err != nil {
+ t.Fatal(err)
+ }
+
db.MustCheck()
- db.View(func(tx *bolt.Tx) error {
+
+ if err := db.View(func(tx *bolt.Tx) error {
b := tx.Bucket([]byte("whozawhats"))
stats := b.Stats()
- equals(t, 0, stats.BranchPageN)
- equals(t, 0, stats.BranchOverflowN)
- equals(t, 0, stats.LeafPageN)
- equals(t, 0, stats.LeafOverflowN)
- equals(t, 0, stats.KeyN)
- equals(t, 1, stats.Depth)
- equals(t, 0, stats.BranchInuse)
- equals(t, 0, stats.LeafInuse)
+ if stats.BranchPageN != 0 {
+ t.Fatalf("unexpected BranchPageN: ", stats.BranchPageN)
+ } else if stats.BranchOverflowN != 0 {
+ t.Fatalf("unexpected BranchOverflowN: ", stats.BranchOverflowN)
+ } else if stats.LeafPageN != 0 {
+ t.Fatalf("unexpected LeafPageN: ", stats.LeafPageN)
+ } else if stats.LeafOverflowN != 0 {
+ t.Fatalf("unexpected LeafOverflowN: ", stats.LeafOverflowN)
+ } else if stats.KeyN != 0 {
+ t.Fatalf("unexpected KeyN: ", stats.KeyN)
+ } else if stats.Depth != 1 {
+ t.Fatalf("unexpected Depth: ", stats.Depth)
+ } else if stats.BranchInuse != 0 {
+ t.Fatalf("unexpected BranchInuse: ", stats.BranchInuse)
+ } else if stats.LeafInuse != 0 {
+ t.Fatalf("unexpected LeafInuse: ", stats.LeafInuse)
+ }
+
if os.Getpagesize() == 4096 {
- // Incompatible page size
- equals(t, 0, stats.BranchAlloc)
- equals(t, 0, stats.LeafAlloc)
+ if stats.BranchAlloc != 0 {
+ t.Fatalf("unexpected BranchAlloc: ", stats.BranchAlloc)
+ } else if stats.LeafAlloc != 0 {
+ t.Fatalf("unexpected LeafAlloc: ", stats.LeafAlloc)
+ }
+ }
+
+ if stats.BucketN != 1 {
+ t.Fatalf("unexpected BucketN: ", stats.BucketN)
+ } else if stats.InlineBucketN != 1 {
+ t.Fatalf("unexpected InlineBucketN: ", stats.InlineBucketN)
+ } else if stats.InlineBucketInuse != 16 {
+ t.Fatalf("unexpected InlineBucketInuse: ", stats.InlineBucketInuse)
}
- equals(t, 1, stats.BucketN)
- equals(t, 1, stats.InlineBucketN)
- equals(t, 16, stats.InlineBucketInuse)
+
return nil
- })
+ }); err != nil {
+ t.Fatal(err)
+ }
}
// Ensure a bucket can calculate stats.
func TestBucket_Stats_Nested(t *testing.T) {
- db := NewTestDB()
- defer db.Close()
+ db := MustOpenDB()
+ defer db.MustClose()
- db.Update(func(tx *bolt.Tx) error {
+ if err := db.Update(func(tx *bolt.Tx) error {
b, err := tx.CreateBucket([]byte("foo"))
- ok(t, err)
+ if err != nil {
+ t.Fatal(err)
+ }
for i := 0; i < 100; i++ {
- b.Put([]byte(fmt.Sprintf("%02d", i)), []byte(fmt.Sprintf("%02d", i)))
+ if err := b.Put([]byte(fmt.Sprintf("%02d", i)), []byte(fmt.Sprintf("%02d", i))); err != nil {
+ t.Fatal(err)
+ }
}
+
bar, err := b.CreateBucket([]byte("bar"))
- ok(t, err)
+ if err != nil {
+ t.Fatal(err)
+ }
for i := 0; i < 10; i++ {
- bar.Put([]byte(strconv.Itoa(i)), []byte(strconv.Itoa(i)))
+ if err := bar.Put([]byte(strconv.Itoa(i)), []byte(strconv.Itoa(i))); err != nil {
+ t.Fatal(err)
+ }
}
+
baz, err := bar.CreateBucket([]byte("baz"))
- ok(t, err)
+ if err != nil {
+ t.Fatal(err)
+ }
for i := 0; i < 10; i++ {
- baz.Put([]byte(strconv.Itoa(i)), []byte(strconv.Itoa(i)))
+ if err := baz.Put([]byte(strconv.Itoa(i)), []byte(strconv.Itoa(i))); err != nil {
+ t.Fatal(err)
+ }
}
+
return nil
- })
+ }); err != nil {
+ t.Fatal(err)
+ }
db.MustCheck()
- db.View(func(tx *bolt.Tx) error {
+ if err := db.View(func(tx *bolt.Tx) error {
b := tx.Bucket([]byte("foo"))
stats := b.Stats()
- equals(t, 0, stats.BranchPageN)
- equals(t, 0, stats.BranchOverflowN)
- equals(t, 2, stats.LeafPageN)
- equals(t, 0, stats.LeafOverflowN)
- equals(t, 122, stats.KeyN)
- equals(t, 3, stats.Depth)
- equals(t, 0, stats.BranchInuse)
+ if stats.BranchPageN != 0 {
+ t.Fatalf("unexpected BranchPageN: ", stats.BranchPageN)
+ } else if stats.BranchOverflowN != 0 {
+ t.Fatalf("unexpected BranchOverflowN: ", stats.BranchOverflowN)
+ } else if stats.LeafPageN != 2 {
+ t.Fatalf("unexpected LeafPageN: ", stats.LeafPageN)
+ } else if stats.LeafOverflowN != 0 {
+ t.Fatalf("unexpected LeafOverflowN: ", stats.LeafOverflowN)
+ } else if stats.KeyN != 122 {
+ t.Fatalf("unexpected KeyN: ", stats.KeyN)
+ } else if stats.Depth != 3 {
+ t.Fatalf("unexpected Depth: ", stats.Depth)
+ } else if stats.BranchInuse != 0 {
+ t.Fatalf("unexpected BranchInuse: ", stats.BranchInuse)
+ }
foo := 16 // foo (pghdr)
foo += 101 * 16 // foo leaf elements
@@ -876,17 +1406,30 @@ func TestBucket_Stats_Nested(t *testing.T) {
baz += 10 * 16 // baz leaf elements
baz += 10 + 10 // baz leaf key/values
- equals(t, foo+bar+baz, stats.LeafInuse)
+ if stats.LeafInuse != foo+bar+baz {
+ t.Fatalf("unexpected LeafInuse: ", stats.LeafInuse)
+ }
+
if os.Getpagesize() == 4096 {
- // Incompatible page size
- equals(t, 0, stats.BranchAlloc)
- equals(t, 8192, stats.LeafAlloc)
+ if stats.BranchAlloc != 0 {
+ t.Fatalf("unexpected BranchAlloc: ", stats.BranchAlloc)
+ } else if stats.LeafAlloc != 8192 {
+ t.Fatalf("unexpected LeafAlloc: ", stats.LeafAlloc)
+ }
}
- equals(t, 3, stats.BucketN)
- equals(t, 1, stats.InlineBucketN)
- equals(t, baz, stats.InlineBucketInuse)
+
+ if stats.BucketN != 3 {
+ t.Fatalf("unexpected BucketN: ", stats.BucketN)
+ } else if stats.InlineBucketN != 1 {
+ t.Fatalf("unexpected InlineBucketN: ", stats.InlineBucketN)
+ } else if stats.InlineBucketInuse != baz {
+ t.Fatalf("unexpected InlineBucketInuse: ", stats.InlineBucketInuse)
+ }
+
return nil
- })
+ }); err != nil {
+ t.Fatal(err)
+ }
}
// Ensure a large bucket can calculate stats.
@@ -895,44 +1438,71 @@ func TestBucket_Stats_Large(t *testing.T) {
t.Skip("skipping test in short mode.")
}
- db := NewTestDB()
- defer db.Close()
+ db := MustOpenDB()
+ defer db.MustClose()
var index int
for i := 0; i < 100; i++ {
- db.Update(func(tx *bolt.Tx) error {
- // Add bucket with lots of keys.
- b, _ := tx.CreateBucketIfNotExists([]byte("widgets"))
+ // Add bucket with lots of keys.
+ if err := db.Update(func(tx *bolt.Tx) error {
+ b, err := tx.CreateBucketIfNotExists([]byte("widgets"))
+ if err != nil {
+ t.Fatal(err)
+ }
for i := 0; i < 1000; i++ {
- b.Put([]byte(strconv.Itoa(index)), []byte(strconv.Itoa(index)))
+ if err := b.Put([]byte(strconv.Itoa(index)), []byte(strconv.Itoa(index))); err != nil {
+ t.Fatal(err)
+ }
index++
}
return nil
- })
+ }); err != nil {
+ t.Fatal(err)
+ }
}
+
db.MustCheck()
- db.View(func(tx *bolt.Tx) error {
- b := tx.Bucket([]byte("widgets"))
- stats := b.Stats()
- equals(t, 13, stats.BranchPageN)
- equals(t, 0, stats.BranchOverflowN)
- equals(t, 1196, stats.LeafPageN)
- equals(t, 0, stats.LeafOverflowN)
- equals(t, 100000, stats.KeyN)
- equals(t, 3, stats.Depth)
- equals(t, 25257, stats.BranchInuse)
- equals(t, 2596916, stats.LeafInuse)
+ if err := db.View(func(tx *bolt.Tx) error {
+ stats := tx.Bucket([]byte("widgets")).Stats()
+ if stats.BranchPageN != 13 {
+ t.Fatalf("unexpected BranchPageN: %d", stats.BranchPageN)
+ } else if stats.BranchOverflowN != 0 {
+ t.Fatalf("unexpected BranchOverflowN: %d", stats.BranchOverflowN)
+ } else if stats.LeafPageN != 1196 {
+ t.Fatalf("unexpected LeafPageN: %d", stats.LeafPageN)
+ } else if stats.LeafOverflowN != 0 {
+ t.Fatalf("unexpected LeafOverflowN: %d", stats.LeafOverflowN)
+ } else if stats.KeyN != 100000 {
+ t.Fatalf("unexpected KeyN: %d", stats.KeyN)
+ } else if stats.Depth != 3 {
+ t.Fatalf("unexpected Depth: %d", stats.Depth)
+ } else if stats.BranchInuse != 25257 {
+ t.Fatalf("unexpected BranchInuse: %d", stats.BranchInuse)
+ } else if stats.LeafInuse != 2596916 {
+ t.Fatalf("unexpected LeafInuse: %d", stats.LeafInuse)
+ }
+
if os.Getpagesize() == 4096 {
- // Incompatible page size
- equals(t, 53248, stats.BranchAlloc)
- equals(t, 4898816, stats.LeafAlloc)
+ if stats.BranchAlloc != 53248 {
+ t.Fatalf("unexpected BranchAlloc: %d", stats.BranchAlloc)
+ } else if stats.LeafAlloc != 4898816 {
+ t.Fatalf("unexpected LeafAlloc: %d", stats.LeafAlloc)
+ }
+ }
+
+ if stats.BucketN != 1 {
+ t.Fatalf("unexpected BucketN: %d", stats.BucketN)
+ } else if stats.InlineBucketN != 0 {
+ t.Fatalf("unexpected InlineBucketN: %d", stats.InlineBucketN)
+ } else if stats.InlineBucketInuse != 0 {
+ t.Fatalf("unexpected InlineBucketInuse: %d", stats.InlineBucketInuse)
}
- equals(t, 1, stats.BucketN)
- equals(t, 0, stats.InlineBucketN)
- equals(t, 0, stats.InlineBucketInuse)
+
return nil
- })
+ }); err != nil {
+ t.Fatal(err)
+ }
}
// Ensure that a bucket can write random keys and values across multiple transactions.
@@ -942,27 +1512,34 @@ func TestBucket_Put_Single(t *testing.T) {
}
index := 0
- f := func(items testdata) bool {
- db := NewTestDB()
- defer db.Close()
+ if err := quick.Check(func(items testdata) bool {
+ db := MustOpenDB()
+ defer db.MustClose()
m := make(map[string][]byte)
- db.Update(func(tx *bolt.Tx) error {
- _, err := tx.CreateBucket([]byte("widgets"))
- return err
- })
+ if err := db.Update(func(tx *bolt.Tx) error {
+ if _, err := tx.CreateBucket([]byte("widgets")); err != nil {
+ t.Fatal(err)
+ }
+ return nil
+ }); err != nil {
+ t.Fatal(err)
+ }
+
for _, item := range items {
- db.Update(func(tx *bolt.Tx) error {
+ if err := db.Update(func(tx *bolt.Tx) error {
if err := tx.Bucket([]byte("widgets")).Put(item.Key, item.Value); err != nil {
panic("put error: " + err.Error())
}
m[string(item.Key)] = item.Value
return nil
- })
+ }); err != nil {
+ t.Fatal(err)
+ }
// Verify all key/values so far.
- db.View(func(tx *bolt.Tx) error {
+ if err := db.View(func(tx *bolt.Tx) error {
i := 0
for k, v := range m {
value := tx.Bucket([]byte("widgets")).Get([]byte(k))
@@ -974,13 +1551,14 @@ func TestBucket_Put_Single(t *testing.T) {
i++
}
return nil
- })
+ }); err != nil {
+ t.Fatal(err)
+ }
}
index++
return true
- }
- if err := quick.Check(f, qconfig()); err != nil {
+ }, nil); err != nil {
t.Error(err)
}
}
@@ -991,25 +1569,34 @@ func TestBucket_Put_Multiple(t *testing.T) {
t.Skip("skipping test in short mode.")
}
- f := func(items testdata) bool {
- db := NewTestDB()
- defer db.Close()
+ if err := quick.Check(func(items testdata) bool {
+ db := MustOpenDB()
+ defer db.MustClose()
+
// Bulk insert all values.
- db.Update(func(tx *bolt.Tx) error {
- _, err := tx.CreateBucket([]byte("widgets"))
- return err
- })
- err := db.Update(func(tx *bolt.Tx) error {
+ if err := db.Update(func(tx *bolt.Tx) error {
+ if _, err := tx.CreateBucket([]byte("widgets")); err != nil {
+ t.Fatal(err)
+ }
+ return nil
+ }); err != nil {
+ t.Fatal(err)
+ }
+
+ if err := db.Update(func(tx *bolt.Tx) error {
b := tx.Bucket([]byte("widgets"))
for _, item := range items {
- ok(t, b.Put(item.Key, item.Value))
+ if err := b.Put(item.Key, item.Value); err != nil {
+ t.Fatal(err)
+ }
}
return nil
- })
- ok(t, err)
+ }); err != nil {
+ t.Fatal(err)
+ }
// Verify all items exist.
- db.View(func(tx *bolt.Tx) error {
+ if err := db.View(func(tx *bolt.Tx) error {
b := tx.Bucket([]byte("widgets"))
for _, item := range items {
value := b.Get(item.Key)
@@ -1019,10 +1606,12 @@ func TestBucket_Put_Multiple(t *testing.T) {
}
}
return nil
- })
+ }); err != nil {
+ t.Fatal(err)
+ }
+
return true
- }
- if err := quick.Check(f, qconfig()); err != nil {
+ }, qconfig()); err != nil {
t.Error(err)
}
}
@@ -1033,68 +1622,98 @@ func TestBucket_Delete_Quick(t *testing.T) {
t.Skip("skipping test in short mode.")
}
- f := func(items testdata) bool {
- db := NewTestDB()
- defer db.Close()
+ if err := quick.Check(func(items testdata) bool {
+ db := MustOpenDB()
+ defer db.MustClose()
+
// Bulk insert all values.
- db.Update(func(tx *bolt.Tx) error {
- _, err := tx.CreateBucket([]byte("widgets"))
- return err
- })
- err := db.Update(func(tx *bolt.Tx) error {
+ if err := db.Update(func(tx *bolt.Tx) error {
+ if _, err := tx.CreateBucket([]byte("widgets")); err != nil {
+ t.Fatal(err)
+ }
+ return nil
+ }); err != nil {
+ t.Fatal(err)
+ }
+
+ if err := db.Update(func(tx *bolt.Tx) error {
b := tx.Bucket([]byte("widgets"))
for _, item := range items {
- ok(t, b.Put(item.Key, item.Value))
+ if err := b.Put(item.Key, item.Value); err != nil {
+ t.Fatal(err)
+ }
}
return nil
- })
- ok(t, err)
+ }); err != nil {
+ t.Fatal(err)
+ }
// Remove items one at a time and check consistency.
for _, item := range items {
- err := db.Update(func(tx *bolt.Tx) error {
+ if err := db.Update(func(tx *bolt.Tx) error {
return tx.Bucket([]byte("widgets")).Delete(item.Key)
- })
- ok(t, err)
+ }); err != nil {
+ t.Fatal(err)
+ }
}
// Anything before our deletion index should be nil.
- db.View(func(tx *bolt.Tx) error {
- tx.Bucket([]byte("widgets")).ForEach(func(k, v []byte) error {
+ if err := db.View(func(tx *bolt.Tx) error {
+ if err := tx.Bucket([]byte("widgets")).ForEach(func(k, v []byte) error {
t.Fatalf("bucket should be empty; found: %06x", trunc(k, 3))
return nil
- })
+ }); err != nil {
+ t.Fatal(err)
+ }
return nil
- })
+ }); err != nil {
+ t.Fatal(err)
+ }
+
return true
- }
- if err := quick.Check(f, qconfig()); err != nil {
+ }, qconfig()); err != nil {
t.Error(err)
}
}
func ExampleBucket_Put() {
// Open the database.
- db, _ := bolt.Open(tempfile(), 0666, nil)
+ db, err := bolt.Open(tempfile(), 0666, nil)
+ if err != nil {
+ log.Fatal(err)
+ }
defer os.Remove(db.Path())
- defer db.Close()
// Start a write transaction.
- db.Update(func(tx *bolt.Tx) error {
+ if err := db.Update(func(tx *bolt.Tx) error {
// Create a bucket.
- tx.CreateBucket([]byte("widgets"))
+ b, err := tx.CreateBucket([]byte("widgets"))
+ if err != nil {
+ return err
+ }
// Set the value "bar" for the key "foo".
- tx.Bucket([]byte("widgets")).Put([]byte("foo"), []byte("bar"))
+ if err := b.Put([]byte("foo"), []byte("bar")); err != nil {
+ return err
+ }
return nil
- })
+ }); err != nil {
+ log.Fatal(err)
+ }
// Read value back in a different read-only transaction.
- db.View(func(tx *bolt.Tx) error {
+ if err := db.View(func(tx *bolt.Tx) error {
value := tx.Bucket([]byte("widgets")).Get([]byte("foo"))
fmt.Printf("The value of 'foo' is: %s\n", value)
return nil
- })
+ }); err != nil {
+ log.Fatal(err)
+ }
+
+ // Close database to release file lock.
+ if err := db.Close(); err != nil {
+ log.Fatal(err)
+ }
// Output:
// The value of 'foo' is: bar
@@ -1102,38 +1721,56 @@ func ExampleBucket_Put() {
func ExampleBucket_Delete() {
// Open the database.
- db, _ := bolt.Open(tempfile(), 0666, nil)
+ db, err := bolt.Open(tempfile(), 0666, nil)
+ if err != nil {
+ log.Fatal(err)
+ }
defer os.Remove(db.Path())
- defer db.Close()
// Start a write transaction.
- db.Update(func(tx *bolt.Tx) error {
+ if err := db.Update(func(tx *bolt.Tx) error {
// Create a bucket.
- tx.CreateBucket([]byte("widgets"))
- b := tx.Bucket([]byte("widgets"))
+ b, err := tx.CreateBucket([]byte("widgets"))
+ if err != nil {
+ return err
+ }
// Set the value "bar" for the key "foo".
- b.Put([]byte("foo"), []byte("bar"))
+ if err := b.Put([]byte("foo"), []byte("bar")); err != nil {
+ return err
+ }
// Retrieve the key back from the database and verify it.
value := b.Get([]byte("foo"))
fmt.Printf("The value of 'foo' was: %s\n", value)
+
return nil
- })
+ }); err != nil {
+ log.Fatal(err)
+ }
// Delete the key in a different write transaction.
- db.Update(func(tx *bolt.Tx) error {
+ if err := db.Update(func(tx *bolt.Tx) error {
return tx.Bucket([]byte("widgets")).Delete([]byte("foo"))
- })
+ }); err != nil {
+ log.Fatal(err)
+ }
// Retrieve the key again.
- db.View(func(tx *bolt.Tx) error {
+ if err := db.View(func(tx *bolt.Tx) error {
value := tx.Bucket([]byte("widgets")).Get([]byte("foo"))
if value == nil {
fmt.Printf("The value of 'foo' is now: nil\n")
}
return nil
- })
+ }); err != nil {
+ log.Fatal(err)
+ }
+
+ // Close database to release file lock.
+ if err := db.Close(); err != nil {
+ log.Fatal(err)
+ }
// Output:
// The value of 'foo' was: bar
@@ -1142,25 +1779,46 @@ func ExampleBucket_Delete() {
func ExampleBucket_ForEach() {
// Open the database.
- db, _ := bolt.Open(tempfile(), 0666, nil)
+ db, err := bolt.Open(tempfile(), 0666, nil)
+ if err != nil {
+ log.Fatal(err)
+ }
defer os.Remove(db.Path())
- defer db.Close()
// Insert data into a bucket.
- db.Update(func(tx *bolt.Tx) error {
- tx.CreateBucket([]byte("animals"))
- b := tx.Bucket([]byte("animals"))
- b.Put([]byte("dog"), []byte("fun"))
- b.Put([]byte("cat"), []byte("lame"))
- b.Put([]byte("liger"), []byte("awesome"))
+ if err := db.Update(func(tx *bolt.Tx) error {
+ b, err := tx.CreateBucket([]byte("animals"))
+ if err != nil {
+ return err
+ }
+
+ if err := b.Put([]byte("dog"), []byte("fun")); err != nil {
+ return err
+ }
+ if err := b.Put([]byte("cat"), []byte("lame")); err != nil {
+ return err
+ }
+ if err := b.Put([]byte("liger"), []byte("awesome")); err != nil {
+ return err
+ }
// Iterate over items in sorted key order.
- b.ForEach(func(k, v []byte) error {
+ if err := b.ForEach(func(k, v []byte) error {
fmt.Printf("A %s is %s.\n", k, v)
return nil
- })
+ }); err != nil {
+ return err
+ }
+
return nil
- })
+ }); err != nil {
+ log.Fatal(err)
+ }
+
+ // Close database to release file lock.
+ if err := db.Close(); err != nil {
+ log.Fatal(err)
+ }
// Output:
// A cat is lame.
generated by cgit v1.2.3 (git 2.49.0) at 2025-07-13 20:40:10 +0000