diff --git a/go/store/types/blob_test.go b/go/store/types/blob_test.go index d411098786..febbeb213d 100644 --- a/go/store/types/blob_test.go +++ b/go/store/types/blob_test.go @@ -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())) } diff --git a/go/store/types/common_supertype_test.go b/go/store/types/common_supertype_test.go index c3adbfda69..5baf99e6e0 100644 --- a/go/store/types/common_supertype_test.go +++ b/go/store/types/common_supertype_test.go @@ -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) } } diff --git a/go/store/types/compare_test.go b/go/store/types/compare_test.go index e686b54e30..cee761deae 100644 --- a/go/store/types/compare_test.go +++ b/go/store/types/compare_test.go @@ -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)) } diff --git a/go/store/types/encode_human_readable_test.go b/go/store/types/encode_human_readable_test.go index 01fb14e81b..800d82cf5c 100644 --- a/go/store/types/encode_human_readable_test.go +++ b/go/store/types/encode_human_readable_test.go @@ -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", 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", 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) } diff --git a/go/store/types/encoding_test.go b/go/store/types/encoding_test.go index 978093b5b7..226ae1d93e 100644 --- a/go/store/types/encoding_test.go +++ b/go/store/types/encoding_test.go @@ -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{}{ diff --git a/go/store/types/equals_test.go b/go/store/types/equals_test.go index 0339c5e5c4..35ac81dbb1 100644 --- a/go/store/types/equals_test.go +++ b/go/store/types/equals_test.go @@ -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)) } diff --git a/go/store/types/incremental_test.go b/go/store/types/incremental_test.go index fa854e1565..ae15915e6d 100644 --- a/go/store/types/incremental_test.go +++ b/go/store/types/incremental_test.go @@ -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)) } diff --git a/go/store/types/list_editor_test.go b/go/store/types/list_editor_test.go index 5143ccfb49..cdcf5968bc 100644 --- a/go/store/types/list_editor_test.go +++ b/go/store/types/list_editor_test.go @@ -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)) } } diff --git a/go/store/types/list_iterator_test.go b/go/store/types/list_iterator_test.go index 708502ef9b..f934d6f8c9 100644 --- a/go/store/types/list_iterator_test.go +++ b/go/store/types/list_iterator_test.go @@ -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())) } diff --git a/go/store/types/list_test.go b/go/store/types/list_test.go index 611c5eb11d..e18087262c 100644 --- a/go/store/types/list_test.go +++ b/go/store/types/list_test.go @@ -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))))) } diff --git a/go/store/types/map_iterator_test.go b/go/store/types/map_iterator_test.go index 845b32f93f..9e6757e44e 100644 --- a/go/store/types/map_iterator_test.go +++ b/go/store/types/map_iterator_test.go @@ -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 diff --git a/go/store/types/map_test.go b/go/store/types/map_test.go index bf3510025e..485f9cea9b 100644 --- a/go/store/types/map_test.go +++ b/go/store/types/map_test.go @@ -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) } diff --git a/go/store/types/ordered_sequences_diff_test.go b/go/store/types/ordered_sequences_diff_test.go index c229773331..8819fc5b55 100644 --- a/go/store/types/ordered_sequences_diff_test.go +++ b/go/store/types/ordered_sequences_diff_test.go @@ -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) diff --git a/go/store/types/path_test.go b/go/store/types/path_test.go index 063bb85509..d5f12e0b92 100644 --- a/go/store/types/path_test.go +++ b/go/store/types/path_test.go @@ -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"), mustList(NewList(context.Background(), vs, Float(42), String("foo"))), String("Map"), 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)") diff --git a/go/store/types/ref_heap_test.go b/go/store/types/ref_heap_test.go index d5e6cd95bc..9a0ec23806 100644 --- a/go/store/types/ref_heap_test.go +++ b/go/store/types/ref_heap_test.go @@ -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) diff --git a/go/store/types/ref_test.go b/go/store/types/ref_test.go index c5e8fc9307..f49d119fd8 100644 --- a/go/store/types/ref_test.go +++ b/go/store/types/ref_test.go @@ -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]) } diff --git a/go/store/types/sequence_cursor_test.go b/go/store/types/sequence_cursor_test.go index 562de11d75..13715b9573 100644 --- a/go/store/types/sequence_cursor_test.go +++ b/go/store/types/sequence_cursor_test.go @@ -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) } } diff --git a/go/store/types/set_iterator_test.go b/go/store/types/set_iterator_test.go index f751082ec0..363aa7c29a 100644 --- a/go/store/types/set_iterator_test.go +++ b/go/store/types/set_iterator_test.go @@ -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) diff --git a/go/store/types/set_test.go b/go/store/types/set_test.go index b58798f009..4ba46f3366 100644 --- a/go/store/types/set_test.go +++ b/go/store/types/set_test.go @@ -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}, diff --git a/go/store/types/simplify_test.go b/go/store/types/simplify_test.go index 7da6e1eef0..41c5c4ca22 100644 --- a/go/store/types/simplify_test.go +++ b/go/store/types/simplify_test.go @@ -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) { diff --git a/go/store/types/struct_test.go b/go/store/types/struct_test.go index c080acce4a..8c09bc4b94 100644 --- a/go/store/types/struct_test.go +++ b/go/store/types/struct_test.go @@ -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), diff --git a/go/store/types/subtype_test.go b/go/store/types/subtype_test.go index b783c4884d..55188f2bb5 100644 --- a/go/store/types/subtype_test.go +++ b/go/store/types/subtype_test.go @@ -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 @@ -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 @@ -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 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, // 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) diff --git a/go/store/types/tuple_test.go b/go/store/types/tuple_test.go index 23d0defb74..6b340174c7 100644 --- a/go/store/types/tuple_test.go +++ b/go/store/types/tuple_test.go @@ -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) diff --git a/go/store/types/type_test.go b/go/store/types/type_test.go index 2c41f6b563..d98dc76743 100644 --- a/go/store/types/type_test.go +++ b/go/store/types/type_test.go @@ -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 diff --git a/go/store/types/validating_decoder_test.go b/go/store/types/validating_decoder_test.go index dfccb984a0..80a700e269 100644 --- a/go/store/types/validating_decoder_test.go +++ b/go/store/types/validating_decoder_test.go @@ -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() { diff --git a/go/store/types/value_store_test.go b/go/store/types/value_store_test.go index dd6e3c39bd..5f2ea4be9a 100644 --- a/go/store/types/value_store_test.go +++ b/go/store/types/value_store_test.go @@ -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) } diff --git a/go/store/types/walk_refs_test.go b/go/store/types/walk_refs_test.go index 34f6b34f22..05c33b0747 100644 --- a/go/store/types/walk_refs_test.go +++ b/go/store/types/walk_refs_test.go @@ -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) }) diff --git a/go/store/types/walk_test.go b/go/store/types/walk_test.go index c7904f72b9..98b9f5fcf0 100644 --- a/go/store/types/walk_test.go +++ b/go/store/types/walk_test.go @@ -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)