本文整理汇总了Golang中github.com/attic-labs/testify/assert.False函数的典型用法代码示例。如果您正苦于以下问题:Golang False函数的具体用法?Golang False怎么用?Golang False使用的例子?那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了False函数的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Golang代码示例。
示例1: TestMapEquals
func TestMapEquals(t *testing.T) {
assert := assert.New(t)
m1 := NewMap()
m2 := m1
m3 := NewMap()
assert.True(m1.Equals(m2))
assert.True(m2.Equals(m1))
assert.True(m3.Equals(m2))
assert.True(m2.Equals(m3))
diffMapTest(assert, m1, m2, 0, 0, 0)
diffMapTest(assert, m1, m3, 0, 0, 0)
diffMapTest(assert, m2, m1, 0, 0, 0)
diffMapTest(assert, m2, m3, 0, 0, 0)
diffMapTest(assert, m3, m1, 0, 0, 0)
diffMapTest(assert, m3, m2, 0, 0, 0)
m1 = NewMap(String("foo"), Number(0.0), String("bar"), NewList())
m2 = m2.SetM(String("foo"), Number(0.0), String("bar"), NewList())
assert.True(m1.Equals(m2))
assert.True(m2.Equals(m1))
assert.False(m2.Equals(m3))
assert.False(m3.Equals(m2))
diffMapTest(assert, m1, m2, 0, 0, 0)
diffMapTest(assert, m1, m3, 2, 0, 0)
diffMapTest(assert, m2, m1, 0, 0, 0)
diffMapTest(assert, m2, m3, 2, 0, 0)
diffMapTest(assert, m3, m1, 0, 2, 0)
diffMapTest(assert, m3, m2, 0, 2, 0)
}
示例2: TestTypeCacheCyclicUnions
func TestTypeCacheCyclicUnions(t *testing.T) {
assert := assert.New(t)
ut := MakeUnionType(MakeCycleType(0), NumberType, StringType, BoolType, BlobType, ValueType, TypeType)
st := MakeStructType("Foo",
[]string{"foo"},
[]*Type{ut},
)
assert.True(ut.Desc.(CompoundDesc).ElemTypes[0].Kind() == CycleKind)
// That the Struct / Cycle landed in index 1 was found empirically.
assert.True(st == st.Desc.(StructDesc).fields[0].t.Desc.(CompoundDesc).ElemTypes[1])
// ut contains an explicit Cycle type; noms must not surrepticiously change existing types so we can be sure that the Union within st is different in that the cycle has been resolved.
assert.False(ut == st.Desc.(StructDesc).fields[0].t)
// Note that the union in this second case is created with a different ordering of its type arguments.
ut2 := MakeUnionType(NumberType, StringType, BoolType, BlobType, ValueType, TypeType, MakeCycleType(0))
st2 := MakeStructType("Foo",
[]string{"foo"},
[]*Type{ut2},
)
assert.True(ut2.Desc.(CompoundDesc).ElemTypes[0].Kind() == CycleKind)
assert.True(st2 == st2.Desc.(StructDesc).fields[0].t.Desc.(CompoundDesc).ElemTypes[1])
assert.False(ut2 == st2.Desc.(StructDesc).fields[0].t)
assert.True(ut == ut2)
assert.True(st == st2)
}
示例3: TestMapEmpty
func TestMapEmpty(t *testing.T) {
assert := assert.New(t)
m := NewMap()
assert.True(m.Empty())
m = m.Set(Bool(false), String("hi"))
assert.False(m.Empty())
m = m.Set(NewList(), NewMap())
assert.False(m.Empty())
}
示例4: TestCauseInTypes
func TestCauseInTypes(t *testing.T) {
assert := assert.New(t)
te := testError{"te"}
te2 := testError2{"te2"}
assert.True(causeInTypes(te, te))
assert.True(causeInTypes(te, te2, te))
assert.False(causeInTypes(te, te2))
assert.False(causeInTypes(te))
}
示例5: TestMapHasRemove
func TestMapHasRemove(t *testing.T) {
assert := assert.New(t)
m1 := NewMap()
assert.False(m1.Has(String("foo")))
m2 := m1.Set(String("foo"), String("foo"))
assert.False(m1.Has(String("foo")))
assert.True(m2.Has(String("foo")))
m3 := m1.Remove(String("foo"))
assert.False(m1.Has(String("foo")))
assert.True(m2.Has(String("foo")))
assert.False(m3.Has(String("foo")))
}
示例6: TestSizeCache
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)
}
示例7: TestStringEquals
func TestStringEquals(t *testing.T) {
assert := assert.New(t)
s1 := String("foo")
s2 := String("foo")
s3 := s2
s4 := String("bar")
assert.True(s1.Equals(s2))
assert.True(s2.Equals(s1))
assert.True(s1.Equals(s3))
assert.True(s3.Equals(s1))
assert.False(s1.Equals(s4))
assert.False(s4.Equals(s1))
}
示例8: TestMapMaybeGet
func TestMapMaybeGet(t *testing.T) {
if testing.Short() {
t.Skip("Skipping test in short mode.")
}
smallTestChunks()
defer normalProductionChunks()
assert := assert.New(t)
doTest := func(tm testMap) {
m := tm.toMap()
for _, entry := range tm.entries {
v, ok := m.MaybeGet(entry.key)
if assert.True(ok, "%v should have been in the map!", entry.key) {
assert.True(v.Equals(entry.value), "%v != %v", v, entry.value)
}
}
_, ok := m.MaybeGet(tm.knownBadKey)
assert.False(ok, "m should not contain %v", tm.knownBadKey)
}
doTest(getTestNativeOrderMap(2))
doTest(getTestRefValueOrderMap(2))
doTest(getTestRefToNativeOrderMap(2, NewTestValueStore()))
doTest(getTestRefToValueOrderMap(2, NewTestValueStore()))
}
示例9: TestMapSetExistingKeyToNewValue
func TestMapSetExistingKeyToNewValue(t *testing.T) {
if testing.Short() {
t.Skip("Skipping test in short mode.")
}
smallTestChunks()
defer normalProductionChunks()
assert := assert.New(t)
tm := getTestNativeOrderMap(2)
original := tm.toMap()
expectedWorking := tm
actual := original
for i, entry := range tm.entries {
newValue := Number(int64(entry.value.(Number)) + 1)
expectedWorking = expectedWorking.SetValue(i, newValue)
actual = actual.Set(entry.key, newValue)
}
expected := expectedWorking.toMap()
assert.Equal(expected.Len(), actual.Len())
assert.True(expected.Equals(actual))
assert.False(original.Equals(actual))
diffMapTest(assert, expected, actual, 0, 0, 0)
}
示例10: AssertNotCalled
// AssertNotCalled asserts that the method was not called.
// It can produce a false result when an argument is a pointer type and the underlying value changed after calling the mocked method.
func (m *Mock) AssertNotCalled(t TestingT, methodName string, arguments ...interface{}) bool {
if !assert.False(t, m.methodWasCalled(methodName, arguments), fmt.Sprintf("The \"%s\" method was called with %d argument(s), but should NOT have been.", methodName, len(arguments))) {
t.Logf("%v", m.expectedCalls())
return false
}
return true
}
示例11: TestGreater
func TestGreater(t *testing.T) {
assert := assert.New(t)
r1 := Parse("sha1-0000000000000000000000000000000000000001")
r2 := Parse("sha1-0000000000000000000000000000000000000002")
assert.False(r1.Greater(r1))
assert.False(r1.Greater(r2))
assert.True(r2.Greater(r1))
assert.False(r2.Greater(r2))
r0 := Hash{}
assert.False(r0.Greater(r0))
assert.False(r0.Greater(r2))
assert.True(r2.Greater(r0))
}
示例12: TestTwoClientsWithEmptyDataset
func TestTwoClientsWithEmptyDataset(t *testing.T) {
assert := assert.New(t)
id1 := "testdataset"
cs := chunks.NewMemoryStore()
dsx := newDS(id1, cs)
dsy := newDS(id1, cs)
// dsx: || -> |a|
a := types.String("a")
dsx, err := dsx.CommitValue(a)
assert.NoError(err)
assert.True(dsx.Head().Get(datas.ValueField).Equals(a))
// dsy: || -> |b|
_, ok := dsy.MaybeHead()
assert.False(ok)
b := types.String("b")
dsy, err = dsy.CommitValue(b)
assert.Error(err)
// Commit failed, but ds1 now has latest head, so we should be able to just try again.
// dsy: |a| -> |b|
dsy, err = dsy.CommitValue(b)
assert.NoError(err)
assert.True(dsy.Head().Get(datas.ValueField).Equals(b))
}
示例13: TestHeadValueFunctions
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)
}
示例14: TestLess
func TestLess(t *testing.T) {
assert := assert.New(t)
r1 := Parse("00000000000000000000000000000001")
r2 := Parse("00000000000000000000000000000002")
assert.False(r1.Less(r1))
assert.True(r1.Less(r2))
assert.False(r2.Less(r1))
assert.False(r2.Less(r2))
r0 := Hash{}
assert.False(r0.Less(r0))
assert.True(r0.Less(r2))
assert.False(r2.Less(r0))
}
示例15: TestTotalOrdering
func TestTotalOrdering(t *testing.T) {
assert := assert.New(t)
// values in increasing order. Some of these are compared by ref so changing the serialization might change the ordering.
values := []Value{
Bool(false), Bool(true),
Number(-10), Number(0), Number(10),
String("a"), String("b"), String("c"),
// The order of these are done by the hash.
NewSet(Number(0), Number(1), Number(2), Number(3)),
BoolType,
// Value - values cannot be value
// Cycle - values cannot be cycle
// Union - values cannot be unions
}
for i, vi := range values {
for j, vj := range values {
if i == j {
assert.True(vi.Equals(vj))
} else if i < j {
x := vi.Less(vj)
assert.True(x)
} else {
x := vi.Less(vj)
assert.False(x)
}
}
}
}