github.com/MetalBlockchain/metalgo@v1.11.9/database/pebbledb/db_test.go (about)

     1  // Copyright (C) 2019-2024, Ava Labs, Inc. All rights reserved.
     2  // See the file LICENSE for licensing terms.
     3  
     4  package pebbledb
     5  
     6  import (
     7  	"fmt"
     8  	"testing"
     9  
    10  	"github.com/prometheus/client_golang/prometheus"
    11  	"github.com/stretchr/testify/require"
    12  
    13  	"github.com/MetalBlockchain/metalgo/database"
    14  	"github.com/MetalBlockchain/metalgo/utils/logging"
    15  )
    16  
    17  func newDB(t testing.TB) *Database {
    18  	folder := t.TempDir()
    19  	db, err := New(folder, nil, logging.NoLog{}, prometheus.NewRegistry())
    20  	require.NoError(t, err)
    21  	return db.(*Database)
    22  }
    23  
    24  func TestInterface(t *testing.T) {
    25  	for name, test := range database.Tests {
    26  		t.Run(name, func(t *testing.T) {
    27  			db := newDB(t)
    28  			test(t, db)
    29  			_ = db.Close()
    30  		})
    31  	}
    32  }
    33  
    34  func FuzzKeyValue(f *testing.F) {
    35  	db := newDB(f)
    36  	database.FuzzKeyValue(f, db)
    37  	_ = db.Close()
    38  }
    39  
    40  func FuzzNewIteratorWithPrefix(f *testing.F) {
    41  	db := newDB(f)
    42  	database.FuzzNewIteratorWithPrefix(f, db)
    43  	_ = db.Close()
    44  }
    45  
    46  func FuzzNewIteratorWithStartAndPrefix(f *testing.F) {
    47  	db := newDB(f)
    48  	database.FuzzNewIteratorWithStartAndPrefix(f, db)
    49  	_ = db.Close()
    50  }
    51  
    52  func BenchmarkInterface(b *testing.B) {
    53  	for _, size := range database.BenchmarkSizes {
    54  		keys, values := database.SetupBenchmark(b, size[0], size[1], size[2])
    55  		for name, bench := range database.Benchmarks {
    56  			b.Run(fmt.Sprintf("pebble_%d_pairs_%d_keys_%d_values_%s", size[0], size[1], size[2], name), func(b *testing.B) {
    57  				db := newDB(b)
    58  				bench(b, db, keys, values)
    59  				_ = db.Close()
    60  			})
    61  		}
    62  	}
    63  }
    64  
    65  func TestKeyRange(t *testing.T) {
    66  	type test struct {
    67  		start         []byte
    68  		prefix        []byte
    69  		expectedLower []byte
    70  		expectedUpper []byte
    71  	}
    72  
    73  	tests := []test{
    74  		{
    75  			start:         nil,
    76  			prefix:        nil,
    77  			expectedLower: nil,
    78  			expectedUpper: nil,
    79  		},
    80  		{
    81  			start:         nil,
    82  			prefix:        []byte{},
    83  			expectedLower: []byte{},
    84  			expectedUpper: nil,
    85  		},
    86  		{
    87  			start:         nil,
    88  			prefix:        []byte{0x00},
    89  			expectedLower: []byte{0x00},
    90  			expectedUpper: []byte{0x01},
    91  		},
    92  		{
    93  			start:         []byte{0x00, 0x02},
    94  			prefix:        []byte{0x00},
    95  			expectedLower: []byte{0x00, 0x02},
    96  			expectedUpper: []byte{0x01},
    97  		},
    98  		{
    99  			start:         []byte{0x01},
   100  			prefix:        []byte{0x00},
   101  			expectedLower: []byte{0x01},
   102  			expectedUpper: []byte{0x01},
   103  		},
   104  		{
   105  			start:         nil,
   106  			prefix:        []byte{0x01},
   107  			expectedLower: []byte{0x01},
   108  			expectedUpper: []byte{0x02},
   109  		},
   110  		{
   111  			start:         nil,
   112  			prefix:        []byte{0xFF},
   113  			expectedLower: []byte{0xFF},
   114  			expectedUpper: nil,
   115  		},
   116  		{
   117  			start:         []byte{0x00},
   118  			prefix:        []byte{0xFF},
   119  			expectedLower: []byte{0xFF},
   120  			expectedUpper: nil,
   121  		},
   122  		{
   123  			start:         nil,
   124  			prefix:        []byte{0x01, 0x02},
   125  			expectedLower: []byte{0x01, 0x02},
   126  			expectedUpper: []byte{0x01, 0x03},
   127  		},
   128  		{
   129  			start:         []byte{0x01, 0x02},
   130  			prefix:        []byte{0x01, 0x02},
   131  			expectedLower: []byte{0x01, 0x02},
   132  			expectedUpper: []byte{0x01, 0x03},
   133  		},
   134  		{
   135  			start:         []byte{0x01, 0x02, 0x05},
   136  			prefix:        []byte{0x01, 0x02},
   137  			expectedLower: []byte{0x01, 0x02, 0x05},
   138  			expectedUpper: []byte{0x01, 0x03},
   139  		},
   140  		{
   141  			start:         nil,
   142  			prefix:        []byte{0x01, 0x02, 0xFF},
   143  			expectedLower: []byte{0x01, 0x02, 0xFF},
   144  			expectedUpper: []byte{0x01, 0x03},
   145  		},
   146  	}
   147  
   148  	for _, tt := range tests {
   149  		t.Run(string(tt.start)+" "+string(tt.prefix), func(t *testing.T) {
   150  			require := require.New(t)
   151  			bounds := keyRange(tt.start, tt.prefix)
   152  			require.Equal(tt.expectedLower, bounds.LowerBound)
   153  			require.Equal(tt.expectedUpper, bounds.UpperBound)
   154  		})
   155  	}
   156  }