Merge pull request #56 from kortschak/testing

Tabulate value comparison tests

graph/iterator/value_comparison_iterator_test.go

@@ -15,6 +15,7 @@
 package iterator
 
 import (
+	"reflect"
 	"testing"
 
 	"github.com/google/cayley/graph"
@@ -30,78 +31,94 @@ func simpleFixedIterator() *Fixed {
 	return f
 }
 
-func checkIteratorContains(ts graph.TripleStore, it graph.Iterator, expected []string, t *testing.T) {
+var comparisonTests = []struct {
-	var actual []string
+	message  string
-	actual = nil
+	operand  graph.Value
-	for {
+	operator Operator
-		val, ok := it.Next()
+	expect   []string
-		if !ok {
+}{
-			break
+	{
-		}
+		message:  "successful int64 less than comparison",
-		actual = append(actual, ts.NameOf(val))
+		operand:  int64(3),
-	}
+		operator: kCompareLT,
-	actualSet := actual[:]
+		expect:   []string{"0", "1", "2"},
-	for _, a := range expected {
+	},
-		found := false
+	{
-		for j, b := range actualSet {
+		message:  "empty int64 less than comparison",
-			if a == b {
+		operand:  int64(0),
-				actualSet = append(actualSet[:j], actualSet[j+1:]...)
+		operator: kCompareLT,
-				found = true
+		expect:   nil,
+	},
+	{
+		message:  "successful int64 greater than comparison",
+		operand:  int64(2),
+		operator: kCompareGT,
+		expect:   []string{"3", "4"},
+	},
+	{
+		message:  "successful int64 greater than or equal comparison",
+		operand:  int64(2),
+		operator: kCompareGTE,
+		expect:   []string{"2", "3", "4"},
+	},
+}
+
+func TestValueComparison(t *testing.T) {
+	for _, test := range comparisonTests {
+		ts := simpleStore
+		vc := NewComparison(simpleFixedIterator(), test.operator, test.operand, ts)
+
+		var got []string
+		for {
+			val, ok := vc.Next()
+			if !ok {
 				break
 			}
+			got = append(got, ts.NameOf(val))
 		}
-		if !found {
+		if !reflect.DeepEqual(got, test.expect) {
-			t.Error("Couldn't find", a, "in actual output.\nActual:", actual, "\nExpected: ", expected, "\nRemainder: ", actualSet)
+			t.Errorf("Failed to show %s, got:%q expect:%q", test.message, got, test.expect)
-			return
 		}
 	}
-	if len(actualSet) != 0 {
-		t.Error("Actual output has more than expected.\nActual:", actual, "\nExpected: ", expected, "\nRemainder: ", actualSet)
-	}
 }
 
-func TestWorkingIntValueComparison(t *testing.T) {
+var vciCheckTests = []struct {
-	ts := simpleStore
+	message  string
-	fixed := simpleFixedIterator()
+	operator Operator
-	vc := NewComparison(fixed, kCompareLT, int64(3), ts)
+	check    graph.Value
-	checkIteratorContains(ts, vc, []string{"0", "1", "2"}, t)
+	expect   bool
-}
+}{
-
+	{
-func TestFailingIntValueComparison(t *testing.T) {
+		message:  "1 is less than 2",
-	ts := simpleStore
+		operator: kCompareGTE,
-	fixed := simpleFixedIterator()
+		check:    1,
-	vc := NewComparison(fixed, kCompareLT, int64(0), ts)
+		expect:   false,
-	checkIteratorContains(ts, vc, []string{}, t)
+	},
-}
+	{
-
+		message:  "2 is greater than or equal to 2",
-func TestWorkingGT(t *testing.T) {
+		operator: kCompareGTE,
-	ts := simpleStore
+		check:    2,
-	fixed := simpleFixedIterator()
+		expect:   true,
-	vc := NewComparison(fixed, kCompareGT, int64(2), ts)
+	},
-	checkIteratorContains(ts, vc, []string{"3", "4"}, t)
+	{
-}
+		message:  "3 is greater than or equal to 2",
-
+		operator: kCompareGTE,
-func TestWorkingGTE(t *testing.T) {
+		check:    3,
-	ts := simpleStore
+		expect:   true,
-	fixed := simpleFixedIterator()
+	},
-	vc := NewComparison(fixed, kCompareGTE, int64(2), ts)
+	{
-	checkIteratorContains(ts, vc, []string{"2", "3", "4"}, t)
+		message:  "5 is absent from iterator",
+		operator: kCompareGTE,
+		check:    5,
+		expect:   false,
+	},
 }
 
 func TestVCICheck(t *testing.T) {
-	ts := simpleStore
+	for _, test := range vciCheckTests {
-	fixed := simpleFixedIterator()
+		vc := NewComparison(simpleFixedIterator(), test.operator, int64(2), simpleStore)
-	vc := NewComparison(fixed, kCompareGTE, int64(2), ts)
+		if vc.Check(test.check) != test.expect {
-	if vc.Check(1) {
+			t.Errorf("Failed to show %s", test.message)
-		t.Error("1 is less than 2, should be GTE")
+		}
-	}
-	if !vc.Check(2) {
-		t.Error("2 is GTE 2")
-	}
-	if !vc.Check(3) {
-		t.Error("3 is GTE 2")
-	}
-	if vc.Check(5) {
-		t.Error("5 is not in the underlying iterator")
 	}
 }

graph/leveldb/all_iterator.go

@@ -105,7 +105,7 @@ func (it *AllIterator) Close() {
 }
 
 func (it *AllIterator) Size() (int64, bool) {
-	size, err := it.ts.GetApproximateSizeForPrefix(it.prefix)
+	size, err := it.ts.SizeOfPrefix(it.prefix)
 	if err == nil {
 		return size, false
 	}

graph/leveldb/iterator.go

@@ -114,7 +114,7 @@ func (it *Iterator) Next() (graph.Value, bool) {
 	return nil, false
 }
 
-func GetPositionFromPrefix(prefix []byte, d graph.Direction, ts *TripleStore) int {
+func PositionOf(prefix []byte, d graph.Direction, ts *TripleStore) int {
 	if bytes.Equal(prefix, []byte("sp")) {
 		switch d {
 		case graph.Subject:
@@ -171,7 +171,7 @@ func (it *Iterator) Check(v graph.Value) bool {
 	if val[0] == 'z' {
 		return false
 	}
-	offset := GetPositionFromPrefix(val[0:2], it.dir, it.ts)
+	offset := PositionOf(val[0:2], it.dir, it.ts)
 	if offset != -1 {
 		if bytes.HasPrefix(val[offset:], it.checkId[1:]) {
 			return true
@@ -187,7 +187,7 @@ func (it *Iterator) Check(v graph.Value) bool {
 }
 
 func (it *Iterator) Size() (int64, bool) {
-	return it.ts.GetSizeFor(it.checkId), true
+	return it.ts.SizeOf(it.checkId), true
 }
 
 func (it *Iterator) DebugString(indent int) string {

graph/leveldb/leveldb_test.go

@@ -176,7 +176,7 @@ func TestLoadDatabase(t *testing.T) {
 	if s := ts.Size(); s != 11 {
 		t.Errorf("Unexpected triplestore size, got:%d expect:11", s)
 	}
-	if s := ts.GetSizeFor(ts.ValueOf("B")); s != 5 {
+	if s := ts.SizeOf(ts.ValueOf("B")); s != 5 {
 		t.Errorf("Unexpected triplestore size, got:%d expect:5", s)
 	}
 
@@ -184,7 +184,7 @@ func TestLoadDatabase(t *testing.T) {
 	if s := ts.Size(); s != 10 {
 		t.Errorf("Unexpected triplestore size after RemoveTriple, got:%d expect:10", s)
 	}
-	if s := ts.GetSizeFor(ts.ValueOf("B")); s != 4 {
+	if s := ts.SizeOf(ts.ValueOf("B")); s != 4 {
 		t.Errorf("Unexpected triplestore size, got:%d expect:4", s)
 	}
 

graph/leveldb/triplestore.go

@@ -332,7 +332,7 @@ func (ts *TripleStore) ValueOf(s string) graph.Value {
 	return ts.createValueKeyFor(s)
 }
 
-func (ts *TripleStore) getValueData(value_key []byte) ValueData {
+func (ts *TripleStore) valueData(value_key []byte) ValueData {
 	var out ValueData
 	if glog.V(3) {
 		glog.V(3).Infof("%s %v\n", string(value_key[0]), value_key)
@@ -357,14 +357,14 @@ func (ts *TripleStore) NameOf(k graph.Value) string {
 		glog.V(2).Infoln("k was nil")
 		return ""
 	}
-	return ts.getValueData(k.([]byte)).Name
+	return ts.valueData(k.([]byte)).Name
 }
 
-func (ts *TripleStore) GetSizeFor(k graph.Value) int64 {
+func (ts *TripleStore) SizeOf(k graph.Value) int64 {
 	if k == nil {
 		return 0
 	}
-	return int64(ts.getValueData(k.([]byte)).Size)
+	return int64(ts.valueData(k.([]byte)).Size)
 }
 
 func (ts *TripleStore) getSize() {
@@ -386,7 +386,7 @@ func (ts *TripleStore) getSize() {
 	ts.size = size
 }
 
-func (ts *TripleStore) GetApproximateSizeForPrefix(pre []byte) (int64, error) {
+func (ts *TripleStore) SizeOfPrefix(pre []byte) (int64, error) {
 	limit := make([]byte, len(pre))
 	copy(limit, pre)
 	end := len(limit) - 1
@@ -394,7 +394,7 @@ func (ts *TripleStore) GetApproximateSizeForPrefix(pre []byte) (int64, error) {
 	ranges := make([]util.Range, 1)
 	ranges[0].Start = pre
 	ranges[0].Limit = limit
-	sizes, err := ts.db.GetApproximateSizes(ranges)
+	sizes, err := ts.db.SizeOf(ranges)
 	if err == nil {
 		return (int64(sizes[0]) >> 6) + 1, nil
 	}
@@ -428,7 +428,7 @@ func (ts *TripleStore) TriplesAllIterator() graph.Iterator {
 
 func (ts *TripleStore) TripleDirection(val graph.Value, d graph.Direction) graph.Value {
 	v := val.([]uint8)
-	offset := GetPositionFromPrefix(v[0:2], d, ts)
+	offset := PositionOf(v[0:2], d, ts)
 	if offset != -1 {
 		return append([]byte("z"), v[offset:offset+ts.hasher.Size()]...)
 	} else {