Golang assert.New函数代码示例

func TestOptions_Init(t *testing.T) {
	a := assert.New(t)

	o := &Options{Type: "html"}
	a.Error(o.Init()) // 未指定 dir

	o.Dir = "./"
	a.NotError(o.Init())

	// 模板不存在
	o.Template = "./not_exists"
	a.Error(o.Init())

	// 未指定 template
	o.Type = "html+"
	o.Template = ""
	a.Error(o.Init())

	// port 未指定
	o.Type = "html+"
	o.Template = "./static"
	a.Error(o.Init())

	// 修正 port
	o.Port = "1234"
	a.NotError(o.Init())
	a.Equal(":1234", o.Port)
}

func TestResultFields(t *testing.T) {
	a := assert.New(t)
	allow := []string{"col1", "col2", "col3"}

	//
	//ResultFields(r *http.Request, allow []string) ([]string, bool)

	r, err := http.NewRequest(http.MethodPut, "/test", nil)
	a.NotError(err).NotNil(r)

	// 非 GET 方法
	ret, ok := ResultFields(r, allow)
	a.False(ok).Nil(ret)

	// 非 GET 方法，即使设置 Method 方法
	r.Header.Set("X-Result-Fields", "col1, col2")
	ret, ok = ResultFields(r, allow)
	a.False(ok).Nil(ret)

	// 指定的字段都是允许的字段
	r.Method = http.MethodGet
	ret, ok = ResultFields(r, allow)
	a.True(ok).Equal([]string{"col1", "col2"}, ret)

	// 包含不允许的字段
	r.Header.Set("X-Result-Fields", "col1,col2, col100 ,col101")
	ret, ok = ResultFields(r, allow)
	a.False(ok).Equal([]string{"col100", "col101"}, ret)

	// 未指定 X-Result-Fields
	r.Header.Del("X-Result-Fields")
	ret, ok = ResultFields(r, allow)
	a.True(ok).Nil(nil)
}

func TestMergeNest(t *testing.T) {
	a := assert.New(t)

	v1 := &s2{S2: "1", S3: &s1{}}
	v2 := &s2{S2: "2", S3: &s1{ID: 2, hide: 2}}

	// deep 为true时，会依次赋值子元素，hide不可导出，所以被忽略
	a.NotError(merge(true, reflect.ValueOf(v1).Elem(), reflect.ValueOf(v2).Elem()))
	a.Equal(v1.ID, 0).Equal(v1.S3.ID, 2).Equal(v1.S3.hide, 0)

	// deep为false时，会将整个v2.S3赋给给v1.S3
	a.NotError(merge(false, reflect.ValueOf(v1).Elem(), reflect.ValueOf(v2).Elem()))
	a.Equal(v1.ID, 0).Equal(v1.S3.ID, 2).Equal(v1.S3.hide, 2)

	// 自动初始化v1.S3
	v1.S3 = nil
	a.NotError(merge(true, reflect.ValueOf(v1).Elem(), reflect.ValueOf(v2).Elem()))
	a.Equal(v1.ID, 0).Equal(v1.S3.ID, 2).Equal(v1.S3.hide, 0)

	// 不会初始化v1.S3
	v1.S3 = nil
	v2.S3 = nil
	a.NotError(merge(true, reflect.ValueOf(v1).Elem(), reflect.ValueOf(v2).Elem()))
	a.Equal(v1.ID, 0).Nil(v1.S3)
}

