Golang assert.Equal函数代码示例

func TestShortRead(t *testing.T) {
	var result []byte
	var buf [2]byte

	for _, test := range readerTests {
		result = result[:0]

		var (
			r   = NewReader(Rope{test.r})
			n   int
			err error
		)
		for err == nil {
			n, err = r.Read(buf[:])

			if err == nil {
				assert.NotEqual(t, n, 0, "Zero-length Read()")
			}

			result = append(result, buf[:n]...)
		}
		assert.Equal(t, test.want, string(result))
		assert.Equal(t, err, io.EOF, "Non-EOF error: "+err.Error())
	}
}

func TestCrewRenderPlain(t *testing.T) {
	c := NewCrew("test")

	// Set some variables
	c.Vars = map[string]interface{}{
		"path": "/usr/local/bin",
		"n":    4,
		"x":    3.45,
	}

	// No placeholders
	s, _ := c.Render("python test.py")
	assert.Equal(t, s, "python test.py")

	// Missing key
	s, err := c.Render("{{bindir}}/python test.py")
	assert.NotEqual(t, err, nil)

	// Typical
	s, err = c.Render("{{path}}/python -n {{n}} -x {{x}} test.py")
	assert.Equal(t, s, "/usr/local/bin/python -n 4 -x 3.45 test.py")

	// Single braces aren't affected
	s, err = c.Render("{path}")
	assert.Equal(t, s, "{path}")

	// Escaped braces aren't affected, but replaced
	s, err = c.Render("{\\{path\\}}")
	assert.Equal(t, s, "{{path}}")

	// Escaped braces, round 2
	s, err = c.Render("\\{\\{path\\}\\}")
	assert.Equal(t, s, "{{path}}")
}

func TestFullRead(t *testing.T) {
	var buf [9]byte // Big enough for all the test strings. Exactly right size for one of them.

	for _, test := range readerTests {
		r := NewReader(Rope{test.r})
		n, err := r.Read(buf[:])

		assert.Equal(t, n, len(test.want), "partial read")
		assert.Equal(t, err, io.EOF, "no immediate EOF")
		assert.Equal(t, test.want, string(buf[:n]), "wrong data")
	}
}

func TestFailedRoutineRun(t *testing.T) {
	r := NewRoutine("git", "flub")
	c := NewCrew("c1")
	rr, err := r.Run(c)

	assert.NotEqual(t, err, nil)
	assert.Equal(t, rr.Done(), true)
	assert.Equal(t, rr.Failed, true)
	assert.Equal(t, rr.Stdin, "")
	assert.Equal(t, rr.Stdout, "")
	assert.Equal(t, rr.Stderr, "git: 'flub' is not a git command. See 'git --help'.\n\nDid you mean this?\n\tpull\n")
}

func TestPlayMoveScene(t *testing.T) {
	p := NewPlay("P0", "")
	s0 := NewScene("S0", "")
	s1 := NewScene("S1", "")

	p.AddScene(s0)
	p.AddScene(s1)

	p.MoveScene(0, s1)
	assert.Equal(t, p.Scenes[0], s1)
	assert.Equal(t, p.Scenes[1], s0)
}

func TestSuccessfulSceneRun(t *testing.T) {
	s := NewScene("S0", "")

	s.NewRoutine("echo", "Hello")
	s.NewRoutine("echo", "Gopher")
	s.NewRoutine("echo", "World")

	c := NewCrew("c1")
	sr, err := s.Run(c)

	assert.Equal(t, err, nil)
	assert.Equal(t, len(sr.Routines), 3)
	assert.Equal(t, sr.Failed, false)
	assert.Equal(t, sr.Done(), true)
}

func TestFailedSceneRun(t *testing.T) {
	s := NewScene("S0", "")

	s.NewRoutine("git", "flub")
	s.NewRoutine("echo", "Gopher")
	s.NewRoutine("echo", "World")

	c := NewCrew("c1")
	sr, err := s.Run(c)

	assert.Equal(t, err, nil)
	assert.Equal(t, len(sr.Routines), 3)
	assert.Equal(t, sr.Failed, true)
	assert.Equal(t, sr.Done(), true)
}

func TestAt(t *testing.T) {
	str := treeR.String()
	length := treeR.Len()
	for i := int64(0); i < length; i++ {
		assert.Equal(t, str[i], treeR.At(i))
	}
}

func TestPlayRun(t *testing.T) {
	p := NewPlay("P0", "")
	c := &Crew{}

	// Nothing to do..
	pr, err := p.Run(c)
	assert.Equal(t, err, nil)
	assert.False(t, pr.Failed)

	// Scene and routine
	s0, _ := p.NewScene("S0", "")
	s0.NewRoutine("echo", "foo")
	pr, err = p.Run(c)
	assert.Equal(t, err, nil)
	assert.False(t, pr.Failed)
}

func TestTrigger(t *testing.T) {
	// Null case
	c, _ := Trigger("testhook", nil)
	assert.Equal(t, c, 0)

	// Local file
	NewLocalHooks()
}

func TestReader(t *testing.T) {
	buf := bytes.NewBuffer(nil)
	for _, test := range readerTests {
		buf.Reset()
		io.Copy(buf, NewReader(Rope{test.r}))
		assert.Equal(t, test.want, buf.String())
	}
}

func TestPlayAddScene(t *testing.T) {
	p := NewPlay("P0", "")
	s0 := NewScene("S0", "")
	s1 := NewScene("S1", "")

	// Yep..
	p.AddScene(s0)
	assert.Equal(t, p.Scenes[0], s0)

	// Yep..
	p.AddScene(s1)
	assert.Equal(t, p.Scenes[1], s1)

	// Nope..
	err := p.AddScene(s1)
	assert.NotEqual(t, err, nil)
}

func TestPlayInsertScene(t *testing.T) {
	p := NewPlay("P0", "")
	s0 := NewScene("S0", "")

	// Cannot insert at a position that does not exist
	err := p.InsertScene(0, s0)
	assert.NotEqual(t, err, nil)

	p.AddScene(s0)

	// Insert new scene at position 0
	ns0 := NewScene("New S0", "")
	err = p.InsertScene(0, ns0)
	assert.Equal(t, err, nil)
	assert.Equal(t, p.Scenes[0], ns0)
	assert.Equal(t, p.Scenes[1], s0)
}

func TestConcatSubstr(t *testing.T) {
	defer disableCoalesce()()

	for _, ss := range substrings {
		got := ss.orig.slice(ss.start, ss.end)
		msg := fmt.Sprintf("%q[%v:%v] != %q", Rope{ss.orig}, ss.start, ss.end, Rope{got})
		assert.Equal(t, ss.want, got, msg)
	}
}

func TestSlice(t *testing.T) {
	defer disableCoalesce()()

	// See concat_test.go for the table used.
	for _, ss := range substrings {
		orig := Rope{ss.orig}
		got := orig.Slice(ss.start, ss.end)
		msg := fmt.Sprintf("%q[%v:%v] != %q", orig, ss.start, ss.end, got)
		assert.Equal(t, ss.want, got.node, msg)
	}
}