func assertPathResolvesTo(assert *assert.Assertions, expect, ref Value, p Path) {
if expect == nil {
assert.Nil(p.Resolve(ref))
return
}
assert.True(expect.Equals(p.Resolve(ref)))
}
func serializeChunks(chnx []chunks.Chunk, assert *assert.Assertions) io.Reader {
body := &bytes.Buffer{}
gw := snappy.NewBufferedWriter(body)
sz := chunks.NewSerializer(gw)
assert.NoError(sz.PutMany(chnx))
assert.NoError(sz.Close())
assert.NoError(gw.Close())
return body
}
func assertPathResolvesTo(assert *assert.Assertions, expect, ref Value, p Path) {
actual := p.Resolve(ref)
if expect == nil {
assert.Nil(actual)
} else if actual == nil {
assert.Fail("", "Expected %s, but got nil", EncodedValue(expect))
} else {
assert.True(expect.Equals(actual), "Expected %s, but got %s", EncodedValue(expect), EncodedValue(actual))
}
}
func testSetOrder(assert *assert.Assertions, valueType *Type, value []Value, expectOrdering []Value) {
m := NewSet(value...)
i := 0
m.IterAll(func(value Value) {
assert.Equal(expectOrdering[i].Hash().String(), value.Hash().String())
i++
})
}
func testMapOrder(assert *assert.Assertions, keyType, valueType *Type, tuples []Value, expectOrdering []Value) {
m := NewMap(tuples...)
i := 0
m.IterAll(func(key, value Value) {
assert.Equal(expectOrdering[i].Hash().String(), key.Hash().String())
i++
})
}
func serializeChunks(chnx []chunks.Chunk, assert *assert.Assertions) io.Reader {
body := &bytes.Buffer{}
sw := snappy.NewBufferedWriter(body)
for _, chunk := range chnx {
chunks.Serialize(chunk, sw)
}
assert.NoError(sw.Close())
return body
}
func diffMapTest(assert *assert.Assertions, m1 Map, m2 Map, numAddsExpected int, numRemovesExpected int, numModifiedExpected int) (added []Value, removed []Value, modified []Value) {
added, removed, modified = accumulateMapDiffChanges(m1, m2)
assert.Equal(numAddsExpected, len(added), "num added is not as expected")
assert.Equal(numRemovesExpected, len(removed), "num removed is not as expected")
assert.Equal(numModifiedExpected, len(modified), "num modified is not as expected")
tm1 := newTestMapFromMap(m1)
tm2 := newTestMapFromMap(m2)
tmAdded, tmRemoved, tmModified := tm1.Diff(tm2)
assert.Equal(numAddsExpected, len(tmAdded), "num added is not as expected")
assert.Equal(numRemovesExpected, len(tmRemoved), "num removed is not as expected")
assert.Equal(numModifiedExpected, len(tmModified), "num modified is not as expected")
assert.Equal(added, tmAdded, "map added != tmMap added")
assert.Equal(removed, tmRemoved, "map removed != tmMap removed")
assert.Equal(modified, tmModified, "map modified != tmMap modified")
return
}
func diffSetTest(assert *assert.Assertions, s1 Set, s2 Set, numAddsExpected int, numRemovesExpected int) (added []Value, removed []Value) {
added, removed = accumulateSetDiffChanges(s1, s2)
assert.Equal(numAddsExpected, len(added), "num added is not as expected")
assert.Equal(numRemovesExpected, len(removed), "num removed is not as expected")
ts1 := newTestSetFromSet(s1)
ts2 := newTestSetFromSet(s2)
tsAdded, tsRemoved := ts1.Diff(ts2)
assert.Equal(numAddsExpected, len(tsAdded), "num added is not as expected")
assert.Equal(numRemovesExpected, len(tsRemoved), "num removed is not as expected")
assert.Equal(added, tsAdded, "set added != tsSet added")
assert.Equal(removed, tsRemoved, "set removed != tsSet removed")
return
}
func assertDiff(assert *assert.Assertions, last []uint64, current []uint64, expect []Splice) {
actual := calcSplices(uint64(len(last)), uint64(len(current)), DEFAULT_MAX_SPLICE_MATRIX_SIZE,
func(i uint64, j uint64) bool { return last[i] == current[j] })
assert.Equal(expect, actual, "splices are different: \nexpect: %v\nactual: %v\n", expect, actual)
}
func assertPathStringResolvesTo(assert *assert.Assertions, expect, ref Value, str string) {
p, err := NewPath().AddPath(str)
assert.NoError(err)
assertPathResolvesTo(assert, expect, ref, p)
}
func IsUsageError(a *assert.Assertions, f func()) {
e := Try(f)
a.IsType(UsageError{}, e)
}
func assertInputNotInStore(input string, h hash.Hash, s ChunkStore, assert *assert.Assertions) {
data := s.Get(h)
assert.Nil(data, "Shouldn't have gotten data for %s", h.String())
}
func assertInputInStore(input string, h hash.Hash, s ChunkStore, assert *assert.Assertions) {
chunk := s.Get(h)
assert.False(chunk.IsEmpty(), "Shouldn't get empty chunk for %s", h.String())
assert.Equal(input, string(chunk.Data()))
}