func TestInitFormXMLString(t *testing.T) {
	a := assert.New(t)

	// 重新注册以下用到的writer
	clearInitializer()
	a.True(Register("debug", logContInitializer), "注册debug时失败")
	a.True(Register("buffer", bufferInitializer), "注册buffer时失败")
	a.True(Register("debugW", debugWInit), "注册debugW时失败")

	xml := `
<?xml version="1.0" encoding="utf-8" ?>
<logs>
	<debug prefix="[DEBUG]">
		<buffer size="10">
			<debugW />
		</buffer>
	</debug>
</logs>
`
	debugW.Reset()
	conts.Add(infoW) // 触发initFromXmlString中的重置功能
	a.True(conts.Len() == 1)
	a.NotError(InitFromXMLString(xml))
	a.True(critical == nil)   // InitFromXMLString会重置所有的日志指向
	a.True(CRITICAL() == nil) // InitFromXMLString会重置所有的日志指向

	Debug("abc")
	a.True(debugW.Len() == 0) // 缓存未达10，依然为空
	Allf("def\n")
	a.True(debugW.Len() == 0) // 缓存未达10，依然为空

	// 测试Flush
	Flush()
	a.True(debugW.Len() > 0)
}

func TestConfig_buildHeaders(t *testing.T) {
	a := assert.New(t)
	fh := func(w http.ResponseWriter, r *http.Request) {
		w.Write([]byte("123"))
	}

	cfg := &Config{Headers: map[string]string{"Server": "test"}}
	h := cfg.buildHeader(http.HandlerFunc(fh))

	r, err := http.NewRequest("GET", "", nil)
	a.NotError(err).NotNil(r)

	w := httptest.NewRecorder()
	h.ServeHTTP(w, r)
	a.Equal(w.Header().Get("Server"), "test")

	// 为空
	cfg = &Config{Headers: map[string]string{}}
	h = cfg.buildHeader(http.HandlerFunc(fh))

	r, err = http.NewRequest("GET", "", nil)
	a.NotError(err).NotNil(r)

	w = httptest.NewRecorder()
	h.ServeHTTP(w, r)
	a.Equal(w.Header().Get("Server"), "")
}

func TestExtsIndex(t *testing.T) {
	a := assert.New(t)

	a.Equal(extsIndex[".cpp"], "cpp")
	a.Equal(extsIndex[".php"], "php")
	a.Equal(extsIndex[".go"], "go")
}

func TestLexer_readN(t *testing.T) {
	a := assert.New(t)

	l := newLexer([]rune("line1\n @api line2 \n"), 100, "file.go")
	a.NotNil(l)

	words, err := l.readN(1, "@api")
	a.NotError(err).Equal(words, []string{"line1"})

	l.match("@api")
	words, err = l.readN(1, "@api") // 行尾并没有@api,匹配eof
	a.NotError(err).Equal(words, []string{"line2"})

	// 多词匹配
	l = newLexer([]rune("word1 word2 word3 word4\n @api word5 word6 \n"), 100, "file.go")
	words, err = l.readN(2, "\n")
	a.NotError(err).Equal(words, []string{"word1", "word2 word3 word4"})

	l.match("@api")
	words, err = l.readN(5, "\n")
	a.Error(err)

	l = newLexer([]rune("word1 word2 word3 word4\n"), 100, "file.go")
	words, err = l.readN(1, "\n")
	a.NotError(err).Equal(words, []string{"word1 word2 word3 word4"})
}

func TestTag_readLine(t *testing.T) {
	a := assert.New(t)
	l := &tag{data: []rune(" line1\n line2 \n")}

	a.Equal(l.readLine(), []rune("line1"))
	a.Equal(l.readLine(), []rune("line2"))
}

func TestTag_readEnd(t *testing.T) {
	a := assert.New(t)
	l := &tag{data: []rune(" line1\n line2 \n")}

	a.Equal(l.readEnd(), "line1\n line2 \n")
	a.Equal(l.readEnd(), "")
}

func TestBlock_endMComment(t *testing.T) {
	a := assert.New(t)
	b := &block{
		Type:  blockTypeSComment,
		Begin: "/*",
		End:   "*/",
	}

	l := &lexer{
		data: []byte("comment1\n*/"),
	}
	rs, found := b.endMComments(l)
	a.True(found).Equal(string(rs), "comment1\n")

	// 多个注释结束符
	l = &lexer{
		data: []byte("comment1\ncomment2*/*/"),
	}
	rs, found = b.endMComments(l)
	a.True(found).Equal(string(rs), "comment1\ncomment2")

	// 空格开头
	l = &lexer{
		data: []byte("\ncomment1\ncomment2*/*/"),
	}
	rs, found = b.endMComments(l)
	a.True(found).Equal(string(rs), "\ncomment1\ncomment2")

	// 没有注释结束符
	l = &lexer{
		data: []byte("comment1"),
	}
	rs, found = b.endMComments(l)
	a.False(found).Nil(rs)
}

