func TestSetHas2(t *testing.T) {
if testing.Short() {
t.Skip("Skipping test in short mode.")
}
smallTestChunks()
defer normalProductionChunks()
assert := assert.New(t)
vs := NewTestValueStore()
doTest := func(ts testSet) {
set := ts.toSet()
set2 := vs.ReadValue(vs.WriteValue(set).TargetHash()).(Set)
for _, v := range ts {
assert.True(set.Has(v))
assert.True(set2.Has(v))
}
diffSetTest(assert, set, set2, 0, 0)
}
doTest(getTestNativeOrderSet(16))
doTest(getTestRefValueOrderSet(2))
doTest(getTestRefToNativeOrderSet(2, vs))
doTest(getTestRefToValueOrderSet(2, vs))
}
func TestHandleWriteValueBackpressure(t *testing.T) {
assert := assert.New(t)
cs := &backpressureCS{ChunkStore: chunks.NewMemoryStore()}
ds := NewDatabase(cs)
l := types.NewList(
ds.WriteValue(types.Bool(true)),
ds.WriteValue(types.Bool(false)),
)
ds.WriteValue(l)
hint := l.Hash()
newItem := types.NewEmptyBlob()
itemChunk := types.EncodeValue(newItem, nil)
l2 := l.Insert(1, types.NewRef(newItem))
listChunk := types.EncodeValue(l2, nil)
body := &bytes.Buffer{}
serializeHints(body, map[hash.Hash]struct{}{hint: struct{}{}})
sz := chunks.NewSerializer(body)
sz.Put(itemChunk)
sz.Put(listChunk)
sz.Close()
w := httptest.NewRecorder()
HandleWriteValue(w, &http.Request{Body: ioutil.NopCloser(body), Method: "POST"}, params{}, cs)
if assert.Equal(httpStatusTooManyRequests, w.Code, "Handler error:\n%s", string(w.Body.Bytes())) {
hashes := deserializeHashes(w.Body)
assert.Len(hashes, 1)
assert.Equal(l2.Hash(), hashes[0])
}
}
func assertWriteTaggedHRSEqual(t *testing.T, expected string, v Value) {
assert := assert.New(t)
var buf bytes.Buffer
w := &hrsWriter{w: &buf, floatFormat: 'g'}
w.WriteTagged(v)
assert.Equal(expected, buf.String())
}
func TestCursorGetMaxNPrevItemsWithSingleItemSequence(t *testing.T) {
assert := assert.New(t)
cur := newTestSequenceCursor([]interface{}{[]interface{}{100}, []interface{}{101}, []interface{}{102}})
assert.Equal([]sequenceItem{}, cur.maxNPrevItems(0))
assert.Equal([]sequenceItem{}, cur.maxNPrevItems(1))
assert.Equal([]sequenceItem{}, cur.maxNPrevItems(2))
assert.Equal([]sequenceItem{}, cur.maxNPrevItems(3))
assert.Equal(0, cur.idx)
assert.True(cur.advance())
assert.Equal([]sequenceItem{}, cur.maxNPrevItems(0))
assert.Equal([]sequenceItem{100}, cur.maxNPrevItems(1))
assert.Equal([]sequenceItem{100}, cur.maxNPrevItems(2))
assert.Equal([]sequenceItem{100}, cur.maxNPrevItems(3))
assert.Equal(0, cur.idx)
assert.True(cur.advance())
assert.Equal([]sequenceItem{}, cur.maxNPrevItems(0))
assert.Equal([]sequenceItem{101}, cur.maxNPrevItems(1))
assert.Equal([]sequenceItem{100, 101}, cur.maxNPrevItems(2))
assert.Equal([]sequenceItem{100, 101}, cur.maxNPrevItems(3))
assert.Equal(0, cur.idx)
assert.False(cur.advance())
assert.Equal([]sequenceItem{102}, cur.maxNPrevItems(1))
assert.Equal([]sequenceItem{101, 102}, cur.maxNPrevItems(2))
assert.Equal([]sequenceItem{100, 101, 102}, cur.maxNPrevItems(3))
assert.Equal([]sequenceItem{100, 101, 102}, cur.maxNPrevItems(4))
assert.Equal(1, cur.idx)
}
func TestHandlePostRoot(t *testing.T) {
assert := assert.New(t)
cs := chunks.NewTestStore()
input1, input2 := "abc", "def"
chnx := []chunks.Chunk{
chunks.NewChunk([]byte(input1)),
chunks.NewChunk([]byte(input2)),
}
err := cs.PutMany(chnx)
assert.NoError(err)
// First attempt should fail, as 'last' won't match.
u := &url.URL{}
queryParams := url.Values{}
queryParams.Add("last", chnx[0].Hash().String())
queryParams.Add("current", chnx[1].Hash().String())
u.RawQuery = queryParams.Encode()
w := httptest.NewRecorder()
HandleRootPost(w, &http.Request{URL: u, Method: "POST"}, params{}, cs)
assert.Equal(http.StatusConflict, w.Code, "Handler error:\n%s", string(w.Body.Bytes()))
// Now, update the root manually to 'last' and try again.
assert.True(cs.UpdateRoot(chnx[0].Hash(), hash.Hash{}))
w = httptest.NewRecorder()
HandleRootPost(w, &http.Request{URL: u, Method: "POST"}, params{}, cs)
assert.Equal(http.StatusOK, w.Code, "Handler error:\n%s", string(w.Body.Bytes()))
}
func TestReadToList(t *testing.T) {
assert := assert.New(t)
ds := datas.NewDatabase(chunks.NewMemoryStore())
dataString := `a,1,true
b,2,false
`
r := NewCSVReader(bytes.NewBufferString(dataString), ',')
headers := []string{"A", "B", "C"}
kinds := KindSlice{types.StringKind, types.NumberKind, types.BoolKind}
l, typ := ReadToList(r, "test", headers, kinds, ds)
assert.Equal(uint64(2), l.Len())
assert.Equal(types.StructKind, typ.Kind())
desc, ok := typ.Desc.(types.StructDesc)
assert.True(ok)
assert.Equal(desc.Len(), 3)
assert.Equal(types.StringKind, desc.Field("A").Kind())
assert.Equal(types.NumberKind, desc.Field("B").Kind())
assert.Equal(types.BoolKind, desc.Field("C").Kind())
assert.True(l.Get(0).(types.Struct).Get("A").Equals(types.String("a")))
assert.True(l.Get(1).(types.Struct).Get("A").Equals(types.String("b")))
assert.True(l.Get(0).(types.Struct).Get("B").Equals(types.Number(1)))
assert.True(l.Get(1).(types.Struct).Get("B").Equals(types.Number(2)))
assert.True(l.Get(0).(types.Struct).Get("C").Equals(types.Bool(true)))
assert.True(l.Get(1).(types.Struct).Get("C").Equals(types.Bool(false)))
}
func TestHandlePostRoot(t *testing.T) {
assert := assert.New(t)
cs := chunks.NewTestStore()
vs := types.NewValueStore(types.NewBatchStoreAdaptor(cs))
commit := NewCommit(types.String("head"), types.NewSet(), types.NewStruct("Meta", types.StructData{}))
newHead := types.NewMap(types.String("dataset1"), vs.WriteValue(commit))
chnx := []chunks.Chunk{
chunks.NewChunk([]byte("abc")),
types.EncodeValue(newHead, nil),
}
err := cs.PutMany(chnx)
assert.NoError(err)
// First attempt should fail, as 'last' won't match.
u := &url.URL{}
queryParams := url.Values{}
queryParams.Add("last", chnx[0].Hash().String())
queryParams.Add("current", chnx[1].Hash().String())
u.RawQuery = queryParams.Encode()
url := u.String()
w := httptest.NewRecorder()
HandleRootPost(w, newRequest("POST", "", url, nil, nil), params{}, cs)
assert.Equal(http.StatusConflict, w.Code, "Handler error:\n%s", string(w.Body.Bytes()))
// Now, update the root manually to 'last' and try again.
assert.True(cs.UpdateRoot(chnx[0].Hash(), hash.Hash{}))
w = httptest.NewRecorder()
HandleRootPost(w, newRequest("POST", "", url, nil, nil), params{}, cs)
assert.Equal(http.StatusOK, w.Code, "Handler error:\n%s", string(w.Body.Bytes()))
}
func TestVerifyStructFieldName(t *testing.T) {
assert := assert.New(t)
assertInvalid := func(n string) {
assert.Panics(func() {
MakeStructType("S", TypeMap{n: StringType})
})
}
assertInvalid("")
assertInvalid(" ")
assertInvalid(" a")
assertInvalid("a ")
assertInvalid("0")
assertInvalid("_")
assertInvalid("0a")
assertInvalid("_a")
assertInvalid("💩")
assertValid := func(n string) {
MakeStructType("S", TypeMap{n: StringType})
}
assertValid("a")
assertValid("A")
assertValid("a0")
assertValid("a_")
assertValid("a0_")
}
func TestStringString(t *testing.T) {
assert := assert.New(t)
s1 := String("")
s2 := String("foo")
assert.Equal("", string(s1))
assert.Equal("foo", string(s2))
}
func TestNomsStructDiff(t *testing.T) {
assert := assert.New(t)
expected := `(root) {
- "four": "four"
+ "four": "four-diff"
}
["three"] {
- field3: "field3-data"
+ field3: "field3-data-diff"
}
`
fieldData := []interface{}{
"field1", "field1-data",
"field2", "field2-data",
"field3", "field3-data",
"field4", "field4-data",
}
s1 := createStruct("TestData", fieldData...)
s2 := s1.Set("field3", types.String("field3-data-diff"))
m1 := createMap("one", 1, "two", 2, "three", s1, "four", "four")
m2 := createMap("one", 1, "two", 2, "three", s2, "four", "four-diff")
buf := util.NewBuffer(nil)
Diff(buf, m1, m2)
assert.Equal(expected, buf.String())
}
func TestTypes(t *testing.T) {
assert := assert.New(t)
vs := NewTestValueStore()
mapType := MakeMapType(StringType, NumberType)
setType := MakeSetType(StringType)
mahType := MakeStructType("MahStruct", TypeMap{
"Field1": StringType,
"Field2": BoolType,
})
recType := MakeStructType("RecursiveStruct", TypeMap{
"self": nil,
})
recType.Desc.(StructDesc).SetField("self", recType)
mRef := vs.WriteValue(mapType).TargetHash()
setRef := vs.WriteValue(setType).TargetHash()
mahRef := vs.WriteValue(mahType).TargetHash()
recRef := vs.WriteValue(recType).TargetHash()
assert.True(mapType.Equals(vs.ReadValue(mRef)))
assert.True(setType.Equals(vs.ReadValue(setRef)))
assert.True(mahType.Equals(vs.ReadValue(mahRef)))
assert.True(recType.Equals(vs.ReadValue(recRef)))
}
func TestSetTypeAfterMutations(t *testing.T) {
assert := assert.New(t)
smallTestChunks()
defer normalProductionChunks()
test := func(n int, c interface{}) {
values := generateNumbersAsValues(n)
s := NewSet(values...)
assert.Equal(s.Len(), uint64(n))
assert.IsType(c, s.sequence())
assert.True(s.Type().Equals(MakeSetType(NumberType)))
s = s.Insert(String("a"))
assert.Equal(s.Len(), uint64(n+1))
assert.IsType(c, s.sequence())
assert.True(s.Type().Equals(MakeSetType(MakeUnionType(NumberType, StringType))))
s = s.Remove(String("a"))
assert.Equal(s.Len(), uint64(n))
assert.IsType(c, s.sequence())
assert.True(s.Type().Equals(MakeSetType(NumberType)))
}
test(10, setLeafSequence{})
test(2000, orderedMetaSequence{})
}
func TestSetIter2(t *testing.T) {
assert := assert.New(t)
smallTestChunks()
defer normalProductionChunks()
doTest := func(ts testSet) {
set := ts.toSet()
sort.Sort(ValueSlice(ts))
idx := uint64(0)
endAt := uint64(64)
set.Iter(func(v Value) (done bool) {
assert.True(ts[idx].Equals(v))
if idx == endAt {
done = true
}
idx++
return
})
assert.Equal(endAt, idx-1)
}
doTest(getTestNativeOrderSet(16))
doTest(getTestRefValueOrderSet(2))
doTest(getTestRefToNativeOrderSet(2, NewTestValueStore()))
doTest(getTestRefToValueOrderSet(2, NewTestValueStore()))
}
func TestSetRemove2(t *testing.T) {
if testing.Short() {
t.Skip("Skipping test in short mode.")
}
smallTestChunks()
defer normalProductionChunks()
assert := assert.New(t)
doTest := func(incr, offset int, ts testSet) {
whole := ts.toSet()
run := func(from, to int) {
expected := ts.Remove(from, to).toSet()
actual := whole.Remove(ts[from:to]...)
assert.Equal(expected.Len(), actual.Len())
assert.True(expected.Equals(actual))
diffSetTest(assert, expected, actual, 0, 0)
}
for i := 0; i < len(ts)-offset; i += incr {
run(i, i+offset)
}
run(len(ts)-offset, len(ts))
}
doTest(18, 3, getTestNativeOrderSet(9))
doTest(64, 1, getTestNativeOrderSet(32))
doTest(32, 1, getTestRefValueOrderSet(4))
doTest(32, 1, getTestRefToNativeOrderSet(4, NewTestValueStore()))
doTest(32, 1, getTestRefToValueOrderSet(4, NewTestValueStore()))
}
func TestListDiffAdd5x5(t *testing.T) {
if testing.Short() {
t.Skip("Skipping test in short mode.")
}
smallTestChunks()
defer normalProductionChunks()
assert := assert.New(t)
nums1 := generateNumbersAsValues(5000)
nums2 := generateNumbersAsValues(5000)
for count := 5; count > 0; count-- {
nums2 = spliceValues(nums2, (count-1)*1000, 0, Number(0), Number(1), Number(2), Number(3), Number(4))
}
l1 := NewList(nums1...)
l2 := NewList(nums2...)
diff1 := accumulateDiffSplices(l1, l2)
diff2 := accumulateDiffSplices(l2, l1)
assert.Equal(len(diff1), len(diff2))
diff2Expected := []Splice{
Splice{5, 0, 5, 5},
Splice{1000, 0, 5, 1005},
Splice{2000, 0, 5, 2010},
Splice{3000, 0, 5, 3015},
Splice{4000, 0, 5, 4020},
}
assert.Equal(diff2Expected, diff2, "expected diff is wrong")
}
func TestListTypeAfterMutations(t *testing.T) {
smallTestChunks()
defer normalProductionChunks()
assert := assert.New(t)
test := func(n int, c interface{}) {
values := generateNumbersAsValues(n)
l := NewList(values...)
assert.Equal(l.Len(), uint64(n))
assert.IsType(c, l.sequence())
assert.True(l.Type().Equals(MakeListType(NumberType)))
l = l.Append(String("a"))
assert.Equal(l.Len(), uint64(n+1))
assert.IsType(c, l.sequence())
assert.True(l.Type().Equals(MakeListType(MakeUnionType(NumberType, StringType))))
l = l.Splice(l.Len()-1, 1)
assert.Equal(l.Len(), uint64(n))
assert.IsType(c, l.sequence())
assert.True(l.Type().Equals(MakeListType(NumberType)))
}
test(15, listLeafSequence{})
test(1500, indexedMetaSequence{})
}
func TestListDiffReplaceReverse5x100(t *testing.T) {
if testing.Short() {
t.Skip("Skipping test in short mode.")
}
smallTestChunks()
defer normalProductionChunks()
assert := assert.New(t)
nums1 := generateNumbersAsValues(5000)
nums2 := generateNumbersAsValues(5000)
for count := 5; count > 0; count-- {
out := reverseValues(nums2[(count-1)*1000 : (count-1)*1000+100])
nums2 = spliceValues(nums2, (count-1)*1000, 100, out...)
}
l1 := NewList(nums1...)
l2 := NewList(nums2...)
diff := accumulateDiffSplices(l2, l1)
diffExpected := []Splice{
Splice{0, 49, 50, 0},
Splice{50, 50, 49, 51},
Splice{1000, 49, 50, 1000},
Splice{1050, 50, 49, 1051},
Splice{2000, 49, 50, 2000},
Splice{2050, 50, 49, 2051},
Splice{3000, 49, 50, 3000},
Splice{3050, 50, 49, 3051},
Splice{4000, 49, 50, 4000},
Splice{4050, 50, 49, 4051},
}
assert.Equal(diffExpected, diff, "expected diff is wrong")
}
func TestStreamingListCreation(t *testing.T) {
smallTestChunks()
defer normalProductionChunks()
if testing.Short() {
t.Skip("Skipping test in short mode.")
}
assert := assert.New(t)
vs := NewTestValueStore()
simpleList := getTestList()
cl := NewList(simpleList...)
valueChan := make(chan Value)
listChan := NewStreamingList(vs, valueChan)
for _, v := range simpleList {
valueChan <- v
}
close(valueChan)
sl := <-listChan
assert.True(cl.Equals(sl))
cl.Iter(func(v Value, idx uint64) (done bool) {
done = !assert.True(v.Equals(sl.Get(idx)))
return
})
}
func TestReadToMap(t *testing.T) {
assert := assert.New(t)
ds := datas.NewDatabase(chunks.NewMemoryStore())
dataString := `a,1,true
b,2,false
`
r := NewCSVReader(bytes.NewBufferString(dataString), ',')
headers := []string{"A", "B", "C"}
kinds := KindSlice{types.StringKind, types.NumberKind, types.BoolKind}
m := ReadToMap(r, headers, 0, kinds, ds)
assert.Equal(uint64(2), m.Len())
assert.True(m.Type().Equals(
types.MakeMapType(types.StringType, types.MakeStructType("", map[string]*types.Type{
"B": types.NumberType,
"C": types.BoolType,
}))))
assert.True(m.Get(types.String("a")).Equals(types.NewStruct("", map[string]types.Value{
"B": types.Number(1),
"C": types.Bool(true),
})))
assert.True(m.Get(types.String("b")).Equals(types.NewStruct("", map[string]types.Value{
"B": types.Number(2),
"C": types.Bool(false),
})))
}
func TestListRemoveAtMiddle(t *testing.T) {
if testing.Short() {
t.Skip("Skipping test in short mode.")
}
assert := assert.New(t)
smallTestChunks()
defer normalProductionChunks()
cl := getTestList().toList()
cl2 := cl.RemoveAt(100)
cl3 := cl2.RemoveAt(200)
expected := getTestList()
assert.Equal(expected, testListFromNomsList(cl))
assert.Equal(getTestListLen(), cl.Len())
assert.True(expected.toList().Equals(cl))
expected = expected.RemoveAt(100)
assert.Equal(expected, testListFromNomsList(cl2))
assert.Equal(getTestListLen()-1, cl2.Len())
assert.True(expected.toList().Equals(cl2))
expected = expected.RemoveAt(200)
assert.Equal(expected, testListFromNomsList(cl3))
assert.Equal(getTestListLen()-2, cl3.Len())
assert.True(expected.toList().Equals(cl3))
}
func assertWriteHRSEqual(t *testing.T, expected string, v Value) {
assert := assert.New(t)
var buf bytes.Buffer
w := &hrsWriter{w: &buf}
w.Write(v)
assert.Equal(expected, buf.String())
}
func TestListRemoveRanges(t *testing.T) {
if testing.Short() {
t.Skip("Skipping test in short mode.")
}
assert := assert.New(t)
smallTestChunks()
defer normalProductionChunks()
testList := getTestList()
whole := testList.toList()
// 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 := testListPart.toList()
actual := whole.Remove(uint64(i), uint64(i+window))
assert.Equal(expected.Len(), actual.Len())
assert.True(expected.Equals(actual))
}
}
// 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 {
assert.Equal(len(testList)-incr, int(whole.Remove(uint64(i), uint64(i+incr)).Len()))
}
}
func TestHandleGetRefs(t *testing.T) {
assert := assert.New(t)
cs := chunks.NewTestStore()
input1, input2 := "abc", "def"
chnx := []chunks.Chunk{
chunks.NewChunk([]byte(input1)),
chunks.NewChunk([]byte(input2)),
}
err := cs.PutMany(chnx)
assert.NoError(err)
body := strings.NewReader(fmt.Sprintf("ref=%s&ref=%s", chnx[0].Hash(), chnx[1].Hash()))
w := httptest.NewRecorder()
HandleGetRefs(w,
&http.Request{Body: ioutil.NopCloser(body), Method: "POST", Header: http.Header{
"Content-Type": {"application/x-www-form-urlencoded"},
}},
params{},
cs,
)
if assert.Equal(http.StatusOK, w.Code, "Handler error:\n%s", string(w.Body.Bytes())) {
chunkChan := make(chan *chunks.Chunk)
go chunks.DeserializeToChan(w.Body, chunkChan)
for c := range chunkChan {
assert.Equal(chnx[0].Hash(), c.Hash())
chnx = chnx[1:]
}
assert.Empty(chnx)
}
}
func TestListSet(t *testing.T) {
if testing.Short() {
t.Skip("Skipping test in short mode.")
}
assert := assert.New(t)
smallTestChunks()
defer normalProductionChunks()
testList := getTestList()
cl := testList.toList()
testIdx := func(idx int, testEquality bool) {
newVal := Number(-1) // Test values are never < 0
cl2 := cl.Set(uint64(idx), newVal)
assert.False(cl.Equals(cl2))
if testEquality {
assert.True(testList.Set(idx, newVal).toList().Equals(cl2))
}
}
// Compare list equality. Increment by 100 because each iteration requires building a new list, which is slow, but always test the last index.
for incr, i := 100, 0; i < len(testList); i += incr {
testIdx(i, true)
}
testIdx(len(testList)-1, true)
// Compare list unequality, 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 {
testIdx(i, false)
}
}
func TestHandleWriteValue(t *testing.T) {
assert := assert.New(t)
cs := chunks.NewTestStore()
ds := NewDatabase(cs)
l := types.NewList(
ds.WriteValue(types.Bool(true)),
ds.WriteValue(types.Bool(false)),
)
ds.WriteValue(l)
hint := l.Hash()
newItem := types.NewEmptyBlob()
itemChunk := types.EncodeValue(newItem, nil)
l2 := l.Insert(1, types.NewRef(newItem))
listChunk := types.EncodeValue(l2, nil)
body := &bytes.Buffer{}
serializeHints(body, map[hash.Hash]struct{}{hint: struct{}{}})
sz := chunks.NewSerializer(body)
sz.Put(itemChunk)
sz.Put(listChunk)
sz.Close()
w := httptest.NewRecorder()
HandleWriteValue(w, &http.Request{Body: ioutil.NopCloser(body), Method: "POST"}, params{}, cs)
if assert.Equal(http.StatusCreated, w.Code, "Handler error:\n%s", string(w.Body.Bytes())) {
ds2 := NewDatabase(cs)
v := ds2.ReadValue(l2.Hash())
if assert.NotNil(v) {
assert.True(v.Equals(l2), "%+v != %+v", v, l2)
}
}
}
func TestListFirstNNumbers(t *testing.T) {
assert := assert.New(t)
nums := generateNumbersAsValues(testListSize)
s := NewList(nums...)
assert.Equal("tqpbqlu036sosdq9kg3lka7sjaklgslg", s.Hash().String())
}
func TestBuildWriteValueRequest(t *testing.T) {
assert := assert.New(t)
input1, input2 := "abc", "def"
chnx := []chunks.Chunk{
chunks.NewChunk([]byte(input1)),
chunks.NewChunk([]byte(input2)),
}
hints := map[hash.Hash]struct{}{
hash.Parse("sha1-0000000000000000000000000000000000000002"): struct{}{},
hash.Parse("sha1-0000000000000000000000000000000000000003"): struct{}{},
}
compressed := buildWriteValueRequest(serializeChunks(chnx, assert), hints)
gr := snappy.NewReader(compressed)
count := 0
for hint := range deserializeHints(gr) {
count++
_, present := hints[hint]
assert.True(present)
}
assert.Equal(len(hints), count)
chunkChan := make(chan *chunks.Chunk, 16)
go chunks.DeserializeToChan(gr, chunkChan)
for c := range chunkChan {
assert.Equal(chnx[0].Hash(), c.Hash())
chnx = chnx[1:]
}
assert.Empty(chnx)
}
func TestListDiffReverseWithLargerLimit(t *testing.T) {
if testing.Short() {
t.Skip("Skipping test in short mode.")
}
smallTestChunks()
defer normalProductionChunks()
assert := assert.New(t)
nums1 := generateNumbersAsValues(5000)
nums2 := reverseValues(nums1)
l1 := NewList(nums1...)
l2 := NewList(nums2...)
diff1 := accumulateDiffSplicesWithLimit(l1, l2, 27e6)
diff2 := accumulateDiffSplicesWithLimit(l2, l1, 27e6)
assert.Equal(len(diff2), len(diff1))
diffExpected := []Splice{
Splice{0, 2499, 2500, 0},
Splice{2500, 2500, 2499, 2501},
}
assert.Equal(diffExpected, diff1, "expected diff is wrong")
assert.Equal(diffExpected, diff2, "expected diff is wrong")
}
func TestTotalOrdering(t *testing.T) {
assert := assert.New(t)
// values in increasing order. Some of these are compared by ref so changing the serialization might change the ordering.
values := []Value{
Bool(false), Bool(true),
Number(-10), Number(0), Number(10),
String("a"), String("b"), String("c"),
// The order of these are done by the hash.
NewSet(Number(0), Number(1), Number(2), Number(3)),
BoolType,
// Value - values cannot be value
// Cycle - values cannot be cycle
// Union - values cannot be unions
}
for i, vi := range values {
for j, vj := range values {
if i == j {
assert.True(vi.Equals(vj))
} else if i < j {
x := vi.Less(vj)
assert.True(x)
} else {
x := vi.Less(vj)
assert.False(x)
}
}
}
}
func TestMapNotStringKeys(t *testing.T) {
assert := assert.New(t)
b1 := NewBlob(bytes.NewBufferString("blob1"))
b2 := NewBlob(bytes.NewBufferString("blob2"))
l := []Value{
Bool(true), String("true"),
Bool(false), String("false"),
Number(1), String("Number: 1"),
Number(0), String("Number: 0"),
b1, String("blob1"),
b2, String("blob2"),
NewList(), String("empty list"),
NewList(NewList()), String("list of list"),
NewMap(), String("empty map"),
NewMap(NewMap(), NewMap()), String("map of map/map"),
NewSet(), String("empty set"),
NewSet(NewSet()), String("map of set/set"),
}
m1 := NewMap(l...)
assert.Equal(uint64(12), m1.Len())
for i := 0; i < len(l); i += 2 {
assert.True(m1.Get(l[i]).Equals(l[i+1]))
}
assert.Nil(m1.Get(Number(42)))
}