mirror/dolt
1
0
Fork 0
mirror of https://github.com/dolthub/dolt.git synced 2025-12-30 16:12:39 -06:00
Code Issues Packages Projects Releases 114 Wiki Activity

Merge pull request #1414 from alrs/store-types-errs

Browse Source 
store/types: fix dropped errors
This commit is contained in:
Zach Musgrave
2021-03-10 14:38:16 -08:00
committed by GitHub
parent e16b2855e8 0aec9c94f0
commit 5ebbefaf60
28 changed files with 911 additions and 871 deletions
Download Patch File Download Diff File Expand all files Collapse all files

48
go/store/types/blob_test.go
View File

@@ -33,6 +33,7 @@ import (
"github.com/dolthub/dolt/go/store/d"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"github.com/stretchr/testify/suite"
)
@@ -97,25 +98,25 @@ func newBlobTestSuite(size uint, expectChunkCount int, expectPrependChunkDiff in
func TestBlobSuite4K(t *testing.T) {
s, err := newBlobTestSuite(12, 2, 2, 2)
assert.NoError(t, err)
require.NoError(t, err)
suite.Run(t, s)
}
func TestBlobSuite64K(t *testing.T) {
s, err := newBlobTestSuite(16, 15, 2, 2)
assert.NoError(t, err)
require.NoError(t, err)
suite.Run(t, s)
}
func TestBlobSuite256K(t *testing.T) {
s, err := newBlobTestSuite(18, 64, 2, 2)
assert.NoError(t, err)
require.NoError(t, err)
suite.Run(t, s)
}
func TestBlobSuite1M(t *testing.T) {
s, err := newBlobTestSuite(20, 245, 2, 2)
assert.NoError(t, err)
require.NoError(t, err)
suite.Run(t, s)
}
@@ -212,11 +213,11 @@ func TestBlobFromReaderThatReturnsDataAndError(t *testing.T) {
tr := &testReader{buf: &bytes.Buffer{}}
b, err := NewBlob(context.Background(), vrw, tr)
assert.NoError(err)
require.NoError(t, err)
actual := &bytes.Buffer{}
_, err = io.Copy(actual, b.Reader(context.Background()))
assert.NoError(err)
require.NoError(t, err)
assert.True(bytes.Equal(actual.Bytes(), tr.buf.Bytes()))
assert.Equal(byte(2), actual.Bytes()[len(actual.Bytes())-1])
@@ -236,11 +237,11 @@ func TestBlobConcat(t *testing.T) {
split := func(b Blob, at int64) (Blob, Blob) {
read1, read2 := b.Reader(context.Background()), b.Reader(context.Background())
b1, err := NewBlob(context.Background(), vs, &io.LimitedReader{R: read1, N: at})
assert.NoError(err)
require.NoError(t, err)
_, err = read2.Seek(at, 0)
assert.NoError(err)
require.NoError(t, err)
b2, err := NewBlob(context.Background(), vs, read2)
assert.NoError(err)
require.NoError(t, err)
return reload(b1), reload(b2)
}
@@ -248,31 +249,32 @@ func TestBlobConcat(t *testing.T) {
// Note that List.Concat is exhaustively tested, don't worry here.
r := rand.New(rand.NewSource(0))
b, err := NewBlob(context.Background(), vs, &io.LimitedReader{R: r, N: 1e6})
assert.NoError(err)
require.NoError(t, err)
b = reload(b)
b1, err := NewEmptyBlob(vs)
assert.NoError(err)
require.NoError(t, err)
b1, err = b1.Concat(context.Background(), b)
assert.NoError(err)
require.NoError(t, err)
assert.True(b.Equals(b1))
b2, err := b.Concat(context.Background(), mustBlob(NewEmptyBlob(vs)))
assert.NoError(err)
require.NoError(t, err)
assert.True(b.Equals(b2))
b3, b4 := split(b, 10)
b34, err := b3.Concat(context.Background(), b4)
assert.NoError(err)
require.NoError(t, err)
assert.True(b.Equals(b34))
b5, b6 := split(b, 1e6-10)
b56, err := b5.Concat(context.Background(), b6)
require.NoError(t, err)
assert.True(b.Equals(b56))
assert.NoError(err)
b7, b8 := split(b, 1e6/2)
b78, err := b7.Concat(context.Background(), b8)
require.NoError(t, err)
assert.True(b.Equals(b78))
}
@@ -282,27 +284,27 @@ func TestBlobNewParallel(t *testing.T) {
readAll := func(b Blob) []byte {
data, err := ioutil.ReadAll(b.Reader(context.Background()))
assert.NoError(err)
require.NoError(t, err)
return data
}
b, err := NewBlob(context.Background(), vrw)
assert.NoError(err)
require.NoError(t, err)
assert.True(b.Len() == 0)
b, err = NewBlob(context.Background(), vrw, strings.NewReader("abc"))
assert.NoError(err)
require.NoError(t, err)
assert.Equal("abc", string(readAll(b)))
b, err = NewBlob(context.Background(), vrw, strings.NewReader("abc"), strings.NewReader("def"))
assert.NoError(err)
require.NoError(t, err)
assert.Equal("abcdef", string(readAll(b)))
p, size := 100, 1024
r := rand.New(rand.NewSource(0))
data := make([]byte, p*size)
_, err = r.Read(data)
assert.NoError(err)
require.NoError(t, err)
readers := make([]io.Reader, p)
for i := range readers {
@@ -310,7 +312,7 @@ func TestBlobNewParallel(t *testing.T) {
}
b, err = NewBlob(context.Background(), vrw, readers...)
assert.NoError(err)
require.NoError(t, err)
assert.Equal(data, readAll(b))
}
@@ -328,9 +330,9 @@ func TestStreamingParallelBlob(t *testing.T) {
vs := newTestValueStore()
blob, err := NewBlob(context.Background(), vs, readers...)
assert.NoError(err)
require.NoError(t, err)
outBuff := &bytes.Buffer{}
_, err = blob.Copy(context.Background(), outBuff)
assert.NoError(err)
require.NoError(t, err)
assert.True(bytes.Equal(buff, outBuff.Bytes()))
}

5
go/store/types/common_supertype_test.go
View File

@@ -19,6 +19,7 @@ import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestContainCommonSupertype(t *testing.T) {
@@ -185,9 +186,9 @@ func TestContainCommonSupertype(t *testing.T) {
for i, c := range cases {
act := ContainCommonSupertype(Format_7_18, c.a, c.b)
aDesc, err := c.a.Describe(context.Background())
assert.NoError(t, err)
require.NoError(t, err)
bDesc, err := c.b.Describe(context.Background())
assert.NoError(t, err)
require.NoError(t, err)
assert.Equal(t, c.out, act, "Test case at position %d; \n\ta:%s\n\tb:%s", i, aDesc, bDesc)
}
}

27
go/store/types/compare_test.go
View File

@@ -28,6 +28,7 @@ import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"github.com/dolthub/dolt/go/store/d"
"github.com/dolthub/dolt/go/store/hash"
@@ -322,11 +323,11 @@ func TestCompareTotalOrdering(t *testing.T) {
assert.True(vi.Equals(vj))
} else if i < j {
x, err := vi.Less(Format_7_18, vj)
assert.NoError(err)
require.NoError(t, err)
assert.True(x)
} else {
x, err := vi.Less(Format_7_18, vj)
assert.NoError(err)
require.NoError(t, err)
assert.False(x)
}
}
@@ -342,30 +343,30 @@ func TestCompareDifferentPrimitiveTypes(t *testing.T) {
words := ValueSlice{String("k1"), String("v1")}
blob, err := NewBlob(context.Background(), vrw, bytes.NewBuffer([]byte{1, 2, 3}))
assert.NoError(err)
require.NoError(t, err)
nList, err := NewList(context.Background(), vrw, nums...)
assert.NoError(err)
require.NoError(t, err)
nMap, err := NewMap(context.Background(), vrw, words...)
assert.NoError(err)
require.NoError(t, err)
nRef, err := NewRef(blob, Format_7_18)
assert.NoError(err)
require.NoError(t, err)
nSet, err := NewSet(context.Background(), vrw, nums...)
assert.NoError(err)
require.NoError(t, err)
nStruct, err := NewStruct(Format_7_18, "teststruct", map[string]Value{"f1": Float(1)})
assert.NoError(err)
require.NoError(t, err)
vals := ValueSlice{Bool(true), Float(19), String("hellow"), blob, nList, nMap, nRef, nSet, nStruct}
err = SortWithErroringLess(ValueSort{vals, Format_7_18})
assert.NoError(err)
require.NoError(t, err)
for i, v1 := range vals {
for j, v2 := range vals {
iBytes := [1024]byte{}
jBytes := [1024]byte{}
bytes1, err := encodeGraphKey(iBytes[:0], v1)
assert.NoError(err)
require.NoError(t, err)
bytes2, err := encodeGraphKey(jBytes[:0], v2)
assert.NoError(err)
require.NoError(t, err)
res := compareEncodedKey(bytes1, bytes2)
expectedRes := compareInts(i, j)
@@ -414,9 +415,9 @@ func TestCompareEncodedKeys(t *testing.T) {
bs2 := [initialBufferSize]byte{}
e1, _, err := encodeKeys(bs1[:0], 0x01020304, MapKind, k1)
assert.NoError(err)
require.NoError(t, err)
e2, _, err := encodeKeys(bs2[:0], 0x01020304, MapKind, k2)
assert.NoError(err)
require.NoError(t, err)
assert.Equal(-1, compareEncodedKeys(e1, e2))
}

61
go/store/types/encode_human_readable_test.go
View File

@@ -29,6 +29,7 @@ import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"github.com/dolthub/dolt/go/store/d"
"github.com/dolthub/dolt/go/store/util/test"
@@ -77,7 +78,7 @@ func TestWriteHumanReadableRef(t *testing.T) {
x := Float(42)
rv, err := vs.WriteValue(context.Background(), x)
assert.NoError(t, err)
require.NoError(t, err)
assertWriteHRSEqual(t, "#0123456789abcdefghijklmnopqrstuv", rv)
}
@@ -85,23 +86,23 @@ func TestWriteHumanReadableCollections(t *testing.T) {
vrw := newTestValueStore()
l, err := NewList(context.Background(), vrw, Float(0), Float(1), Float(2), Float(3))
assert.NoError(t, err)
require.NoError(t, err)
assertWriteHRSEqual(t, "[ // 4 items\n 0,\n 1,\n 2,\n 3,\n]", l)
s, err := NewSet(context.Background(), vrw, Float(0), Float(1), Float(2), Float(3))
assert.NoError(t, err)
require.NoError(t, err)
assertWriteHRSEqual(t, "set { // 4 items\n 0,\n 1,\n 2,\n 3,\n}", s)
m, err := NewMap(context.Background(), vrw, Float(0), Bool(false), Float(1), Bool(true))
assert.NoError(t, err)
require.NoError(t, err)
assertWriteHRSEqual(t, "map {\n 0: false,\n 1: true,\n}", m)
l2, err := NewList(context.Background(), vrw)
assert.NoError(t, err)
require.NoError(t, err)
assertWriteHRSEqual(t, "[]", l2)
l3, err := NewList(context.Background(), vrw, Float(0))
assert.NoError(t, err)
require.NoError(t, err)
assertWriteHRSEqual(t, "[\n 0,\n]", l3)
nums := make([]Value, 2000)
@@ -109,7 +110,7 @@ func TestWriteHumanReadableCollections(t *testing.T) {
nums[i] = Float(0)
}
l4, err := NewList(context.Background(), vrw, nums...)
assert.NoError(t, err)
require.NoError(t, err)
assertWriteHRSEqual(t, "[ // 2,000 items\n"+strings.Repeat(" 0,\n", 2000)+"]", l4)
}
@@ -117,17 +118,17 @@ func TestWriteHumanReadableNested(t *testing.T) {
vrw := newTestValueStore()
l, err := NewList(context.Background(), vrw, Float(0), Float(1))
assert.NoError(t, err)
require.NoError(t, err)
l2, err := NewList(context.Background(), vrw, Float(2), Float(3))
assert.NoError(t, err)
require.NoError(t, err)
s, err := NewSet(context.Background(), vrw, String("a"), String("b"))
assert.NoError(t, err)
require.NoError(t, err)
s2, err := NewSet(context.Background(), vrw, String("c"), String("d"))
assert.NoError(t, err)
require.NoError(t, err)
m, err := NewMap(context.Background(), vrw, s, l, s2, l2)
assert.NoError(t, err)
require.NoError(t, err)
assertWriteHRSEqual(t, `map {
set {
"c",
@@ -185,18 +186,18 @@ func TestWriteHumanReadableBlob(t *testing.T) {
assertWriteHRSEqual(t, "blob {}", mustValue(NewEmptyBlob(vrw)))
b1, err := NewBlob(context.Background(), vrw, bytes.NewBuffer([]byte{0x01}))
assert.NoError(t, err)
require.NoError(t, err)
assertWriteHRSEqual(t, "blob {01}", b1)
b2, err := NewBlob(context.Background(), vrw, bytes.NewBuffer([]byte{0x01, 0x02}))
assert.NoError(t, err)
require.NoError(t, err)
assertWriteHRSEqual(t, "blob {01 02}", b2)
b3, err := NewBlob(context.Background(), vrw, bytes.NewBuffer([]byte{
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
}))
assert.NoError(t, err)
require.NoError(t, err)
assertWriteHRSEqual(t, "blob {00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f}", b3)
b4, err := NewBlob(context.Background(), vrw, bytes.NewBuffer([]byte{
@@ -204,7 +205,7 @@ func TestWriteHumanReadableBlob(t *testing.T) {
0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
0x10,
}))
assert.NoError(t, err)
require.NoError(t, err)
assertWriteHRSEqual(t, "blob { // 17 B\n 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f\n 10\n}", b4)
bs := make([]byte, 256)
@@ -213,11 +214,11 @@ func TestWriteHumanReadableBlob(t *testing.T) {
}
b5, err := NewBlob(context.Background(), vrw, bytes.NewBuffer(bs))
assert.NoError(t, err)
require.NoError(t, err)
assertWriteHRSEqual(t, "blob { // 256 B\n 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f\n 10 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f\n 20 21 22 23 24 25 26 27 28 29 2a 2b 2c 2d 2e 2f\n 30 31 32 33 34 35 36 37 38 39 3a 3b 3c 3d 3e 3f\n 40 41 42 43 44 45 46 47 48 49 4a 4b 4c 4d 4e 4f\n 50 51 52 53 54 55 56 57 58 59 5a 5b 5c 5d 5e 5f\n 60 61 62 63 64 65 66 67 68 69 6a 6b 6c 6d 6e 6f\n 70 71 72 73 74 75 76 77 78 79 7a 7b 7c 7d 7e 7f\n 80 81 82 83 84 85 86 87 88 89 8a 8b 8c 8d 8e 8f\n 90 91 92 93 94 95 96 97 98 99 9a 9b 9c 9d 9e 9f\n a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 aa ab ac ad ae af\n b0 b1 b2 b3 b4 b5 b6 b7 b8 b9 ba bb bc bd be bf\n c0 c1 c2 c3 c4 c5 c6 c7 c8 c9 ca cb cc cd ce cf\n d0 d1 d2 d3 d4 d5 d6 d7 d8 d9 da db dc dd de df\n e0 e1 e2 e3 e4 e5 e6 e7 e8 e9 ea eb ec ed ee ef\n f0 f1 f2 f3 f4 f5 f6 f7 f8 f9 fa fb fc fd fe ff\n}", b5)
b6, err := NewBlob(context.Background(), vrw, bytes.NewBuffer(make([]byte, 16*100)))
assert.NoError(t, err)
require.NoError(t, err)
row := " " + strings.Repeat("00 ", 15) + "00\n"
s := strings.Repeat(row, 100)
assertWriteHRSEqual(t, "blob { // 1.6 kB\n"+s+"}", b6)
@@ -227,17 +228,17 @@ func TestWriteHumanReadableListOfBlob(t *testing.T) {
vrw := newTestValueStore()
b1, err := NewBlob(context.Background(), vrw, bytes.NewBuffer([]byte{0x01}))
assert.NoError(t, err)
require.NoError(t, err)
b2, err := NewBlob(context.Background(), vrw, bytes.NewBuffer([]byte{0x02}))
assert.NoError(t, err)
require.NoError(t, err)
b3, err := NewBlob(context.Background(), vrw, bytes.NewBuffer([]byte{
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
0x10,
}))
assert.NoError(t, err)
require.NoError(t, err)
l, err := NewList(context.Background(), vrw, b1, mustValue(NewEmptyBlob(vrw)), b2, b3)
assert.NoError(t, err)
require.NoError(t, err)
assertWriteHRSEqual(t, "[ // 4 items\n blob {01},\n blob {},\n blob {02},\n blob { // 17 B\n 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f\n 10\n },\n]", l)
}
@@ -340,22 +341,22 @@ func TestEmptyCollections(t *testing.T) {
vrw := newTestValueStore()
a, err := MakeStructType("Nothing")
assert.NoError(t, err)
require.NoError(t, err)
assertWriteHRSEqual(t, "Struct Nothing {}", a)
b, err := NewStruct(Format_7_18, "Rien", StructData{})
assert.NoError(t, err)
require.NoError(t, err)
assertWriteHRSEqual(t, "struct Rien {}", b)
c, err := MakeMapType(PrimitiveTypeMap[BlobKind], PrimitiveTypeMap[FloatKind])
assert.NoError(t, err)
require.NoError(t, err)
assertWriteHRSEqual(t, "Map<Blob, Float>", c)
d, err := NewMap(context.Background(), vrw)
assert.NoError(t, err)
require.NoError(t, err)
assertWriteHRSEqual(t, "map {}", d)
e, err := MakeSetType(PrimitiveTypeMap[StringKind])
assert.NoError(t, err)
require.NoError(t, err)
assertWriteHRSEqual(t, "Set<String>", e)
f, err := NewSet(context.Background(), vrw)
assert.NoError(t, err)
require.NoError(t, err)
assertWriteHRSEqual(t, "set {}", f)
}
@@ -364,7 +365,7 @@ func TestEncodedValueMaxLines(t *testing.T) {
vrw := newTestValueStore()
l1, err := NewList(context.Background(), vrw, generateNumbersAsValues(11)...)
assert.NoError(err)
require.NoError(t, err)
expected := strings.Join(strings.SplitAfterN(mustString(EncodedValue(context.Background(), l1)), "\n", 6)[:5], "")
actual, err := EncodedValueMaxLines(context.Background(), l1, 5)
assert.True(err == writers.MaxLinesErr)
@@ -380,7 +381,7 @@ func TestWriteHumanReadableStructOptionalFields(t *testing.T) {
typ, err := MakeStructType("S1",
StructField{"a", PrimitiveTypeMap[BoolKind], false},
StructField{"b", PrimitiveTypeMap[BoolKind], true})
assert.NoError(t, err)
require.NoError(t, err)
assertWriteHRSEqual(t, "Struct S1 {\n a: Bool,\n b?: Bool,\n}", typ)
}

37
go/store/types/encoding_test.go
View File

@@ -30,6 +30,7 @@ import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"github.com/dolthub/dolt/go/store/hash"
)
@@ -67,12 +68,12 @@ func assertEncoding(t *testing.T, expect []interface{}, v Value) {
vs := newTestValueStore()
w := newBinaryNomsWriter()
err := v.writeTo(&w, Format_7_18)
assert.NoError(t, err)
require.NoError(t, err)
assert.EqualValues(t, expectedAsByteSlice, w.data())
dec := newValueDecoder(expectedAsByteSlice, vs)
v2, err := dec.readValue(Format_7_18)
assert.NoError(t, err)
require.NoError(t, err)
assert.True(t, v.Equals(v2))
}
@@ -81,9 +82,9 @@ func TestRoundTrips(t *testing.T) {
assertRoundTrips := func(v Value) {
chnk, err := EncodeValue(v, Format_7_18)
assert.NoError(t, err)
require.NoError(t, err)
out, err := DecodeValue(chnk, vs)
assert.NoError(t, err)
require.NoError(t, err)
assert.True(t, v.Equals(out))
}
@@ -129,26 +130,26 @@ func TestRoundTrips(t *testing.T) {
assertRoundTrips(String("💩"))
st, err := NewStruct(Format_7_18, "", StructData{"a": Bool(true), "b": String("foo"), "c": Float(2.3)})
assert.NoError(t, err)
require.NoError(t, err)
assertRoundTrips(st)
ll, err := newListLeafSequence(vs, Float(4), Float(5), Float(6), Float(7))
assert.NoError(t, err)
require.NoError(t, err)
listLeaf := newList(ll)
assertRoundTrips(listLeaf)
ref, err := NewRef(listLeaf, Format_7_18)
assert.NoError(t, err)
require.NoError(t, err)
k10, err := orderedKeyFromInt(10, Format_7_18)
assert.NoError(t, err)
require.NoError(t, err)
k20, err := orderedKeyFromInt(20, Format_7_18)
assert.NoError(t, err)
require.NoError(t, err)
mt1, err := newMetaTuple(ref, k10, 10)
assert.NoError(t, err)
require.NoError(t, err)
mt2, err := newMetaTuple(ref, k20, 20)
assert.NoError(t, err)
require.NoError(t, err)
mseq, err := newListMetaSequence(1, []metaTuple{mt1, mt2}, vs)
assert.NoError(t, err)
require.NoError(t, err)
assertRoundTrips(newList(mseq))
}
@@ -378,16 +379,16 @@ func TestWriteStruct(t *testing.T) {
func TestWriteStructTooMuchData(t *testing.T) {
s, err := NewStruct(Format_7_18, "S", StructData{"x": Float(42), "b": Bool(true)})
assert.NoError(t, err)
require.NoError(t, err)
c, err := EncodeValue(s, Format_7_18)
assert.NoError(t, err)
require.NoError(t, err)
data := c.Data()
buff := make([]byte, len(data)+1)
copy(buff, data)
buff[len(data)] = 5 // Add a bogus extrabyte
assert.Panics(t, func() {
_, err := decodeFromBytes(buff, newTestValueStore())
assert.NoError(t, err)
require.NoError(t, err)
})
}
@@ -485,9 +486,9 @@ func TestWriteCompoundSet(t *testing.T) {
vrw := newTestValueStore()
sls, err := newSetLeafSequence(vrw, Float(0), Float(1))
assert.NoError(t, err)
require.NoError(t, err)
sls2, err := newSetLeafSequence(vrw, Float(2), Float(3), Float(4))
assert.NoError(t, err)
require.NoError(t, err)
set1 := newSet(sls)
set2 := newSet(sls2)
@@ -568,7 +569,7 @@ func TestWriteListOfUnionWithType(t *testing.T) {
vrw := newTestValueStore()
structType, err := MakeStructType("S", StructField{"x", PrimitiveTypeMap[FloatKind], false})
assert.NoError(t, err)
require.NoError(t, err)
assertEncoding(t,
[]interface{}{

9
go/store/types/equals_test.go
View File

@@ -27,6 +27,7 @@ import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestValueEquals(t *testing.T) {
@@ -98,17 +99,17 @@ func TestValueEquals(t *testing.T) {
for i, f1 := range values {
for j, f2 := range values {
v1, err := f1()
assert.NoError(err)
require.NoError(t, err)
v2, err := f2()
assert.NoError(err)
require.NoError(t, err)
assert.Equal(v1.Equals(v2), i == j)
}
v, err := f1()
assert.NoError(err)
require.NoError(t, err)
if v != nil {
r, err := NewRef(v, Format_7_18)
assert.NoError(err)
require.NoError(t, err)
assert.False(r.Equals(v))
assert.False(v.Equals(r))
}

44
go/store/types/incremental_test.go
View File

@@ -27,6 +27,7 @@ import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"github.com/dolthub/dolt/go/store/chunks"
)
@@ -59,17 +60,17 @@ func TestIncrementalLoadList(t *testing.T) {
vs := NewValueStore(cs)
expected, err := NewList(context.Background(), vs, getTestVals(vs)...)
assert.NoError(err)
require.NoError(t, err)
ref, err := vs.WriteValue(context.Background(), expected)
assert.NoError(err)
require.NoError(t, err)
hash := ref.TargetHash()
rt, err := vs.Root(context.Background())
assert.NoError(err)
require.NoError(t, err)
_, err = vs.Commit(context.Background(), rt, rt)
assert.NoError(err)
require.NoError(t, err)
actualVar, err := vs.ReadValue(context.Background(), hash)
assert.NoError(err)
require.NoError(t, err)
actual := actualVar.(List)
expectedCount := cs.Reads()
@@ -78,9 +79,9 @@ func TestIncrementalLoadList(t *testing.T) {
chunkReads := make([]int, expected.Len())
for i := uint64(0); i < expected.Len(); i++ {
v, err := actual.Get(context.Background(), i)
assert.NoError(err)
require.NoError(t, err)
v2, err := expected.Get(context.Background(), i)
assert.NoError(err)
require.NoError(t, err)
assert.True(v2.Equals(v))
expectedCount += isEncodedOutOfLine(v)
@@ -88,7 +89,7 @@ func TestIncrementalLoadList(t *testing.T) {
// Do it again to make sure multiple derefs don't do multiple loads.
_, err = actual.Get(context.Background(), i)
assert.NoError(err)
require.NoError(t, err)
assert.Equal(expectedCount+chunkReads[i], cs.Reads())
}
}
@@ -100,12 +101,13 @@ func SkipTestIncrementalLoadSet(t *testing.T) {
vs := NewValueStore(cs)
expected, err := NewSet(context.Background(), vs, getTestVals(vs)...)
assert.NoError(err)
require.NoError(t, err)
ref, err := vs.WriteValue(context.Background(), expected)
require.NoError(t, err)
refHash := ref.TargetHash()
actualVar, err := vs.ReadValue(context.Background(), refHash)
assert.NoError(err)
require.NoError(t, err)
actual := actualVar.(Set)
expectedCount := cs.Reads()
@@ -116,7 +118,7 @@ func SkipTestIncrementalLoadSet(t *testing.T) {
return false, nil
})
assert.NoError(err)
require.NoError(t, err)
}
func SkipTestIncrementalLoadMap(t *testing.T) {
@@ -126,13 +128,13 @@ func SkipTestIncrementalLoadMap(t *testing.T) {
vs := NewValueStore(cs)
expected, err := NewMap(context.Background(), vs, getTestVals(vs)...)
assert.NoError(err)
require.NoError(t, err)
ref, err := vs.WriteValue(context.Background(), expected)
assert.NoError(err)
require.NoError(t, err)
refHash := ref.TargetHash()
actualVar, err := vs.ReadValue(context.Background(), refHash)
assert.NoError(err)
require.NoError(t, err)
actual := actualVar.(Map)
expectedCount := cs.Reads()
@@ -143,7 +145,7 @@ func SkipTestIncrementalLoadMap(t *testing.T) {
assert.Equal(expectedCount, cs.Reads())
return false, nil
})
assert.NoError(err)
require.NoError(t, err)
}
func SkipTestIncrementalAddRef(t *testing.T) {
@@ -154,27 +156,27 @@ func SkipTestIncrementalAddRef(t *testing.T) {
expectedItem := Float(42)
ref, err := vs.WriteValue(context.Background(), expectedItem)
assert.NoError(err)
require.NoError(t, err)
expected, err := NewList(context.Background(), vs, ref)
assert.NoError(err)
require.NoError(t, err)
ref, err = vs.WriteValue(context.Background(), expected)
assert.NoError(err)
require.NoError(t, err)
actualVar, err := vs.ReadValue(context.Background(), ref.TargetHash())
assert.NoError(err)
require.NoError(t, err)
assert.Equal(1, cs.Reads())
assert.True(expected.Equals(actualVar))
actual := actualVar.(List)
actualItem, err := actual.Get(context.Background(), 0)
assert.NoError(err)
require.NoError(t, err)
assert.Equal(2, cs.Reads())
assert.True(expectedItem.Equals(actualItem))
// do it again to make sure caching works.
actualItem, err = actual.Get(context.Background(), 0)
assert.NoError(err)
require.NoError(t, err)
assert.Equal(2, cs.Reads())
assert.True(expectedItem.Equals(actualItem))
}

19
go/store/types/list_editor_test.go
View File

@@ -27,6 +27,7 @@ import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func listOfInts(vrw ValueReadWriter, vals ...int) (List, error) {
@@ -54,7 +55,7 @@ func assertState(t *testing.T, vrw ValueReadWriter, le *ListEditor, expectItems
for i, v := range expectItems {
item, err := le.Get(context.Background(), uint64(i))
assert.NoError(t, err)
require.NoError(t, err)
assert.Equal(t, Float(v), item)
}
@@ -66,9 +67,9 @@ func assertState(t *testing.T, vrw ValueReadWriter, le *ListEditor, expectItems
assert.Equal(t, expectEditCount, actualEditCount)
l, err := listOfInts(vrw, expectItems...)
assert.NoError(t, err)
require.NoError(t, err)
l2, err := le.List(context.Background())
assert.NoError(t, err)
require.NoError(t, err)
assert.True(t, l.Equals(l2))
}
@@ -114,13 +115,13 @@ func TestListEditorBasic(t *testing.T) {
le.Append(NullValue)
le.Append(Float(4))
l, err := le.List(context.Background())
assert.NoError(t, err)
require.NoError(t, err)
v3, err := l.Get(context.Background(), 3)
assert.NoError(t, err)
require.NoError(t, err)
assert.True(t, IsNull(v3))
v4, err := l.Get(context.Background(), 4)
assert.NoError(t, err)
require.NoError(t, err)
assert.True(t, v4.Equals(Float(4)))
})
}
@@ -249,7 +250,7 @@ func TestListSpliceFuzzer(t *testing.T) {
for i := 0; i < rounds; i++ {
tl := newTestList(startCount)
l, err := tl.toList(vrw)
assert.NoError(t, err)
require.NoError(t, err)
le := l.Edit()
for j := 0; j < splices; j++ {
@@ -258,9 +259,9 @@ func TestListSpliceFuzzer(t *testing.T) {
le.Splice(idx, removed, AsValuables(insert)...)
}
expect, err := tl.toList(vrw)
assert.NoError(t, err)
require.NoError(t, err)
actual, err := le.List(context.Background())
assert.NoError(t, err)
require.NoError(t, err)
assert.True(t, expect.Equals(actual))
}
}

13
go/store/types/list_iterator_test.go
View File

@@ -26,6 +26,7 @@ import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestListIterator(t *testing.T) {
@@ -34,20 +35,20 @@ func TestListIterator(t *testing.T) {
numbers := append(generateNumbersAsValues(10), Float(20), Float(25))
l, err := NewList(context.Background(), vrw, numbers...)
assert.NoError(err)
require.NoError(t, err)
i, err := l.Iterator(context.Background())
assert.NoError(err)
require.NoError(t, err)
vs, err := iterToSlice(i)
assert.NoError(err)
require.NoError(t, err)
assert.True(vs.Equals(numbers), "Expected: %v != actual: %v", numbers, vs)
i, err = l.IteratorAt(context.Background(), 3)
assert.NoError(err)
require.NoError(t, err)
vs, err = iterToSlice(i)
assert.NoError(err)
require.NoError(t, err)
assert.True(vs.Equals(numbers[3:]), "Expected: %v != actual: %v", numbers, vs)
i, err = l.IteratorAt(context.Background(), l.Len())
assert.NoError(err)
require.NoError(t, err)
assert.Nil(i.Next(context.Background()))
}

248
go/store/types/list_test.go
View File

@@ -27,6 +27,7 @@ import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"github.com/stretchr/testify/suite"
"github.com/dolthub/dolt/go/store/atomicerr"
@@ -86,14 +87,14 @@ func newTestList(length int) testList {
func validateList(t *testing.T, vrw ValueReadWriter, l List, values ValueSlice) {
l, err := NewList(context.Background(), vrw, values...)
assert.NoError(t, err)
require.NoError(t, err)
assert.True(t, l.Equals(l))
out := ValueSlice{}
err = l.IterAll(context.Background(), func(v Value, idx uint64) error {
out = append(out, v)
return nil
})
assert.NoError(t, err)
require.NoError(t, err)
assert.True(t, out.Equals(values))
}
@@ -206,12 +207,12 @@ func TestListInsert(t *testing.T) {
tl := newTestList(1024)
list, err := tl.toList(vrw)
assert.NoError(err)
require.NoError(t, err)
for i := 0; i < len(tl); i += 16 {
tl = tl.Insert(i, Float(i))
list, err = list.Edit().Insert(uint64(i), Float(i)).List(context.Background())
assert.NoError(err)
require.NoError(t, err)
}
assert.True(mustList(tl.toList(vrw)).Equals(list))
@@ -227,12 +228,12 @@ func TestListRemove(t *testing.T) {
tl := newTestList(1024)
list, err := tl.toList(vrw)
assert.NoError(err)
require.NoError(t, err)
for i := len(tl) - 16; i >= 0; i -= 16 {
tl = tl.Remove(i, i+4)
list, err = list.Edit().Remove(uint64(i), uint64(i+4)).List(context.Background())
assert.NoError(err)
require.NoError(t, err)
}
assert.True(mustList(tl.toList(vrw)).Equals(list))
@@ -243,14 +244,14 @@ func TestListRemoveAt(t *testing.T) {
vrw := newTestValueStore()
l0, err := NewList(context.Background(), vrw)
assert.NoError(err)
require.NoError(t, err)
l0, err = l0.Edit().Append(Bool(false), Bool(true)).List(context.Background())
assert.NoError(err)
require.NoError(t, err)
l1, err := l0.Edit().RemoveAt(1).List(context.Background())
assert.NoError(err)
require.NoError(t, err)
assert.True(mustList(NewList(context.Background(), vrw, Bool(false))).Equals(l1))
l1, err = l1.Edit().RemoveAt(0).List(context.Background())
assert.NoError(err)
require.NoError(t, err)
assert.True(mustList(NewList(context.Background(), vrw)).Equals(l1))
assert.Panics(func() {
@@ -298,7 +299,7 @@ func TestStreamingListCreation(t *testing.T) {
simpleList := getTestList()
cl, err := NewList(context.Background(), vs, simpleList...)
assert.NoError(err)
require.NoError(t, err)
valueChan := make(chan Value)
ae := atomicerr.New()
@@ -315,7 +316,7 @@ func TestStreamingListCreation(t *testing.T) {
done = !assert.True(v.Equals(mustValue(sl.Get(context.Background(), idx))))
return
})
assert.NoError(err)
require.NoError(t, err)
}
func TestListAppend(t *testing.T) {
@@ -331,7 +332,7 @@ func TestListAppend(t *testing.T) {
newList := func(items testList) List {
l, err := NewList(context.Background(), vrw, items...)
assert.NoError(err)
require.NoError(t, err)
return l
}
@@ -340,21 +341,21 @@ func TestListAppend(t *testing.T) {
simple = append(simple, v)
return nil
})
assert.NoError(err)
require.NoError(t, err)
return
}
cl := newList(getTestList())
cl2, err := cl.Edit().Append(Float(42)).List(context.Background())
assert.NoError(err)
require.NoError(t, err)
cl3, err := cl2.Edit().Append(Float(43)).List(context.Background())
assert.NoError(err)
require.NoError(t, err)
cl4, err := cl3.Edit().Append(getTestList().AsValuables()...).List(context.Background())
assert.NoError(err)
require.NoError(t, err)
cl5, err := cl4.Edit().Append(Float(44), Float(45)).List(context.Background())
assert.NoError(err)
require.NoError(t, err)
cl6, err := cl5.Edit().Append(getTestList().AsValuables()...).List(context.Background())
assert.NoError(err)
require.NoError(t, err)
expected := getTestList()
assert.Equal(expected, listToSimple(cl))
@@ -400,10 +401,10 @@ func TestListValidateInsertAscending(t *testing.T) {
values := generateNumbersAsValues(1000)
s, err := NewList(context.Background(), vrw)
assert.NoError(t, err)
require.NoError(t, err)
for i, v := range values {
s, err = s.Edit().Insert(uint64(i), v).List(context.Background())
assert.NoError(t, err)
require.NoError(t, err)
validateList(t, vrw, s, values[0:i+1])
}
}
@@ -420,13 +421,13 @@ func TestListValidateInsertAtZero(t *testing.T) {
values := generateNumbersAsValues(1000)
s, err := NewList(context.Background(), vrw)
assert.NoError(t, err)
require.NoError(t, err)
count := len(values)
for count > 0 {
count--
v := values[count]
s, err = s.Edit().Insert(uint64(0), v).List(context.Background())
assert.NoError(t, err)
require.NoError(t, err)
validateList(t, vrw, s, values[count:])
}
}
@@ -440,7 +441,7 @@ func TestListInsertNothing(t *testing.T) {
vrw := newTestValueStore()
cl, err := getTestList().toList(vrw)
assert.NoError(err)
require.NoError(t, err)
assert.True(cl.Equals(mustList(cl.Edit().Insert(0).List(context.Background()))))
for i := uint64(1); i < getTestListLen(); i *= 2 {
@@ -462,17 +463,17 @@ func TestListInsertStart(t *testing.T) {
vrw := newTestValueStore()
cl, err := getTestList().toList(vrw)
assert.NoError(err)
require.NoError(t, err)
cl2, err := cl.Edit().Insert(0, Float(42)).List(context.Background())
assert.NoError(err)
require.NoError(t, err)
cl3, err := cl2.Edit().Insert(0, Float(43)).List(context.Background())
assert.NoError(err)
require.NoError(t, err)
cl4, err := cl3.Edit().Insert(0, getTestList().AsValuables()...).List(context.Background())
assert.NoError(err)
require.NoError(t, err)
cl5, err := cl4.Edit().Insert(0, Float(44), Float(45)).List(context.Background())
assert.NoError(err)
require.NoError(t, err)
cl6, err := cl5.Edit().Insert(0, getTestList().AsValuables()...).List(context.Background())
assert.NoError(err)
require.NoError(t, err)
expected := getTestList()
assert.Equal(expected, testListFromNomsList(cl))
@@ -517,19 +518,19 @@ func TestListInsertMiddle(t *testing.T) {
vrw := newTestValueStore()
cl, err := getTestList().toList(vrw)
assert.NoError(err)
require.NoError(t, err)
cl2, err := cl.Edit().Insert(100, Float(42)).List(context.Background())
assert.NoError(err)
require.NoError(t, err)
cl3, err := cl2.Edit().Insert(200, Float(43)).List(context.Background())
assert.NoError(err)
require.NoError(t, err)
cl4, err := cl3.Edit().Insert(300, getTestList().AsValuables()...).List(context.Background())
assert.NoError(err)
require.NoError(t, err)
cl5, err := cl4.Edit().Insert(400, Float(44), Float(45)).List(context.Background())
assert.NoError(err)
require.NoError(t, err)
cl6, err := cl5.Edit().Insert(500, getTestList().AsValuables()...).List(context.Background())
assert.NoError(err)
require.NoError(t, err)
cl7, err := cl6.Edit().Insert(600, Float(100)).List(context.Background())
assert.NoError(err)
require.NoError(t, err)
expected := getTestList()
assert.Equal(expected, testListFromNomsList(cl))
@@ -580,16 +581,16 @@ func TestListInsertRanges(t *testing.T) {
testList := getTestList()
whole, err := testList.toList(vrw)
assert.NoError(err)
require.NoError(t, err)
// Compare list equality. Increment by 256 (16^2) because each iteration requires building a new list, which is slow.
for incr, i := 256, 0; i < len(testList)-incr; i += incr {
for window := 1; window <= incr; window *= 16 {
testListPart := testList.Remove(i, i+window)
l, err := testListPart.toList(vrw)
assert.NoError(err)
require.NoError(t, err)
actual, err := l.Edit().Insert(uint64(i), testList[i:i+window].AsValuables()...).List(context.Background())
assert.NoError(err)
require.NoError(t, err)
assert.Equal(whole.Len(), actual.Len())
assert.True(whole.Equals(actual))
}
@@ -598,7 +599,7 @@ func TestListInsertRanges(t *testing.T) {
// Compare list length, which doesn't require building a new list every iteration, so the increment can be smaller.
for incr, i := 10, 0; i < len(testList); i += incr {
l, err := whole.Edit().Insert(uint64(i), testList[0:incr].AsValuables()...).List(context.Background())
assert.NoError(err)
require.NoError(t, err)
assert.Equal(len(testList)+incr, int(l.Len()))
}
}
@@ -612,12 +613,12 @@ func TestListRemoveNothing(t *testing.T) {
vrw := newTestValueStore()
cl, err := getTestList().toList(vrw)
assert.NoError(err)
require.NoError(t, err)
assert.True(cl.Equals(mustList(cl.Edit().Remove(0, 0).List(context.Background()))))
for i := uint64(1); i < getTestListLen(); i *= 2 {
l, err := cl.Edit().Remove(i, i).List(context.Background())
assert.NoError(err)
require.NoError(t, err)
assert.True(cl.Equals(l))
}
assert.True(cl.Equals(mustList(cl.Edit().Remove(cl.Len()-1, cl.Len()-1).List(context.Background()))))
@@ -633,12 +634,12 @@ func TestListRemoveEverything(t *testing.T) {
vrw := newTestValueStore()
l, err := getTestList().toList(vrw)
assert.NoError(err)
require.NoError(t, err)
cl, err := l.Edit().Remove(0, getTestListLen()).List(context.Background())
assert.NoError(err)
require.NoError(t, err)
l, err = NewList(context.Background(), vrw)
assert.NoError(err)
require.NoError(t, err)
assert.True(l.Equals(cl))
assert.Equal(0, int(cl.Len()))
}
@@ -655,11 +656,11 @@ func TestListRemoveAtMiddle(t *testing.T) {
vrw := newTestValueStore()
cl, err := getTestList().toList(vrw)
assert.NoError(err)
require.NoError(t, err)
cl2, err := cl.Edit().RemoveAt(100).List(context.Background())
assert.NoError(err)
require.NoError(t, err)
cl3, err := cl2.Edit().RemoveAt(200).List(context.Background())
assert.NoError(err)
require.NoError(t, err)
expected := getTestList()
assert.Equal(expected, testListFromNomsList(cl))
@@ -690,16 +691,16 @@ func TestListRemoveRanges(t *testing.T) {
testList := getTestList()
whole, err := testList.toList(vrw)
assert.NoError(err)
require.NoError(t, err)
// Compare list equality. Increment by 256 (16^2) because each iteration requires building a new list, which is slow.
for incr, i := 256, 0; i < len(testList)-incr; i += incr {
for window := 1; window <= incr; window *= 16 {
testListPart := testList.Remove(i, i+window)
expected, err := testListPart.toList(vrw)
assert.NoError(err)
require.NoError(t, err)
actual, err := whole.Edit().Remove(uint64(i), uint64(i+window)).List(context.Background())
assert.NoError(err)
require.NoError(t, err)
assert.Equal(expected.Len(), actual.Len())
assert.True(expected.Equals(actual))
}
@@ -708,7 +709,7 @@ func TestListRemoveRanges(t *testing.T) {
// Compare list length, which doesn't require building a new list every iteration, so the increment can be smaller.
for incr, i := 10, 0; i < len(testList)-incr; i += incr {
l, err := whole.Edit().Remove(uint64(i), uint64(i+incr)).List(context.Background())
assert.NoError(err)
require.NoError(t, err)
assert.Equal(len(testList)-incr, int(l.Len()))
}
}
@@ -726,13 +727,13 @@ func TestListRemoveAtEnd(t *testing.T) {
tl := getTestListWithLen(testListSize / 10)
cl, err := tl.toList(vrw)
assert.NoError(err)
require.NoError(t, err)
for i := len(tl) - 1; i >= 0; i-- {
cl, err = cl.Edit().Remove(uint64(i), uint64(i+1)).List(context.Background())
assert.NoError(err)
require.NoError(t, err)
expect, err := tl[0:i].toList(vrw)
assert.NoError(err)
require.NoError(t, err)
assert.True(expect.Equals(cl))
}
}
@@ -750,16 +751,16 @@ func TestListSet(t *testing.T) {
testList := getTestList()
cl, err := testList.toList(vrw)
assert.NoError(err)
require.NoError(t, err)
testIdx := func(idx int, testEquality bool) {
newVal := Float(-1) // Test values are never < 0
cl2, err := cl.Edit().Set(uint64(idx), newVal).List(context.Background())
assert.NoError(err)
require.NoError(t, err)
assert.False(cl.Equals(cl2))
if testEquality {
l, err := testList.Set(idx, newVal).toList(vrw)
assert.NoError(err)
require.NoError(t, err)
assert.True(l.Equals(cl2))
}
}
@@ -781,7 +782,7 @@ func TestListFirstNNumbers(t *testing.T) {
nums := generateNumbersAsValues(testListSize)
_, err := NewList(context.Background(), vrw, nums...)
assert.NoError(t, err)
require.NoError(t, err)
}
func TestListRefOfStructFirstNNumbers(t *testing.T) {
@@ -792,7 +793,7 @@ func TestListRefOfStructFirstNNumbers(t *testing.T) {
nums := generateNumbersAsRefOfStructs(vrw, testListSize)
_, err := NewList(context.Background(), vrw, nums...)
assert.NoError(t, err)
require.NoError(t, err)
}
func TestListModifyAfterRead(t *testing.T) {
@@ -804,22 +805,22 @@ func TestListModifyAfterRead(t *testing.T) {
vs := newTestValueStore()
list, err := getTestList().toList(vs)
assert.NoError(err)
require.NoError(t, err)
// Drop chunk values.
ref, err := vs.WriteValue(context.Background(), list)
assert.NoError(err)
require.NoError(t, err)
v, err := vs.ReadValue(context.Background(), ref.TargetHash())
assert.NoError(err)
require.NoError(t, err)
list = v.(List)
// Modify/query. Once upon a time this would crash.
llen := list.Len()
z, err := list.Get(context.Background(), 0)
assert.NoError(err)
require.NoError(t, err)
list, err = list.Edit().RemoveAt(0).List(context.Background())
assert.NoError(err)
require.NoError(t, err)
assert.Equal(llen-1, list.Len())
list, err = list.Edit().Append(z).List(context.Background())
assert.NoError(err)
require.NoError(t, err)
assert.Equal(llen, list.Len())
}
@@ -860,9 +861,9 @@ func TestListDiffIdentical(t *testing.T) {
assert := assert.New(t)
nums := generateNumbersAsValues(5)
l1, err := NewList(context.Background(), vrw, nums...)
assert.NoError(err)
require.NoError(t, err)
l2, err := NewList(context.Background(), vrw, nums...)
assert.NoError(err)
require.NoError(t, err)
diff1 := accumulateDiffSplices(l1, l2)
diff2 := accumulateDiffSplices(l2, l1)
@@ -880,9 +881,9 @@ func TestListDiffVersusEmpty(t *testing.T) {
assert := assert.New(t)
nums1 := generateNumbersAsValues(5)
l1, err := NewList(context.Background(), vrw, nums1...)
assert.NoError(err)
require.NoError(t, err)
l2, err := NewList(context.Background(), vrw)
assert.NoError(err)
require.NoError(t, err)
diff1 := accumulateDiffSplices(l1, l2)
diff2 := accumulateDiffSplices(l2, l1)
@@ -907,9 +908,9 @@ func TestListDiffReverse(t *testing.T) {
nums1 := generateNumbersAsValues(5000)
nums2 := reverseValues(nums1)
l1, err := NewList(context.Background(), vrw, nums1...)
assert.NoError(err)
require.NoError(t, err)
l2, err := NewList(context.Background(), vrw, nums2...)
assert.NoError(err)
require.NoError(t, err)
diff1 := accumulateDiffSplices(l1, l2)
diff2 := accumulateDiffSplices(l2, l1)
@@ -936,14 +937,14 @@ func TestListDiffReverseWithLargerLimit(t *testing.T) {
nums2 := reverseValues(nums1)
l1, err := NewList(context.Background(), vrw, nums1...)
assert.NoError(err)
require.NoError(t, err)
l2, err := NewList(context.Background(), vrw, nums2...)
assert.NoError(err)
require.NoError(t, err)
diff1, err := accumulateDiffSplicesWithLimit(l1, l2, 27e6)
assert.NoError(err)
require.NoError(t, err)
diff2, err := accumulateDiffSplicesWithLimit(l2, l1, 27e6)
assert.NoError(err)
require.NoError(t, err)
assert.Equal(len(diff2), len(diff1))
diffExpected := []Splice{
@@ -971,9 +972,9 @@ func TestListDiffRemove5x100(t *testing.T) {
nums2 = spliceValues(nums2, (count-1)*1000, 100)
}
l1, err := NewList(context.Background(), vrw, nums1...)
assert.NoError(err)
require.NoError(t, err)
l2, err := NewList(context.Background(), vrw, nums2...)
assert.NoError(err)
require.NoError(t, err)
diff1 := accumulateDiffSplices(l1, l2)
diff2 := accumulateDiffSplices(l2, l1)
@@ -1006,9 +1007,9 @@ func TestListDiffAdd5x5(t *testing.T) {
nums2 = spliceValues(nums2, (count-1)*1000, 0, Float(0), Float(1), Float(2), Float(3), Float(4))
}
l1, err := NewList(context.Background(), vrw, nums1...)
assert.NoError(err)
require.NoError(t, err)
l2, err := NewList(context.Background(), vrw, nums2...)
assert.NoError(err)
require.NoError(t, err)
diff1 := accumulateDiffSplices(l1, l2)
diff2 := accumulateDiffSplices(l2, l1)
@@ -1042,9 +1043,9 @@ func TestListDiffReplaceReverse5x100(t *testing.T) {
nums2 = spliceValues(nums2, (count-1)*1000, 100, out...)
}
l1, err := NewList(context.Background(), vrw, nums1...)
assert.NoError(err)
require.NoError(t, err)
l2, err := NewList(context.Background(), vrw, nums2...)
assert.NoError(err)
require.NoError(t, err)
diff := accumulateDiffSplices(l2, l1)
diffExpected := []Splice{
@@ -1072,9 +1073,9 @@ func TestListDiffString1(t *testing.T) {
nums1 := []Value{String("one"), String("two"), String("three")}
nums2 := []Value{String("one"), String("two"), String("three")}
l1, err := NewList(context.Background(), vrw, nums1...)
assert.NoError(err)
require.NoError(t, err)
l2, err := NewList(context.Background(), vrw, nums2...)
assert.NoError(err)
require.NoError(t, err)
diff := accumulateDiffSplices(l2, l1)
assert.Equal(0, len(diff))
@@ -1090,9 +1091,9 @@ func TestListDiffString2(t *testing.T) {
nums1 := []Value{String("one"), String("two"), String("three")}
nums2 := []Value{String("one"), String("two"), String("three"), String("four")}
l1, err := NewList(context.Background(), vrw, nums1...)
assert.NoError(err)
require.NoError(t, err)
l2, err := NewList(context.Background(), vrw, nums2...)
assert.NoError(err)
require.NoError(t, err)
diff := accumulateDiffSplices(l2, l1)
diffExpected := []Splice{
@@ -1111,9 +1112,9 @@ func TestListDiffString3(t *testing.T) {
nums1 := []Value{String("one"), String("two"), String("three")}
nums2 := []Value{String("one"), String("two"), String("four")}
l1, err := NewList(context.Background(), vrw, nums1...)
assert.NoError(err)
require.NoError(t, err)
l2, err := NewList(context.Background(), vrw, nums2...)
assert.NoError(err)
require.NoError(t, err)
diff := accumulateDiffSplices(l2, l1)
diffExpected := []Splice{
@@ -1135,32 +1136,33 @@ func TestListDiffLargeWithSameMiddle(t *testing.T) {
vs1 := NewValueStore(cs1)
nums1 := generateNumbersAsValues(4000)
l1, err := NewList(context.Background(), vs1, nums1...)
assert.NoError(err)
require.NoError(t, err)
ref, err := vs1.WriteValue(context.Background(), l1)
assert.NoError(err)
require.NoError(t, err)
hash1 := ref.TargetHash()
rt, err := vs1.Root(context.Background())
assert.NoError(err)
require.NoError(t, err)
_, err = vs1.Commit(context.Background(), rt, rt)
assert.NoError(err)
require.NoError(t, err)
v, err := vs1.ReadValue(context.Background(), hash1)
assert.NoError(err)
require.NoError(t, err)
refList1 := v.(List)
cs2 := storage.NewView()
vs2 := NewValueStore(cs2)
nums2 := generateNumbersAsValuesFromToBy(5, 3550, 1)
l2, err := NewList(context.Background(), vs2, nums2...)
assert.NoError(err)
require.NoError(t, err)
ref, err = vs2.WriteValue(context.Background(), l2)
assert.NoError(err)
require.NoError(t, err)
hash2 := ref.TargetHash()
rt, err = vs1.Root(context.Background())
assert.NoError(err)
require.NoError(t, err)
_, err = vs2.Commit(context.Background(), rt, rt)
assert.NoError(err)
require.NoError(t, err)
v, err = vs2.ReadValue(context.Background(), hash2)
require.NoError(t, err)
refList2 := v.(List)
// diff lists without value store
@@ -1188,13 +1190,14 @@ func TestListDiffAllValuesInSequenceRemoved(t *testing.T) {
newSequenceMetaTuple := func(vs ...Value) metaTuple {
seq, err := newListLeafSequence(vrw, vs...)
assert.NoError(err)
require.NoError(t, err)
list := newList(seq)
ref, err := vrw.WriteValue(context.Background(), list)
assert.NoError(err)
require.NoError(t, err)
ordKey, err := orderedKeyFromInt(len(vs), Format_7_18)
require.NoError(t, err)
mt, err := newMetaTuple(ref, ordKey, uint64(len(vs)))
assert.NoError(err)
require.NoError(t, err)
return mt
}
@@ -1204,10 +1207,10 @@ func TestListDiffAllValuesInSequenceRemoved(t *testing.T) {
m3 := newSequenceMetaTuple(Float(9), Float(10), Float(11), Float(12), Float(13), Float(14), Float(15))
mseq, err := newListMetaSequence(1, []metaTuple{m1, m3}, vrw)
assert.NoError(err)
require.NoError(t, err)
l1 := newList(mseq) // [1, 2, 3][9, 10, 11, 12, 13, 14, 15]
mseq, err = newListMetaSequence(1, []metaTuple{m1, m2, m3}, vrw)
assert.NoError(err)
require.NoError(t, err)
l2 := newList(mseq) // [1, 2, 3][4, 5, 6, 7, 8][9, 10, 11, 12, 13, 14, 15]
diff := accumulateDiffSplices(l2, l1)
@@ -1230,19 +1233,19 @@ func TestListTypeAfterMutations(t *testing.T) {
values := generateNumbersAsValues(n)
l, err := NewList(context.Background(), vrw, values...)
assert.NoError(err)
require.NoError(t, err)
assert.Equal(l.Len(), uint64(n))
assert.IsType(c, l.asSequence())
assert.True(mustType(TypeOf(l)).Equals(mustType(MakeListType(PrimitiveTypeMap[FloatKind]))))
l, err = l.Edit().Append(String("a")).List(context.Background())
assert.NoError(err)
require.NoError(t, err)
assert.Equal(l.Len(), uint64(n+1))
assert.IsType(c, l.asSequence())
assert.True(mustType(TypeOf(l)).Equals(mustType(MakeListType(mustType(MakeUnionType(PrimitiveTypeMap[FloatKind], PrimitiveTypeMap[StringKind]))))))
l, err = l.Edit().Splice(l.Len()-1, 1).List(context.Background())
assert.NoError(err)
require.NoError(t, err)
assert.Equal(l.Len(), uint64(n))
assert.IsType(c, l.asSequence())
assert.True(mustType(TypeOf(l)).Equals(mustType(MakeListType(PrimitiveTypeMap[FloatKind]))))
@@ -1261,22 +1264,23 @@ func TestListRemoveLastWhenNotLoaded(t *testing.T) {
vs := newTestValueStore()
reload := func(l List) List {
ref, err := vs.WriteValue(context.Background(), l)
assert.NoError(err)
require.NoError(t, err)
v, err := vs.ReadValue(context.Background(), ref.TargetHash())
require.NoError(t, err)
return v.(List)
}
tl := newTestList(1024)
nl, err := tl.toList(vs)
assert.NoError(err)
require.NoError(t, err)
for len(tl) > 0 {
tl = tl[:len(tl)-1]
l, err := nl.Edit().RemoveAt(uint64(len(tl))).List(context.Background())
assert.NoError(err)
require.NoError(t, err)
nl = reload(l)
l, err = tl.toList(vs)
assert.NoError(err)
require.NoError(t, err)
assert.True(l.Equals(nl))
}
}
@@ -1294,9 +1298,9 @@ func TestListConcat(t *testing.T) {
vs := newTestValueStore()
reload := func(vs *ValueStore, l List) List {
ref, err := vs.WriteValue(context.Background(), l)
assert.NoError(err)
require.NoError(t, err)
val, err := vs.ReadValue(context.Background(), ref.TargetHash())
assert.NoError(err)
require.NoError(t, err)
return val.(List)
}
@@ -1309,13 +1313,13 @@ func TestListConcat(t *testing.T) {
}
list, err := listSlice.toList(vs)
assert.NoError(err)
require.NoError(t, err)
for i := from; i < to; i += by {
fst := reload(vs, mustList(listSlice[:i].toList(vs)))
snd := reload(vs, mustList(listSlice[i:].toList(vs)))
actual, err := fst.Concat(context.Background(), snd)
assert.NoError(err)
require.NoError(t, err)
assert.True(list.Equals(actual),
"fail at %d/%d (with expected length %d, actual %d)", i, size, list.Len(), actual.Len())
}
@@ -1347,11 +1351,11 @@ func TestListConcatDifferentTypes(t *testing.T) {
whole = append(whole, snd...)
nl, err := NewList(context.Background(), vrw, fst...)
assert.NoError(err)
require.NoError(t, err)
concat, err := nl.Concat(context.Background(), mustList(NewList(context.Background(), vrw, snd...)))
assert.NoError(err)
require.NoError(t, err)
nl, err = NewList(context.Background(), vrw, whole...)
assert.NoError(err)
require.NoError(t, err)
assert.True(nl.Equals(concat))
}
@@ -1368,7 +1372,7 @@ func TestListWithStructShouldHaveOptionalFields(t *testing.T) {
"b": String("bar"),
})),
)
assert.NoError(err)
require.NoError(t, err)
assert.True(
mustType(MakeListType(mustType(MakeStructType("Foo",
StructField{"a", PrimitiveTypeMap[FloatKind], false},
@@ -1393,18 +1397,18 @@ func TestListOfListsDoesNotWriteRoots(t *testing.T) {
vrw := newTestValueStore()
l1, err := NewList(context.Background(), vrw, String("a"), String("b"))
assert.NoError(err)
require.NoError(t, err)
l2, err := NewList(context.Background(), vrw, String("c"), String("d"))
assert.NoError(err)
require.NoError(t, err)
l3, err := NewList(context.Background(), vrw, l1, l2)
assert.NoError(err)
require.NoError(t, err)
assert.Nil(mustValue(vrw.ReadValue(context.Background(), mustHash(l1.Hash(Format_7_18)))))
assert.Nil(mustValue(vrw.ReadValue(context.Background(), mustHash(l2.Hash(Format_7_18)))))
assert.Nil(mustValue(vrw.ReadValue(context.Background(), mustHash(l3.Hash(Format_7_18)))))
_, err = vrw.WriteValue(context.Background(), l3)
assert.NoError(err)
require.NoError(t, err)
assert.Nil(mustValue(vrw.ReadValue(context.Background(), mustHash(l1.Hash(Format_7_18)))))
assert.Nil(mustValue(vrw.ReadValue(context.Background(), mustHash(l2.Hash(Format_7_18)))))
}

14
go/store/types/map_iterator_test.go
View File

@@ -35,18 +35,18 @@ func TestMapIterator(t *testing.T) {
vrw := newTestValueStore()
m, err := NewMap(context.Background(), vrw)
assert.NoError(err)
require.NoError(t, err)
me := m.Edit()
for i := 0; i < 5; i++ {
me.Set(String(string(byte(65+i))), Float(i))
}
m, err = me.Map(context.Background())
assert.NoError(err)
require.NoError(t, err)
test := func(it MapIterator, start int, msg string) {
for i := start; i < 5; i++ {
k, v, err := it.Next(context.Background())
assert.NoError(err)
require.NoError(t, err)
assert.True(k.Equals(k), msg)
assert.True(v.Equals(v), msg)
@@ -54,7 +54,7 @@ func TestMapIterator(t *testing.T) {
assert.True(Float(i).Equals(v), msg)
}
k, v, err := it.Next(context.Background())
assert.NoError(err)
require.NoError(t, err)
assert.Nil(k, msg)
assert.Nil(v, msg)
}
@@ -75,7 +75,7 @@ func TestReverseMapIterator(t *testing.T) {
ctx := context.Background()
vrw := newTestValueStore()
m, err := NewMap(ctx, vrw)
assert.NoError(t, err)
require.NoError(t, err)
me := m.Edit()
for i := 0; i <= 100; i += 2 {
@@ -83,7 +83,7 @@ func TestReverseMapIterator(t *testing.T) {
}
m, err = me.Map(context.Background())
assert.NoError(t, err)
require.NoError(t, err)
test := func(start, expected int, name string) {
t.Run(name, func(t *testing.T) {
@@ -95,7 +95,7 @@ func TestReverseMapIterator(t *testing.T) {
for {
k, v, err := it.Next(ctx)
assert.NoError(t, err)
require.NoError(t, err)
if k == nil {
break

259
go/store/types/map_test.go
View File

@@ -33,6 +33,7 @@ import (
"github.com/google/uuid"
"github.com/shopspring/decimal"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"github.com/stretchr/testify/suite"
"github.com/dolthub/dolt/go/store/chunks"
@@ -195,7 +196,7 @@ func validateMap(t *testing.T, vrw ValueReadWriter, m Map, entries mapEntrySlice
return nil
})
assert.NoError(t, err)
require.NoError(t, err)
assert.True(t, out.Equals(entries))
}
@@ -474,7 +475,7 @@ func TestMapDiff(t *testing.T) {
map2 := testMap2.toMap(vrw)
mapDiffAdded, mapDiffRemoved, mapDiffModified, err := accumulateMapDiffChanges(map1, map2)
assert.NoError(t, err)
require.NoError(t, err)
assert.Equal(t, testMapAdded, mapDiffAdded, "testMap.diff != map.diff")
assert.Equal(t, testMapRemoved, mapDiffRemoved, "testMap.diff != map.diff")
assert.Equal(t, testMapModified, mapDiffModified, "testMap.diff != map.diff")
@@ -502,26 +503,26 @@ func TestMapMutationReadWriteCount(t *testing.T) {
numEdits := 10000
vals := make([]Value, 0, numEdits)
m, err := NewMap(context.Background(), vs)
assert.NoError(t, err)
require.NoError(t, err)
me := m.Edit()
for i := 0; i < 10000; i++ {
s, err := newLargeStruct(i)
assert.NoError(t, err)
require.NoError(t, err)
vals = append(vals, s)
me.Set(Float(i), s)
}
m, err = me.Map(context.Background())
assert.NoError(t, err)
require.NoError(t, err)
r, err := vs.WriteValue(context.Background(), m)
assert.NoError(t, err)
require.NoError(t, err)
rt, err := vs.Root(context.Background())
assert.NoError(t, err)
require.NoError(t, err)
_, err = vs.Commit(context.Background(), rt, rt)
assert.NoError(t, err)
require.NoError(t, err)
v, err := r.TargetValue(context.Background(), vs)
assert.NoError(t, err)
require.NoError(t, err)
m = v.(Map)
assert.NoError(t, err)
require.NoError(t, err)
every := 100
@@ -531,10 +532,10 @@ func TestMapMutationReadWriteCount(t *testing.T) {
k := Float(i)
s := vals[i].(Struct)
n, ok, err := s.MaybeGet("Number")
assert.NoError(t, err)
require.NoError(t, err)
assert.True(t, ok)
s, err = s.Set("Number", Float(float64(n.(Float))+1))
assert.NoError(t, err)
require.NoError(t, err)
me.Set(k, s)
}
}
@@ -543,15 +544,15 @@ func TestMapMutationReadWriteCount(t *testing.T) {
rdCnt := cs.Reads()
m, err = me.Map(context.Background())
assert.NoError(t, err)
require.NoError(t, err)
rt, err = vs.Root(context.Background())
assert.NoError(t, err)
require.NoError(t, err)
_, err = vs.Commit(context.Background(), rt, rt)
assert.NoError(t, err)
require.NoError(t, err)
ref, err := NewRef(m, Format_7_18)
assert.NoError(t, err)
require.NoError(t, err)
assert.Equal(t, uint64(3), ref.Height())
assert.Equal(t, 105, cs.Reads()-rdCnt)
assert.Equal(t, 62, cs.Writes()-wrCnt)
@@ -573,7 +574,7 @@ func TestMapInfiniteChunkBug(t *testing.T) {
prefix := buff.String()
m, err := NewMap(context.Background(), vrw)
assert.NoError(t, err)
require.NoError(t, err)
me := m.Edit()
for i := 0; i < 10000; i++ {
@@ -581,7 +582,7 @@ func TestMapInfiniteChunkBug(t *testing.T) {
}
_, err = me.Map(context.Background())
assert.NoError(t, err)
require.NoError(t, err)
}
func TestNewMap(t *testing.T) {
@@ -589,17 +590,17 @@ func TestNewMap(t *testing.T) {
vrw := newTestValueStore()
m, err := NewMap(context.Background(), vrw)
assert.NoError(err)
require.NoError(t, err)
assert.Equal(uint64(0), m.Len())
m, err = NewMap(context.Background(), vrw, String("foo1"), String("bar1"), String("foo2"), String("bar2"))
assert.NoError(err)
require.NoError(t, err)
assert.Equal(uint64(2), m.Len())
foo1Str, ok, err := m.MaybeGet(context.Background(), String("foo1"))
assert.NoError(err)
require.NoError(t, err)
assert.True(ok)
assert.True(String("bar1").Equals(foo1Str))
foo2Str, ok, err := m.MaybeGet(context.Background(), String("foo2"))
assert.NoError(err)
require.NoError(t, err)
assert.True(ok)
assert.True(String("bar2").Equals(foo2Str))
}
@@ -615,10 +616,10 @@ func TestMapUniqueKeysString(t *testing.T) {
String("hello"), String("foo"),
}
m, err := NewMap(context.Background(), vrw, l...)
assert.NoError(err)
require.NoError(t, err)
assert.Equal(uint64(3), m.Len())
v, ok, err := m.MaybeGet(context.Background(), String("hello"))
assert.NoError(err)
require.NoError(t, err)
assert.True(ok)
assert.True(String("foo").Equals(v))
}
@@ -635,10 +636,10 @@ func TestMapUniqueKeysNumber(t *testing.T) {
Float(1), Float(5),
}
m, err := NewMap(context.Background(), vrw, l...)
assert.NoError(err)
require.NoError(t, err)
assert.Equal(uint64(4), m.Len())
v, ok, err := m.MaybeGet(context.Background(), Float(1))
assert.NoError(err)
require.NoError(t, err)
assert.True(ok)
assert.True(Float(5).Equals(v))
}
@@ -660,19 +661,19 @@ func TestMapHas(t *testing.T) {
tm := toTestMap(scale, vrw)
m := tm.toMap(vrw)
ref, err := vrw.WriteValue(context.Background(), m)
assert.NoError(err)
require.NoError(t, err)
mval2, err := vrw.ReadValue(context.Background(), ref.TargetHash())
m2 := mval2.(Map)
for _, entry := range tm.entries.entries {
k, v := entry.key, entry.value
assert.True(m.Has(context.Background(), k))
kv, ok, err := m.MaybeGet(context.Background(), k)
assert.NoError(err)
require.NoError(t, err)
assert.True(ok)
assert.True(kv.Equals(v))
assert.True(m2.Has(context.Background(), k))
kv, ok, err = m2.MaybeGet(context.Background(), k)
assert.NoError(err)
require.NoError(t, err)
assert.True(ok)
assert.True(kv.Equals(v))
}
@@ -716,7 +717,7 @@ func TestMapHasRemove(t *testing.T) {
vrw := newTestValueStore()
m, err := NewMap(context.Background(), vrw)
assert.NoError(err)
require.NoError(t, err)
me := m.Edit()
initial := []string{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m"}
@@ -726,7 +727,7 @@ func TestMapHasRemove(t *testing.T) {
}
m, err = me.Map(context.Background())
assert.NoError(err)
require.NoError(t, err)
assert.True(m.Len() == uint64(len(initial)))
assert.True(hasAll(m, initial...))
assert.True(hasNone(m, initialUnexpected...))
@@ -759,7 +760,7 @@ func TestMapHasRemove(t *testing.T) {
me.Set(String("r"), Int(1))
m, err = me.Map(context.Background())
assert.NoError(err)
require.NoError(t, err)
expected := []string{"a", "c", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "p", "q", "r", "s"}
unexpected := []string{"b", "d", "o"}
assert.True(hasAll(m, expected...))
@@ -785,7 +786,7 @@ func TestMapRemove(t *testing.T) {
run := func(i int) {
expected := tm.Remove(i, i+1).toMap(vs)
actual, err := whole.Edit().Remove(tm.entries.entries[i].key).Map(context.Background())
assert.NoError(err)
require.NoError(t, err)
assert.Equal(expected.Len(), actual.Len())
assert.True(expected.Equals(actual))
diffMapTest(assert, expected, actual, 0, 0, 0)
@@ -813,7 +814,7 @@ func TestMapRemoveNonexistentKey(t *testing.T) {
tm := getTestNativeOrderMap(2, vrw)
original := tm.toMap(vrw)
actual, err := original.Edit().Remove(Float(-1)).Map(context.Background()) // rand.Int63 returns non-negative numbers.
assert.NoError(err)
require.NoError(t, err)
assert.Equal(original.Len(), actual.Len())
assert.True(original.Equals(actual))
@@ -828,16 +829,16 @@ func TestMapFirst(t *testing.T) {
vrw := newTestValueStore()
m1, err := NewMap(context.Background(), vrw)
assert.NoError(err)
require.NoError(t, err)
k, v, err := m1.First(context.Background())
assert.NoError(err)
require.NoError(t, err)
assert.Nil(k)
assert.Nil(v)
m1, err = m1.Edit().Set(String("foo"), String("bar")).Set(String("hot"), String("dog")).Map(context.Background())
assert.NoError(err)
require.NoError(t, err)
ak, av, err := m1.First(context.Background())
assert.NoError(err)
require.NoError(t, err)
var ek, ev Value
err = m1.Iter(context.Background(), func(k, v Value) (stop bool, err error) {
@@ -845,7 +846,7 @@ func TestMapFirst(t *testing.T) {
return true, nil
})
assert.NoError(err)
require.NoError(t, err)
assert.True(ek.Equals(ak))
assert.True(ev.Equals(av))
}
@@ -864,9 +865,9 @@ func TestMapFirst2(t *testing.T) {
tm := toTestMap(scale, vrw)
m := tm.toMap(vrw)
err := SortWithErroringLess(tm.entries)
assert.NoError(err)
require.NoError(t, err)
actualKey, actualValue, err := m.First(context.Background())
assert.NoError(err)
require.NoError(t, err)
assert.True(tm.entries.entries[0].key.Equals(actualKey))
assert.True(tm.entries.entries[0].value.Equals(actualValue))
}
@@ -886,16 +887,16 @@ func TestMapLast(t *testing.T) {
vrw := newTestValueStore()
m1, err := NewMap(context.Background(), vrw)
assert.NoError(err)
require.NoError(t, err)
k, v, err := m1.First(context.Background())
assert.NoError(err)
require.NoError(t, err)
assert.Nil(k)
assert.Nil(v)
m1, err = m1.Edit().Set(String("foo"), String("bar")).Set(String("hot"), String("dog")).Map(context.Background())
assert.NoError(err)
require.NoError(t, err)
ak, av, err := m1.Last(context.Background())
assert.NoError(err)
require.NoError(t, err)
var ek, ev Value
err = m1.Iter(context.Background(), func(k, v Value) (stop bool, err error) {
@@ -903,7 +904,7 @@ func TestMapLast(t *testing.T) {
return false, nil
})
assert.NoError(err)
require.NoError(t, err)
assert.True(ek.Equals(ak))
assert.True(ev.Equals(av))
}
@@ -922,9 +923,9 @@ func TestMapLast2(t *testing.T) {
tm := toTestMap(scale, vrw)
m := tm.toMap(vrw)
err := SortWithErroringLess(tm.entries)
assert.NoError(err)
require.NoError(t, err)
actualKey, actualValue, err := m.Last(context.Background())
assert.NoError(err)
require.NoError(t, err)
assert.True(tm.entries.entries[len(tm.entries.entries)-1].key.Equals(actualKey))
assert.True(tm.entries.entries[len(tm.entries.entries)-1].value.Equals(actualValue))
}
@@ -946,16 +947,16 @@ func TestMapSetGet(t *testing.T) {
assertMapVal := func(me *MapEditor, k, expectedVal Value) *MapEditor {
m, err := me.Map(ctx)
assert.NoError(err)
require.NoError(t, err)
mV, ok, err := m.MaybeGet(ctx, k)
assert.NoError(err)
require.NoError(t, err)
assert.True(ok == (expectedVal != nil))
assert.True((expectedVal == nil && mV == nil) || expectedVal.Equals(mV))
return m.Edit()
}
m, err := NewMap(ctx, vrw)
assert.NoError(err)
require.NoError(t, err)
me := m.Edit()
me = assertMapVal(me, String("a"), nil)
@@ -997,7 +998,7 @@ func TestMapSetGet(t *testing.T) {
me = assertMapVal(me, String("never-inserted"), nil)
m, err = me.Map(context.Background())
assert.NoError(err)
require.NoError(t, err)
assert.True(m.Len() == 0)
}
@@ -1006,10 +1007,10 @@ func validateMapInsertion(t *testing.T, tm testMap) {
ctx := context.Background()
allMap, err := NewMap(context.Background(), vrw)
assert.NoError(t, err)
require.NoError(t, err)
allMe := allMap.Edit()
incrMap, err := NewMap(context.Background(), vrw)
assert.NoError(t, err)
require.NoError(t, err)
incrMe := incrMap.Edit()
for _, entry := range tm.entries.entries {
@@ -1017,14 +1018,14 @@ func validateMapInsertion(t *testing.T, tm testMap) {
incrMe.Set(entry.key, entry.value)
currIncrMap, err := incrMe.Map(ctx)
assert.NoError(t, err)
require.NoError(t, err)
incrMe = currIncrMap.Edit()
}
m1, err := allMe.Map(ctx)
assert.NoError(t, err)
require.NoError(t, err)
m2, err := incrMe.Map(ctx)
assert.NoError(t, err)
require.NoError(t, err)
validateMap(t, vrw, m1, tm.entries)
validateMap(t, vrw, m2, tm.entries)
@@ -1057,7 +1058,7 @@ func TestMapSet(t *testing.T) {
expected := tm.toMap(vrw)
run := func(from, to int) {
actual, err := tm.Remove(from, to).toMap(vrw).Edit().SetM(toValuable(tm.Flatten(from, to))...).Map(context.Background())
assert.NoError(err)
require.NoError(t, err)
assert.Equal(expected.Len(), actual.Len())
assert.True(expected.Equals(actual))
diffMapTest(assert, expected, actual, 0, 0, 0)
@@ -1080,23 +1081,23 @@ func TestMapSetM(t *testing.T) {
vrw := newTestValueStore()
m1, err := NewMap(context.Background(), vrw)
assert.NoError(err)
require.NoError(t, err)
m2, err := m1.Edit().SetM().Map(context.Background())
assert.NoError(err)
require.NoError(t, err)
assert.True(m1.Equals(m2))
m3, err := m2.Edit().SetM(String("foo"), String("bar"), String("hot"), String("dog")).Map(context.Background())
assert.NoError(err)
require.NoError(t, err)
assert.Equal(uint64(2), m3.Len())
fooStr, ok, err := m3.MaybeGet(context.Background(), String("foo"))
assert.NoError(err)
require.NoError(t, err)
assert.True(ok)
assert.True(String("bar").Equals(fooStr))
hotStr, ok, err := m3.MaybeGet(context.Background(), String("hot"))
assert.NoError(err)
require.NoError(t, err)
assert.True(ok)
assert.True(String("dog").Equals(hotStr))
m4, err := m3.Edit().SetM(String("mon"), String("key")).Map(context.Background())
assert.NoError(err)
require.NoError(t, err)
assert.Equal(uint64(2), m3.Len())
assert.Equal(uint64(3), m4.Len())
}
@@ -1124,7 +1125,7 @@ func TestMapSetExistingKeyToNewValue(t *testing.T) {
var err error
actual, err = actual.Edit().Set(entry.key, newValue).Map(context.Background())
assert.NoError(err)
require.NoError(t, err)
}
expected := expectedWorking.toMap(vrw)
@@ -1140,7 +1141,7 @@ func TestMapDuplicateSet(t *testing.T) {
vrw := newTestValueStore()
m1, err := NewMap(context.Background(), vrw, Bool(true), Bool(true), Float(42), Float(42), Float(42), Float(42))
assert.NoError(err)
require.NoError(t, err)
assert.Equal(uint64(2), m1.Len())
}
@@ -1160,13 +1161,13 @@ func TestMapMaybeGet(t *testing.T) {
m := tm.toMap(vrw)
for _, entry := range tm.entries.entries {
v, ok, err := m.MaybeGet(context.Background(), entry.key)
assert.NoError(err)
require.NoError(t, err)
if assert.True(ok, "%v should have been in the map!", entry.key) {
assert.True(v.Equals(entry.value), "%v != %v", v, entry.value)
}
}
_, ok, err := m.MaybeGet(context.Background(), tm.knownBadKey)
assert.NoError(err)
require.NoError(t, err)
assert.False(ok, "m should not contain %v", tm.knownBadKey)
}
@@ -1182,7 +1183,7 @@ func TestMapIter(t *testing.T) {
m, err := NewMap(context.Background(), vrw)
assert.NoError(err)
require.NoError(t, err)
type entry struct {
key Value
@@ -1207,13 +1208,13 @@ func TestMapIter(t *testing.T) {
}
err = m.Iter(context.Background(), cb)
assert.NoError(err)
require.NoError(t, err)
assert.Equal(0, len(results))
m, err = m.Edit().Set(String("a"), Float(0)).Set(String("b"), Float(1)).Map(context.Background())
assert.NoError(err)
require.NoError(t, err)
err = m.Iter(context.Background(), cb)
assert.NoError(err)
require.NoError(t, err)
assert.Equal(2, len(results))
assert.True(got(String("a"), Float(0)))
assert.True(got(String("b"), Float(1)))
@@ -1221,7 +1222,7 @@ func TestMapIter(t *testing.T) {
results = resultList{}
stop = true
err = m.Iter(context.Background(), cb)
assert.NoError(err)
require.NoError(t, err)
assert.Equal(1, len(results))
// Iteration order not guaranteed, but it has to be one of these.
assert.True(got(String("a"), Float(0)) || got(String("b"), Float(1)))
@@ -1238,7 +1239,7 @@ func TestMapIter2(t *testing.T) {
tm := toTestMap(scale, vrw)
m := tm.toMap(vrw)
err := SortWithErroringLess(tm.entries)
assert.NoError(err)
require.NoError(t, err)
idx := uint64(0)
endAt := uint64(64)
@@ -1252,7 +1253,7 @@ func TestMapIter2(t *testing.T) {
return done, nil
})
assert.NoError(err)
require.NoError(t, err)
assert.Equal(endAt, idx-1)
}
@@ -1291,7 +1292,7 @@ func TestMapIterAll(t *testing.T) {
tm := toTestMap(scale, vrw)
m := tm.toMap(vrw)
err := SortWithErroringLess(tm.entries)
assert.NoError(err)
require.NoError(t, err)
idx := uint64(0)
err = m.IterAll(context.Background(), func(k, v Value) error {
@@ -1302,7 +1303,7 @@ func TestMapIterAll(t *testing.T) {
return nil
})
assert.NoError(err)
require.NoError(t, err)
}
doTest(getTestNativeOrderMap, 16)
@@ -1317,10 +1318,10 @@ func TestMapEquals(t *testing.T) {
vrw := newTestValueStore()
m1, err := NewMap(context.Background(), vrw)
assert.NoError(err)
require.NoError(t, err)
m2 := m1
m3, err := NewMap(context.Background(), vrw)
assert.NoError(err)
require.NoError(t, err)
assert.True(m1.Equals(m2))
assert.True(m2.Equals(m1))
@@ -1334,9 +1335,9 @@ func TestMapEquals(t *testing.T) {
diffMapTest(assert, m3, m2, 0, 0, 0)
m1, err = NewMap(context.Background(), vrw, String("foo"), Float(0.0), String("bar"), mustList(NewList(context.Background(), vrw)))
assert.NoError(err)
require.NoError(t, err)
m2, err = m2.Edit().Set(String("foo"), Float(0.0)).Set(String("bar"), mustList(NewList(context.Background(), vrw))).Map(context.Background())
assert.NoError(err)
require.NoError(t, err)
assert.True(m1.Equals(m2))
assert.True(m2.Equals(m1))
assert.False(m2.Equals(m3))
@@ -1355,9 +1356,9 @@ func TestMapNotStringKeys(t *testing.T) {
vrw := newTestValueStore()
b1, err := NewBlob(context.Background(), vrw, bytes.NewBufferString("blob1"))
assert.NoError(err)
require.NoError(t, err)
b2, err := NewBlob(context.Background(), vrw, bytes.NewBufferString("blob2"))
assert.NoError(err)
require.NoError(t, err)
l := []Value{
Bool(true), String("true"),
Bool(false), String("false"),
@@ -1373,16 +1374,16 @@ func TestMapNotStringKeys(t *testing.T) {
mustValue(NewSet(context.Background(), vrw, mustValue(NewSet(context.Background(), vrw)))), String("map of set/set"),
}
m1, err := NewMap(context.Background(), vrw, l...)
assert.NoError(err)
require.NoError(t, err)
assert.Equal(uint64(12), m1.Len())
for i := 0; i < len(l); i += 2 {
v, ok, err := m1.MaybeGet(context.Background(), l[i])
assert.NoError(err)
require.NoError(t, err)
assert.True(ok)
assert.True(v.Equals(l[i+1]))
}
v, ok, err := m1.MaybeGet(context.Background(), Float(42))
assert.NoError(err)
require.NoError(t, err)
assert.False(ok)
assert.Nil(v)
}
@@ -1692,27 +1693,27 @@ func TestMapEmpty(t *testing.T) {
ctx := context.Background()
m, err := NewMap(ctx, vrw)
assert.NoError(err)
require.NoError(t, err)
me := m.Edit()
m, err = me.Map(ctx)
assert.NoError(err)
require.NoError(t, err)
me = m.Edit()
assert.True(m.Empty())
me.Set(Bool(false), String("hi"))
m, err = me.Map(ctx)
assert.NoError(err)
require.NoError(t, err)
me = m.Edit()
assert.False(m.Empty())
l, err := NewList(ctx, vrw)
assert.NoError(err)
require.NoError(t, err)
m2, err := NewMap(ctx, vrw)
assert.NoError(err)
require.NoError(t, err)
me.Set(l, m2)
m, err = me.Map(ctx)
assert.NoError(err)
require.NoError(t, err)
assert.False(m.Empty())
}
@@ -1723,30 +1724,30 @@ func TestMapType(t *testing.T) {
emptyMapType := mustType(MakeMapType(mustType(MakeUnionType()), mustType(MakeUnionType())))
m, err := NewMap(context.Background(), vrw)
assert.NoError(err)
require.NoError(t, err)
mt, err := TypeOf(m)
assert.NoError(err)
require.NoError(t, err)
assert.True(mt.Equals(emptyMapType))
m2, err := m.Edit().Remove(String("B")).Map(context.Background())
assert.NoError(err)
require.NoError(t, err)
assert.True(emptyMapType.Equals(mustType(TypeOf(m2))))
tr, err := MakeMapType(PrimitiveTypeMap[StringKind], PrimitiveTypeMap[FloatKind])
assert.NoError(err)
require.NoError(t, err)
m2, err = m.Edit().Set(String("A"), Float(1)).Map(context.Background())
assert.NoError(err)
require.NoError(t, err)
assert.True(tr.Equals(mustType(TypeOf(m2))))
m2, err = m.Edit().Set(String("B"), Float(2)).Set(String("C"), Float(2)).Map(context.Background())
assert.NoError(err)
require.NoError(t, err)
assert.True(tr.Equals(mustType(TypeOf(m2))))
m3, err := m2.Edit().Set(String("A"), Bool(true)).Map(context.Background())
assert.NoError(err)
require.NoError(t, err)
assert.True(mustType(MakeMapType(PrimitiveTypeMap[StringKind], mustType(MakeUnionType(PrimitiveTypeMap[BoolKind], PrimitiveTypeMap[FloatKind])))).Equals(mustType(TypeOf(m3))), mustString(mustType(TypeOf(m3)).Describe(context.Background())))
m4, err := m3.Edit().Set(Bool(true), Float(1)).Map(context.Background())
assert.NoError(err)
require.NoError(t, err)
assert.True(mustType(MakeMapType(mustType(MakeUnionType(PrimitiveTypeMap[BoolKind], PrimitiveTypeMap[StringKind])), mustType(MakeUnionType(PrimitiveTypeMap[BoolKind], PrimitiveTypeMap[FloatKind])))).Equals(mustType(TypeOf(m4))))
}
@@ -1756,21 +1757,21 @@ func TestMapChunks(t *testing.T) {
vrw := newTestValueStore()
l1, err := NewMap(context.Background(), vrw, Float(0), Float(1))
assert.NoError(err)
require.NoError(t, err)
c1 := getChunks(l1)
assert.Len(c1, 0)
ref1, err := NewRef(Float(0), Format_7_18)
assert.NoError(err)
require.NoError(t, err)
l2, err := NewMap(context.Background(), vrw, ref1, Float(1))
assert.NoError(err)
require.NoError(t, err)
c2 := getChunks(l2)
assert.Len(c2, 1)
ref2, err := NewRef(Float(1), Format_7_18)
assert.NoError(err)
require.NoError(t, err)
l3, err := NewMap(context.Background(), vrw, Float(0), ref2)
assert.NoError(err)
require.NoError(t, err)
c3 := getChunks(l3)
assert.Len(c3, 1)
}
@@ -1789,7 +1790,7 @@ func TestMapFirstNNumbers(t *testing.T) {
}
m, err := NewMap(context.Background(), vrw, kvs...)
assert.NoError(err)
require.NoError(t, err)
assert.Equal(deriveCollectionHeight(m), getRefHeightOfCollection(m))
}
@@ -1803,16 +1804,16 @@ func TestMapRefOfStructFirstNNumbers(t *testing.T) {
kvs := []Value{}
for i := 0; i < testMapSize; i++ {
k, err := vs.WriteValue(context.Background(), mustValue(NewStruct(Format_7_18, "num", StructData{"n": Float(i)})))
assert.NoError(err)
require.NoError(t, err)
v, err := vs.WriteValue(context.Background(), mustValue(NewStruct(Format_7_18, "num", StructData{"n": Float(i + 1)})))
assert.NoError(err)
require.NoError(t, err)
assert.NotNil(k)
assert.NotNil(v)
kvs = append(kvs, k, v)
}
m, err := NewMap(context.Background(), vs, kvs...)
assert.NoError(err)
require.NoError(t, err)
// height + 1 because the leaves are Ref values (with height 1).
assert.Equal(deriveCollectionHeight(m)+1, getRefHeightOfCollection(m))
}
@@ -1828,24 +1829,24 @@ func TestMapModifyAfterRead(t *testing.T) {
// Drop chunk values.
ref, err := vs.WriteValue(context.Background(), m)
assert.NoError(err)
require.NoError(t, err)
v, err := vs.ReadValue(context.Background(), ref.TargetHash())
assert.NoError(err)
require.NoError(t, err)
m = v.(Map)
// Modify/query. Once upon a time this would crash.
fst, fstval, err := m.First(context.Background())
assert.NoError(err)
require.NoError(t, err)
m, err = m.Edit().Remove(fst).Map(context.Background())
assert.NoError(err)
require.NoError(t, err)
assert.False(m.Has(context.Background(), fst))
fst2, _, err := m.First(context.Background())
assert.NoError(err)
require.NoError(t, err)
assert.True(m.Has(context.Background(), fst2))
m, err = m.Edit().Set(fst, fstval).Map(context.Background())
assert.NoError(err)
require.NoError(t, err)
assert.True(m.Has(context.Background(), fst))
}
@@ -1862,19 +1863,19 @@ func TestMapTypeAfterMutations(t *testing.T) {
}
m, err := NewMap(context.Background(), vrw, values...)
assert.NoError(err)
require.NoError(t, err)
assert.Equal(m.Len(), uint64(n))
assert.IsType(c, m.asSequence())
assert.True(mustType(TypeOf(m)).Equals(mustType(MakeMapType(PrimitiveTypeMap[FloatKind], PrimitiveTypeMap[FloatKind]))))
m, err = m.Edit().Set(String("a"), String("a")).Map(context.Background())
assert.NoError(err)
require.NoError(t, err)
assert.Equal(m.Len(), uint64(n+1))
assert.IsType(c, m.asSequence())
assert.True(mustType(TypeOf(m)).Equals(mustType(MakeMapType(mustType(MakeUnionType(PrimitiveTypeMap[FloatKind], PrimitiveTypeMap[StringKind])), mustType(MakeUnionType(PrimitiveTypeMap[FloatKind], PrimitiveTypeMap[StringKind]))))))
m, err = m.Edit().Remove(String("a")).Map(context.Background())
assert.NoError(err)
require.NoError(t, err)
assert.Equal(m.Len(), uint64(n))
assert.IsType(c, m.asSequence())
assert.True(mustType(TypeOf(m)).Equals(mustType(MakeMapType(PrimitiveTypeMap[FloatKind], PrimitiveTypeMap[FloatKind]))))
@@ -1912,17 +1913,17 @@ func TestCompoundMapWithValuesOfEveryType(t *testing.T) {
}
m, err := NewMap(context.Background(), vrw, kvs...)
assert.NoError(err)
require.NoError(t, err)
for i := 1; m.asSequence().isLeaf(); i++ {
k := Float(i)
kvs = append(kvs, k, v)
m, err = m.Edit().Set(k, v).Map(context.Background())
assert.NoError(err)
require.NoError(t, err)
}
assert.Equal(len(kvs)/2, int(m.Len()))
fk, fv, err := m.First(context.Background())
assert.NoError(err)
require.NoError(t, err)
assert.True(bool(fk.(Bool)))
assert.True(v.Equals(fv))
@@ -1931,7 +1932,7 @@ func TestCompoundMapWithValuesOfEveryType(t *testing.T) {
assert.True(m.Has(context.Background(), keyOrValue))
retrievedVal, ok, err := m.MaybeGet(context.Background(), keyOrValue)
assert.True(ok)
assert.NoError(err)
require.NoError(t, err)
assert.True(v.Equals(retrievedVal))
} else {
assert.True(v.Equals(keyOrValue))
@@ -1942,7 +1943,7 @@ func TestCompoundMapWithValuesOfEveryType(t *testing.T) {
k := kvs[0]
kvs = kvs[2:]
m, err = m.Edit().Remove(k).Map(context.Background())
assert.NoError(err)
require.NoError(t, err)
assert.False(m.Has(context.Background(), k))
assert.Equal(len(kvs)/2, int(m.Len()))
}
@@ -1980,9 +1981,9 @@ func TestMapRemoveLastWhenNotLoaded(t *testing.T) {
entr = entr[:len(entr)-1]
tm.entries.entries = entr
m, err := nm.Edit().Remove(last.key).Map(context.Background())
assert.NoError(err)
require.NoError(t, err)
nm, err = reload(m)
assert.NoError(err)
require.NoError(t, err)
assert.True(tm.toMap(vs).Equals(nm))
}
}
@@ -2007,13 +2008,13 @@ func TestMapIterFrom(t *testing.T) {
res = append(res, k, v)
return false, nil
})
assert.NoError(err)
require.NoError(t, err)
return res
}
kvs := generateNumbersAsValuesFromToBy(-50, 50, 1)
m1, err := NewMap(context.Background(), vrw, kvs...)
assert.NoError(err)
require.NoError(t, err)
assert.True(kvs.Equals(test(m1, nil, Float(1000))))
assert.True(kvs.Equals(test(m1, Float(-1000), Float(1000))))
assert.True(kvs.Equals(test(m1, Float(-50), Float(1000))))
@@ -2032,11 +2033,11 @@ func TestMapAt(t *testing.T) {
values := []Value{Bool(false), Float(42), String("a"), String("b"), String("c"), String("d")}
m, err := NewMap(context.Background(), vrw, values...)
assert.NoError(err)
require.NoError(t, err)
for i := 0; i < len(values); i += 2 {
k, v, err := m.At(context.Background(), uint64(i/2))
assert.NoError(err)
require.NoError(t, err)
assert.Equal(values[i], k)
assert.Equal(values[i+1], v)
}

17
go/store/types/ordered_sequences_diff_test.go
View File

@@ -27,6 +27,7 @@ import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"github.com/stretchr/testify/suite"
)
@@ -221,11 +222,11 @@ func TestOrderedSequencesDiffCloseWithoutReading(t *testing.T) {
runTest := func(t *testing.T, df diffFn) {
set1, err := NewSet(context.Background(), vs)
assert.NoError(t, err)
require.NoError(t, err)
s1 := set1.orderedSequence
// A single item should be enough, but generate lots anyway.
set2, err := NewSet(context.Background(), vs, generateNumbersAsValuesFromToBy(0, 1000, 1)...)
assert.NoError(t, err)
require.NoError(t, err)
s2 := set2.orderedSequence
changeChan := make(chan ValueChanged)
@@ -279,15 +280,15 @@ func TestOrderedSequenceDiffWithMetaNodeGap(t *testing.T) {
}
m1, err := newSetSequenceMt(Float(1), Float(2))
assert.NoError(err)
require.NoError(t, err)
m2, err := newSetSequenceMt(Float(3), Float(4))
assert.NoError(err)
require.NoError(t, err)
m3, err := newSetSequenceMt(Float(5), Float(6))
assert.NoError(err)
require.NoError(t, err)
s1, err := newSetMetaSequence(1, []metaTuple{m1, m3}, vrw)
assert.NoError(err)
require.NoError(t, err)
s2, err := newSetMetaSequence(1, []metaTuple{m1, m2, m3}, vrw)
assert.NoError(err)
require.NoError(t, err)
runTest := func(df diffFn) {
var err error
@@ -316,7 +317,7 @@ func TestOrderedSequenceDiffWithMetaNodeGap(t *testing.T) {
i++
}
assert.Equal(len(expected), i)
assert.NoError(err)
require.NoError(t, err)
}
runTest(orderedSequenceDiffBest)

77
go/store/types/path_test.go
View File

@@ -28,6 +28,7 @@ import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"github.com/dolthub/dolt/go/store/hash"
)
@@ -65,7 +66,7 @@ func TestPathStruct(t *testing.T) {
"baz": Float(203),
})
assert.NoError(err)
require.NoError(t, err)
assertResolvesTo(assert, String("foo"), v, `.foo`)
assertResolvesTo(assert, Bool(false), v, `.bar`)
assertResolvesTo(assert, Float(203), v, `.baz`)
@@ -75,7 +76,7 @@ func TestPathStruct(t *testing.T) {
"v1": v,
})
assert.NoError(err)
require.NoError(t, err)
assertResolvesTo(assert, String("foo"), v2, `.v1.foo`)
assertResolvesTo(assert, Bool(false), v2, `.v1.bar`)
assertResolvesTo(assert, Float(203), v2, `.v1.baz`)
@@ -92,7 +93,7 @@ func TestPathStructType(t *testing.T) {
StructField{Name: "baz", Type: PrimitiveTypeMap[FloatKind]},
)
assert.NoError(err)
require.NoError(t, err)
assertResolvesTo(assert, PrimitiveTypeMap[StringKind], typ, `.foo`)
assertResolvesTo(assert, PrimitiveTypeMap[BoolKind], typ, `.bar`)
assertResolvesTo(assert, PrimitiveTypeMap[FloatKind], typ, `.baz`)
@@ -102,7 +103,7 @@ func TestPathStructType(t *testing.T) {
StructField{Name: "typ", Type: typ},
)
assert.NoError(err)
require.NoError(t, err)
assertResolvesTo(assert, typ, typ2, `.typ`)
assertResolvesTo(assert, PrimitiveTypeMap[StringKind], typ2, `.typ.foo`)
assertResolvesTo(assert, PrimitiveTypeMap[BoolKind], typ2, `.typ.bar`)
@@ -123,7 +124,7 @@ func TestPathIndex(t *testing.T) {
var err error
v, err = NewList(context.Background(), vs, Float(1), Float(3), String("foo"), Bool(false))
assert.NoError(err)
require.NoError(t, err)
resolvesTo(Float(1), Float(0), "[0]")
resolvesTo(Float(3), Float(1), "[1]")
@@ -143,7 +144,7 @@ func TestPathIndex(t *testing.T) {
String("two"), String("bar"),
)
assert.NoError(err)
require.NoError(t, err)
resolvesTo(String("foo"), Float(1), "[1]")
resolvesTo(String("bar"), String("two"), `["two"]`)
resolvesTo(Float(23), Bool(false), "[false]")
@@ -155,13 +156,13 @@ func TestPathIndexType(t *testing.T) {
assert := assert.New(t)
st, err := MakeSetType(PrimitiveTypeMap[FloatKind])
assert.NoError(err)
require.NoError(t, err)
lt, err := MakeListType(st)
assert.NoError(err)
require.NoError(t, err)
mt, err := MakeMapType(st, lt)
assert.NoError(err)
require.NoError(t, err)
ut, err := MakeUnionType(lt, mt, st)
assert.NoError(err)
require.NoError(t, err)
assertResolvesTo(assert, PrimitiveTypeMap[FloatKind], st, "[0]")
assertResolvesTo(assert, PrimitiveTypeMap[FloatKind], st, "[-1]")
@@ -204,13 +205,13 @@ func TestPathHashIndex(t *testing.T) {
b := Bool(true)
br, err := NewRef(b, Format_7_18)
assert.NoError(err)
require.NoError(t, err)
i := Float(0)
str := String("foo")
l, err := NewList(context.Background(), vs, b, i, str)
assert.NoError(err)
require.NoError(t, err)
lr, err := NewRef(l, Format_7_18)
assert.NoError(err)
require.NoError(t, err)
m, err := NewMap(context.Background(), vs,
b, br,
br, i,
@@ -218,9 +219,9 @@ func TestPathHashIndex(t *testing.T) {
l, lr,
lr, b,
)
assert.NoError(err)
require.NoError(t, err)
s, err := NewSet(context.Background(), vs, b, br, i, str, l, lr)
assert.NoError(err)
require.NoError(t, err)
resolvesTo := func(col, key, expVal, expKey Value) {
assertResolvesTo(assert, expVal, col, hashIdx(key))
@@ -273,7 +274,7 @@ func TestPathMulti(t *testing.T) {
String("c"), String("car"),
)
assert.NoError(err)
require.NoError(t, err)
m2, err := NewMap(context.Background(), vs,
Bool(false), String("earth"),
@@ -281,17 +282,17 @@ func TestPathMulti(t *testing.T) {
m1, String("fire"),
)
assert.NoError(err)
require.NoError(t, err)
l, err := NewList(context.Background(), vs, m1, m2)
assert.NoError(err)
require.NoError(t, err)
s, err := NewStruct(Format_7_18, "", StructData{
"foo": l,
})
assert.NoError(err)
require.NoError(t, err)
assertResolvesTo(assert, l, s, `.foo`)
assertResolvesTo(assert, m1, s, `.foo[0]`)
@@ -324,7 +325,7 @@ func TestPathParseSuccess(t *testing.T) {
test := func(str string) {
p, err := ParsePath(str)
assert.NoError(err)
require.NoError(t, err)
expectStr := str
switch expectStr { // Human readable serialization special cases.
case "[1e4]":
@@ -338,7 +339,7 @@ func TestPathParseSuccess(t *testing.T) {
}
h, err := Float(42).Hash(Format_7_18) // arbitrary hash
assert.NoError(err)
require.NoError(t, err)
test(".foo")
test(".foo@type")
@@ -454,19 +455,19 @@ func TestPathEquals(t *testing.T) {
assert.True(Path{}.Equals(Path{}))
for _, s := range equalPaths {
p, err := ParsePath(s)
assert.NoError(err)
require.NoError(t, err)
assert.True(p.Equals(p))
}
simple, err := ParsePath(`["one"].two`)
assert.NoError(err)
require.NoError(t, err)
assert.False(Path{}.Equals(simple))
for _, a := range notEqualPaths {
s0, s1 := a[0], a[1]
p0, err := ParsePath(s0)
assert.NoError(err)
require.NoError(t, err)
p1, err := ParsePath(s1)
assert.NoError(err)
require.NoError(t, err)
assert.False(p0.Equals(p1))
}
}
@@ -496,12 +497,12 @@ func TestCopyPath(t *testing.T) {
for _, s1 := range testCases {
expected, err := ParsePath(s1 + `["anIndex"]`)
assert.NoError(err)
require.NoError(t, err)
var p Path
if s1 != "" {
p, err = ParsePath(s1)
}
assert.NoError(err)
require.NoError(t, err)
p1 := p.Append(NewIndexPath(String("anIndex")))
if len(p) > 0 {
p[0] = expected[1] // if p1 really is a copy, this shouldn't be noticed
@@ -530,7 +531,7 @@ func TestPathType(t *testing.T) {
String("number"), Float(42),
String("List<number|string>"), mustList(NewList(context.Background(), vs, Float(42), String("foo"))),
String("Map<Bool, Bool>"), mustMap(NewMap(context.Background(), vs, Bool(true), Bool(false))))
assert.NoError(err)
require.NoError(t, err)
err = m.IterAll(context.Background(), func(k, cv Value) error {
ks := k.(String)
@@ -544,20 +545,20 @@ func TestPathType(t *testing.T) {
return nil
})
assert.NoError(err)
require.NoError(t, err)
assertResolvesTo(assert, PrimitiveTypeMap[StringKind], m, `["string"]@key@type`)
assertResolvesTo(assert, mustType(TypeOf(m)), m, `@type`)
s, err := NewStruct(Format_7_18, "", StructData{
"str": String("foo"),
"num": Float(42),
})
assert.NoError(err)
require.NoError(t, err)
str, ok, err := s.MaybeGet("str")
assert.NoError(err)
require.NoError(t, err)
assert.True(ok)
num, ok, err := s.MaybeGet("num")
assert.NoError(err)
require.NoError(t, err)
assert.True(ok)
assertResolvesTo(assert, mustType(TypeOf(str)), s, ".str@type")
assertResolvesTo(assert, mustType(TypeOf(num)), s, ".num@type")
@@ -569,15 +570,15 @@ func TestPathTarget(t *testing.T) {
s, err := NewStruct(Format_7_18, "", StructData{
"foo": String("bar"),
})
assert.NoError(err)
require.NoError(t, err)
vs := newTestValueStore()
r, err := vs.WriteValue(context.Background(), s)
assert.NoError(err)
require.NoError(t, err)
s2, err := NewStruct(Format_7_18, "", StructData{
"ref": r,
})
assert.NoError(err)
require.NoError(t, err)
assertResolvesToWithVR(assert, nil, String("notref"), `@target`, vs)
assertResolvesToWithVR(assert, s, r, `@target`, vs)
assertResolvesToWithVR(assert, String("bar"), r, `@target.foo`, vs)
@@ -597,7 +598,7 @@ func TestPathAtAnnotation(t *testing.T) {
var err error
v, err = NewList(context.Background(), vs, Float(1), Float(3), String("foo"), Bool(false))
assert.NoError(err)
require.NoError(t, err)
resolvesTo(Float(1), nil, "@at(0)")
resolvesTo(Float(3), nil, "@at(1)")
@@ -616,7 +617,7 @@ func TestPathAtAnnotation(t *testing.T) {
Float(2.3),
String("two"),
)
assert.NoError(err)
require.NoError(t, err)
resolvesTo(Bool(false), Bool(false), "@at(0)")
resolvesTo(Float(1), Float(1), "@at(1)")
@@ -635,7 +636,7 @@ func TestPathAtAnnotation(t *testing.T) {
Float(2.3), Float(4.5),
String("two"), String("bar"),
)
assert.NoError(err)
require.NoError(t, err)
resolvesTo(Float(23), Bool(false), "@at(0)")
resolvesTo(String("foo"), Float(1), "@at(1)")

15
go/store/types/ref_heap_test.go
View File

@@ -26,6 +26,7 @@ import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestRefByHeight(t *testing.T) {
@@ -47,13 +48,13 @@ func TestRefByHeight(t *testing.T) {
h := RefByHeight{}
r1, err := newRefWithHeight(1)
assert.NoError(err)
require.NoError(t, err)
r2, err := newRefWithHeight(2)
assert.NoError(err)
require.NoError(t, err)
r3, err := newRefWithHeight(3)
assert.NoError(err)
require.NoError(t, err)
r4, err := newRefWithHeight(2)
assert.NoError(err)
require.NoError(t, err)
h.PushBack(r1)
assert.Equal(r1, h.PeekEnd())
@@ -101,7 +102,7 @@ func TestDropIndices(t *testing.T) {
h := &RefByHeight{}
for i := 0; i < 10; i++ {
ref, err := NewRef(Float(i), Format_7_18)
assert.NoError(t, err)
require.NoError(t, err)
h.PushBack(ref)
}
sort.Sort(h)
@@ -119,9 +120,9 @@ func TestPopRefsOfHeight(t *testing.T) {
h := &RefByHeight{}
for i, n := range []int{6, 3, 6, 6, 2} {
hsh, err := Float(i).Hash(Format_7_18)
assert.NoError(t, err)
require.NoError(t, err)
r, err := constructRef(Format_7_18, hsh, PrimitiveTypeMap[FloatKind], uint64(n))
assert.NoError(t, err)
require.NoError(t, err)
h.PushBack(r)
}
sort.Sort(h)

33
go/store/types/ref_test.go
View File

@@ -26,6 +26,7 @@ import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestRefInList(t *testing.T) {
@@ -34,13 +35,13 @@ func TestRefInList(t *testing.T) {
vs := newTestValueStore()
l, err := NewList(context.Background(), vs)
assert.NoError(err)
require.NoError(t, err)
r, err := NewRef(l, Format_7_18)
assert.NoError(err)
require.NoError(t, err)
l, err = l.Edit().Append(r).List(context.Background())
assert.NoError(err)
require.NoError(t, err)
r2, err := l.Get(context.Background(), 0)
assert.NoError(err)
require.NoError(t, err)
assert.True(r.Equals(r2))
}
@@ -50,15 +51,15 @@ func TestRefInSet(t *testing.T) {
vs := newTestValueStore()
s, err := NewSet(context.Background(), vs)
assert.NoError(err)
require.NoError(t, err)
r, err := NewRef(s, Format_7_18)
assert.NoError(err)
require.NoError(t, err)
se, err := s.Edit().Insert(r)
assert.NoError(err)
require.NoError(t, err)
s, err = se.Set(context.Background())
assert.NoError(err)
require.NoError(t, err)
r2, err := s.First(context.Background())
assert.NoError(err)
require.NoError(t, err)
assert.True(r.Equals(r2))
}
@@ -68,18 +69,18 @@ func TestRefInMap(t *testing.T) {
vs := newTestValueStore()
m, err := NewMap(context.Background(), vs)
assert.NoError(err)
require.NoError(t, err)
r, err := NewRef(m, Format_7_18)
assert.NoError(err)
require.NoError(t, err)
m, err = m.Edit().Set(Float(0), r).Set(r, Float(1)).Map(context.Background())
assert.NoError(err)
require.NoError(t, err)
r2, ok, err := m.MaybeGet(context.Background(), Float(0))
assert.NoError(err)
require.NoError(t, err)
assert.True(ok)
assert.True(r.Equals(r2))
i, ok, err := m.MaybeGet(context.Background(), r)
assert.NoError(err)
require.NoError(t, err)
assert.True(ok)
assert.Equal(int32(1), int32(i.(Float)))
}
@@ -90,9 +91,9 @@ func TestRefChunks(t *testing.T) {
vs := newTestValueStore()
l, err := NewList(context.Background(), vs)
assert.NoError(err)
require.NoError(t, err)
r, err := NewRef(l, Format_7_18)
assert.NoError(err)
require.NoError(t, err)
assert.Len(getChunks(r), 1)
assert.Equal(r, getChunks(r)[0])
}

3
go/store/types/sequence_cursor_test.go
View File

@@ -26,6 +26,7 @@ import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"github.com/dolthub/dolt/go/store/hash"
)
@@ -158,7 +159,7 @@ func TestTestCursor(t *testing.T) {
assert.Equal(expectOk, cur.valid())
if cur.valid() {
seq, err := cur.current()
assert.NoError(err)
require.NoError(t, err)
assert.Equal(expectVal, seq)
}
}

134
go/store/types/set_iterator_test.go
View File

@@ -27,6 +27,7 @@ import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestSetIterator(t *testing.T) {
@@ -36,15 +37,15 @@ func TestSetIterator(t *testing.T) {
numbers := append(generateNumbersAsValues(10), Float(20), Float(25))
s, err := NewSet(context.Background(), vs, numbers...)
assert.NoError(err)
require.NoError(t, err)
i, err := s.Iterator(context.Background())
assert.NoError(err)
require.NoError(t, err)
vals, err := iterToSlice(i)
assert.NoError(err)
require.NoError(t, err)
assert.True(vals.Equals(numbers), "Expected: %v != actual: %v", numbers, vs)
i, err = s.Iterator(context.Background())
assert.NoError(err)
require.NoError(t, err)
assert.Panics(func() {
_, _ = i.SkipTo(context.Background(), nil)
})
@@ -60,35 +61,35 @@ func TestSetIterator(t *testing.T) {
assert.Nil(i.SkipTo(context.Background(), Float(1)))
i, err = s.Iterator(context.Background())
assert.NoError(err)
require.NoError(t, err)
assert.Equal(Float(0), mustValue(i.Next(context.Background())))
assert.Equal(Float(1), mustValue(i.Next(context.Background())))
assert.Equal(Float(3), mustValue(i.SkipTo(context.Background(), Float(3))))
assert.Equal(Float(4), mustValue(i.Next(context.Background())))
empty, err := NewSet(context.Background(), vs)
assert.NoError(err)
require.NoError(t, err)
assert.Nil(mustSIter(empty.Iterator(context.Background())).Next(context.Background()))
assert.Nil(mustSIter(empty.Iterator(context.Background())).SkipTo(context.Background(), Float(-30)))
set, err := NewSet(context.Background(), vs, Float(42))
assert.NoError(err)
require.NoError(t, err)
single, err := set.Iterator(context.Background())
assert.NoError(err)
require.NoError(t, err)
assert.Equal(Float(42), mustValue(single.SkipTo(context.Background(), Float(42))))
assert.Equal(nil, mustValue(single.SkipTo(context.Background(), Float(42))))
set, err = NewSet(context.Background(), vs, Float(42))
assert.NoError(err)
require.NoError(t, err)
single, err = set.Iterator(context.Background())
assert.NoError(err)
require.NoError(t, err)
assert.Equal(Float(42), mustValue(single.SkipTo(context.Background(), Float(42))))
assert.Equal(nil, mustValue(single.Next(context.Background())))
set, err = NewSet(context.Background(), vs, Float(42))
assert.NoError(err)
require.NoError(t, err)
single, err = set.Iterator(context.Background())
assert.NoError(err)
require.NoError(t, err)
assert.Equal(Float(42), mustValue(single.SkipTo(context.Background(), Float(21))))
}
@@ -99,23 +100,23 @@ func TestSetIteratorAt(t *testing.T) {
numbers := append(generateNumbersAsValues(5), Float(10))
s, err := NewSet(context.Background(), vs, numbers...)
assert.NoError(err)
require.NoError(t, err)
i, err := s.IteratorAt(context.Background(), 0)
assert.NoError(err)
require.NoError(t, err)
vals, err := iterToSlice(i)
assert.NoError(err)
require.NoError(t, err)
assert.True(vals.Equals(numbers), "Expected: %v != actual: %v", numbers, vs)
i, err = s.IteratorAt(context.Background(), 2)
assert.NoError(err)
require.NoError(t, err)
vals, err = iterToSlice(i)
assert.NoError(err)
require.NoError(t, err)
assert.True(vals.Equals(numbers[2:]), "Expected: %v != actual: %v", numbers[2:], vs)
i, err = s.IteratorAt(context.Background(), 10)
assert.NoError(err)
require.NoError(t, err)
vals, err = iterToSlice(i)
assert.NoError(err)
require.NoError(t, err)
assert.True(vals.Equals(nil), "Expected: %v != actual: %v", nil, vs)
}
@@ -126,41 +127,42 @@ func TestSetIteratorFrom(t *testing.T) {
numbers := append(generateNumbersAsValues(5), Float(10), Float(20))
s, err := NewSet(context.Background(), vs, numbers...)
assert.NoError(err)
require.NoError(t, err)
i, err := s.IteratorFrom(context.Background(), Float(0))
require.NoError(t, err)
vals, err := iterToSlice(i)
assert.NoError(err)
require.NoError(t, err)
assert.True(vals.Equals(numbers), "Expected: %v != actual: %v", numbers, vs)
i, err = s.IteratorFrom(context.Background(), Float(2))
assert.NoError(err)
require.NoError(t, err)
vals, err = iterToSlice(i)
assert.NoError(err)
require.NoError(t, err)
assert.True(vals.Equals(numbers[2:]), "Expected: %v != actual: %v", numbers[2:], vs)
i, err = s.IteratorFrom(context.Background(), Float(10))
assert.NoError(err)
require.NoError(t, err)
vals, err = iterToSlice(i)
assert.NoError(err)
require.NoError(t, err)
assert.True(vals.Equals(ValueSlice{Float(10), Float(20)}), "Expected: %v != actual: %v", nil, vs)
i, err = s.IteratorFrom(context.Background(), Float(20))
assert.NoError(err)
require.NoError(t, err)
vals, err = iterToSlice(i)
assert.NoError(err)
require.NoError(t, err)
assert.True(vals.Equals(ValueSlice{Float(20)}), "Expected: %v != actual: %v", nil, vs)
i, err = s.IteratorFrom(context.Background(), Float(100))
assert.NoError(err)
require.NoError(t, err)
vals, err = iterToSlice(i)
assert.NoError(err)
require.NoError(t, err)
assert.True(vals.Equals(nil), "Expected: %v != actual: %v", nil, vs)
// Not present. Starts at next larger.
i, err = s.IteratorFrom(context.Background(), Float(15))
assert.NoError(err)
require.NoError(t, err)
vals, err = iterToSlice(i)
assert.NoError(err)
require.NoError(t, err)
assert.True(vals.Equals(ValueSlice{Float(20)}), "Expected: %v != actual: %v", nil, vs)
}
@@ -222,32 +224,32 @@ func TestIntersectionIterator(t *testing.T) {
vs := newTestValueStore()
byTwos, err := NewSet(context.Background(), vs, generateNumbersAsValuesFromToBy(0, 200, 2)...)
assert.NoError(err)
require.NoError(t, err)
byThrees, err := NewSet(context.Background(), vs, generateNumbersAsValuesFromToBy(0, 200, 3)...)
assert.NoError(err)
require.NoError(t, err)
byFives, err := NewSet(context.Background(), vs, generateNumbersAsValuesFromToBy(0, 200, 5)...)
assert.NoError(err)
require.NoError(t, err)
i1, err := NewIntersectionIterator(context.Background(), Format_7_18, mustSIter(byTwos.Iterator(context.Background())), mustSIter(byThrees.Iterator(context.Background())))
assert.NoError(err)
require.NoError(t, err)
vals, err := iterToSlice(i1)
assert.NoError(err)
require.NoError(t, err)
expectedRes := generateNumbersAsValuesFromToBy(0, 200, 6)
assert.True(vals.Equals(expectedRes), "Expected: %v != actual: %v", expectedRes, vs)
it1, err := NewIntersectionIterator(context.Background(), Format_7_18, mustSIter(byTwos.Iterator(context.Background())), mustSIter(byThrees.Iterator(context.Background())))
assert.NoError(err)
require.NoError(t, err)
it2, err := NewIntersectionIterator(context.Background(), Format_7_18, it1, mustSIter(byFives.Iterator(context.Background())))
assert.NoError(err)
require.NoError(t, err)
vals, err = iterToSlice(it2)
assert.NoError(err)
require.NoError(t, err)
expectedRes = generateNumbersAsValuesFromToBy(0, 200, 30)
assert.True(vals.Equals(expectedRes), "Expected: %v != actual: %v", expectedRes, vs)
it1, err = NewIntersectionIterator(context.Background(), Format_7_18, mustSIter(byThrees.Iterator(context.Background())), mustSIter(byFives.Iterator(context.Background())))
assert.NoError(err)
require.NoError(t, err)
it2, err = NewIntersectionIterator(context.Background(), Format_7_18, it1, mustSIter(byTwos.Iterator(context.Background())))
assert.NoError(err)
require.NoError(t, err)
assert.Panics(func() {
_, _ = it2.SkipTo(context.Background(), nil)
@@ -266,34 +268,34 @@ func TestCombinationIterator(t *testing.T) {
vs := newTestValueStore()
byTwos, err := NewSet(context.Background(), vs, generateNumbersAsValuesFromToBy(0, 70, 2)...)
assert.NoError(err)
require.NoError(t, err)
byThrees, err := NewSet(context.Background(), vs, generateNumbersAsValuesFromToBy(0, 70, 3)...)
assert.NoError(err)
require.NoError(t, err)
byFives, err := NewSet(context.Background(), vs, generateNumbersAsValuesFromToBy(0, 70, 5)...)
assert.NoError(err)
require.NoError(t, err)
bySevens, err := NewSet(context.Background(), vs, generateNumbersAsValuesFromToBy(0, 70, 7)...)
assert.NoError(err)
require.NoError(t, err)
it1, err := NewIntersectionIterator(context.Background(), Format_7_18, mustSIter(byTwos.Iterator(context.Background())), mustSIter(bySevens.Iterator(context.Background())))
assert.NoError(err)
require.NoError(t, err)
it2, err := NewIntersectionIterator(context.Background(), Format_7_18, mustSIter(byFives.Iterator(context.Background())), mustSIter(byThrees.Iterator(context.Background())))
assert.NoError(err)
require.NoError(t, err)
ut1, err := NewUnionIterator(context.Background(), Format_7_18, it1, it2)
assert.NoError(err)
require.NoError(t, err)
vals, err := iterToSlice(ut1)
assert.NoError(err)
require.NoError(t, err)
expectedRes := intsToValueSlice(0, 14, 15, 28, 30, 42, 45, 56, 60)
assert.NoError(err)
require.NoError(t, err)
assert.True(vals.Equals(expectedRes), "Expected: %v != actual: %v", expectedRes, vs)
ut1, err = NewUnionIterator(context.Background(), Format_7_18, mustSIter(byTwos.Iterator(context.Background())), mustSIter(bySevens.Iterator(context.Background())))
assert.NoError(err)
require.NoError(t, err)
it2, err = NewIntersectionIterator(context.Background(), Format_7_18, mustSIter(byFives.Iterator(context.Background())), mustSIter(byThrees.Iterator(context.Background())))
assert.NoError(err)
require.NoError(t, err)
ut2, err := NewIntersectionIterator(context.Background(), Format_7_18, ut1, it2)
assert.NoError(err)
require.NoError(t, err)
vals, err = iterToSlice(ut2)
assert.NoError(err)
require.NoError(t, err)
expectedRes = intsToValueSlice(0, 30, 60)
assert.True(vals.Equals(expectedRes), "Expected: %v != actual: %v", expectedRes, vs)
}
@@ -339,22 +341,22 @@ func TestUnionComplexity(t *testing.T) {
callCount1 := 0
itrs, err := createSetsWithDistinctNumbers(vs, numSets, numElemsPerSet)
assert.NoError(err)
require.NoError(t, err)
iter, err := iterize(itrs, NewUnionTestIterator, &callCount1)
assert.NoError(err)
require.NoError(t, err)
vals, err := iterToSlice(iter)
assert.NoError(err)
require.NoError(t, err)
expected := generateNumbersAsValueSlice(numSets * numElemsPerSet)
assert.True(expected.Equals(vals), "expected: %v != actual: %v", expected, vals)
assert.True(expectedMax > callCount1, "callCount: %d exceeds expectedMax: %d", callCount1, expectedMax)
callCount2 := 0
itrs, err = createSetsWithSameNumbers(vs, numSets, numElemsPerSet)
assert.NoError(err)
require.NoError(t, err)
iter, err = iterize(itrs, NewUnionTestIterator, &callCount2)
assert.NoError(err)
require.NoError(t, err)
vals, err = iterToSlice(iter)
assert.NoError(err)
require.NoError(t, err)
expected = generateNumbersAsValueSlice(numElemsPerSet)
assert.True(expected.Equals(vals), "expected: %v != actual: %v", expected, vals)
assert.True(expectedMax > callCount2, "callCount: %d exceeds expectedMax: %d", callCount2, expectedMax)
@@ -401,22 +403,22 @@ func TestIntersectComplexity(t *testing.T) {
callCount1 := 0
itrs, err := createSetsWithDistinctNumbers(vs, numSets, numElemsPerSet)
assert.NoError(err)
require.NoError(t, err)
iter, err := iterize(itrs, NewIntersectionTestIterator, &callCount1)
assert.NoError(err)
require.NoError(t, err)
vals, err := iterToSlice(iter)
assert.NoError(err)
require.NoError(t, err)
expected := ValueSlice{}
assert.True(expected.Equals(vals), "expected: %v != actual: %v", expected, vals)
assert.True(expectedMax > callCount1, "callCount: %d exceeds expectedMax: %d", callCount1, expectedMax)
callCount2 := 0
itrs, err = createSetsWithSameNumbers(vs, numSets, numElemsPerSet)
assert.NoError(err)
require.NoError(t, err)
iter, err = iterize(itrs, NewIntersectionTestIterator, &callCount2)
assert.NoError(err)
require.NoError(t, err)
vals, err = iterToSlice(iter)
assert.NoError(err)
require.NoError(t, err)
expected = generateNumbersAsValueSlice(numElemsPerSet)
assert.True(expected.Equals(vals), "expected: %v != actual: %v", expected, vals)
assert.True(expectedMax > callCount2, "callCount: %d exceeds expectedMax: %d", callCount2, expectedMax)

259
go/store/types/set_test.go
View File

@@ -32,6 +32,7 @@ import (
"github.com/dolthub/dolt/go/store/atomicerr"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"github.com/stretchr/testify/suite"
)
@@ -128,7 +129,7 @@ func newRandomTestSet(length int, gen genValueFn) testSet {
func validateSet(t *testing.T, vrw ValueReadWriter, s Set, values ValueSlice) {
s, err := NewSet(context.Background(), vrw, values...)
assert.NoError(t, err)
require.NoError(t, err)
assert.True(t, s.Equals(s))
out := ValueSlice{}
_ = s.IterAll(context.Background(), func(v Value) error {
@@ -333,22 +334,22 @@ func TestNewSet(t *testing.T) {
vs := newTestValueStore()
s, err := NewSet(context.Background(), vs)
assert.NoError(err)
require.NoError(t, err)
assert.True(mustType(MakeSetType(mustType(MakeUnionType()))).Equals(mustType(TypeOf(s))))
assert.Equal(uint64(0), s.Len())
s, err = NewSet(context.Background(), vs, Float(0))
assert.NoError(err)
require.NoError(t, err)
assert.True(mustType(MakeSetType(PrimitiveTypeMap[FloatKind])).Equals(mustType(TypeOf(s))))
s, err = NewSet(context.Background(), vs)
assert.NoError(err)
require.NoError(t, err)
assert.IsType(mustType(MakeSetType(PrimitiveTypeMap[FloatKind])), mustType(TypeOf(s)))
se, err := s.Edit().Remove(Float(1))
assert.NoError(err)
require.NoError(t, err)
s2, err := se.Set(context.Background())
assert.NoError(err)
require.NoError(t, err)
assert.IsType(mustType(TypeOf(s)), mustType(TypeOf(s2)))
}
@@ -358,18 +359,18 @@ func TestSetLen(t *testing.T) {
vs := newTestValueStore()
s0, err := NewSet(context.Background(), vs)
assert.NoError(err)
require.NoError(t, err)
assert.Equal(uint64(0), s0.Len())
s1, err := NewSet(context.Background(), vs, Bool(true), Float(1), String("hi"))
assert.NoError(err)
require.NoError(t, err)
assert.Equal(uint64(3), s1.Len())
diffSetTest(assert, s0, s1, 0, 3)
diffSetTest(assert, s1, s0, 3, 0)
se2, err := s1.Edit().Insert(Bool(false))
assert.NoError(err)
require.NoError(t, err)
s2, err := se2.Set(context.Background())
assert.NoError(err)
require.NoError(t, err)
assert.Equal(uint64(4), s2.Len())
diffSetTest(assert, s0, s2, 0, 4)
diffSetTest(assert, s2, s0, 4, 0)
@@ -377,9 +378,9 @@ func TestSetLen(t *testing.T) {
diffSetTest(assert, s2, s1, 1, 0)
se3, err := s2.Edit().Remove(Bool(true))
assert.NoError(err)
require.NoError(t, err)
s3, err := se3.Set(context.Background())
assert.NoError(err)
require.NoError(t, err)
assert.Equal(uint64(3), s3.Len())
diffSetTest(assert, s2, s3, 1, 0)
diffSetTest(assert, s3, s2, 0, 1)
@@ -390,7 +391,7 @@ func TestSetEmpty(t *testing.T) {
vs := newTestValueStore()
s, err := NewSet(context.Background(), vs)
assert.NoError(err)
require.NoError(t, err)
assert.True(s.Empty())
assert.Equal(uint64(0), s.Len())
}
@@ -400,12 +401,12 @@ func TestSetEmptyInsert(t *testing.T) {
vs := newTestValueStore()
s, err := NewSet(context.Background(), vs)
assert.NoError(err)
require.NoError(t, err)
assert.True(s.Empty())
se, err := s.Edit().Insert(Bool(false))
assert.NoError(err)
require.NoError(t, err)
s, err = se.Set(context.Background())
assert.NoError(err)
require.NoError(t, err)
assert.False(s.Empty())
assert.Equal(uint64(1), s.Len())
}
@@ -415,18 +416,18 @@ func TestSetEmptyInsertRemove(t *testing.T) {
vs := newTestValueStore()
s, err := NewSet(context.Background(), vs)
assert.NoError(err)
require.NoError(t, err)
assert.True(s.Empty())
se, err := s.Edit().Insert(Bool(false))
assert.NoError(err)
require.NoError(t, err)
s, err = se.Set(context.Background())
assert.NoError(err)
require.NoError(t, err)
assert.False(s.Empty())
assert.Equal(uint64(1), s.Len())
se, err = s.Edit().Remove(Bool(false))
assert.NoError(err)
require.NoError(t, err)
s, err = se.Set(context.Background())
assert.NoError(err)
require.NoError(t, err)
assert.True(s.Empty())
assert.Equal(uint64(0), s.Len())
}
@@ -437,7 +438,7 @@ func TestSetDuplicateInsert(t *testing.T) {
vs := newTestValueStore()
s1, err := NewSet(context.Background(), vs, Bool(true), Float(42), Float(42))
assert.NoError(err)
require.NoError(t, err)
assert.Equal(uint64(2), s1.Len())
}
@@ -446,7 +447,7 @@ func TestSetUniqueKeysString(t *testing.T) {
vs := newTestValueStore()
s1, err := NewSet(context.Background(), vs, String("hello"), String("world"), String("hello"))
assert.NoError(err)
require.NoError(t, err)
assert.Equal(uint64(2), s1.Len())
assert.True(s1.Has(context.Background(), String("hello")))
assert.True(s1.Has(context.Background(), String("world")))
@@ -458,7 +459,7 @@ func TestSetUniqueKeysNumber(t *testing.T) {
vs := newTestValueStore()
s1, err := NewSet(context.Background(), vs, Float(4), Float(1), Float(0), Float(0), Float(1), Float(3))
assert.NoError(err)
require.NoError(t, err)
assert.Equal(uint64(4), s1.Len())
assert.True(s1.Has(context.Background(), Float(4)))
assert.True(s1.Has(context.Background(), Float(1)))
@@ -472,7 +473,7 @@ func TestSetHas(t *testing.T) {
vs := newTestValueStore()
s1, err := NewSet(context.Background(), vs, Bool(true), Float(1), String("hi"))
assert.NoError(err)
require.NoError(t, err)
assert.True(s1.Has(context.Background(), Bool(true)))
assert.False(s1.Has(context.Background(), Bool(false)))
assert.True(s1.Has(context.Background(), Float(1)))
@@ -481,9 +482,9 @@ func TestSetHas(t *testing.T) {
assert.False(s1.Has(context.Background(), String("ho")))
se2, err := s1.Edit().Insert(Bool(false))
assert.NoError(err)
require.NoError(t, err)
s2, err := se2.Set(context.Background())
assert.NoError(err)
require.NoError(t, err)
assert.True(s2.Has(context.Background(), Bool(false)))
assert.True(s2.Has(context.Background(), Bool(true)))
@@ -505,13 +506,13 @@ func TestSetHas2(t *testing.T) {
vrw := newTestValueStore()
ts := toTestSet(scale, vrw)
set, err := ts.toSet(vrw)
assert.NoError(err)
require.NoError(t, err)
ref, err := vrw.WriteValue(context.Background(), set)
assert.NoError(err)
require.NoError(t, err)
val2, err := vrw.ReadValue(context.Background(), ref.TargetHash())
assert.NoError(err)
require.NoError(t, err)
set2 := val2.(Set)
assert.NoError(err)
require.NoError(t, err)
for _, v := range ts {
assert.True(set.Has(context.Background(), v))
assert.True(set2.Has(context.Background(), v))
@@ -527,12 +528,12 @@ func TestSetHas2(t *testing.T) {
func validateSetInsertion(t *testing.T, vrw ValueReadWriter, values ValueSlice) {
s, err := NewSet(context.Background(), vrw)
assert.NoError(t, err)
require.NoError(t, err)
for i, v := range values {
se, err := s.Edit().Insert(v)
assert.NoError(t, err)
require.NoError(t, err)
s, err = se.Set(context.Background())
assert.NoError(t, err)
require.NoError(t, err)
validateSet(t, vrw, s, values[0:i+1])
}
}
@@ -555,27 +556,27 @@ func TestSetInsert(t *testing.T) {
vs := newTestValueStore()
s, err := NewSet(context.Background(), vs)
assert.NoError(err)
require.NoError(t, err)
v1 := Bool(false)
v2 := Bool(true)
v3 := Float(0)
assert.False(s.Has(context.Background(), v1))
se, err := s.Edit().Insert(v1)
assert.NoError(err)
require.NoError(t, err)
s, err = se.Set(context.Background())
assert.NoError(err)
require.NoError(t, err)
assert.True(s.Has(context.Background(), v1))
se, err = s.Edit().Insert(v2)
assert.NoError(err)
require.NoError(t, err)
s, err = se.Set(context.Background())
assert.NoError(err)
require.NoError(t, err)
assert.True(s.Has(context.Background(), v1))
assert.True(s.Has(context.Background(), v2))
se2, err := s.Edit().Insert(v3)
assert.NoError(err)
require.NoError(t, err)
s2, err := se2.Set(context.Background())
assert.NoError(err)
require.NoError(t, err)
assert.True(s.Has(context.Background(), v1))
assert.True(s.Has(context.Background(), v2))
assert.False(s.Has(context.Background(), v3))
@@ -598,14 +599,14 @@ func TestSetInsert2(t *testing.T) {
vrw := newTestValueStore()
ts := toTestSet(scale, vrw)
expected, err := ts.toSet(vrw)
assert.NoError(err)
require.NoError(t, err)
run := func(from, to int) {
s, err := ts.Remove(from, to).toSet(vrw)
assert.NoError(err)
require.NoError(t, err)
se, err := s.Edit().Insert(ts[from:to]...)
assert.NoError(err)
require.NoError(t, err)
actual, err := se.Set(context.Background())
assert.NoError(err)
require.NoError(t, err)
assert.Equal(expected.Len(), actual.Len())
assert.True(expected.Equals(actual))
diffSetTest(assert, expected, actual, 0, 0)
@@ -633,11 +634,11 @@ func TestSetInsertExistingValue(t *testing.T) {
ts := getTestNativeOrderSet(2, vs)
original, err := ts.toSet(vs)
assert.NoError(err)
require.NoError(t, err)
se, err := original.Edit().Insert(ts[0])
assert.NoError(err)
require.NoError(t, err)
actual, err := se.Set(context.Background())
assert.NoError(err)
require.NoError(t, err)
assert.Equal(original.Len(), actual.Len())
assert.True(original.Equals(actual))
@@ -651,21 +652,21 @@ func TestSetRemove(t *testing.T) {
v2 := Bool(true)
v3 := Float(0)
s, err := NewSet(context.Background(), vs, v1, v2, v3)
assert.NoError(err)
require.NoError(t, err)
assert.True(s.Has(context.Background(), v1))
assert.True(s.Has(context.Background(), v2))
assert.True(s.Has(context.Background(), v3))
se, err := s.Edit().Remove(v1)
assert.NoError(err)
require.NoError(t, err)
s, err = se.Set(context.Background())
assert.NoError(err)
require.NoError(t, err)
assert.False(s.Has(context.Background(), v1))
assert.True(s.Has(context.Background(), v2))
assert.True(s.Has(context.Background(), v3))
se2, err := s.Edit().Remove(v2)
assert.NoError(err)
require.NoError(t, err)
s2, err := se2.Set(context.Background())
assert.NoError(err)
require.NoError(t, err)
assert.False(s.Has(context.Background(), v1))
assert.True(s.Has(context.Background(), v2))
assert.True(s.Has(context.Background(), v3))
@@ -688,14 +689,14 @@ func TestSetRemove2(t *testing.T) {
vrw := newTestValueStore()
ts := toTestSet(scale, vrw)
whole, err := ts.toSet(vrw)
assert.NoError(err)
require.NoError(t, err)
run := func(from, to int) {
expected, err := ts.Remove(from, to).toSet(vrw)
assert.NoError(err)
require.NoError(t, err)
se, err := whole.Edit().Remove(ts[from:to]...)
assert.NoError(err)
require.NoError(t, err)
actual, err := se.Set(context.Background())
assert.NoError(err)
require.NoError(t, err)
assert.Equal(expected.Len(), actual.Len())
assert.True(expected.Equals(actual))
diffSetTest(assert, expected, actual, 0, 0)
@@ -719,11 +720,11 @@ func TestSetRemoveNonexistentValue(t *testing.T) {
ts := getTestNativeOrderSet(2, vs)
original, err := ts.toSet(vs)
assert.NoError(err)
require.NoError(t, err)
se, err := original.Edit().Remove(Float(-1))
assert.NoError(err)
require.NoError(t, err)
actual, err := se.Set(context.Background()) // rand.Int63 returns non-negative values.
assert.NoError(err)
require.NoError(t, err)
assert.Equal(original.Len(), actual.Len())
assert.True(original.Equals(actual))
@@ -734,27 +735,27 @@ func TestSetFirst(t *testing.T) {
vs := newTestValueStore()
s, err := NewSet(context.Background(), vs)
assert.NoError(err)
require.NoError(t, err)
assert.Nil(s.First(context.Background()))
se, err := s.Edit().Insert(Float(1))
assert.NoError(err)
require.NoError(t, err)
s, err = se.Set(context.Background())
assert.NoError(err)
require.NoError(t, err)
assert.NotNil(s.First(context.Background()))
se, err = s.Edit().Insert(Float(2))
assert.NoError(err)
require.NoError(t, err)
s, err = se.Set(context.Background())
assert.NoError(err)
require.NoError(t, err)
assert.NotNil(s.First(context.Background()))
se2, err := s.Edit().Remove(Float(1))
assert.NoError(err)
require.NoError(t, err)
s2, err := se2.Set(context.Background())
assert.NoError(err)
require.NoError(t, err)
assert.NotNil(s2.First(context.Background()))
se2, err = s2.Edit().Remove(Float(2))
assert.NoError(err)
require.NoError(t, err)
s2, err = se2.Set(context.Background())
assert.NoError(err)
require.NoError(t, err)
assert.Nil(s2.First(context.Background()))
}
@@ -765,12 +766,12 @@ func TestSetOfStruct(t *testing.T) {
elems := []Value{}
for i := 0; i < 200; i++ {
st, err := NewStruct(Format_7_18, "S1", StructData{"o": Float(i)})
assert.NoError(err)
require.NoError(t, err)
elems = append(elems, st)
}
s, err := NewSet(context.Background(), vs, elems...)
assert.NoError(err)
require.NoError(t, err)
for i := 0; i < 200; i++ {
assert.True(s.Has(context.Background(), elems[i]))
}
@@ -781,21 +782,23 @@ func TestSetIter(t *testing.T) {
vs := newTestValueStore()
s, err := NewSet(context.Background(), vs, Float(0), Float(1), Float(2), Float(3), Float(4))
assert.NoError(err)
require.NoError(t, err)
acc, err := NewSet(context.Background(), vs)
require.NoError(t, err)
err = s.Iter(context.Background(), func(v Value) (bool, error) {
_, ok := v.(Float)
assert.True(ok)
se, err := acc.Edit().Insert(v)
assert.NoError(err)
require.NoError(t, err)
acc, err = se.Set(context.Background())
assert.NoError(err)
require.NoError(t, err)
return false, nil
})
require.NoError(t, err)
assert.True(s.Equals(acc))
acc, err = NewSet(context.Background(), vs)
assert.NoError(err)
require.NoError(t, err)
_ = s.Iter(context.Background(), func(v Value) (bool, error) {
return true, nil
})
@@ -812,9 +815,9 @@ func TestSetIter2(t *testing.T) {
vrw := newTestValueStore()
ts := toTestSet(scale, vrw)
set, err := ts.toSet(vrw)
assert.NoError(err)
require.NoError(t, err)
err = SortWithErroringLess(ValueSort{ts, Format_7_18})
assert.NoError(err)
require.NoError(t, err)
idx := uint64(0)
endAt := uint64(64)
@@ -841,16 +844,16 @@ func TestSetIterAll(t *testing.T) {
vs := newTestValueStore()
s, err := NewSet(context.Background(), vs, Float(0), Float(1), Float(2), Float(3), Float(4))
assert.NoError(err)
require.NoError(t, err)
acc, err := NewSet(context.Background(), vs)
assert.NoError(err)
require.NoError(t, err)
_ = s.IterAll(context.Background(), func(v Value) error {
_, ok := v.(Float)
assert.True(ok)
se, err := acc.Edit().Insert(v)
assert.NoError(err)
require.NoError(t, err)
acc, err = se.Set(context.Background())
assert.NoError(err)
require.NoError(t, err)
return nil
})
assert.True(s.Equals(acc))
@@ -866,9 +869,9 @@ func TestSetIterAll2(t *testing.T) {
vrw := newTestValueStore()
ts := toTestSet(scale, vrw)
set, err := ts.toSet(vrw)
assert.NoError(err)
require.NoError(t, err)
err = SortWithErroringLess(ValueSort{ts, Format_7_18})
assert.NoError(err)
require.NoError(t, err)
idx := uint64(0)
_ = set.IterAll(context.Background(), func(v Value) error {
@@ -1024,34 +1027,34 @@ func TestSetType(t *testing.T) {
vs := newTestValueStore()
s, err := NewSet(context.Background(), vs)
assert.NoError(err)
require.NoError(t, err)
assert.True(mustType(TypeOf(s)).Equals(mustType(MakeSetType(mustType(MakeUnionType())))))
s, err = NewSet(context.Background(), vs, Float(0))
assert.NoError(err)
require.NoError(t, err)
assert.True(mustType(TypeOf(s)).Equals(mustType(MakeSetType(PrimitiveTypeMap[FloatKind]))))
se2, err := s.Edit().Remove(Float(1))
assert.NoError(err)
require.NoError(t, err)
s2, err := se2.Set(context.Background())
assert.NoError(err)
require.NoError(t, err)
assert.True(mustType(TypeOf(s2)).Equals(mustType(MakeSetType(PrimitiveTypeMap[FloatKind]))))
se2, err = s.Edit().Insert(Float(0), Float(1))
assert.NoError(err)
require.NoError(t, err)
s2, err = se2.Set(context.Background())
assert.NoError(err)
require.NoError(t, err)
assert.True(mustType(TypeOf(s)).Equals(mustType(TypeOf(s2))))
se3, err := s.Edit().Insert(Bool(true))
assert.NoError(err)
require.NoError(t, err)
s3, err := se3.Set(context.Background())
assert.NoError(err)
require.NoError(t, err)
assert.True(mustType(TypeOf(s3)).Equals(mustType(MakeSetType(mustType(MakeUnionType(PrimitiveTypeMap[BoolKind], PrimitiveTypeMap[FloatKind]))))))
se4, err := s.Edit().Insert(Float(3), Bool(true))
assert.NoError(err)
require.NoError(t, err)
s4, err := se4.Set(context.Background())
assert.NoError(err)
require.NoError(t, err)
assert.True(mustType(TypeOf(s4)).Equals(mustType(MakeSetType(mustType(MakeUnionType(PrimitiveTypeMap[BoolKind], PrimitiveTypeMap[FloatKind]))))))
}
@@ -1060,13 +1063,14 @@ func TestSetChunks(t *testing.T) {
vs := newTestValueStore()
l1, err := NewSet(context.Background(), vs, Float(0))
assert.NoError(err)
require.NoError(t, err)
c1 := getChunks(l1)
assert.Len(c1, 0)
ref, err := NewRef(Float(0), Format_7_18)
require.NoError(t, err)
l2, err := NewSet(context.Background(), vs, ref)
assert.NoError(err)
require.NoError(t, err)
c2 := getChunks(l2)
assert.Len(c2, 1)
}
@@ -1081,11 +1085,11 @@ func TestSetChunks2(t *testing.T) {
vrw := newTestValueStore()
ts := toTestSet(scale, vrw)
set, err := ts.toSet(vrw)
assert.NoError(err)
require.NoError(t, err)
ref, err := vrw.WriteValue(context.Background(), set)
assert.NoError(err)
require.NoError(t, err)
val, err := vrw.ReadValue(context.Background(), ref.TargetHash())
assert.NoError(err)
require.NoError(t, err)
set2chunks := getChunks(val)
for i, r := range getChunks(set) {
assert.True(mustType(TypeOf(r)).Equals(mustType(TypeOf(set2chunks[i]))), "%s != %s", mustString(mustType(TypeOf(r)).Describe(context.Background())), mustString(mustType(TypeOf(set2chunks[i])).Describe(context.Background())))
@@ -1104,7 +1108,7 @@ func TestSetFirstNNumbers(t *testing.T) {
nums := generateNumbersAsValues(testSetSize)
s, err := NewSet(context.Background(), vs, nums...)
assert.NoError(err)
require.NoError(t, err)
assert.Equal(deriveCollectionHeight(s), getRefHeightOfCollection(s))
}
@@ -1117,7 +1121,7 @@ func TestSetRefOfStructFirstNNumbers(t *testing.T) {
nums := generateNumbersAsRefOfStructs(vs, testSetSize)
s, err := NewSet(context.Background(), vs, nums...)
assert.NoError(err)
require.NoError(t, err)
// height + 1 because the leaves are Ref values (with height 1).
assert.Equal(deriveCollectionHeight(s)+1, getRefHeightOfCollection(s))
}
@@ -1129,29 +1133,29 @@ func TestSetModifyAfterRead(t *testing.T) {
assert := assert.New(t)
vs := newTestValueStore()
set, err := getTestNativeOrderSet(2, vs).toSet(vs)
assert.NoError(err)
require.NoError(t, err)
// Drop chunk values.
ref, err := vs.WriteValue(context.Background(), set)
assert.NoError(err)
require.NoError(t, err)
val, err := vs.ReadValue(context.Background(), ref.TargetHash())
assert.NoError(err)
require.NoError(t, err)
set = val.(Set)
assert.NoError(err)
require.NoError(t, err)
// Modify/query. Once upon a time this would crash.
fst, err := set.First(context.Background())
assert.NoError(err)
require.NoError(t, err)
se, err := set.Edit().Remove(fst)
assert.NoError(err)
require.NoError(t, err)
set, err = se.Set(context.Background())
assert.NoError(err)
require.NoError(t, err)
assert.False(set.Has(context.Background(), fst))
val, err = set.First(context.Background())
assert.NoError(err)
require.NoError(t, err)
assert.True(set.Has(context.Background(), val))
se, err = set.Edit().Insert(fst)
assert.NoError(err)
require.NoError(t, err)
set, err = se.Set(context.Background())
assert.NoError(err)
require.NoError(t, err)
assert.True(set.Has(context.Background(), fst))
}
@@ -1166,22 +1170,23 @@ func TestSetTypeAfterMutations(t *testing.T) {
values := generateNumbersAsValues(n)
s, err := NewSet(context.Background(), vs, values...)
assert.NoError(err)
require.NoError(t, err)
assert.Equal(s.Len(), uint64(n))
assert.IsType(c, s.asSequence())
assert.True(mustType(TypeOf(s)).Equals(mustType(MakeSetType(PrimitiveTypeMap[FloatKind]))))
se, err := s.Edit().Insert(String("a"))
assert.NoError(err)
require.NoError(t, err)
s, err = se.Set(context.Background())
require.NoError(t, err)
assert.Equal(s.Len(), uint64(n+1))
assert.IsType(c, s.asSequence())
assert.True(mustType(TypeOf(s)).Equals(mustType(MakeSetType(mustType(MakeUnionType(PrimitiveTypeMap[FloatKind], PrimitiveTypeMap[StringKind]))))))
se, err = s.Edit().Remove(String("a"))
assert.NoError(err)
require.NoError(t, err)
s, err = se.Set(context.Background())
assert.NoError(err)
require.NoError(t, err)
assert.Equal(s.Len(), uint64(n))
assert.IsType(c, s.asSequence())
assert.True(mustType(TypeOf(s)).Equals(mustType(MakeSetType(PrimitiveTypeMap[FloatKind]))))
@@ -1220,14 +1225,14 @@ func TestChunkedSetWithValuesOfEveryType(t *testing.T) {
}
s, err := NewSet(context.Background(), vs, vals...)
assert.NoError(err)
require.NoError(t, err)
for i := 1; s.asSequence().isLeaf(); i++ {
v := Float(i)
vals = append(vals, v)
se, err := s.Edit().Insert(v)
assert.NoError(err)
require.NoError(t, err)
s, err = se.Set(context.Background())
assert.NoError(err)
require.NoError(t, err)
}
assert.Equal(len(vals), int(s.Len()))
@@ -1241,9 +1246,9 @@ func TestChunkedSetWithValuesOfEveryType(t *testing.T) {
v := vals[0]
vals = vals[1:]
se, err := s.Edit().Remove(v)
assert.NoError(err)
require.NoError(t, err)
s, err = se.Set(context.Background())
assert.NoError(err)
require.NoError(t, err)
assert.False(s.Has(context.Background(), v))
assert.Equal(len(vals), int(s.Len()))
}
@@ -1258,23 +1263,23 @@ func TestSetRemoveLastWhenNotLoaded(t *testing.T) {
vs := newTestValueStore()
reload := func(s Set) Set {
ref, err := vs.WriteValue(context.Background(), s)
assert.NoError(err)
require.NoError(t, err)
v, err := vs.ReadValue(context.Background(), ref.TargetHash())
assert.NoError(err)
require.NoError(t, err)
return v.(Set)
}
ts := getTestNativeOrderSet(8, vs)
ns, err := ts.toSet(vs)
assert.NoError(err)
require.NoError(t, err)
for len(ts) > 0 {
last := ts[len(ts)-1]
ts = ts[:len(ts)-1]
se, err := ns.Edit().Remove(last)
assert.NoError(err)
require.NoError(t, err)
s, err := se.Set(context.Background())
assert.NoError(err)
require.NoError(t, err)
ns = reload(s)
assert.True(mustSet(ts.toSet(vs)).Equals(ns))
}
@@ -1286,11 +1291,11 @@ func TestSetAt(t *testing.T) {
values := []Value{Bool(false), Float(42), String("a"), String("b"), String("c")}
s, err := NewSet(context.Background(), vs, values...)
assert.NoError(err)
require.NoError(t, err)
for i, v := range values {
valAt, err := s.At(context.Background(), uint64(i))
assert.NoError(err)
require.NoError(t, err)
assert.Equal(v, valAt)
}
@@ -1312,7 +1317,7 @@ func TestSetWithStructShouldHaveOptionalFields(t *testing.T) {
"b": String("bar"),
})),
)
assert.NoError(err)
require.NoError(t, err)
assert.True(
mustType(MakeSetType(mustType(MakeStructType("Foo",
StructField{"a", PrimitiveTypeMap[FloatKind], false},

5
go/store/types/simplify_test.go
View File

@@ -19,6 +19,7 @@ import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestSimplifyStructFields(t *testing.T) {
@@ -27,7 +28,7 @@ func TestSimplifyStructFields(t *testing.T) {
test := func(in []structTypeFields, exp structTypeFields) {
// simplifier := newSimplifier(false)
act, err := simplifyStructFields(in, typeset{}, false)
assert.NoError(err)
require.NoError(t, err)
assert.Equal(act, exp)
}
@@ -78,7 +79,7 @@ func TestSimplifyType(t *testing.T) {
run := func(intersectStructs bool) {
test := func(in, exp *Type) {
act, err := simplifyType(in, intersectStructs)
assert.NoError(err)
require.NoError(t, err)
assert.True(exp.Equals(act), "Expected: %s\nActual: %s", mustString(exp.Describe(context.Background())), mustString(act.Describe(context.Background())))
}
testSame := func(t *Type) {

62
go/store/types/struct_test.go
View File

@@ -26,6 +26,7 @@ import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func getChunks(v Value) (chunks []Ref) {
@@ -40,9 +41,9 @@ func TestGenericStructEquals(t *testing.T) {
assert := assert.New(t)
s1, err := NewStruct(Format_7_18, "S1", StructData{"s": String("hi"), "x": Bool(true)})
assert.NoError(err)
require.NoError(t, err)
s2, err := NewStruct(Format_7_18, "S1", StructData{"s": String("hi"), "x": Bool(true)})
assert.NoError(err)
require.NoError(t, err)
assert.True(s1.Equals(s2))
assert.True(s2.Equals(s1))
@@ -53,11 +54,11 @@ func TestGenericStructChunks(t *testing.T) {
b := Bool(true)
s1, err := NewStruct(Format_7_18, "S1", StructData{"r": mustRef(NewRef(b, Format_7_18))})
assert.NoError(err)
require.NoError(t, err)
assert.Len(getChunks(s1), 1)
h, err := Bool(true).Hash(Format_7_18)
assert.NoError(err)
require.NoError(t, err)
assert.Equal(h, getChunks(s1)[0].TargetHash())
}
@@ -65,20 +66,21 @@ func TestGenericStructNew(t *testing.T) {
assert := assert.New(t)
s, err := NewStruct(Format_7_18, "S2", StructData{"b": Bool(true), "o": String("hi")})
assert.NoError(err)
require.NoError(t, err)
v, _, err := s.MaybeGet("b")
assert.NoError(err)
require.NoError(t, err)
assert.True(v.Equals(Bool(true)))
_, ok, err := s.MaybeGet("missing")
assert.NoError(err)
require.NoError(t, err)
assert.False(ok)
s2, err := NewStruct(Format_7_18, "S2", StructData{"b": Bool(false), "o": String("hi")})
require.NoError(t, err)
v2, _, err := s2.MaybeGet("b")
assert.NoError(err)
require.NoError(t, err)
assert.True(v2.Equals(Bool(false)))
o, ok, err := s2.MaybeGet("o")
assert.NoError(err)
require.NoError(t, err)
assert.True(ok)
assert.True(String("hi").Equals(o))
}
@@ -88,17 +90,17 @@ func TestGenericStructSet(t *testing.T) {
vs := newTestValueStore()
s, err := NewStruct(Format_7_18, "S3", StructData{"b": Bool(true), "o": String("hi")})
assert.NoError(err)
require.NoError(t, err)
s2, err := s.Set("b", Bool(false))
assert.NoError(err)
require.NoError(t, err)
s3, err := s2.Set("b", Bool(true))
assert.NoError(err)
require.NoError(t, err)
assert.True(s.Equals(s3))
// Changes the type
s4, err := s.Set("b", Float(42))
assert.NoError(err)
require.NoError(t, err)
assert.True(mustType(MakeStructType("S3",
StructField{"b", PrimitiveTypeMap[FloatKind], false},
StructField{"o", PrimitiveTypeMap[StringKind], false},
@@ -106,7 +108,7 @@ func TestGenericStructSet(t *testing.T) {
// Adds a new field
s5, err := s.Set("x", Float(42))
assert.NoError(err)
require.NoError(t, err)
assert.True(mustType(MakeStructType("S3",
StructField{"b", PrimitiveTypeMap[BoolKind], false},
StructField{"o", PrimitiveTypeMap[StringKind], false},
@@ -115,44 +117,44 @@ func TestGenericStructSet(t *testing.T) {
// Subtype is not equal.
s6, err := NewStruct(Format_7_18, "", StructData{"l": mustList(NewList(context.Background(), vs, Float(0), Float(1), Bool(false), Bool(true)))})
assert.NoError(err)
require.NoError(t, err)
s7, err := s6.Set("l", mustList(NewList(context.Background(), vs, Float(2), Float(3))))
assert.NoError(err)
require.NoError(t, err)
t7, err := MakeStructTypeFromFields("", FieldMap{
"l": mustType(MakeListType(PrimitiveTypeMap[FloatKind])),
})
assert.NoError(err)
require.NoError(t, err)
assert.True(t7.Equals(mustType(TypeOf(s7))))
s8, err := NewStruct(Format_7_18, "S", StructData{"a": Bool(true), "c": Bool(true)})
assert.NoError(err)
require.NoError(t, err)
s9, err := s8.Set("b", Bool(true))
assert.NoError(err)
require.NoError(t, err)
st, err := NewStruct(Format_7_18, "S", StructData{"a": Bool(true), "b": Bool(true), "c": Bool(true)})
assert.True(s9.Equals(st))
assert.NoError(err)
require.NoError(t, err)
}
func TestGenericStructDelete(t *testing.T) {
assert := assert.New(t)
s1, err := NewStruct(Format_7_18, "S", StructData{"b": Bool(true), "o": String("hi")})
assert.NoError(err)
require.NoError(t, err)
s2, err := s1.Delete("notThere")
assert.NoError(err)
require.NoError(t, err)
assert.True(s1.Equals(s2))
s3, err := s1.Delete("o")
assert.NoError(err)
require.NoError(t, err)
s4, err := NewStruct(Format_7_18, "S", StructData{"b": Bool(true)})
assert.NoError(err)
require.NoError(t, err)
assert.True(s3.Equals(s4))
s5, err := s3.Delete("b")
assert.NoError(err)
require.NoError(t, err)
s6, err := NewStruct(Format_7_18, "S", StructData{})
assert.NoError(err)
require.NoError(t, err)
assert.True(s5.Equals(s6))
}
@@ -188,7 +190,7 @@ func TestStructDiff(t *testing.T) {
i++
}
assert.Equal(len(expect), i, "Wrong number of changes")
assert.NoError(err)
require.NoError(t, err)
}
vc := func(ct DiffChangeType, fieldName string, oldV, newV Value) ValueChanged {
@@ -196,7 +198,7 @@ func TestStructDiff(t *testing.T) {
}
s1, err := NewStruct(Format_7_18, "", StructData{"a": Bool(true), "b": String("hi"), "c": Float(4)})
assert.NoError(err)
require.NoError(t, err)
assertDiff([]ValueChanged{},
s1, mustStruct(NewStruct(Format_7_18, "", StructData{"a": Bool(true), "b": String("hi"), "c": Float(4)})))
@@ -312,7 +314,7 @@ func TestMakeStructTemplate(t *testing.T) {
assertValidStructName := func(n string) {
template := MakeStructTemplate(n, []string{})
str, err := template.NewStruct(Format_7_18, nil)
assert.NoError(err)
require.NoError(t, err)
assert.Equal(n, str.Name())
}
@@ -368,7 +370,7 @@ func TestMakeStructTemplate(t *testing.T) {
template := MakeStructTemplate("A", []string{"a", "b"})
str, err := template.NewStruct(Format_7_18, []Value{Float(42), Bool(true)})
assert.NoError(err)
require.NoError(t, err)
assert.True(mustStruct(NewStruct(Format_7_18, "A", StructData{
"a": Float(42),
"b": Bool(true),

168
go/store/types/subtype_test.go
View File

@@ -29,6 +29,7 @@ import (
"github.com/google/uuid"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"github.com/dolthub/dolt/go/store/d"
)
@@ -99,7 +100,7 @@ func TestAssertTypeValue(t *testing.T) {
assertSubtype(context.Background(), Format_7_18, PrimitiveTypeMap[ValueKind], Float(1))
assertSubtype(context.Background(), Format_7_18, PrimitiveTypeMap[ValueKind], String("abc"))
l, err := NewList(context.Background(), vs, Float(0), Float(1), Float(2), Float(3))
assert.NoError(t, err)
require.NoError(t, err)
assertSubtype(context.Background(), Format_7_18, PrimitiveTypeMap[ValueKind], l)
}
@@ -107,7 +108,7 @@ func TestAssertTypeBlob(t *testing.T) {
vs := newTestValueStore()
blob, err := NewBlob(context.Background(), vs, bytes.NewBuffer([]byte{0x00, 0x01}))
assert.NoError(t, err)
require.NoError(t, err)
assertAll(t, PrimitiveTypeMap[BlobKind], blob)
}
@@ -115,8 +116,9 @@ func TestAssertTypeList(tt *testing.T) {
vs := newTestValueStore()
listOfNumberType, err := MakeListType(PrimitiveTypeMap[FloatKind])
require.NoError(tt, err)
l, err := NewList(context.Background(), vs, Float(0), Float(1), Float(2), Float(3))
assert.NoError(tt, err)
require.NoError(tt, err)
assertSubtype(context.Background(), Format_7_18, listOfNumberType, l)
assertAll(tt, listOfNumberType, l)
assertSubtype(context.Background(), Format_7_18, mustType(MakeListType(PrimitiveTypeMap[ValueKind])), l)
@@ -126,9 +128,9 @@ func TestAssertTypeMap(tt *testing.T) {
vs := newTestValueStore()
mapOfNumberToStringType, err := MakeMapType(PrimitiveTypeMap[FloatKind], PrimitiveTypeMap[StringKind])
assert.NoError(tt, err)
require.NoError(tt, err)
m, err := NewMap(context.Background(), vs, Float(0), String("a"), Float(2), String("b"))
assert.NoError(tt, err)
require.NoError(tt, err)
assertSubtype(context.Background(), Format_7_18, mapOfNumberToStringType, m)
assertAll(tt, mapOfNumberToStringType, m)
assertSubtype(context.Background(), Format_7_18, mustType(MakeMapType(PrimitiveTypeMap[ValueKind], PrimitiveTypeMap[ValueKind])), m)
@@ -138,9 +140,9 @@ func TestAssertTypeSet(tt *testing.T) {
vs := newTestValueStore()
setOfNumberType, err := MakeSetType(PrimitiveTypeMap[FloatKind])
assert.NoError(tt, err)
require.NoError(tt, err)
s, err := NewSet(context.Background(), vs, Float(0), Float(1), Float(2), Float(3))
assert.NoError(tt, err)
require.NoError(tt, err)
assertSubtype(context.Background(), Format_7_18, setOfNumberType, s)
assertAll(tt, setOfNumberType, s)
assertSubtype(context.Background(), Format_7_18, mustType(MakeSetType(PrimitiveTypeMap[ValueKind])), s)
@@ -148,7 +150,7 @@ func TestAssertTypeSet(tt *testing.T) {
func TestAssertTypeType(tt *testing.T) {
t, err := MakeSetType(PrimitiveTypeMap[FloatKind])
assert.NoError(tt, err)
require.NoError(tt, err)
assertSubtype(context.Background(), Format_7_18, PrimitiveTypeMap[TypeKind], t)
assertAll(tt, PrimitiveTypeMap[TypeKind], t)
assertSubtype(context.Background(), Format_7_18, PrimitiveTypeMap[ValueKind], t)
@@ -156,10 +158,10 @@ func TestAssertTypeType(tt *testing.T) {
func TestAssertTypeStruct(tt *testing.T) {
t, err := MakeStructType("Struct", StructField{"x", PrimitiveTypeMap[BoolKind], false})
assert.NoError(tt, err)
require.NoError(tt, err)
v, err := NewStruct(Format_7_18, "Struct", StructData{"x": Bool(true)})
assert.NoError(tt, err)
require.NoError(tt, err)
assertSubtype(context.Background(), Format_7_18, t, v)
assertAll(tt, t, v)
assertSubtype(context.Background(), Format_7_18, PrimitiveTypeMap[ValueKind], v)
@@ -176,11 +178,11 @@ func TestAssertTypeUnion(tt *testing.T) {
assertSubtype(context.Background(), Format_7_18, mustType(MakeUnionType(PrimitiveTypeMap[FloatKind], PrimitiveTypeMap[StringKind], PrimitiveTypeMap[BoolKind])), Bool(true))
lt, err := MakeListType(mustType(MakeUnionType(PrimitiveTypeMap[FloatKind], PrimitiveTypeMap[StringKind])))
assert.NoError(tt, err)
require.NoError(tt, err)
assertSubtype(context.Background(), Format_7_18, lt, mustList(NewList(context.Background(), vs, Float(1), String("hi"), Float(2), String("bye"))))
st, err := MakeSetType(PrimitiveTypeMap[StringKind])
assert.NoError(tt, err)
require.NoError(tt, err)
assertSubtype(context.Background(), Format_7_18, mustType(MakeUnionType(st, PrimitiveTypeMap[FloatKind])), Float(42))
assertSubtype(context.Background(), Format_7_18, mustType(MakeUnionType(st, PrimitiveTypeMap[FloatKind])), mustValue(NewSet(context.Background(), vs, String("a"), String("b"))))
@@ -228,11 +230,11 @@ func TestAssertTypeEmptyListUnion(tt *testing.T) {
vs := newTestValueStore()
ut, err := MakeUnionType()
assert.NoError(tt, err)
require.NoError(tt, err)
lt, err := MakeListType(ut)
assert.NoError(tt, err)
require.NoError(tt, err)
l, err := NewList(context.Background(), vs)
assert.NoError(tt, err)
require.NoError(tt, err)
assertSubtype(context.Background(), Format_7_18, lt, l)
}
@@ -240,9 +242,9 @@ func TestAssertTypeEmptyList(tt *testing.T) {
vs := newTestValueStore()
lt, err := MakeListType(PrimitiveTypeMap[FloatKind])
assert.NoError(tt, err)
require.NoError(tt, err)
l, err := NewList(context.Background(), vs)
assert.NoError(tt, err)
require.NoError(tt, err)
assertSubtype(context.Background(), Format_7_18, lt, l)
// List<> not a subtype of List<Float>
@@ -253,9 +255,9 @@ func TestAssertTypeEmptySet(tt *testing.T) {
vs := newTestValueStore()
st, err := MakeSetType(PrimitiveTypeMap[FloatKind])
assert.NoError(tt, err)
require.NoError(tt, err)
s, err := NewSet(context.Background(), vs)
assert.NoError(tt, err)
require.NoError(tt, err)
assertSubtype(context.Background(), Format_7_18, st, s)
// Set<> not a subtype of Set<Float>
@@ -266,28 +268,28 @@ func TestAssertTypeEmptyMap(tt *testing.T) {
vs := newTestValueStore()
mt, err := MakeMapType(PrimitiveTypeMap[FloatKind], PrimitiveTypeMap[StringKind])
assert.NoError(tt, err)
require.NoError(tt, err)
m, err := NewMap(context.Background(), vs)
assert.NoError(tt, err)
require.NoError(tt, err)
assertSubtype(context.Background(), Format_7_18, mt, m)
// Map<> not a subtype of Map<Float, Float>
m2, err := NewMap(context.Background(), vs, Float(1), Float(2))
assert.NoError(tt, err)
require.NoError(tt, err)
assertInvalid(tt, mustType(MakeMapType(mustType(MakeUnionType()), mustType(MakeUnionType()))), m2)
}
func TestAssertTypeStructSubtypeByName(tt *testing.T) {
namedT, err := MakeStructType("Name", StructField{"x", PrimitiveTypeMap[FloatKind], false})
assert.NoError(tt, err)
require.NoError(tt, err)
anonT, err := MakeStructType("", StructField{"x", PrimitiveTypeMap[FloatKind], false})
assert.NoError(tt, err)
require.NoError(tt, err)
namedV, err := NewStruct(Format_7_18, "Name", StructData{"x": Float(42)})
assert.NoError(tt, err)
require.NoError(tt, err)
name2V, err := NewStruct(Format_7_18, "foo", StructData{"x": Float(42)})
assert.NoError(tt, err)
require.NoError(tt, err)
anonV, err := NewStruct(Format_7_18, "", StructData{"x": Float(42)})
assert.NoError(tt, err)
require.NoError(tt, err)
assertSubtype(context.Background(), Format_7_18, namedT, namedV)
assertInvalid(tt, namedT, name2V)
@@ -300,17 +302,17 @@ func TestAssertTypeStructSubtypeByName(tt *testing.T) {
func TestAssertTypeStructSubtypeExtraFields(tt *testing.T) {
at, err := MakeStructType("")
assert.NoError(tt, err)
require.NoError(tt, err)
bt, err := MakeStructType("", StructField{"x", PrimitiveTypeMap[FloatKind], false})
assert.NoError(tt, err)
require.NoError(tt, err)
ct, err := MakeStructType("", StructField{"s", PrimitiveTypeMap[StringKind], false}, StructField{"x", PrimitiveTypeMap[FloatKind], false})
assert.NoError(tt, err)
require.NoError(tt, err)
av, err := NewStruct(Format_7_18, "", StructData{})
assert.NoError(tt, err)
require.NoError(tt, err)
bv, err := NewStruct(Format_7_18, "", StructData{"x": Float(1)})
assert.NoError(tt, err)
require.NoError(tt, err)
cv, err := NewStruct(Format_7_18, "", StructData{"x": Float(2), "s": String("hi")})
assert.NoError(tt, err)
require.NoError(tt, err)
assertSubtype(context.Background(), Format_7_18, at, av)
assertInvalid(tt, bt, av)
@@ -332,26 +334,26 @@ func TestAssertTypeStructSubtype(tt *testing.T) {
"value": Float(1),
"parents": mustValue(NewSet(context.Background(), vs)),
})
assert.NoError(tt, err)
require.NoError(tt, err)
t1, err := MakeStructType("Commit",
StructField{"parents", mustType(MakeSetType(mustType(MakeUnionType()))), false},
StructField{"value", PrimitiveTypeMap[FloatKind], false},
)
assert.NoError(tt, err)
require.NoError(tt, err)
assertSubtype(context.Background(), Format_7_18, t1, c1)
t11, err := MakeStructType("Commit",
StructField{"parents", mustType(MakeSetType(mustType(MakeRefType(MakeCycleType("Commit"))))), false},
StructField{"value", PrimitiveTypeMap[FloatKind], false},
)
assert.NoError(tt, err)
require.NoError(tt, err)
assertSubtype(context.Background(), Format_7_18, t11, c1)
c2, err := NewStruct(Format_7_18, "Commit", StructData{
"value": Float(2),
"parents": mustValue(NewSet(context.Background(), vs, mustRef(NewRef(c1, Format_7_18)))),
})
assert.NoError(tt, err)
require.NoError(tt, err)
assertSubtype(context.Background(), Format_7_18, t11, c2)
}
@@ -364,7 +366,7 @@ func TestAssertTypeCycleUnion(tt *testing.T) {
StructField{"x", MakeCycleType("S"), false},
StructField{"y", PrimitiveTypeMap[FloatKind], false},
)
assert.NoError(tt, err)
require.NoError(tt, err)
// struct S {
// x: Cycle<S>,
// y: Float | String,
@@ -374,7 +376,7 @@ func TestAssertTypeCycleUnion(tt *testing.T) {
StructField{"y", mustType(MakeUnionType(PrimitiveTypeMap[FloatKind], PrimitiveTypeMap[StringKind])), false},
)
assert.NoError(tt, err)
require.NoError(tt, err)
assert.True(tt, IsSubtype(Format_7_18, t2, t1))
assert.False(tt, IsSubtype(Format_7_18, t1, t2))
@@ -387,7 +389,7 @@ func TestAssertTypeCycleUnion(tt *testing.T) {
StructField{"y", mustType(MakeUnionType(PrimitiveTypeMap[FloatKind], PrimitiveTypeMap[StringKind])), false},
)
assert.NoError(tt, err)
require.NoError(tt, err)
assert.True(tt, IsSubtype(Format_7_18, t3, t1))
assert.False(tt, IsSubtype(Format_7_18, t1, t3))
@@ -403,7 +405,7 @@ func TestAssertTypeCycleUnion(tt *testing.T) {
StructField{"y", PrimitiveTypeMap[FloatKind], false},
)
assert.NoError(tt, err)
require.NoError(tt, err)
assert.True(tt, IsSubtype(Format_7_18, t4, t1))
assert.False(tt, IsSubtype(Format_7_18, t1, t4))
@@ -432,7 +434,7 @@ func TestAssertTypeCycleUnion(tt *testing.T) {
false,
},
)
assert.NoError(tt, err)
require.NoError(tt, err)
tc, err := MakeStructType("A",
StructField{
@@ -441,7 +443,7 @@ func TestAssertTypeCycleUnion(tt *testing.T) {
false,
},
)
assert.NoError(tt, err)
require.NoError(tt, err)
assert.False(tt, IsSubtype(Format_7_18, tb, tc))
assert.False(tt, IsSubtype(Format_7_18, tc, tb))
@@ -456,13 +458,13 @@ func TestIsSubtypeEmptySruct(tt *testing.T) {
StructField{"a", PrimitiveTypeMap[FloatKind], false},
StructField{"b", EmptyStructType, false},
)
assert.NoError(tt, err)
require.NoError(tt, err)
// struct {
// a: Float,
// }
t2, err := MakeStructType("X", StructField{"a", PrimitiveTypeMap[FloatKind], false})
assert.NoError(tt, err)
require.NoError(tt, err)
assert.False(tt, IsSubtype(Format_7_18, t1, t2))
assert.True(tt, IsSubtype(Format_7_18, t2, t1))
@@ -470,20 +472,20 @@ func TestIsSubtypeEmptySruct(tt *testing.T) {
func TestIsSubtypeCompoundUnion(tt *testing.T) {
rt, err := MakeListType(EmptyStructType)
assert.NoError(tt, err)
require.NoError(tt, err)
st1, err := MakeStructType("One", StructField{"a", PrimitiveTypeMap[FloatKind], false})
assert.NoError(tt, err)
require.NoError(tt, err)
st2, err := MakeStructType("Two", StructField{"b", PrimitiveTypeMap[StringKind], false})
assert.NoError(tt, err)
require.NoError(tt, err)
ct, err := MakeListType(mustType(MakeUnionType(st1, st2)))
assert.NoError(tt, err)
require.NoError(tt, err)
assert.True(tt, IsSubtype(Format_7_18, rt, ct))
assert.False(tt, IsSubtype(Format_7_18, ct, rt))
ct2, err := MakeListType(mustType(MakeUnionType(st1, st2, PrimitiveTypeMap[FloatKind])))
assert.NoError(tt, err)
require.NoError(tt, err)
assert.False(tt, IsSubtype(Format_7_18, rt, ct2))
assert.False(tt, IsSubtype(Format_7_18, ct2, rt))
}
@@ -492,25 +494,27 @@ func TestIsSubtypeOptionalFields(tt *testing.T) {
assert := assert.New(tt)
s1, err := MakeStructType("", StructField{"a", PrimitiveTypeMap[FloatKind], true})
assert.NoError(err)
require.NoError(tt, err)
s2, err := MakeStructType("", StructField{"a", PrimitiveTypeMap[FloatKind], false})
assert.NoError(err)
require.NoError(tt, err)
assert.True(IsSubtype(Format_7_18, s1, s2))
assert.False(IsSubtype(Format_7_18, s2, s1))
s3, err := MakeStructType("", StructField{"a", PrimitiveTypeMap[StringKind], false})
require.NoError(tt, err)
assert.False(IsSubtype(Format_7_18, s1, s3))
assert.False(IsSubtype(Format_7_18, s3, s1))
s4, err := MakeStructType("", StructField{"a", PrimitiveTypeMap[StringKind], true})
require.NoError(tt, err)
assert.False(IsSubtype(Format_7_18, s1, s4))
assert.False(IsSubtype(Format_7_18, s4, s1))
test := func(t1s, t2s string, exp1, exp2 bool) {
t1, err := makeTestStructTypeFromFieldNames(t1s)
assert.NoError(err)
require.NoError(tt, err)
t2, err := makeTestStructTypeFromFieldNames(t2s)
assert.NoError(err)
require.NoError(tt, err)
assert.Equal(exp1, IsSubtype(Format_7_18, t1, t2))
assert.Equal(exp2, IsSubtype(Format_7_18, t2, t1))
assert.False(t1.Equals(t2))
@@ -544,9 +548,9 @@ func TestIsSubtypeOptionalFields(tt *testing.T) {
test("a? c? e?", "b d", true, false)
t1, err := MakeStructType("", StructField{"a", PrimitiveTypeMap[BoolKind], true})
assert.NoError(err)
require.NoError(tt, err)
t2, err := MakeStructType("", StructField{"a", PrimitiveTypeMap[FloatKind], true})
assert.NoError(err)
require.NoError(tt, err)
assert.False(IsSubtype(Format_7_18, t1, t2))
assert.False(IsSubtype(Format_7_18, t2, t1))
}
@@ -596,9 +600,9 @@ func TestIsSubtypeDisallowExtraStructFields(tt *testing.T) {
test := func(t1s, t2s string, exp1, exp2 bool) {
t1, err := makeTestStructTypeFromFieldNames(t1s)
assert.NoError(err)
require.NoError(tt, err)
t2, err := makeTestStructTypeFromFieldNames(t2s)
assert.NoError(err)
require.NoError(tt, err)
assert.Equal(exp1, IsSubtypeDisallowExtraStructFields(Format_7_18, t1, t2))
assert.Equal(exp2, IsSubtypeDisallowExtraStructFields(Format_7_18, t2, t1))
assert.False(t1.Equals(t2))
@@ -693,14 +697,14 @@ func TestIsValueSubtypeOf(tt *testing.T) {
newChunkedList := func(vals ...Value) List {
newSequenceMetaTuple := func(v Value) metaTuple {
seq, err := newListLeafSequence(vs, v)
assert.NoError(err)
require.NoError(tt, err)
list := newList(seq)
ref, err := vs.WriteValue(context.Background(), list)
assert.NoError(err)
require.NoError(tt, err)
ordKey, err := newOrderedKey(v, Format_7_18)
assert.NoError(err)
require.NoError(tt, err)
mt, err := newMetaTuple(ref, ordKey, 1)
assert.NoError(err)
require.NoError(tt, err)
return mt
}
@@ -709,7 +713,7 @@ func TestIsValueSubtypeOf(tt *testing.T) {
tuples[i] = newSequenceMetaTuple(v)
}
mseq, err := newListMetaSequence(1, tuples, vs)
assert.NoError(err)
require.NoError(tt, err)
return newList(mseq)
}
@@ -732,14 +736,14 @@ func TestIsValueSubtypeOf(tt *testing.T) {
newChunkedSet := func(vals ...Value) Set {
newSequenceMetaTuple := func(v Value) metaTuple {
seq, err := newSetLeafSequence(vs, v)
assert.NoError(err)
require.NoError(tt, err)
set := newSet(seq)
ref, err := vs.WriteValue(context.Background(), set)
assert.NoError(err)
require.NoError(tt, err)
ordKey, err := newOrderedKey(v, Format_7_18)
assert.NoError(err)
require.NoError(tt, err)
mt, err := newMetaTuple(ref, ordKey, 1)
assert.NoError(err)
require.NoError(tt, err)
return mt
}
@@ -772,14 +776,14 @@ func TestIsValueSubtypeOf(tt *testing.T) {
newChunkedMap := func(vals ...Value) Map {
newSequenceMetaTuple := func(e mapEntry) metaTuple {
seq, err := newMapLeafSequence(vs, e)
assert.NoError(err)
require.NoError(tt, err)
m := newMap(seq)
ref, err := vs.WriteValue(context.Background(), m)
assert.NoError(err)
require.NoError(tt, err)
ordKey, err := newOrderedKey(e.key, Format_7_18)
assert.NoError(err)
require.NoError(tt, err)
mt, err := newMetaTuple(ref, ordKey, 1)
assert.NoError(err)
require.NoError(tt, err)
return mt
}
@@ -881,13 +885,13 @@ func TestIsValueSubtypeOf(tt *testing.T) {
for i, c := range children {
var err error
childrenAsRefs[i], err = NewRef(c, Format_7_18)
assert.NoError(err)
require.NoError(tt, err)
}
rv, err := NewStruct(Format_7_18, "Node", StructData{
"value": value,
"children": mustList(NewList(context.Background(), vs, childrenAsRefs...)),
})
assert.NoError(err)
require.NoError(tt, err)
return rv
}
@@ -895,7 +899,7 @@ func TestIsValueSubtypeOf(tt *testing.T) {
StructField{"value", PrimitiveTypeMap[FloatKind], false},
StructField{"children", mustType(MakeListType(mustType(MakeRefType(MakeCycleType("Node"))))), false},
)
assert.NoError(err)
require.NoError(tt, err)
assertTrue(
node(Float(0), node(Float(1)), node(Float(2), node(Float(3)))),
@@ -915,19 +919,19 @@ func TestIsValueSubtypeOf(tt *testing.T) {
StructField{"a", PrimitiveTypeMap[FloatKind], false},
StructField{"b", MakeCycleType("A"), false},
)
assert.NoError(err)
require.NoError(tt, err)
t2, err := MakeStructType("A",
StructField{"a", PrimitiveTypeMap[FloatKind], false},
StructField{"b", MakeCycleType("A"), true},
)
assert.NoError(err)
require.NoError(tt, err)
v, err := NewStruct(Format_7_18, "A", StructData{
"a": Float(1),
"b": mustValue(NewStruct(Format_7_18, "A", StructData{
"a": Float(2),
})),
})
assert.NoError(err)
require.NoError(tt, err)
assertFalse(v, t1)
assertTrue(v, t2)
@@ -938,12 +942,12 @@ func TestIsValueSubtypeOf(tt *testing.T) {
StructField{"aa", PrimitiveTypeMap[FloatKind], true},
StructField{"bb", PrimitiveTypeMap[BoolKind], false},
)
assert.NoError(err)
require.NoError(tt, err)
v, err := NewStruct(Format_7_18, "A", StructData{
"a": Float(1),
"b": Bool(true),
})
assert.NoError(err)
require.NoError(tt, err)
assertFalse(v, t)
}
}
@@ -953,11 +957,11 @@ func TestIsValueSubtypeOfDetails(tt *testing.T) {
test := func(vString, tString string, exp1, exp2 bool) {
v, err := makeTestStructFromFieldNames(vString)
assert.NoError(tt, err)
require.NoError(tt, err)
t, err := makeTestStructTypeFromFieldNames(tString)
assert.NoError(tt, err)
require.NoError(tt, err)
isSub, hasExtra, err := IsValueSubtypeOfDetails(Format_7_18, v, t)
assert.NoError(tt, err)
require.NoError(tt, err)
a.Equal(exp1, isSub, "expected %t for IsSub, received: %t", exp1, isSub)
if isSub {
a.Equal(exp2, hasExtra, "expected %t for hasExtra, received: %t", exp2, hasExtra)

30
go/store/types/tuple_test.go
View File

@@ -34,7 +34,7 @@ const (
func TestTupleEquality(t *testing.T) {
values := []Value{String("aoeu"), Int(-1234), Uint(1234)}
tpl, err := NewTuple(Format_7_18, values...)
assert.NoError(t, err)
require.NoError(t, err)
if !tpl.Equals(tpl) {
t.Error("Tuple not equal to itself")
@@ -42,7 +42,7 @@ func TestTupleEquality(t *testing.T) {
id := UUID(uuid.MustParse(ZeroUUID))
tpl2, err := tpl.Append(id)
assert.NoError(t, err)
require.NoError(t, err)
idIdx := tpl2.Len() - 1
if tpl.Equals(tpl2) {
@@ -50,41 +50,41 @@ func TestTupleEquality(t *testing.T) {
}
temp, err := tpl2.Set(idIdx, id)
assert.NoError(t, err)
require.NoError(t, err)
temp, err = temp.Set(0, String("aoeu"))
assert.NoError(t, err)
require.NoError(t, err)
temp, err = temp.Set(1, Int(-1234))
assert.NoError(t, err)
require.NoError(t, err)
tpl3, err := temp.Set(2, Uint(1234))
assert.NoError(t, err)
require.NoError(t, err)
if !tpl2.Equals(tpl3) {
t.Error("")
}
tpl3, err = tpl2.Set(0, String("aoeu"))
assert.NoError(t, err)
require.NoError(t, err)
if !tpl2.Equals(tpl3) {
t.Error("")
}
tpl3, err = tpl2.Set(1, Int(-1234))
assert.NoError(t, err)
require.NoError(t, err)
if !tpl2.Equals(tpl3) {
t.Error("")
}
tpl3, err = tpl2.Set(2, Uint(1234))
assert.NoError(t, err)
require.NoError(t, err)
if !tpl2.Equals(tpl3) {
t.Error("")
}
tpl3, err = tpl2.Set(idIdx, id)
assert.NoError(t, err)
require.NoError(t, err)
if !tpl2.Equals(tpl3) {
t.Error("")
@@ -95,7 +95,7 @@ func TestTupleEquality(t *testing.T) {
}
idVal, err := tpl3.Get(idIdx)
assert.NoError(t, err)
require.NoError(t, err)
if idVal.Kind() != UUIDKind {
t.Error("Unexpected type")
@@ -117,7 +117,7 @@ func TestTupleEquality(t *testing.T) {
return false, nil
})
assert.NoError(t, err)
require.NoError(t, err)
}
func TestTupleLess(t *testing.T) {
@@ -166,13 +166,13 @@ func TestTupleLess(t *testing.T) {
for _, test := range tests {
tpl1, err := NewTuple(Format_7_18, test.vals1...)
assert.NoError(t, err)
require.NoError(t, err)
tpl2, err := NewTuple(Format_7_18, test.vals2...)
assert.NoError(t, err)
require.NoError(t, err)
actual, err := tpl1.Less(Format_7_18, tpl2)
assert.NoError(t, err)
require.NoError(t, err)
if actual != test.expected {
t.Error("tpl1:", mustString(EncodedValue(context.Background(), tpl1)), "tpl2:", mustString(EncodedValue(context.Background(), tpl2)), "expected", test.expected, "actual:", actual)

19
go/store/types/type_test.go
View File

@@ -26,6 +26,7 @@ import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestTypes(t *testing.T) {
@@ -33,16 +34,16 @@ func TestTypes(t *testing.T) {
vs := newTestValueStore()
mapType, err := MakeMapType(PrimitiveTypeMap[StringKind], PrimitiveTypeMap[FloatKind])
assert.NoError(err)
require.NoError(t, err)
setType, err := MakeSetType(PrimitiveTypeMap[StringKind])
assert.NoError(err)
require.NoError(t, err)
mahType, err := MakeStructType("MahStruct",
StructField{"Field1", PrimitiveTypeMap[StringKind], false},
StructField{"Field2", PrimitiveTypeMap[BoolKind], false},
)
assert.NoError(err)
require.NoError(t, err)
recType, err := MakeStructType("RecursiveStruct", StructField{"self", MakeCycleType("RecursiveStruct"), false})
assert.NoError(err)
require.NoError(t, err)
mRef := mustRef(vs.WriteValue(context.Background(), mapType)).TargetHash()
setRef := mustRef(vs.WriteValue(context.Background(), setType)).TargetHash()
@@ -62,9 +63,9 @@ func TestTypeType(t *testing.T) {
func TestTypeRefDescribe(t *testing.T) {
assert := assert.New(t)
mapType, err := MakeMapType(PrimitiveTypeMap[StringKind], PrimitiveTypeMap[FloatKind])
assert.NoError(err)
require.NoError(t, err)
setType, err := MakeSetType(PrimitiveTypeMap[StringKind])
assert.NoError(err)
require.NoError(t, err)
assert.Equal("Bool", mustString(PrimitiveTypeMap[BoolKind].Describe(context.Background())))
assert.Equal("Float", mustString(PrimitiveTypeMap[FloatKind].Describe(context.Background())))
@@ -81,7 +82,7 @@ func TestTypeRefDescribe(t *testing.T) {
StructField{"Field1", PrimitiveTypeMap[StringKind], false},
StructField{"Field2", PrimitiveTypeMap[BoolKind], false},
)
assert.NoError(err)
require.NoError(t, err)
assert.Equal("Struct MahStruct {\n Field1: String,\n Field2: Bool,\n}", mustString(mahType.Describe(context.Background())))
}
@@ -201,9 +202,9 @@ func TestStructUnionWithCycles(tt *testing.T) {
vs := newTestValueStore()
t1, _ := inodeType.Desc.(StructDesc).Field("contents")
enc, err := EncodeValue(t1, Format_7_18)
assert.NoError(tt, err)
require.NoError(tt, err)
t2, err := DecodeValue(enc, vs)
assert.NoError(tt, err)
require.NoError(tt, err)
assert.True(tt, t1.Equals(t2))
// Note that we cannot ensure pointer equality between t1 and t2 because the

9
go/store/types/validating_decoder_test.go
View File

@@ -25,6 +25,7 @@ import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"github.com/dolthub/dolt/go/store/chunks"
)
@@ -32,12 +33,12 @@ import (
func TestValidatingBatchingSinkDecode(t *testing.T) {
v := Float(42)
c, err := EncodeValue(v, Format_7_18)
assert.NoError(t, err)
require.NoError(t, err)
storage := &chunks.TestStorage{}
vdc := NewValidatingDecoder(storage.NewView())
dc, err := vdc.Decode(&c)
assert.NoError(t, err)
require.NoError(t, err)
assert.True(t, v.Equals(*dc.Value))
}
@@ -47,10 +48,10 @@ func assertPanicsOnInvalidChunk(t *testing.T, data []interface{}) {
dataAsByteSlice := toBinaryNomsReaderData(data)
dec := newValueDecoder(dataAsByteSlice, vs)
v, err := dec.readValue(Format_7_18)
assert.NoError(t, err)
require.NoError(t, err)
c, err := EncodeValue(v, Format_7_18)
assert.NoError(t, err)
require.NoError(t, err)
vdc := NewValidatingDecoder(storage.NewView())
assert.Panics(t, func() {

131
go/store/types/value_store_test.go
View File

@@ -26,6 +26,7 @@ import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"github.com/dolthub/dolt/go/store/chunks"
"github.com/dolthub/dolt/go/store/hash"
@@ -39,11 +40,11 @@ func TestValueReadWriteRead(t *testing.T) {
assert.Nil(vs.ReadValue(context.Background(), mustHash(s.Hash(Format_7_18)))) // nil
h := mustRef(vs.WriteValue(context.Background(), s)).TargetHash()
rt, err := vs.Root(context.Background())
assert.NoError(err)
require.NoError(t, err)
_, err = vs.Commit(context.Background(), rt, rt)
assert.NoError(err)
require.NoError(t, err)
v, err := vs.ReadValue(context.Background(), h) // non-nil
assert.NoError(err)
require.NoError(t, err)
if assert.NotNil(v) {
assert.True(s.Equals(v), "%s != %s", mustString(EncodedValue(context.Background(), s)), mustString(EncodedValue(context.Background(), v)))
}
@@ -57,21 +58,21 @@ func TestReadWriteCache(t *testing.T) {
var v Value = Bool(true)
r, err := vs.WriteValue(context.Background(), v)
assert.NoError(err)
require.NoError(t, err)
assert.NotEqual(hash.Hash{}, r.TargetHash())
rt, err := vs.Root(context.Background())
assert.NoError(err)
require.NoError(t, err)
_, err = vs.Commit(context.Background(), rt, rt)
assert.NoError(err)
require.NoError(t, err)
assert.Equal(1, ts.Writes())
v, err = vs.ReadValue(context.Background(), r.TargetHash())
assert.NoError(err)
require.NoError(t, err)
assert.True(v.Equals(Bool(true)))
assert.Equal(1, ts.Reads())
v, err = vs.ReadValue(context.Background(), r.TargetHash())
assert.NoError(err)
require.NoError(t, err)
assert.True(v.Equals(Bool(true)))
assert.Equal(1, ts.Reads())
}
@@ -86,20 +87,20 @@ func TestValueReadMany(t *testing.T) {
h := mustRef(vs.WriteValue(context.Background(), v)).TargetHash()
hashes = append(hashes, h)
rt, err := vs.Root(context.Background())
assert.NoError(err)
require.NoError(t, err)
_, err = vs.Commit(context.Background(), rt, rt)
assert.NoError(err)
require.NoError(t, err)
}
// Get one Value into vs's Value cache
_, err := vs.ReadValue(context.Background(), mustHash(vals[0].Hash(Format_7_18)))
assert.NoError(err)
require.NoError(t, err)
// Get one Value into vs's pendingPuts
three := Float(3)
vals = append(vals, three)
_, err = vs.WriteValue(context.Background(), three)
assert.NoError(err)
require.NoError(t, err)
hashes = append(hashes, mustHash(three.Hash(Format_7_18)))
// Add one Value to request that's not in vs
@@ -107,7 +108,7 @@ func TestValueReadMany(t *testing.T) {
found := map[hash.Hash]Value{}
readValues, err := vs.ReadManyValues(context.Background(), hashes)
assert.NoError(err)
require.NoError(t, err)
for i, v := range readValues {
if v != nil {
@@ -133,9 +134,9 @@ func TestValueWriteFlush(t *testing.T) {
assert.NotZero(vs.bufferedChunkSize)
rt, err := vs.Root(context.Background())
assert.NoError(err)
require.NoError(t, err)
_, err = vs.Commit(context.Background(), rt, rt)
assert.NoError(err)
require.NoError(t, err)
assert.Zero(vs.bufferedChunkSize)
}
@@ -181,45 +182,45 @@ func TestFlushOrder(t *testing.T) {
s := String("oy")
n := Float(42)
sr, err := vs.WriteValue(context.Background(), s)
assert.NoError(err)
require.NoError(t, err)
nr, err := vs.WriteValue(context.Background(), n)
assert.NoError(err)
require.NoError(t, err)
ccs.expect(sr, nr)
ml, err := NewList(context.Background(), vs, sr, nr)
assert.NoError(err)
require.NoError(t, err)
b, err := NewEmptyBlob(vs)
assert.NoError(err)
require.NoError(t, err)
br, err := vs.WriteValue(context.Background(), b)
assert.NoError(err)
require.NoError(t, err)
mlr, err := vs.WriteValue(context.Background(), ml)
assert.NoError(err)
require.NoError(t, err)
ccs.expect(br, mlr)
ml1, err := NewList(context.Background(), vs, br, mlr)
assert.NoError(err)
require.NoError(t, err)
f := Bool(false)
fr, err := vs.WriteValue(context.Background(), f)
assert.NoError(err)
require.NoError(t, err)
ccs.expect(fr)
ml2, err := NewList(context.Background(), vs, fr)
assert.NoError(err)
require.NoError(t, err)
ml1r, err := vs.WriteValue(context.Background(), ml1)
assert.NoError(err)
require.NoError(t, err)
ml2r, err := vs.WriteValue(context.Background(), ml2)
assert.NoError(err)
require.NoError(t, err)
ccs.expect(ml1r, ml2r)
l, err := NewList(context.Background(), vs, ml1r, ml2r)
assert.NoError(err)
require.NoError(t, err)
r, err := vs.WriteValue(context.Background(), l)
assert.NoError(err)
require.NoError(t, err)
ccs.expect(r)
rt, err := vs.Root(context.Background())
assert.NoError(err)
require.NoError(t, err)
_, err = vs.Commit(context.Background(), rt, rt)
assert.NoError(err)
require.NoError(t, err)
}
func TestFlushOverSize(t *testing.T) {
@@ -230,7 +231,7 @@ func TestFlushOverSize(t *testing.T) {
s := String("oy")
sr, err := vs.WriteValue(context.Background(), s)
assert.NoError(err)
require.NoError(t, err)
ccs.expect(sr)
NewList(context.Background(), vs, sr) // will write the root chunk
}
@@ -248,44 +249,44 @@ func TestTolerateTopDown(t *testing.T) {
// S
S := String("oy")
sr, err := vs.WriteValue(context.Background(), S)
assert.NoError(err)
require.NoError(t, err)
ccs.expect(sr)
ML, err := NewList(context.Background(), vs, sr)
assert.NoError(err)
require.NoError(t, err)
mlr, err := vs.WriteValue(context.Background(), ML)
assert.NoError(err)
require.NoError(t, err)
ccs.expect(mlr)
L, err := NewList(context.Background(), vs, mlr)
assert.NoError(err)
require.NoError(t, err)
lr, err := vs.WriteValue(context.Background(), L)
assert.NoError(err)
require.NoError(t, err)
ccs.expect(lr)
rt, err := vs.Root(context.Background())
assert.NoError(err)
require.NoError(t, err)
_, err = vs.Commit(context.Background(), rt, rt)
assert.NoError(err)
require.NoError(t, err)
assert.Zero(len(vs.bufferedChunks))
ST, err := NewStruct(Format_7_18, "", StructData{"r": mlr})
assert.NoError(err)
require.NoError(t, err)
str, err := vs.WriteValue(context.Background(), ST) // ST into bufferedChunks
assert.NoError(err)
require.NoError(t, err)
_, err = vs.WriteValue(context.Background(), S) // S into bufferedChunks
assert.NoError(err)
require.NoError(t, err)
_, err = vs.WriteValue(context.Background(), ML) // ML into bufferedChunks AND withBufferedChunks
assert.NoError(err)
require.NoError(t, err)
// At this point, ValueStore believes ST is a standalone chunk, and that ML -> S
// So, it'll look at ML, the one parent it knows about, first and write its child (S). Then, it'll write ML, and then it'll flush the remaining buffered chunks, which is just ST.
ccs.expect(sr, mlr, str)
rt, err = vs.Root(context.Background())
assert.NoError(err)
require.NoError(t, err)
_, err = vs.Commit(context.Background(), rt, rt)
assert.NoError(err)
require.NoError(t, err)
}
func TestPanicOnBadVersion(t *testing.T) {
@@ -300,14 +301,14 @@ func TestPanicOnBadVersion(t *testing.T) {
cvs := NewValueStore(&badVersionStore{ChunkStore: storage.NewView()})
assert.Panics(t, func() {
b, err := NewEmptyBlob(cvs)
assert.NoError(t, err)
require.NoError(t, err)
_, err = cvs.WriteValue(context.Background(), b)
assert.NoError(t, err)
require.NoError(t, err)
rt, err := cvs.Root(context.Background())
assert.NoError(t, err)
require.NoError(t, err)
_, err = cvs.Commit(context.Background(), rt, rt)
assert.NoError(t, err)
require.NoError(t, err)
})
})
}
@@ -317,17 +318,17 @@ func TestPanicIfDangling(t *testing.T) {
vs := newTestValueStore()
r, err := NewRef(Bool(true), Format_7_18)
assert.NoError(err)
require.NoError(t, err)
l, err := NewList(context.Background(), vs, r)
assert.NoError(err)
require.NoError(t, err)
_, err = vs.WriteValue(context.Background(), l)
assert.NoError(err)
require.NoError(t, err)
assert.Panics(func() {
rt, err := vs.Root(context.Background())
assert.NoError(err)
require.NoError(t, err)
_, err = vs.Commit(context.Background(), rt, rt)
assert.NoError(err)
require.NoError(t, err)
})
}
@@ -336,16 +337,16 @@ func TestSkipEnforceCompleteness(t *testing.T) {
vs.SetEnforceCompleteness(false)
r, err := NewRef(Bool(true), Format_7_18)
assert.NoError(t, err)
require.NoError(t, err)
l, err := NewList(context.Background(), vs, r)
assert.NoError(t, err)
require.NoError(t, err)
_, err = vs.WriteValue(context.Background(), l)
assert.NoError(t, err)
require.NoError(t, err)
rt, err := vs.Root(context.Background())
assert.NoError(t, err)
require.NoError(t, err)
_, err = vs.Commit(context.Background(), rt, rt)
assert.NoError(t, err)
require.NoError(t, err)
}
func TestGC(t *testing.T) {
@@ -361,27 +362,27 @@ func TestGC(t *testing.T) {
h1 := mustRef(vs.WriteValue(ctx, set1)).TargetHash()
rt, err := vs.Root(ctx)
assert.NoError(err)
require.NoError(t, err)
ok, err := vs.Commit(ctx, h1, rt)
assert.NoError(err)
require.NoError(t, err)
assert.True(ok)
h2 := mustRef(vs.WriteValue(ctx, set2)).TargetHash()
v1, err := vs.ReadValue(ctx, h1) // non-nil
assert.NoError(err)
require.NoError(t, err)
assert.NotNil(v1)
v2, err := vs.ReadValue(ctx, h2) // non-nil
assert.NoError(err)
require.NoError(t, err)
assert.NotNil(v2)
err = vs.GC(ctx)
assert.NoError(err)
require.NoError(t, err)
v1, err = vs.ReadValue(ctx, h1) // non-nil
assert.NoError(err)
require.NoError(t, err)
assert.NotNil(v1)
v2, err = vs.ReadValue(ctx, h2) // nil
assert.NoError(err)
require.NoError(t, err)
assert.Nil(v2)
}

35
go/store/types/walk_refs_test.go
View File

@@ -29,6 +29,7 @@ import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"github.com/dolthub/dolt/go/store/hash"
)
@@ -42,7 +43,7 @@ func TestWalkRefs(t *testing.T) {
return nil
})
val, err := EncodeValue(v, Format_7_18)
assert.NoError(err)
require.NoError(t, err)
err = WalkRefs(val, Format_7_18, func(r Ref) error {
if assert.True(len(expected) > 0) {
assert.Equal(expected[0], r.TargetHash())
@@ -51,7 +52,7 @@ func TestWalkRefs(t *testing.T) {
return nil
})
assert.NoError(err)
require.NoError(t, err)
assert.Len(expected, 0)
}
@@ -60,7 +61,7 @@ func TestWalkRefs(t *testing.T) {
t.Run("Typed", func(t *testing.T) {
vrw := newTestValueStore()
s, err := NewStruct(Format_7_18, "", StructData{"n": Float(1)})
assert.NoError(t, err)
require.NoError(t, err)
runTest(mustRef(NewRef(mustMap(NewMap(context.Background(), vrw, s, Float(2))), Format_7_18)), t)
})
t.Run("OfValue", func(t *testing.T) {
@@ -75,7 +76,7 @@ func TestWalkRefs(t *testing.T) {
"num": Float(42),
}
st, err := NewStruct(Format_7_18, "nom", data)
assert.NoError(t, err)
require.NoError(t, err)
runTest(st, t)
})
@@ -85,7 +86,7 @@ func TestWalkRefs(t *testing.T) {
for i := range vs {
var err error
vs[i], err = NewStruct(Format_7_18, "", StructData{"n": Float(r.Uint64())})
assert.NoError(t, err)
require.NoError(t, err)
}
return vs
}
@@ -97,16 +98,16 @@ func TestWalkRefs(t *testing.T) {
t.Run("OfRefs", func(t *testing.T) {
l, err := NewList(context.Background(), vrw, mustValue(vrw.WriteValue(context.Background(), Float(42))), mustValue(vrw.WriteValue(context.Background(), Float(0))))
assert.NoError(t, err)
require.NoError(t, err)
runTest(l, t)
})
t.Run("Chunked", func(t *testing.T) {
l, err := NewList(context.Background(), vrw, newValueSlice(r)...)
assert.NoError(t, err)
require.NoError(t, err)
for l.sequence.isLeaf() {
l, err = l.Concat(context.Background(), mustList(NewList(context.Background(), vrw, newValueSlice(r)...)))
assert.NoError(t, err)
require.NoError(t, err)
}
runTest(l, t)
})
@@ -119,19 +120,19 @@ func TestWalkRefs(t *testing.T) {
t.Run("OfRefs", func(t *testing.T) {
s, err := NewSet(context.Background(), vrw, mustValue(vrw.WriteValue(context.Background(), Float(42))), mustValue(vrw.WriteValue(context.Background(), Float(0))))
assert.NoError(t, err)
require.NoError(t, err)
runTest(s, t)
})
t.Run("Chunked", func(t *testing.T) {
s, err := NewSet(context.Background(), vrw, newValueSlice(r)...)
assert.NoError(t, err)
require.NoError(t, err)
for s.isLeaf() {
e := s.Edit()
e, err = e.Insert(newValueSlice(r)...)
assert.NoError(t, err)
require.NoError(t, err)
s, err = e.Set(context.Background())
assert.NoError(t, err)
require.NoError(t, err)
}
runTest(s, t)
})
@@ -144,13 +145,13 @@ func TestWalkRefs(t *testing.T) {
t.Run("OfRefs", func(t *testing.T) {
m, err := NewMap(context.Background(), vrw, mustValue(vrw.WriteValue(context.Background(), Float(42))), mustValue(vrw.WriteValue(context.Background(), Float(0))))
assert.NoError(t, err)
require.NoError(t, err)
runTest(m, t)
})
t.Run("Chunked", func(t *testing.T) {
m, err := NewMap(context.Background(), vrw, newValueSlice(r)...)
assert.NoError(t, err)
require.NoError(t, err)
for m.isLeaf() {
e := m.Edit()
vs := newValueSlice(r)
@@ -158,7 +159,7 @@ func TestWalkRefs(t *testing.T) {
e = e.Set(vs[i], vs[i+1])
}
m, err = e.Map(context.Background())
assert.NoError(t, err)
require.NoError(t, err)
}
runTest(m, t)
})
@@ -175,11 +176,11 @@ func TestWalkRefs(t *testing.T) {
return bytes.NewReader(scratch)
}
b, err := NewBlob(context.Background(), vrw, freshRandomBytes())
assert.NoError(t, err)
require.NoError(t, err)
for b.sequence.isLeaf() {
var err error
b, err = b.Concat(context.Background(), mustBlob(NewBlob(context.Background(), vrw, freshRandomBytes())))
assert.NoError(t, err)
require.NoError(t, err)
}
runTest(b, t)
})

1
go/store/types/walk_test.go
View File

@@ -229,6 +229,7 @@ func (suite *WalkTestSuite) TestSkipMapValue() {
shouldAlsoSee, err := NewSet(context.Background(), suite.vs, shouldAlsoSeeItem)
suite.NoError(err)
wholeMap, err := NewMap(context.Background(), suite.vs, suite.shouldSee, suite.mustSkip, shouldAlsoSee, suite.shouldSee)
suite.NoError(err)
reached := suite.skipWorker(wholeMap)
for _, v := range []Value{wholeMap, suite.shouldSee, suite.shouldSeeItem, suite.mustSkip, shouldAlsoSee, shouldAlsoSeeItem} {
suite.True(reached.Contains(Format_7_18, v), "Doesn't contain %+v", v)