func TestSetFirst(t *testing.T) {
assert := assert.New(t)
s := NewSet()
assert.Nil(s.First())
s = s.Insert(Number(1))
assert.NotNil(s.First())
s = s.Insert(Number(2))
assert.NotNil(s.First())
s2 := s.Remove(Number(1))
assert.NotNil(s2.First())
s2 = s2.Remove(Number(2))
assert.Nil(s2.First())
}
func TestTry2(t *testing.T) {
assert := assert.New(t)
assert.Panics(func() {
Try(func() {
panic(te)
})
})
assert.Panics(func() {
Try(func() {
PanicIfError(te)
}, te2)
})
assert.Error(func() error {
return Try(func() {
PanicIfError(te)
})
}())
assert.Error(func() error {
return Try(func() {
PanicIfError(te)
}, testError{})
}())
assert.Nil(func() error {
return Try(func() {
PanicIfError(nil)
})
}())
}
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)))
}
func TestMapSetGet(t *testing.T) {
assert := assert.New(t)
m1 := NewMap()
assert.Nil(m1.Get(String("foo")))
m2 := m1.Set(String("foo"), Number(42))
assert.Nil(m1.Get(String("foo")))
assert.True(Number(42).Equals(m2.Get(String("foo"))))
m3 := m2.Set(String("foo"), Number(43))
assert.Nil(m1.Get(String("foo")))
assert.True(Number(42).Equals(m2.Get(String("foo"))))
assert.True(Number(43).Equals(m3.Get(String("foo"))))
m4 := m3.Remove(String("foo"))
assert.Nil(m1.Get(String("foo")))
assert.True(Number(42).Equals(m2.Get(String("foo"))))
assert.True(Number(43).Equals(m3.Get(String("foo"))))
assert.Nil(m4.Get(String("foo")))
}
func TestMapFirst(t *testing.T) {
assert := assert.New(t)
m1 := NewMap()
k, v := m1.First()
assert.Nil(k)
assert.Nil(v)
m1 = m1.Set(String("foo"), String("bar"))
m1 = m1.Set(String("hot"), String("dog"))
ak, av := m1.First()
var ek, ev Value
m1.Iter(func(k, v Value) (stop bool) {
ek, ev = k, v
return true
})
assert.True(ek.Equals(ak))
assert.True(ev.Equals(av))
}
func TestWrap(t *testing.T) {
assert := assert.New(t)
te := testError{"te"}
we := Wrap(te)
assert.Equal(te, we.Cause())
assert.IsType(wrappedError{}, we)
assert.Equal(we, Wrap(we))
fmt.Printf("st: %s, cause: %s\n", we.Error(), we.Cause())
assert.Nil(Wrap(nil))
}
func TestSizeCache(t *testing.T) {
assert := assert.New(t)
defSize := uint64(200)
c := New(1024)
for i, v := range []string{"data-1", "data-2", "data-3", "data-4", "data-5", "data-6", "data-7", "data-8", "data-9"} {
c.Add(hashFromString(v), defSize, v)
maxElements := uint64(i + 1)
if maxElements >= uint64(5) {
maxElements = uint64(5)
}
assert.Equal(maxElements*defSize, c.totalSize)
}
_, ok := c.Get(hashFromString("data-1"))
assert.False(ok)
assert.Equal(hashFromString("data-5"), c.lru.Front().Value)
v, ok := c.Get(hashFromString("data-5"))
assert.True(ok)
assert.Equal("data-5", v.(string))
assert.Equal(hashFromString("data-5"), c.lru.Back().Value)
assert.Equal(hashFromString("data-6"), c.lru.Front().Value)
c.Add(hashFromString("data-7"), defSize, "data-7")
assert.Equal(hashFromString("data-7"), c.lru.Back().Value)
assert.Equal(uint64(1000), c.totalSize)
c.Add(hashFromString("no-data"), 0, nil)
v, ok = c.Get(hashFromString("no-data"))
assert.True(ok)
assert.Nil(v)
assert.Equal(hashFromString("no-data"), c.lru.Back().Value)
assert.Equal(uint64(1000), c.totalSize)
assert.Equal(6, c.lru.Len())
assert.Equal(6, len(c.cache))
for _, v := range []string{"data-5", "data-6", "data-7", "data-8", "data-9"} {
c.Get(hashFromString(v))
assert.Equal(hashFromString(v), c.lru.Back().Value)
}
assert.Equal(hashFromString("no-data"), c.lru.Front().Value)
c.Add(hashFromString("data-10"), 200, "data-10")
assert.Equal(uint64(1000), c.totalSize)
assert.Equal(5, c.lru.Len())
assert.Equal(5, len(c.cache))
_, ok = c.Get(hashFromString("no-data"))
assert.False(ok)
_, ok = c.Get(hashFromString("data-5"))
assert.False(ok)
}
func TestMapSetGet(t *testing.T) {
assert := assert.New(t)
smallTestChunks()
defer normalProductionChunks()
m1 := NewMap()
assert.Nil(m1.Get(String("foo")))
m2 := m1.Set(String("foo"), Number(42))
assert.Nil(m1.Get(String("foo")))
assert.True(Number(42).Equals(m2.Get(String("foo"))))
m3 := m2.Set(String("foo"), Number(43))
assert.Nil(m1.Get(String("foo")))
assert.True(Number(42).Equals(m2.Get(String("foo"))))
assert.True(Number(43).Equals(m3.Get(String("foo"))))
m4 := m3.Remove(String("foo"))
assert.Nil(m1.Get(String("foo")))
assert.True(Number(42).Equals(m2.Get(String("foo"))))
assert.True(Number(43).Equals(m3.Get(String("foo"))))
assert.Nil(m4.Get(String("foo")))
}
func TestAbsolutePaths(t *testing.T) {
assert := assert.New(t)
s0, s1 := types.String("foo"), types.String("bar")
list := types.NewList(s0, s1)
emptySet := types.NewSet()
db := datas.NewDatabase(chunks.NewMemoryStore())
db.WriteValue(s0)
db.WriteValue(s1)
db.WriteValue(list)
db.WriteValue(emptySet)
var err error
db, err = db.Commit("ds", datas.NewCommit(list, types.NewSet(), types.EmptyStruct))
assert.NoError(err)
head := db.Head("ds")
resolvesTo := func(exp types.Value, str string) {
p, err := NewAbsolutePath(str)
assert.NoError(err)
act := p.Resolve(db)
if exp == nil {
assert.Nil(act)
} else {
assert.True(exp.Equals(act), "%s Expected %s Actual %s", str, types.EncodedValue(exp), types.EncodedValue(act))
}
}
resolvesTo(head, "ds")
resolvesTo(emptySet, "ds.parents")
resolvesTo(list, "ds.value")
resolvesTo(s0, "ds.value[0]")
resolvesTo(s1, "ds.value[1]")
resolvesTo(head, "#"+head.Hash().String())
resolvesTo(list, "#"+list.Hash().String())
resolvesTo(s0, "#"+s0.Hash().String())
resolvesTo(s1, "#"+s1.Hash().String())
resolvesTo(s0, "#"+list.Hash().String()+"[0]")
resolvesTo(s1, "#"+list.Hash().String()+"[1]")
resolvesTo(nil, "foo")
resolvesTo(nil, "foo.parents")
resolvesTo(nil, "foo.value")
resolvesTo(nil, "foo.value[0]")
resolvesTo(nil, "#"+types.String("baz").Hash().String())
resolvesTo(nil, "#"+types.String("baz").Hash().String()+"[0]")
}
func TestSuiteLogging(t *testing.T) {
testT := testing.T{}
suiteLoggingTester := new(SuiteLoggingTester)
capture := StdoutCapture{}
capture.StartCapture()
Run(&testT, suiteLoggingTester)
output, err := capture.StopCapture()
assert.Nil(t, err, "Got an error trying to capture stdout!")
// Failed tests' output is always printed
assert.Contains(t, output, "TESTLOGFAIL")
if testing.Verbose() {
// In verbose mode, output from successful tests is also printed
assert.Contains(t, output, "TESTLOGPASS")
} else {
assert.NotContains(t, output, "TESTLOGPASS")
}
}
func Test_Mock_Return_Once(t *testing.T) {
// make a test impl object
var mockedService = new(TestExampleImplementation)
c := mockedService.On("TheExampleMethod", "A", "B", true).
Return(1, "two", true).
Once()
require.Equal(t, []*Call{c}, mockedService.ExpectedCalls)
call := mockedService.ExpectedCalls[0]
assert.Equal(t, "TheExampleMethod", call.Method)
assert.Equal(t, "A", call.Arguments[0])
assert.Equal(t, "B", call.Arguments[1])
assert.Equal(t, true, call.Arguments[2])
assert.Equal(t, 1, call.ReturnArguments[0])
assert.Equal(t, "two", call.ReturnArguments[1])
assert.Equal(t, true, call.ReturnArguments[2])
assert.Equal(t, 1, call.Repeatability)
assert.Nil(t, call.WaitFor)
}
// Nil asserts that the specified object is nil.
//
// assert.Nil(t, err, "err should be nothing")
//
// Returns whether the assertion was successful (true) or not (false).
func Nil(t TestingT, object interface{}, msgAndArgs ...interface{}) {
if !assert.Nil(t, object, msgAndArgs...) {
t.FailNow()
}
}
func TestTypeCacheCyclicStruct2(t *testing.T) {
assert := assert.New(t)
// Foo {
// bar: Cycle<1>
// foo: Cycle<0>
// }
st := MakeStructType("Foo",
[]string{"bar", "foo"},
[]*Type{
MakeCycleType(1),
MakeCycleType(0),
},
)
assert.True(st.HasUnresolvedCycle())
assert.Nil(st.serialization)
// foo ref is cyclic
assert.True(st == st.Desc.(StructDesc).fields[1].t)
// Bar {
// baz: Cycle<1>
// foo: Foo {
// bar: Cycle<1>
// foo: Cycle<0>
// }
// }
st2 := MakeStructType("Bar",
[]string{"baz", "foo"},
[]*Type{
MakeCycleType(1),
st,
},
)
assert.True(st2.HasUnresolvedCycle())
assert.Nil(st2.serialization)
// foo ref is cyclic
assert.True(st2.Desc.(StructDesc).fields[1].t == st2.Desc.(StructDesc).fields[1].t.Desc.(StructDesc).fields[1].t)
// bar ref is cyclic
assert.True(st2 == st2.Desc.(StructDesc).fields[1].t.Desc.(StructDesc).fields[0].t)
// Baz {
// bar: Bar {
// baz: Cycle<1>
// foo: Foo {
// bar: Cycle<1>
// foo: Cycle<0>
// }
// }
// baz: Cycle<0>
// }
st3 := MakeStructType("Baz",
[]string{"bar", "baz"},
[]*Type{
st2,
MakeCycleType(0),
},
)
assert.False(st3.HasUnresolvedCycle())
assert.NotNil(st3.serialization)
// foo ref is cyclic
assert.True(st3.Desc.(StructDesc).fields[0].t.Desc.(StructDesc).fields[1].t == st3.Desc.(StructDesc).fields[0].t.Desc.(StructDesc).fields[1].t.Desc.(StructDesc).fields[1].t)
// bar ref is cyclic
assert.True(st3.Desc.(StructDesc).fields[0].t == st3.Desc.(StructDesc).fields[0].t.Desc.(StructDesc).fields[0].t.Desc.(StructDesc).fields[0].t)
// baz second-level ref is cyclic
assert.True(st3 == st3.Desc.(StructDesc).fields[0].t.Desc.(StructDesc).fields[0].t)
// baz top-level ref is cyclic
assert.True(st3 == st3.Desc.(StructDesc).fields[1].t)
}