func TestQuery_Int(t *testing.T) {
	a := assert.New(t)

	form := url.Values(map[string][]string{
		"q1": []string{"1"},
		"q2": []string{"21", "22"},
		"q4": []string{"four"},
	})
	r := &http.Request{Form: form}

	q := &Query{
		abortOnError: false,
		errors:       map[string]string{},
		values:       make(map[string]value, len(form)),
		request:      r,
	}

	q1 := q.Int("q1", 12)
	msgs := q.Parse()
	a.Equal(len(msgs), 0).Equal(*q1, 1)

	q2 := q.Int64("q2", 12)
	msgs = q.Parse()
	a.Equal(len(msgs), 0).Equal(*q2, 21)

	q3 := q.Int64("q3", 32)
	msgs = q.Parse()
	a.Equal(len(msgs), 0).Equal(*q3, 32)

	// 出错的情况下，返回默认值
	q4 := q.Int64("q4", 32)
	msgs = q.Parse()
	a.Equal(len(msgs), 1).Equal(*q4, 32)
}

func TestBlock_endSComment(t *testing.T) {
	a := assert.New(t)
	b := &block{
		Type:  blockTypeSComment,
		Begin: `//`,
	}

	l := &lexer{
		data: []byte("comment1\n"),
	}
	rs, err := b.endSComments(l)
	a.NotError(err).Equal(string(rs), "comment1\n")

	// 没有换行符，则自动取到结束符。
	l = &lexer{
		data: []byte("comment1"),
	}
	rs, err = b.endSComments(l)
	a.NotError(err).Equal(string(rs), "comment1")

	// 多行连续的单行注释。
	l = &lexer{
		data: []byte("comment1\n//comment2\n //comment3"),
	}
	rs, err = b.endSComments(l)
	a.NotError(err).Equal(string(rs), "comment1\ncomment2\ncomment3")

	// 多行不连续的单行注释。
	l = &lexer{
		data: []byte("comment1\n // comment2\n\n //comment3\n"),
	}
	rs, err = b.endSComments(l)
	a.NotError(err).Equal(string(rs), "comment1\n comment2\n")
}

func TestBlock_endString(t *testing.T) {
	a := assert.New(t)
	b := &block{
		Type:   blockTypeString,
		Begin:  `"`,
		End:    `"`,
		Escape: "\\",
	}

	l := &lexer{
		data: []byte(`text"`),
	}
	rs, ok := b.endString(l)
	a.True(ok).Nil(rs)

	// 带转义字符
	l = &lexer{
		data: []byte(`te\"xt"`),
	}
	rs, ok = b.endString(l)
	a.True(ok).
		Nil(rs).
		Equal(l.pos, len(l.data))

	// 找不到匹配字符串
	l = &lexer{
		data: []byte("text"),
	}
	rs, ok = b.endString(l)
	a.False(ok).Nil(rs)
}

// bytes
func TestBytes1(t *testing.T) {
	a := assert.New(t)

	a.NotEqual(bytes(random, 10, []byte("1234123lks;df")), bytes(random, 10, []byte("1234123lks;df")))
	a.NotEqual(bytes(random, 10, []byte("1234123lks;df")), bytes(random, 10, []byte("1234123lks;df")))
	a.NotEqual(bytes(random, 10, []byte("1234123lks;df")), bytes(random, 10, []byte("1234123lks;df")))
}

func TestLogWriter_Write(t *testing.T) {
	a := assert.New(t)

	l := &logWriter{out: os.Stdout, prefix: "[TEST] ", color: colors.Red}
	_, err := l.Write([]byte("这是一行红色前缀的字"))
	a.NotError(err)
}