func TestLeaf(t *testing.T) {
v := leaf("foo")
assert.Equal(t, depthT(0), v.depth())
assert.Equal(t, int64(3), v.length())
assert.Equal(t, v, v.slice(0, v.length()))
assert.Equal(t, v, v.slice(-100, 100))
assert.Equal(t, leaf("f"), v.slice(0, 1))
assert.Equal(t, leaf("f"), v.slice(-100, 1))
assert.Equal(t, leaf("o"), v.slice(2, v.length()))
assert.Equal(t, leaf(""), v.slice(2, 1))
assert.Equal(t, v, v.dropPrefix(0))
assert.Equal(t, v, v.dropPrefix(-100))
assert.Equal(t, leaf("oo"), v.dropPrefix(1))
assert.Equal(t, leaf(""), v.dropPrefix(3))
assert.Equal(t, leaf(""), v.dropPrefix(100))
assert.Equal(t, v, v.dropPostfix(3))
assert.Equal(t, v, v.dropPostfix(100))
assert.Equal(t, leaf("fo"), v.dropPostfix(2))
assert.Equal(t, leaf(""), v.dropPostfix(0))
assert.Equal(t, leaf(""), v.dropPostfix(-100))
buf := bytes.NewBuffer(nil)
v.WriteTo(buf)
assert.Equal(t, "foo", buf.String())
counter := 0
err := v.walkLeaves(func(l string) error {
if counter > 0 {
t.Errorf("leaf.walkLeaves: function called too many times")
return errors.New("called a lot")
}
counter++
assert.Equal(t, string(v), l)
return nil
})
assert.Nil(t, err)
}
func TestWalk(t *testing.T) {
defer disableCoalesce()()
for _, r := range []Rope{Rope{}, emptyRope} {
r.Walk(func(_ string) error {
t.Error("call to empty Rope's Walk parameter")
return nil
})
}
for _, r := range []Rope{
New("abc").AppendString("def").AppendString("ghi"),
} {
str := r.String()
err := r.Walk(func(part string) error {
assert.Equal(t, str[:len(part)], part)
str = str[len(part):]
return nil
})
assert.Nil(t, err)
assert.Equal(t, "", str)
}
for _, r := range []Rope{
New("abc").AppendString("def").AppendString("ghi"),
} {
str := r.String()
err := r.Walk(func(part string) error {
assert.Equal(t, str[:len(part)], part)
str = str[len(part):]
if len(str) < 4 {
return errors.New("stop now")
}
return nil
})
assert.Equal(t, err, errors.New("stop now"))
assert.True(t, 0 < len(str) && len(str) < 4)
}
}
func TestReadAt(t *testing.T) {
want := treeR.Bytes()
buf := make([]byte, len(want)+1)
for start := 0; start < len(buf); start++ {
for end := start; end <= len(buf); end++ {
length := end - start
b := buf[0:length]
n, err := treeR.ReadAt(b, int64(start))
// Basic io.ReaderAt contract
assert.True(t, n <= length)
if n < length {
assert.Equal(t, io.EOF, err)
}
// Expected actual end and length
eEnd := end
if eEnd > len(want) {
eEnd = len(want)
}
eLen := eEnd - start
// Check for correctness
assert.Equal(t, eLen, n)
if eLen < length {
assert.Equal(t, io.EOF, err)
} else if eLen > length {
assert.Nil(t, err)
} else {
assert.True(t, err == nil || err == io.EOF)
}
assert.Equal(t, want[start:eEnd], b[:n])
}
}
}
func TestConcatWalkLeaves(t *testing.T) {
counter := 0
err := tree.walkLeaves(func(l string) error {
switch counter {
case 0:
assert.Equal(t, string(lhs), l)
case 1:
assert.Equal(t, string(rhs), l)
case 2:
t.Errorf("leaf.walkLeaves: function called too many times")
default:
// Ignore more than two calls, error has already been produced.
}
counter++
return nil
})
assert.Nil(t, err)
counter = 0
err = tree.walkLeaves(func(l string) error {
switch counter {
case 0:
assert.Equal(t, string(lhs), l)
return errors.New("stop now")
case 1:
t.Errorf("leaf.walkLeaves: did not stop after returning true")
default:
// Ignore more than two calls, error has already been produced.
}
counter++
return nil
})
assert.Equal(t, errors.New("stop now"), err)
}
