func TestSuiteGetters(t *testing.T) {
suite := new(SuiteTester)
suite.SetT(t)
assert.NotNil(t, suite.Assert())
assert.Equal(t, suite.Assertions, suite.Assert())
assert.NotNil(t, suite.Require())
assert.Equal(t, suite.require, suite.Require())
}
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 Test_Mock_Return_Run(t *testing.T) {
// make a test impl object
var mockedService = new(TestExampleImplementation)
fn := func(args Arguments) {
arg := args.Get(0).(*ExampleType)
arg.ran = true
}
c := mockedService.Mock.
On("TheExampleMethod3", AnythingOfType("*mock.ExampleType")).
Return(nil).
Run(fn)
require.Equal(t, []*Call{c}, mockedService.ExpectedCalls)
call := mockedService.Mock.ExpectedCalls[0]
assert.Equal(t, "TheExampleMethod3", call.Method)
assert.Equal(t, AnythingOfType("*mock.ExampleType"), call.Arguments[0])
assert.Equal(t, nil, call.ReturnArguments[0])
assert.Equal(t, 0, call.Repeatability)
assert.NotEqual(t, nil, call.WaitFor)
assert.NotNil(t, call.Run)
et := ExampleType{}
assert.Equal(t, false, et.ran)
mockedService.TheExampleMethod3(&et)
assert.Equal(t, true, et.ran)
}
func TestParseError(t *testing.T) {
assert := assert.New(t)
assertParseError := func(s string) {
e := d.Try(func() { Parse(s) })
_, ok := e.(d.WrappedError)
assert.True(ok)
}
assertParseError("foo")
// too few digits
assertParseError("0000000000000000000000000000000")
// too many digits
assertParseError("000000000000000000000000000000000")
// 'w' not valid base32
assertParseError("00000000000000000000000000000000w")
// no prefix
assertParseError("sha1-00000000000000000000000000000000")
assertParseError("sha2-00000000000000000000000000000000")
r := Parse("00000000000000000000000000000000")
assert.NotNil(r)
}
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 Test_Mock_TestData(t *testing.T) {
var mockedService = new(TestExampleImplementation)
if assert.NotNil(t, mockedService.TestData()) {
mockedService.TestData().Set("something", 123)
assert.Equal(t, 123, mockedService.TestData().Get("something").Data())
}
}
func TestMapRefOfStructFirstNNumbers(t *testing.T) {
if testing.Short() {
t.Skip("Skipping test in short mode.")
}
assert := assert.New(t)
vs := NewTestValueStore()
kvs := []Value{}
for i := 0; i < testMapSize; i++ {
k := vs.WriteValue(NewStruct("num", StructData{"n": Number(i)}))
v := vs.WriteValue(NewStruct("num", StructData{"n": Number(i + 1)}))
assert.NotNil(k)
assert.NotNil(v)
kvs = append(kvs, k, v)
}
m := NewMap(kvs...)
assert.Equal("g49bom2pq40n2v927846vpmc3injuf5a", m.Hash().String())
// height + 1 because the leaves are Ref values (with height 1).
assert.Equal(deriveCollectionHeight(m)+1, getRefHeightOfCollection(m))
}
func TestTypeCacheList(t *testing.T) {
assert := assert.New(t)
lbt := MakeListType(BoolType)
lbt2 := MakeListType(BoolType)
assert.True(lbt == lbt2)
assert.NotNil(lbt.serialization)
lst := MakeListType(StringType)
lnt := MakeListType(NumberType)
assert.False(lst == lnt)
assert.NotNil(lnt.serialization)
assert.NotNil(lst.serialization)
lst2 := MakeListType(StringType)
assert.True(lst == lst2)
assert.NotNil(lst.serialization)
lnt2 := MakeListType(NumberType)
assert.True(lnt == lnt2)
lbt3 := MakeListType(BoolType)
assert.True(lbt == lbt3)
}
func TestTypeCacheUnion(t *testing.T) {
assert := assert.New(t)
ut := MakeUnionType(NumberType)
ut2 := MakeUnionType(NumberType)
assert.True(ut == ut2)
assert.NotNil(ut.serialization)
ut = MakeUnionType(NumberType, StringType)
ut2 = MakeUnionType(StringType, NumberType)
assert.True(ut == ut2)
ut = MakeUnionType(StringType, BoolType, NumberType)
ut2 = MakeUnionType(NumberType, StringType, BoolType)
assert.True(ut == ut2)
}
func TestTypeCacheStruct(t *testing.T) {
assert := assert.New(t)
st := MakeStructType("Foo",
[]string{"bar", "foo"},
[]*Type{StringType, NumberType},
)
st2 := MakeStructType("Foo",
[]string{"bar", "foo"},
[]*Type{StringType, NumberType},
)
assert.True(st == st2)
assert.NotNil(st.serialization)
}
func TestTypeCacheCyclicStruct(t *testing.T) {
assert := assert.New(t)
st := MakeStructType("Foo",
[]string{"foo"},
[]*Type{MakeRefType(MakeCycleType(0))},
)
assert.True(st == st.Desc.(StructDesc).fields[0].t.Desc.(CompoundDesc).ElemTypes[0])
assert.False(st.HasUnresolvedCycle())
assert.NotNil(st.serialization)
st2 := MakeStructType("Foo",
[]string{"foo"},
[]*Type{MakeRefType(MakeCycleType(0))},
)
assert.True(st2 == st2.Desc.(StructDesc).fields[0].t.Desc.(CompoundDesc).ElemTypes[0])
assert.True(st == st2)
}
func Test_Mock_findExpectedCall(t *testing.T) {
m := new(Mock)
m.On("One", 1).Return("one")
m.On("Two", 2).Return("two")
m.On("Two", 3).Return("three")
f, c := m.findExpectedCall("Two", 3)
if assert.Equal(t, 2, f) {
if assert.NotNil(t, c) {
assert.Equal(t, "Two", c.Method)
assert.Equal(t, 3, c.Arguments[0])
assert.Equal(t, "three", c.ReturnArguments[0])
}
}
}
func TestReadParseError(t *testing.T) {
assert := assert.New(t)
ds := datas.NewDatabase(chunks.NewMemoryStore())
dataString := `a,"b`
r := NewCSVReader(bytes.NewBufferString(dataString), ',')
headers := []string{"A", "B"}
kinds := KindSlice{types.StringKind, types.StringKind}
func() {
defer func() {
r := recover()
assert.NotNil(r)
_, ok := r.(*csv.ParseError)
assert.True(ok, "Should be a ParseError")
}()
ReadToList(r, "test", headers, kinds, ds)
}()
}
func TestParseError(t *testing.T) {
assert := assert.New(t)
assertParseError := func(s string) {
e := d.Try(func() { Parse(s) })
assert.IsType(d.UsageError{}, e)
}
assertParseError("foo")
assertParseError("sha1")
assertParseError("sha1-0")
// too many digits
assertParseError("sha1-00000000000000000000000000000000000000000")
// 'g' not valid hex
assertParseError("sha1-000000000000000000000000000000000000000g")
// sha2 not supported
assertParseError("sha2-0000000000000000000000000000000000000000")
r := Parse("sha1-0000000000000000000000000000000000000000")
assert.NotNil(r)
}
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)
}
func (s *SuiteLoggingTester) TestLoggingFail() {
s.T().Log("TESTLOGFAIL")
assert.NotNil(s.T(), nil) // expected to fail
}
// NotNil asserts that the specified object is not nil.
//
// assert.NotNil(t, err, "err should be something")
//
// Returns whether the assertion was successful (true) or not (false).
func NotNil(t TestingT, object interface{}, msgAndArgs ...interface{}) {
if !assert.NotNil(t, object, msgAndArgs...) {
t.FailNow()
}
}