func Test_ASTInline_Equal(t *testing.T) { node1 := &ASTInline{} node2 := &ASTInline{} assert.True(t, node1.Equal(node1), "ASTInline not equal to itself") assert.True(t, node1.Equal(node2), "empty ASTInlines not equal") node1.lang = "foo" node2.lang = "bar" assert.False(t, node1.Equal(node2), "ASTInlines equal despite different lang") node2.lang = "foo" assert.True(t, node1.Equal(node2), "ASTInlines not equal") node1.content = "hello\nworld\n" node2.content = "hello\nworld" assert.False(t, node1.Equal(node2), "ASTInlines equal despite different content") node2.content += "\n" assert.True(t, node1.Equal(node2), "ASTInlines not equal") }
func Test_ListNode_basics(t *testing.T) { node0 := NewStubNode("foo") node1 := NewStubNode("bar baz") node2 := NewStubNode("qux") list1 := newListNode(node0, node1, node2) assert.Equal(t, "ListNode", list1.Typename()) assert.Equal(t, "foo,bar baz,qux", list1.Name()) assert.Equal(t, `["foo", "bar baz", "qux"]`, list1.String()) assert.Equal(t, "foo,bar baz,qux", list1.ValueString()) assert.Equal(t, "foo 'bar baz' qux", list1.CommandString()) expect1 := []types.FuObject{node0, node1, node2} assert.Equal(t, expect1, list1.List()) expect2 := []Node{node0, node1, node2} assert.Equal(t, expect2, list1.Nodes()) list2 := newListNode(node0, node1, node2) assert.True(t, list1.Equal(list2)) list3 := newListNode(node1, node0, node2) assert.False(t, list1.Equal(list3)) list4 := list3.copy().(*ListNode) assert.False(t, list3 == list4) assert.True(t, list3.Equal(list4)) }
func TestGame_IsOver(t *testing.T) { var game Game = NewGame() var board = game.Board() t.Log("New Game is not over") assert.False(t, game.IsOver()) t.Log("Game with two-in-a-row is not over") AddMarks(board, "X", 4, 8) assert.False(t, game.IsOver()) t.Log("Game with three-in-a-row \"X\" is over") board.Mark(0, "X") assert.True(t, game.IsOver()) t.Log("Game with three-in-a-row \"O\" is over") board.Reset() AddMarks(board, "O", 2, 4, 6) assert.True(t, game.IsOver()) t.Log("Game with three-in-a-row mismatched is not over") board.Mark(2, "X") assert.False(t, game.IsOver()) t.Log("Game with nearly-full, non-winning board is not over") board.Reset() AddMarks(board, "X", 0, 1, 4, 5) AddMarks(board, "O", 2, 3, 7, 8) assert.False(t, game.IsOver()) t.Log("Game with full, non-winning board is over") board.Mark(6, "X") assert.True(t, game.IsOver()) }
func TestSpResult(t *testing.T) { r := NewSpResult() assert.Equal(t, -1, r.status) assert.Equal(t, -1, r.currentResult) assert.False(t, r.HasOutputParams()) assert.False(t, r.HasResults()) assert.False(t, r.NextResult()) assert.Nil(t, r.Result()) }
func Test_ValueMap_basics(t *testing.T) { ns := NewValueMap() val, ok := ns.Lookup("foo") assert.False(t, ok) val, ok = ns.Lookup("bar") assert.False(t, ok) ns.Assign("foo", MakeFuString("blurp")) val, ok = ns.Lookup("foo") assert.True(t, ok) assert.Equal(t, "blurp", val.ValueString()) val, ok = ns.Lookup("bar") assert.False(t, ok) }
func TestSetMasks(t *testing.T) { m := new(Masks) assert.False(t, m.Grayscale) m.Set(0x01) assert.True(t, m.Grayscale) assert.False(t, m.ShowBackgroundLeft) m.Set(0x02) assert.True(t, m.ShowBackgroundLeft) assert.False(t, m.ShowSpritesLeft) m.Set(0x04) assert.True(t, m.ShowSpritesLeft) assert.False(t, m.ShowBackground) m.Set(0x08) assert.True(t, m.ShowBackground) assert.False(t, m.ShowSprites) m.Set(0x10) assert.True(t, m.ShowSprites) assert.False(t, m.IntenseReds) m.Set(0x20) assert.True(t, m.IntenseReds) assert.False(t, m.IntenseGreens) m.Set(0x40) assert.True(t, m.IntenseGreens) assert.False(t, m.IntenseBlues) m.Set(0x80) assert.True(t, m.IntenseBlues) }
// hmmmm: interface-wise, this tests that FinderNode.Add() returns an // object whose CommandString() behaves sensibly... but in // implementation terms, it's really a test of FuList.CommandString() func Test_FinderNode_Add_CommandString(t *testing.T) { finder1 := NewFinderNode("*.c", "*.h") finder2 := NewFinderNode("doc/???.txt") finder3 := NewFinderNode() sum1, err := finder1.Add(finder2) assert.Nil(t, err) assert.Equal(t, "'*.c' '*.h' 'doc/???.txt'", sum1.CommandString()) sum2, err := finder3.Add(sum1) assert.Nil(t, err) assert.Equal(t, "'*.c' '*.h' 'doc/???.txt'", sum2.CommandString()) assert.False(t, sum1.Equal(sum2)) sum2b, err := finder3.Add(sum1) assert.Nil(t, err) assert.True(t, sum2.Equal(sum2b), "expected equal ListNodes:\nsum2 = %T %v\nsum2b = %T %v", sum2, sum2, sum2b, sum2b) // This is a silly thing to do, and perhaps we should filter out // the duplicate patterns... but I don't think so. If the user // constructs something silly, we do something silly. sum3, err := sum1.Add(sum2) assert.Nil(t, err) assert.Equal(t, "'*.c' '*.h' 'doc/???.txt' '*.c' '*.h' 'doc/???.txt'", sum3.CommandString()) }
func TestConnect(t *testing.T) { conn := ConnectToTestDb(t) assert.NotNil(t, conn) defer conn.Close() assert.True(t, conn.isLive()) assert.False(t, conn.isDead()) }
func TestMapStaticFile(t *testing.T) { codecService := new(codecservices.WebCodecService) h := NewHttpHandler(codecService) h.MapStaticFile("/static-file", "/location/of/static-file") assert.Equal(t, 1, len(h.HandlersPipe())) staticHandler := h.HandlersPipe()[0].(*PathMatchHandler) if assert.Equal(t, 1, len(staticHandler.HttpMethods)) { assert.Equal(t, goweb_http.MethodGet, staticHandler.HttpMethods[0]) } var ctx context.Context var willHandle bool ctx = context_test.MakeTestContextWithPath("/static-file") willHandle, _ = staticHandler.WillHandle(ctx) assert.True(t, willHandle, "Static handler should handle") ctx = context_test.MakeTestContextWithPath("static-file") willHandle, _ = staticHandler.WillHandle(ctx) assert.True(t, willHandle, "Static handler should handle") ctx = context_test.MakeTestContextWithPath("static-file/") willHandle, _ = staticHandler.WillHandle(ctx) assert.True(t, willHandle, "Static handler should handle") ctx = context_test.MakeTestContextWithPath("static-file/something-else") willHandle, _ = staticHandler.WillHandle(ctx) assert.False(t, willHandle, "Static handler NOT should handle") }
// AssertNotCalled asserts that the method was not called. func (m *Mock) AssertNotCalled(t *testing.T, 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("%s", m.ExpectedCalls) return false } return true }
func TestPathMatchHandler_BreakCurrentPipeline(t *testing.T) { pathPattern, _ := paths.NewPathPattern("collection/{id}/name") h := NewPathMatchHandler(pathPattern, HandlerExecutionFunc(func(c context.Context) error { return nil })) h.BreakCurrentPipeline = true ctx1 := context_test.MakeTestContextWithPath("/collection/123/name") breakCurrentPipeline, _ := h.Handle(ctx1) assert.True(t, breakCurrentPipeline) h = NewPathMatchHandler(pathPattern, HandlerExecutionFunc(func(c context.Context) error { return nil })) h.BreakCurrentPipeline = false ctx1 = context_test.MakeTestContextWithPath("/collection/123/name") breakCurrentPipeline, _ = h.Handle(ctx1) assert.False(t, breakCurrentPipeline) }
func TestInterruptingNMISetsNMI(t *testing.T) { p := NewCPU() assert.False(t, p.nmi.Occurred) p.Interrupt(NMI) assert.True(t, p.nmi.Occurred) }
func Test_BuiltinList(t *testing.T) { blist := BuiltinList{} fn, ok := blist.Lookup("foo") assert.False(t, ok) assert.Nil(t, fn) callable := types.NewFixedFunction("foo", 3, nil) blist.builtins = append(blist.builtins, callable) fn, ok = blist.Lookup("foo") assert.True(t, ok) assert.Equal(t, callable, fn) blist.builtins = append( blist.builtins, types.NewFixedFunction("bar", 0, nil)) blist.builtins = append( blist.builtins, types.NewFixedFunction("bop", 0, nil)) blist.builtins = append( blist.builtins, types.NewFixedFunction("bam", 0, nil)) blist.builtins = append( blist.builtins, types.NewFixedFunction("pow", 0, nil)) assert.Equal(t, 5, blist.NumBuiltins()) actual := make([]string, 0, 5) visit := func(name string, code types.FuObject) error { actual = append(actual, name) if name == "bam" { return errors.New("bam!") } return nil } err := blist.ForEach(visit) assert.Equal(t, []string{"foo", "bar", "bop", "bam"}, actual) assert.Equal(t, "bam!", err.Error()) }
func test_AccessChannel(t *testing.T, err_msg string, timer NetAccessRule, timeout time.Duration) (err error) { timeout_chan := make(chan struct{}, 1) timeout_func := func() { time.Sleep(timeout) close(timeout_chan) } go timeout_func() i := 0 for i < 5 { access_chan := timer.AccessChannel() break_loop := false for !break_loop { select { case <-timeout_chan: return errors.New(fmt.Sprintf("Access channel timed out at iteration %i", i)) case _, ok := <-access_chan: assert.False(t, ok, err_msg) i++ break_loop = true } } } return nil }
func Test_FuString_Lookup(t *testing.T) { // strings have no attributes s := MakeFuString("blah") val, ok := s.Lookup("foo") assert.Nil(t, val) assert.False(t, ok) }
func TestPathMatchHandler(t *testing.T) { pathPattern, _ := paths.NewPathPattern("collection/{id}/name") var called bool = false h := NewPathMatchHandler(pathPattern, HandlerExecutionFunc(func(c context.Context) error { called = true return nil })) ctx1 := context_test.MakeTestContextWithPath("/collection/123/name") will, _ := h.WillHandle(ctx1) assert.True(t, will) h.Handle(ctx1) assert.True(t, called, "Method should be called") assert.Equal(t, "123", ctx1.Data().Get(context.DataKeyPathParameters).(objects.Map).Get("id")) ctx2 := context_test.MakeTestContextWithPath("/collection") will, _ = h.WillHandle(ctx2) assert.False(t, will) assert.Nil(t, ctx2.Data().Get(context.DataKeyPathParameters)) h.BreakCurrentPipeline = true shouldStop, handleErr := h.Handle(ctx2) assert.Nil(t, handleErr) assert.True(t, shouldStop) assert.True(t, called, "Handler func should get called") }
func Test_ValueStack_Assign(t *testing.T) { ns0 := NewValueMap() stack := NewValueStack() assert.Equal(t, 0, len(stack)) stack.Push(ns0) assert.Equal(t, 1, len(stack)) val1 := MakeFuString("hello") val2 := MakeFuString("world") val3 := MakeFuString("fnord") stack.Assign("foo", val1) val, ok := stack.Lookup("foo") assert.True(t, ok) assert.True(t, val.Equal(val1)) stack.Assign("foo", val2) val, ok = stack.Lookup("foo") assert.True(t, ok) assert.True(t, val.Equal(val2)) ns1 := NewValueMap() stack.Push(ns1) assert.Equal(t, 2, len(stack)) stack.Assign("bar", val1) stack.Assign("foo", val3) // make sure we can get the new values out of the stack val, ok = stack.Lookup("bar") assert.True(t, val.Equal(val1)) val, ok = stack.Lookup("foo") assert.True(t, val.Equal(val3)) // peek under the hood and make sure each one was added to the // right namespace: bar is a new name, so it will be in the // innermost (last) namespace val, ok = ns1.Lookup("bar") assert.True(t, val.Equal(val1)) val, ok = ns0.Lookup("bar") assert.False(t, ok) // foo already existed in an enclosing namespace, so Assign() // replaced it there val, ok = ns0.Lookup("foo") assert.True(t, val.Equal(val3)) val, ok = ns1.Lookup("foo") assert.False(t, ok) }
func TestResultNext(t *testing.T) { r := testResult() assert.Equal(t, len(r.Rows), 3) assert.True(t, r.Next()) assert.True(t, r.Next()) assert.True(t, r.Next()) assert.False(t, r.Next()) }
func TestfuzzyContains(t *testing.T) { min := 50 max := 100 rect := image.Rect(min, min, max, max) assert.False(t, fuzzyContains(&rect, image.Pt(0, 0))) coord1 := min - fuzzyness assert.True(t, fuzzyContains(&rect, image.Pt(coord1, coord1))) assert.True(t, fuzzyContains(&rect, image.Pt(75, 75))) coord2 := max + fuzzyness assert.True(t, fuzzyContains(&rect, image.Pt(coord2, coord2))) assert.False(t, fuzzyContains(&rect, image.Pt(150, 150))) }
func TestPathPattern_GetPathMatch_Edges(t *testing.T) { // everything gp, _ := NewPathPattern(MatchAllPaths) assert.True(t, gp.GetPathMatch(NewPath("/people/123/books")).Matches) assert.True(t, gp.GetPathMatch(NewPath("/people")).Matches) assert.True(t, gp.GetPathMatch(NewPath("/")).Matches) assert.True(t, gp.GetPathMatch(NewPath("")).Matches) // root gp, _ = NewPathPattern("/") assert.True(t, gp.GetPathMatch(NewPath("/")).Matches) assert.True(t, gp.GetPathMatch(NewPath("")).Matches) assert.False(t, gp.GetPathMatch(NewPath("/people/123/books")).Matches) assert.False(t, gp.GetPathMatch(NewPath("/people")).Matches) }
func Test_Arguments_Is(t *testing.T) { var args Arguments = []interface{}{"string", 123, true} assert.True(t, args.Is("string", 123, true)) assert.False(t, args.Is("wrong", 456, false)) }
func TestPPUReadingPPUSTATUSSetsVBlanksStartedToFalse(t *testing.T) { p := NewPPU() p.Status.VBlankStarted = true p.Read(PPUSTATUS) assert.False(t, p.Status.VBlankStarted) }
func TestExecSpReturnValue(t *testing.T) { conn := ConnectToTestDb(t) err := createProcedure(conn, "test_return_value", " as return 123") assert.Nil(t, err) rst, err := conn.ExecSp("test_return_value") assert.Nil(t, err) assert.False(t, rst.HasResults()) assert.Equal(t, 123, rst.Status()) }
func Test_FinderNode_Equal(t *testing.T) { finder1 := NewFinderNode("*.c", "*.h") finder2 := NewFinderNode("*.c", "*.h") finder3 := NewFinderNode("*.h", "*.c") assert.True(t, finder1.Equal(finder1)) assert.True(t, finder1.Equal(finder2)) assert.False(t, finder1.Equal(finder3)) }
func TestGame_IsValidMove(t *testing.T) { var game = NewGame() var board = game.Board() t.Log("#IsValidMove returns true if the selected space is blank") assert.True(t, game.IsValidMove(1)) assert.True(t, game.IsValidMove(2)) t.Log("#IsValidMove returns true if the selected space is blank") board.Mark(1, "X") board.Mark(2, "O") assert.False(t, game.IsValidMove(1)) assert.False(t, game.IsValidMove(2)) t.Log("#IsValidMove returns false if the provided index is out of range") assert.False(t, game.IsValidMove(-1)) assert.False(t, game.IsValidMove(9)) }
func TestExecSpInputParams(t *testing.T) { conn := ConnectToTestDb(t) err := createProcedure(conn, "test_input_params", "@p1 int = 0, @p2 int, @p3 as varchar(10), @p4 datetime, @p5 varbinary(10) = null as select @p1 = @p1 + @p2; return @p1") assert.Nil(t, err) rst, err := conn.ExecSp("test_input_params", 123, 234, "pero", time.Now(), []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 0}) assert.Nil(t, err) assert.False(t, rst.HasResults()) assert.Equal(t, 357, rst.Status()) }
func TestNoBool(t *testing.T) { fg := newFlagGroup() f := fg.Flag("b", "").Default("true") b := f.Bool() fg.init() tokens := Tokenize([]string{"--no-b"}) _, err := fg.parse(tokens, false) assert.NoError(t, err) assert.False(t, *b) }
func TestPPUStepOnScanlineNegAndFirstCycleClearVBlankStarted(t *testing.T) { p := NewPPU() p.Scanline = -1 p.Cycle = 1 p.VBlankStarted = true p.Step() assert.False(t, p.Status.VBlankStarted) }
func TestPPUStepOnScanlineNegFirstCycleClearsSprite0Hit(t *testing.T) { p := NewPPU() p.Scanline = -1 p.Status.Sprite0Hit = true p.Cycle = 1 p.Step() assert.False(t, p.Status.Sprite0Hit) }
func TestEval(t *testing.T) { assert.Equal(t, 1, Init()) r, err := Eval("1+3*4") assert.Nil(t, err) assert.True(t, r.IsNumeric()) assert.False(t, r.IsComplex()) assert.Panics(t, func() { r.AsComplex() }) num := r.AsNumeric() assert.Equal(t, 1, num.Len()) assert.Equal(t, 13, num.Get(0)) r = EvalOrDie("sqrt(-2+0i)") assert.False(t, r.IsNumeric()) assert.True(t, r.IsComplex()) assert.Panics(t, func() { r.AsNumeric() }) cpl := r.AsComplex() assert.Equal(t, 1, cpl.Len()) assert.Equal(t, complex(0, math.Sqrt(2)), cpl.Get(0)) }