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 TestValidateRef(t *testing.T) {
ds := createTestDataset("test")
b := types.Bool(true)
r := ds.Database().WriteValue(b)
assert.Panics(t, func() { ds.validateRefAsCommit(r) })
assert.Panics(t, func() { ds.validateRefAsCommit(types.NewRef(b)) })
}
func TestGenericStructSet(t *testing.T) {
assert := assert.New(t)
s := NewStruct("S3", StructData{"b": Bool(true), "o": String("hi")})
s2 := s.Set("b", Bool(false))
assert.Panics(func() { s.Set("b", Number(1)) })
assert.Panics(func() { s.Set("x", Number(1)) })
s3 := s2.Set("b", Bool(true))
assert.True(s.Equals(s3))
}
func TestTry(t *testing.T) {
assert := assert.New(t)
IsUsageError(assert, func() { Exp.Fail("hey-o") })
assert.Panics(func() {
Try(func() { Chk.Fail("hey-o") })
})
assert.Panics(func() {
Try(func() { panic("hey-o") })
})
}
func TestTryCatch(t *testing.T) {
assert := assert.New(t)
assert.Panics(func() {
TryCatch(func() {
panic(Wrap(te))
},
func(err error) error {
if !causeInTypes(err, testError2{}) {
panic(err)
}
return Unwrap(err)
})
})
assert.Panics(func() {
TryCatch(func() {
panic(te)
},
func(err error) error {
if !causeInTypes(err, testError{}) {
panic(err)
}
return Unwrap(err)
})
})
assert.IsType(wrappedError{}, func() error {
return TryCatch(func() {
panic(Wrap(te))
},
func(err error) error {
return err
})
}())
assert.Error(func() error {
return TryCatch(func() {
panic(Wrap(te))
},
func(err error) error {
if !causeInTypes(err, testError2{}, testError{}) {
panic(err)
}
return Unwrap(err)
})
}())
}
func TestVerifyStructName(t *testing.T) {
assert := assert.New(t)
assertInvalid := func(n string) {
assert.Panics(func() {
MakeStructType(n, []string{}, []*Type{})
})
}
assertInvalid(" ")
assertInvalid(" a")
assertInvalid("a ")
assertInvalid("0")
assertInvalid("_")
assertInvalid("0a")
assertInvalid("_a")
assertInvalid("💩")
assertValid := func(n string) {
MakeStructType(n, []string{}, []*Type{})
}
assertValid("")
assertValid("a")
assertValid("A")
assertValid("a0")
assertValid("a_")
assertValid("a0_")
}
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 TestHeadValueFunctions(t *testing.T) {
assert := assert.New(t)
id1 := "testdataset"
id2 := "otherdataset"
cs := chunks.NewMemoryStore()
ds1 := newDS(id1, cs)
// ds1: |a|
a := types.String("a")
ds1, err := ds1.CommitValue(a)
assert.NoError(err)
hv := ds1.Head().Get(datas.ValueField)
assert.Equal(a, hv)
assert.Equal(a, ds1.HeadValue())
hv, ok := ds1.MaybeHeadValue()
assert.True(ok)
assert.Equal(a, hv)
ds2 := newDS(id2, cs)
assert.Panics(func() {
ds2.HeadValue()
})
_, ok = ds2.MaybeHeadValue()
assert.False(ok)
}
func TestPanicIfTrue(t *testing.T) {
assert := assert.New(t)
arg := "arg value"
format := "could be a format: %s"
formatted := fmt.Sprintf(format, arg)
assert.Panics(func() {
PanicIfTrue(true, "Panicking!!!!")
})
assert.NotPanics(func() {
PanicIfTrue(false, "Not panicking")
})
err := Try(func() {
PanicIfTrue(true, format)
})
assert.Equal(errors.New(format), Unwrap(err))
err = Try(func() {
PanicIfTrue(true, format, arg)
})
assert.Equal(errors.New(formatted), Unwrap(err))
}
func Test_Mock_On_WithFuncPanics(t *testing.T) {
// make a test impl object
var mockedService = new(TestExampleImplementation)
assert.Panics(t, func() {
mockedService.On("TheExampleMethodFunc", func(string) error { return nil })
})
}
func TestDuplicateHeaderName(t *testing.T) {
assert := assert.New(t)
ds := datas.NewDatabase(chunks.NewMemoryStore())
dataString := "1,2\n3,4\n"
r := NewCSVReader(bytes.NewBufferString(dataString), ',')
headers := []string{"A", "A"}
kinds := KindSlice{types.StringKind, types.StringKind}
assert.Panics(func() { ReadToList(r, "test", headers, kinds, ds) })
}
func TestInvalidCyclesAndUnions(t *testing.T) {
assert := assert.New(t)
assert.Panics(func() {
MakeStructType("A",
[]string{"a"},
[]*Type{MakeStructType("A", []string{"a"}, []*Type{MakeCycleType(1)})})
})
}
func TestChunkChunkCloses(t *testing.T) {
assert := assert.New(t)
input := "abc"
w := NewChunkWriter()
_, err := w.Write([]byte(input))
assert.NoError(err)
w.Chunk()
assert.Panics(func() { w.Write([]byte(input)) }, "Write() after Close() should barf!")
}
func Test_Mock_Called_Unexpected(t *testing.T) {
var mockedService = new(TestExampleImplementation)
// make sure it panics if no expectation was made
assert.Panics(t, func() {
mockedService.Called(1, 2, 3)
}, "Calling unexpected method should panic")
}
func TestEnsureChunksFails(t *testing.T) {
assert := assert.New(t)
cs := chunks.NewTestStore()
cvs := newLocalValueStore(cs)
b := NewEmptyBlob()
bref := NewRef(b)
assert.Panics(func() { cvs.ensureChunksInCache(bref) })
s := String("oy")
cs.Put(EncodeValue(b, nil))
cs.Put(EncodeValue(s, nil))
badRef := constructRef(MakeRefType(MakePrimitiveType(BoolKind)), s.Hash(), 1)
l := NewList(bref, badRef)
cs.Put(EncodeValue(l, nil))
assert.Panics(func() { cvs.ensureChunksInCache(l) })
}
func TestCheckChunksNotInCache(t *testing.T) {
assert := assert.New(t)
cs := chunks.NewTestStore()
cvs := newLocalValueStore(cs)
b := NewEmptyBlob()
cs.Put(EncodeValue(b, nil))
bref := NewRef(b)
assert.Panics(func() { cvs.chunkHintsFromCache(bref) })
}
func TestWriteStructTooMuchData(t *testing.T) {
s := NewStruct("S", StructData{"x": Number(42), "b": Bool(true)})
c := EncodeValue(s, nil)
data := c.Data()
buff := make([]byte, len(data)+1)
copy(buff, data)
buff[len(data)] = 5 // Add a bogus extrabyte
assert.Panics(t, func() {
DecodeFromBytes(buff, nil, staticTypeCache)
})
}
func TestIdValidation(t *testing.T) {
assert := assert.New(t)
store := datas.NewDatabase(chunks.NewMemoryStore())
invalidDatasetNames := []string{" ", "", "a ", " a", "$", "#", ":", "\n", "💩"}
for _, id := range invalidDatasetNames {
assert.Panics(func() {
NewDataset(store, id)
})
}
}
func TestGenericStructNew(t *testing.T) {
assert := assert.New(t)
s := NewStruct("S2", map[string]Value{"b": Bool(true), "o": String("hi")})
assert.True(s.Get("b").Equals(Bool(true)))
_, ok := s.MaybeGet("missing")
assert.False(ok)
s2 := NewStruct("S2", map[string]Value{"b": Bool(false), "o": String("hi")})
assert.True(s2.Get("b").Equals(Bool(false)))
o, ok := s2.MaybeGet("o")
assert.True(ok)
assert.True(String("hi").Equals(o))
typ := MakeStructType("S2", TypeMap{
"b": BoolType,
"o": StringType,
})
assert.Panics(func() { NewStructWithType(typ, nil) })
assert.Panics(func() { NewStructWithType(typ, map[string]Value{"o": String("hi")}) })
}
func TestGenericStructNew(t *testing.T) {
assert := assert.New(t)
s := NewStruct("S2", StructData{"b": Bool(true), "o": String("hi")})
assert.True(s.Get("b").Equals(Bool(true)))
_, ok := s.MaybeGet("missing")
assert.False(ok)
s2 := NewStruct("S2", StructData{"b": Bool(false), "o": String("hi")})
assert.True(s2.Get("b").Equals(Bool(false)))
o, ok := s2.MaybeGet("o")
assert.True(ok)
assert.True(String("hi").Equals(o))
typ := MakeStructType("S2",
[]string{"b", "o"},
[]*Type{BoolType, StringType},
)
assert.Panics(func() { NewStructWithType(typ, nil) })
assert.Panics(func() { NewStructWithType(typ, ValueSlice{String("hi")}) })
}
func Test_Mock_On_WithIntArgMatcher(t *testing.T) {
var mockedService TestExampleImplementation
mockedService.On("TheExampleMethod",
MatchedBy(func(a int) bool {
return a == 1
}), MatchedBy(func(b int) bool {
return b == 2
}), MatchedBy(func(c int) bool {
return c == 3
})).Return(0, nil)
assert.Panics(t, func() {
mockedService.TheExampleMethod(1, 2, 4)
})
assert.Panics(t, func() {
mockedService.TheExampleMethod(2, 2, 3)
})
assert.NotPanics(t, func() {
mockedService.TheExampleMethod(1, 2, 3)
})
}
func TestPanicIfNotType(t *testing.T) {
assert := assert.New(t)
te := testError{"te"}
te2 := testError2{"te2"}
assert.Panics(func() {
PanicIfNotType(te, te2)
})
assert.Equal(te, PanicIfNotType(te, te))
assert.Equal(te2, PanicIfNotType(te2, te, te2))
}
func TestListRemoveAt(t *testing.T) {
assert := assert.New(t)
l0 := NewList()
l0 = l0.Append(Bool(false), Bool(true))
l1 := l0.RemoveAt(1)
assert.True(NewList(Bool(false)).Equals(l1))
l1 = l1.RemoveAt(0)
assert.True(NewList().Equals(l1))
assert.Panics(func() {
l1.RemoveAt(0)
})
}
func Test_Mock_Called_For_SetTime_Expectation(t *testing.T) {
var mockedService = new(TestExampleImplementation)
mockedService.On("TheExampleMethod", 1, 2, 3).Return(5, "6", true).Times(4)
mockedService.TheExampleMethod(1, 2, 3)
mockedService.TheExampleMethod(1, 2, 3)
mockedService.TheExampleMethod(1, 2, 3)
mockedService.TheExampleMethod(1, 2, 3)
assert.Panics(t, func() {
mockedService.TheExampleMethod(1, 2, 3)
})
}
func Test_Mock_On_WithVariadicFuncWithInterface(t *testing.T) {
// make a test impl object
var mockedService = new(TestExampleImplementation)
c := mockedService.On("TheExampleMethodVariadicInterface", []interface{}{1, 2, 3}).
Return(nil)
assert.Equal(t, []*Call{c}, mockedService.ExpectedCalls)
assert.Equal(t, 1, len(c.Arguments))
assert.Equal(t, []interface{}{1, 2, 3}, c.Arguments[0])
assert.NotPanics(t, func() {
mockedService.TheExampleMethodVariadicInterface(1, 2, 3)
})
assert.Panics(t, func() {
mockedService.TheExampleMethodVariadicInterface(1, 2)
})
}
func TestPanicOnReadBadVersion(t *testing.T) {
cvs := newLocalValueStore(&badVersionStore{chunks.NewTestStore()})
assert.Panics(t, func() { cvs.ReadValue(hash.Hash{}) })
}
func TestPanicOnWriteBadVersion(t *testing.T) {
cvs := newLocalValueStore(&badVersionStore{chunks.NewTestStore()})
assert.Panics(t, func() { cvs.WriteValue(NewEmptyBlob()) })
}
func assertInvalid(tt *testing.T, t *Type, v Value) {
assert := assert.New(tt)
assert.Panics(func() {
assertSubtype(t, v)
})
}
// Panics asserts that the code inside the specified PanicTestFunc panics.
//
// assert.Panics(t, func(){
// GoCrazy()
// }, "Calling GoCrazy() should panic")
//
// Returns whether the assertion was successful (true) or not (false).
func Panics(t TestingT, f assert.PanicTestFunc, msgAndArgs ...interface{}) {
if !assert.Panics(t, f, msgAndArgs...) {
t.FailNow()
}
}
func TestBogusValueWithUnresolvedCycle(t *testing.T) {
g := bogusType(1)
assert.Panics(t, func() {
EncodeValue(g, nil)
})
}