Continue PR #96 (Fix result from stringToChar() is not null terminated)

compaction_filter.go

@@ -23,21 +23,24 @@ type CompactionFilter interface {
 
 	// The name of the compaction filter, for logging
 	Name() string
+	CName() *C.char
 }
 
 // NewNativeCompactionFilter creates a CompactionFilter object.
 func NewNativeCompactionFilter(c *C.rocksdb_compactionfilter_t) CompactionFilter {
-	return nativeCompactionFilter{c}
+	return nativeCompactionFilter{c, C.CString("")}
 }
 
 type nativeCompactionFilter struct {
-	c *C.rocksdb_compactionfilter_t
+	c     *C.rocksdb_compactionfilter_t
+	cname *C.char
 }
 
 func (c nativeCompactionFilter) Filter(level int, key, val []byte) (remove bool, newVal []byte) {
 	return false, nil
 }
-func (c nativeCompactionFilter) Name() string { return "" }
+func (c nativeCompactionFilter) Name() string   { return "" }
+func (c nativeCompactionFilter) CName() *C.char { return c.cname }
 
 // Hold references to compaction filters.
 var compactionFilters = NewCOWList()
@@ -64,5 +67,5 @@ func gorocksdb_compactionfilter_filter(idx int, cLevel C.int, cKey *C.char, cKey
 
 //export gorocksdb_compactionfilter_name
 func gorocksdb_compactionfilter_name(idx int) *C.char {
-	return stringToChar(compactionFilters.Get(idx).(CompactionFilter).Name())
+	return compactionFilters.Get(idx).(CompactionFilter).CName()
 }

compaction_filter_test.go

@@ -15,18 +15,16 @@ func TestCompactionFilter(t *testing.T) {
 		deleteKey    = []byte("delete")
 	)
 	db := newTestDB(t, "TestCompactionFilter", func(opts *Options) {
-		opts.SetCompactionFilter(&mockCompactionFilter{
-			filter: func(level int, key, val []byte) (remove bool, newVal []byte) {
-				if bytes.Equal(key, changeKey) {
-					return false, changeValNew
-				}
-				if bytes.Equal(key, deleteKey) {
-					return true, val
-				}
-				t.Errorf("key %q not expected during compaction", key)
-				return false, nil
-			},
-		})
+		opts.SetCompactionFilter(NewMockCompactionFilter(func(level int, key, val []byte) (remove bool, newVal []byte) {
+			if bytes.Equal(key, changeKey) {
+				return false, changeValNew
+			}
+			if bytes.Equal(key, deleteKey) {
+				return true, val
+			}
+			t.Errorf("key %q not expected during compaction", key)
+			return false, nil
+		}))
 	})
 	defer db.Close()
 
@@ -51,11 +49,7 @@ func TestCompactionFilter(t *testing.T) {
 	ensure.True(t, v2.Data() == nil)
 }
 
-type mockCompactionFilter struct {
-	filter func(level int, key, val []byte) (remove bool, newVal []byte)
-}
-
-func (m *mockCompactionFilter) Name() string { return "gorocksdb.test" }
-func (m *mockCompactionFilter) Filter(level int, key, val []byte) (bool, []byte) {
-	return m.filter(level, key, val)
+func TestCompactionFilterName(t *testing.T) {
+	cf := NewMockCompactionFilter(nil)
+	ensure.DeepEqual(t, cf.Name(), GetCName(cf.CName()))
 }

compaction_filter_test_mockstub.go

@@ -0,0 +1,21 @@
+package gorocksdb
+
+import "C"
+
+func NewMockCompactionFilter(f func(level int, key, val []byte) (remove bool, newVal []byte)) CompactionFilter {
+	return &mockCompactionFilter{
+		filter: f,
+	}
+}
+
+type mockCompactionFilter struct {
+	filter func(level int, key, val []byte) (remove bool, newVal []byte)
+}
+
+func (m *mockCompactionFilter) Name() string   { return "gorocksdb.test" }
+func (m *mockCompactionFilter) CName() *C.char { return C.CString("gorocksdb.test") }
+func (m *mockCompactionFilter) Filter(level int, key, val []byte) (bool, []byte) {
+	return m.filter(level, key, val)
+}
+
+func GetCName(c *C.char) string { return C.GoString(c) }

comparator.go

@@ -14,19 +14,22 @@ type Comparator interface {
 
 	// The name of the comparator.
 	Name() string
+	CName() *C.char
 }
 
 // NewNativeComparator creates a Comparator object.
 func NewNativeComparator(c *C.rocksdb_comparator_t) Comparator {
-	return nativeComparator{c}
+	return nativeComparator{c, C.CString("")}
 }
 
 type nativeComparator struct {
-	c *C.rocksdb_comparator_t
+	c     *C.rocksdb_comparator_t
+	cname *C.char
 }
 
 func (c nativeComparator) Compare(a, b []byte) int { return 0 }
 func (c nativeComparator) Name() string            { return "" }
+func (c nativeComparator) CName() *C.char          { return c.cname }
 
 // Hold references to comperators.
 var comperators = NewCOWList()
@@ -44,5 +47,5 @@ func gorocksdb_comparator_compare(idx int, cKeyA *C.char, cKeyALen C.size_t, cKe
 
 //export gorocksdb_comparator_name
 func gorocksdb_comparator_name(idx int) *C.char {
-	return stringToChar(comperators.Get(idx).(Comparator).Name())
+	return comperators.Get(idx).(Comparator).CName()
 }

comparator_test.go

@@ -1,15 +1,14 @@
 package gorocksdb
 
 import (
-	"bytes"
 	"testing"
 
 	"github.com/facebookgo/ensure"
 )
 
 func TestComparator(t *testing.T) {
 	db := newTestDB(t, "TestComparator", func(opts *Options) {
-		opts.SetComparator(&bytesReverseComparator{})
+		opts.SetComparator(NewMockBytesReverseComparator())
 	})
 	defer db.Close()
 
@@ -38,10 +37,3 @@ func TestComparator(t *testing.T) {
 	// ensure that the order is correct
 	ensure.DeepEqual(t, actualKeys, givenKeys)
 }
-
-type bytesReverseComparator struct{}
-
-func (cmp *bytesReverseComparator) Name() string { return "gorocksdb.bytes-reverse" }
-func (cmp *bytesReverseComparator) Compare(a, b []byte) int {
-	return bytes.Compare(a, b) * -1
-}

comparator_test_mockstub.go

@@ -0,0 +1,16 @@
+package gorocksdb
+
+import "bytes"
+import "C"
+
+func NewMockBytesReverseComparator() Comparator {
+	return &bytesReverseComparator{}
+}
+
+type bytesReverseComparator struct{}
+
+func (cmp *bytesReverseComparator) Name() string   { return "gorocksdb.bytes-reverse" }
+func (cmp *bytesReverseComparator) CName() *C.char { return C.CString("gorocksdb.bytes-reverse") }
+func (cmp *bytesReverseComparator) Compare(a, b []byte) int {
+	return bytes.Compare(a, b) * -1
+}

filter_policy.go

@@ -19,20 +19,23 @@ type FilterPolicy interface {
 
 	// Return the name of this policy.
 	Name() string
+	CName() *C.char
 }
 
 // NewNativeFilterPolicy creates a FilterPolicy object.
 func NewNativeFilterPolicy(c *C.rocksdb_filterpolicy_t) FilterPolicy {
-	return nativeFilterPolicy{c}
+	return nativeFilterPolicy{c, C.CString("")}
 }
 
 type nativeFilterPolicy struct {
-	c *C.rocksdb_filterpolicy_t
+	c     *C.rocksdb_filterpolicy_t
+	cname *C.char
 }
 
 func (fp nativeFilterPolicy) CreateFilter(keys [][]byte) []byte          { return nil }
 func (fp nativeFilterPolicy) KeyMayMatch(key []byte, filter []byte) bool { return false }
 func (fp nativeFilterPolicy) Name() string                               { return "" }
+func (fp nativeFilterPolicy) CName() *C.char                             { return fp.cname }
 
 // NewBloomFilter returns a new filter policy that uses a bloom filter with approximately
 // the specified number of bits per key.  A good value for bits_per_key
@@ -79,5 +82,5 @@ func gorocksdb_filterpolicy_key_may_match(idx int, cKey *C.char, cKeyLen C.size_
 
 //export gorocksdb_filterpolicy_name
 func gorocksdb_filterpolicy_name(idx int) *C.char {
-	return stringToChar(filterPolicies.Get(idx).(FilterPolicy).Name())
+	return filterPolicies.Get(idx).(FilterPolicy).CName()
 }

filter_policy_test.go

@@ -23,19 +23,18 @@ func TestFilterPolicy(t *testing.T) {
 		createFilterCalled = false
 		keyMayMatchCalled  = false
 	)
-	policy := &mockFilterPolicy{
-		createFilter: func(keys [][]byte) []byte {
+	policy := NewMockFilterPolicy(
+		func(keys [][]byte) []byte {
 			createFilterCalled = true
 			ensure.DeepEqual(&fatalAsError{t}, keys, givenKeys)
 			return givenFilter
 		},
-		keyMayMatch: func(key, filter []byte) bool {
+		func(key, filter []byte) bool {
 			keyMayMatchCalled = true
 			ensure.DeepEqual(&fatalAsError{t}, key, givenKeys[0])
 			ensure.DeepEqual(&fatalAsError{t}, filter, givenFilter)
 			return true
-		},
-	}
+		})
 
 	db := newTestDB(t, "TestFilterPolicy", func(opts *Options) {
 		blockOpts := NewDefaultBlockBasedTableOptions()
@@ -61,16 +60,3 @@ func TestFilterPolicy(t *testing.T) {
 	ensure.Nil(t, err)
 	ensure.True(t, keyMayMatchCalled)
 }
-
-type mockFilterPolicy struct {
-	createFilter func(keys [][]byte) []byte
-	keyMayMatch  func(key, filter []byte) bool
-}
-
-func (m *mockFilterPolicy) Name() string { return "gorocksdb.test" }
-func (m *mockFilterPolicy) CreateFilter(keys [][]byte) []byte {
-	return m.createFilter(keys)
-}
-func (m *mockFilterPolicy) KeyMayMatch(key, filter []byte) bool {
-	return m.keyMayMatch(key, filter)
-}

filter_policy_test_mockstub.go

@@ -0,0 +1,21 @@
+package gorocksdb
+
+import "C"
+
+func NewMockFilterPolicy(cf func(keys [][]byte) []byte, kmm func(key, filter []byte) bool) FilterPolicy {
+	return &mockFilterPolicy{cf, kmm}
+}
+
+type mockFilterPolicy struct {
+	createFilter func(keys [][]byte) []byte
+	keyMayMatch  func(key, filter []byte) bool
+}
+
+func (m *mockFilterPolicy) Name() string   { return "gorocksdb.test" }
+func (m *mockFilterPolicy) CName() *C.char { return C.CString("gorocksdb.test") }
+func (m *mockFilterPolicy) CreateFilter(keys [][]byte) []byte {
+	return m.createFilter(keys)
+}
+func (m *mockFilterPolicy) KeyMayMatch(key, filter []byte) bool {
+	return m.keyMayMatch(key, filter)
+}

merge_operator.go

@@ -45,15 +45,17 @@ type MergeOperator interface {
 
 	// The name of the MergeOperator.
 	Name() string
+	CName() *C.char
 }
 
 // NewNativeMergeOperator creates a MergeOperator object.
 func NewNativeMergeOperator(c *C.rocksdb_mergeoperator_t) MergeOperator {
-	return nativeMergeOperator{c}
+	return nativeMergeOperator{c, C.CString("")}
 }
 
 type nativeMergeOperator struct {
-	c *C.rocksdb_mergeoperator_t
+	c     *C.rocksdb_mergeoperator_t
+	cname *C.char
 }
 
 func (mo nativeMergeOperator) FullMerge(key, existingValue []byte, operands [][]byte) ([]byte, bool) {
@@ -62,7 +64,8 @@ func (mo nativeMergeOperator) FullMerge(key, existingValue []byte, operands [][]
 func (mo nativeMergeOperator) PartialMerge(key, leftOperand, rightOperand []byte) ([]byte, bool) {
 	return nil, false
 }
-func (mo nativeMergeOperator) Name() string { return "" }
+func (mo nativeMergeOperator) Name() string   { return "" }
+func (mo nativeMergeOperator) CName() *C.char { return mo.cname }
 
 // Hold references to merge operators.
 var mergeOperators = NewCOWList()
@@ -123,5 +126,5 @@ func gorocksdb_mergeoperator_partial_merge_multi(idx int, cKey *C.char, cKeyLen
 
 //export gorocksdb_mergeoperator_name
 func gorocksdb_mergeoperator_name(idx int) *C.char {
-	return stringToChar(mergeOperators.Get(idx).(MergeOperator).Name())
+	return mergeOperators.Get(idx).(MergeOperator).CName()
 }

merge_operator_test.go

@@ -13,14 +13,13 @@ func TestMergeOperator(t *testing.T) {
 		givenVal2   = []byte("bar")
 		givenMerged = []byte("foobar")
 	)
-	merger := &mockMergeOperator{
-		fullMerge: func(key, existingValue []byte, operands [][]byte) ([]byte, bool) {
-			ensure.DeepEqual(&fatalAsError{t}, key, givenKey)
-			ensure.DeepEqual(&fatalAsError{t}, existingValue, givenVal1)
-			ensure.DeepEqual(&fatalAsError{t}, operands, [][]byte{givenVal2})
-			return givenMerged, true
-		},
-	}
+	merger := NewMockMergeOperator(func(key, existingValue []byte, operands [][]byte) ([]byte, bool) {
+		ensure.DeepEqual(&fatalAsError{t}, key, givenKey)
+		ensure.DeepEqual(&fatalAsError{t}, existingValue, givenVal1)
+		ensure.DeepEqual(&fatalAsError{t}, operands, [][]byte{givenVal2})
+		return givenMerged, true
+	}, nil)
+
 	db := newTestDB(t, "TestMergeOperator", func(opts *Options) {
 		opts.SetMergeOperator(merger)
 	})
@@ -39,16 +38,3 @@ func TestMergeOperator(t *testing.T) {
 	ensure.Nil(t, err)
 	ensure.DeepEqual(t, v1.Data(), givenMerged)
 }
-
-type mockMergeOperator struct {
-	fullMerge    func(key, existingValue []byte, operands [][]byte) ([]byte, bool)
-	partialMerge func(key, leftOperand, rightOperand []byte) ([]byte, bool)
-}
-
-func (m *mockMergeOperator) Name() string { return "gorocksdb.test" }
-func (m *mockMergeOperator) FullMerge(key, existingValue []byte, operands [][]byte) ([]byte, bool) {
-	return m.fullMerge(key, existingValue, operands)
-}
-func (m *mockMergeOperator) PartialMerge(key, leftOperand, rightOperand []byte) ([]byte, bool) {
-	return m.partialMerge(key, leftOperand, rightOperand)
-}

merge_operator_test_mockstub.go

@@ -0,0 +1,21 @@
+package gorocksdb
+
+import "C"
+
+func NewMockMergeOperator(fm func(key, existingValue []byte, operands [][]byte) ([]byte, bool), pm func(key, leftOperand, rightOperand []byte) ([]byte, bool)) MergeOperator {
+	return &mockMergeOperator{fm, pm}
+}
+
+type mockMergeOperator struct {
+	fullMerge    func(key, existingValue []byte, operands [][]byte) ([]byte, bool)
+	partialMerge func(key, leftOperand, rightOperand []byte) ([]byte, bool)
+}
+
+func (m *mockMergeOperator) Name() string   { return "gorocksdb.test" }
+func (m *mockMergeOperator) CName() *C.char { return C.CString("gorocksdb.test") }
+func (m *mockMergeOperator) FullMerge(key, existingValue []byte, operands [][]byte) ([]byte, bool) {
+	return m.fullMerge(key, existingValue, operands)
+}
+func (m *mockMergeOperator) PartialMerge(key, leftOperand, rightOperand []byte) ([]byte, bool) {
+	return m.partialMerge(key, leftOperand, rightOperand)
+}