fix: unittests

cmd/doc_test.go

@@ -4,12 +4,11 @@ import (
 	"testing"
 
 	"github.com/spf13/cobra/doc"
+	"github.com/stretchr/testify/assert"
 )
 
 // run this test to generate markdown docs for hrp command
 func TestGenMarkdownTree(t *testing.T) {
 	err := doc.GenMarkdownTree(rootCmd, "../../docs/cmd")
-	if err != nil {
+	assert.Nil(t, err)
-		t.Fatal(err)
-	}
 }

cmd/ios/ios_test.go

@@ -2,13 +2,14 @@
 
 package ios
 
-import "testing"
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
 
 func TestGetDevice(t *testing.T) {
 	device, err := getDevice(udid)
-	if err != nil {
+	require.Nil(t, err)
-		t.Fatal(err)
-	}
-
 	t.Logf("device: %v", device)
 }

convert/from_curl_test.go

@@ -6,7 +6,7 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
-var curlPath = "../../../examples/data/curl/curl_examples.txt"
+var curlPath = "../examples/data/curl/curl_examples.txt"
 
 func TestLoadCurlCase(t *testing.T) {
 	tCase, err := LoadCurlCase(curlPath)

internal/version/VERSION

@@ -1 +1 @@
-v5.0.0-beta-2503052140
+v5.0.0-beta-2503052208

parser_test.go

@@ -10,77 +10,52 @@ import (
 	"time"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestBuildURL(t *testing.T) {
 	var preparedURL *url.URL
 
 	preparedURL = buildURL("https://postman-echo.com", "/get", nil)
-	if !assert.Equal(t, preparedURL.String(), "https://postman-echo.com/get/") {
+	assert.Equal(t, preparedURL.String(), "https://postman-echo.com/get/")
-		t.Fatal()
-	}
 	preparedURL = buildURL("https://postman-echo.com", "get", nil)
-	if !assert.Equal(t, preparedURL.String(), "https://postman-echo.com/get/") {
+	assert.Equal(t, preparedURL.String(), "https://postman-echo.com/get/")
-		t.Fatal()
-	}
 	preparedURL = buildURL("https://postman-echo.com/", "/get", nil)
-	if !assert.Equal(t, preparedURL.String(), "https://postman-echo.com/get/") {
+	assert.Equal(t, preparedURL.String(), "https://postman-echo.com/get/")
-		t.Fatal()
-	}
 
 	preparedURL = buildURL("https://postman-echo.com/abc/", "/get?a=1&b=2", nil)
-	if !assert.Equal(t, preparedURL.String(), "https://postman-echo.com/abc/get?a=1&b=2") {
+	assert.Equal(t, preparedURL.String(), "https://postman-echo.com/abc/get?a=1&b=2")
-		t.Fatal()
-	}
 	preparedURL = buildURL("https://postman-echo.com/abc", "get?a=1&b=2", nil)
-	if !assert.Equal(t, preparedURL.String(), "https://postman-echo.com/abc/get?a=1&b=2") {
+	assert.Equal(t, preparedURL.String(), "https://postman-echo.com/abc/get?a=1&b=2")
-		t.Fatal()
-	}
 
 	// omit query string in base url
 	preparedURL = buildURL("https://postman-echo.com/abc?x=6&y=9", "/get?a=1&b=2", nil)
-	if !assert.Equal(t, preparedURL.String(), "https://postman-echo.com/abc/get?a=1&b=2") {
+	assert.Equal(t, preparedURL.String(), "https://postman-echo.com/abc/get?a=1&b=2")
-		t.Fatal()
-	}
 
 	preparedURL = buildURL("", "https://postman-echo.com/get", nil)
-	if !assert.Equal(t, preparedURL.String(), "https://postman-echo.com/get/") {
+	assert.Equal(t, preparedURL.String(), "https://postman-echo.com/get/")
-		t.Fatal()
-	}
 
 	// notice: step request url > config base url
 	preparedURL = buildURL("https://postman-echo.com", "https://httpbin.org/get", nil)
-	if !assert.Equal(t, preparedURL.String(), "https://httpbin.org/get/") {
+	assert.Equal(t, preparedURL.String(), "https://httpbin.org/get/")
-		t.Fatal()
-	}
 
 	// websocket url
 	preparedURL = buildURL("wss://ws.postman-echo.com/raw", "", nil)
-	if !assert.Equal(t, preparedURL.String(), "wss://ws.postman-echo.com/raw/") {
+	assert.Equal(t, preparedURL.String(), "wss://ws.postman-echo.com/raw/")
-		t.Fatal()
-	}
 
 	preparedURL = buildURL("wss://ws.postman-echo.com", "/raw", nil)
-	if !assert.Equal(t, preparedURL.String(), "wss://ws.postman-echo.com/raw/") {
+	assert.Equal(t, preparedURL.String(), "wss://ws.postman-echo.com/raw/")
-		t.Fatal()
-	}
 
 	preparedURL = buildURL("wss://ws.postman-echo.com/raw", "ws://echo.websocket.events", nil)
-	if !assert.Equal(t, preparedURL.String(), "ws://echo.websocket.events/") {
+	assert.Equal(t, preparedURL.String(), "ws://echo.websocket.events/")
-		t.Fatal()
-	}
 
 	queryParams := url.Values{}
 	queryParams.Add("c", "3")
 	queryParams.Add("d", "4")
 	preparedURL = buildURL("https://postman-echo.com/", "/get/", queryParams)
-	if !assert.Equal(t, preparedURL.String(), "https://postman-echo.com/get?c=3&d=4") {
+	assert.Equal(t, preparedURL.String(), "https://postman-echo.com/get?c=3&d=4")
-		t.Fatal()
-	}
 	preparedURL = buildURL("https://postman-echo.com/abc", "get?a=1&b=2", queryParams)
-	if !assert.Equal(t, preparedURL.String(), "https://postman-echo.com/abc/get?a=1&b=2&c=3&d=4") {
+	assert.Equal(t, preparedURL.String(), "https://postman-echo.com/abc/get?a=1&b=2&c=3&d=4")
-		t.Fatal()
-	}
 }
 
 func TestRegexCompileVariable(t *testing.T) {
@@ -95,9 +70,7 @@ func TestRegexCompileVariable(t *testing.T) {
 
 	for _, expr := range testData {
 		varMatched := regexCompileVariable.FindStringSubmatch(expr)
-		if !assert.Len(t, varMatched, 3) {
+		assert.Len(t, varMatched, 3)
-			t.Fatal()
-		}
 	}
 }
 
@@ -112,9 +85,7 @@ func TestRegexCompileAbnormalVariable(t *testing.T) {
 
 	for _, expr := range testData {
 		varMatched := regexCompileVariable.FindStringSubmatch(expr)
-		if !assert.Len(t, varMatched, 0) {
+		assert.Len(t, varMatched, 0)
-			t.Fatal()
-		}
 	}
 }
 
@@ -130,9 +101,7 @@ func TestRegexCompileFunction(t *testing.T) {
 
 	for _, expr := range testData {
 		varMatched := regexCompileFunction.FindStringSubmatch(expr)
-		if !assert.Len(t, varMatched, 3) {
+		assert.Len(t, varMatched, 3)
-			t.Fatal()
-		}
 	}
 }
 
@@ -152,9 +121,7 @@ func TestRegexCompileAbnormalFunction(t *testing.T) {
 
 	for _, expr := range testData {
 		varMatched := regexCompileFunction.FindStringSubmatch(expr)
-		if !assert.Len(t, varMatched, 0) {
+		assert.Len(t, varMatched, 0)
-			t.Fatal()
-		}
 	}
 }
 
@@ -214,12 +181,8 @@ func TestParseDataStringWithVariables(t *testing.T) {
 	parser := NewParser()
 	for _, data := range testData {
 		parsedData, err := parser.Parse(data.expr, variablesMapping)
-		if !assert.NoError(t, err) {
+		assert.Nil(t, err)
-			t.Fatal()
+		assert.Equal(t, data.expect, parsedData)
-		}
-		if !assert.Equal(t, data.expect, parsedData) {
-			t.Fatal()
-		}
 	}
 }
 
@@ -239,12 +202,8 @@ func TestParseDataStringWithUndefinedVariables(t *testing.T) {
 	parser := NewParser()
 	for _, data := range testData {
 		parsedData, err := parser.Parse(data.expr, variablesMapping)
-		if !assert.Error(t, err) {
+		assert.Error(t, err)
-			t.Fatal()
+		assert.Equal(t, data.expect, parsedData)
-		}
-		if !assert.Equal(t, data.expect, parsedData) {
-			t.Fatal()
-		}
 	}
 }
 
@@ -284,12 +243,8 @@ func TestParseDataStringWithVariablesAbnormal(t *testing.T) {
 	parser := NewParser()
 	for _, data := range testData {
 		parsedData, err := parser.Parse(data.expr, variablesMapping)
-		if !assert.NoError(t, err) {
+		assert.Nil(t, err)
-			t.Fatal()
+		assert.Equal(t, data.expect, parsedData)
-		}
-		if !assert.Equal(t, data.expect, parsedData) {
-			t.Fatal()
-		}
 	}
 }
 
@@ -315,12 +270,8 @@ func TestParseDataMapWithVariables(t *testing.T) {
 	parser := NewParser()
 	for _, data := range testData {
 		parsedData, err := parser.Parse(data.expr, variablesMapping)
-		if !assert.NoError(t, err) {
+		assert.Nil(t, err)
-			t.Fatal()
+		assert.Equal(t, data.expect, parsedData)
-		}
-		if !assert.Equal(t, data.expect, parsedData) {
-			t.Fatal()
-		}
 	}
 }
 
@@ -349,12 +300,8 @@ func TestParseHeaders(t *testing.T) {
 	parser := NewParser()
 	for _, data := range testData {
 		parsedHeaders, err := parser.ParseHeaders(data.rawHeaders, variablesMapping)
-		if !assert.NoError(t, err) {
+		assert.Nil(t, err)
-			t.Fatal()
+		assert.Equal(t, data.expectHeaders, parsedHeaders)
-		}
-		if !assert.Equal(t, data.expectHeaders, parsedHeaders) {
-			t.Fatal()
-		}
 	}
 }
 
@@ -378,9 +325,7 @@ func TestMergeVariables(t *testing.T) {
 
 	for _, data := range testData {
 		mergedVariables := mergeVariables(data.stepVariables, data.configVariables)
-		if !assert.Equal(t, data.expectVariables, mergedVariables) {
+		assert.Equal(t, data.expectVariables, mergedVariables)
-			t.Fatal()
-		}
 	}
 }
 
@@ -414,9 +359,7 @@ func TestMergeMap(t *testing.T) {
 
 	for _, data := range testData {
 		mergedMap := mergeMap(data.m, data.overriddenMap)
-		if !assert.Equal(t, data.expectMap, mergedMap) {
+		assert.Equal(t, data.expectMap, mergedMap)
-			t.Fatal()
-		}
 	}
 }
 
@@ -445,9 +388,7 @@ func TestMergeSlices(t *testing.T) {
 
 	for _, data := range testData {
 		mergedSlice := mergeSlices(data.slice, data.overriddenSlice)
-		if !assert.Equal(t, data.expectSlice, mergedSlice) {
+		assert.Equal(t, data.expectSlice, mergedSlice)
-			t.Fatal()
-		}
 	}
 }
 
@@ -484,9 +425,7 @@ func TestMergeValidators(t *testing.T) {
 
 	for _, data := range testData {
 		mergedValidators := mergeValidators(data.validators, data.overriddenValidators)
-		if !assert.Equal(t, data.expectValidators, mergedValidators) {
+		assert.Equal(t, data.expectValidators, mergedValidators)
-			t.Fatal()
-		}
 	}
 }
 
@@ -495,37 +434,23 @@ func TestCallBuiltinFunction(t *testing.T) {
 
 	// call function without arguments
 	_, err := parser.callFunc("get_timestamp")
-	if !assert.NoError(t, err) {
+	assert.Nil(t, err)
-		t.Fatal()
-	}
 
 	// call function with one argument
 	timeStart := time.Now()
 	_, err = parser.callFunc("sleep", 1)
-	if !assert.NoError(t, err) {
+	assert.Nil(t, err)
-		t.Fatal()
+	assert.Greater(t, time.Since(timeStart), time.Duration(1)*time.Second)
-	}
-	if !assert.Greater(t, time.Since(timeStart), time.Duration(1)*time.Second) {
-		t.Fatal()
-	}
 
 	// call function with one argument
 	result, err := parser.callFunc("gen_random_string", 10)
-	if !assert.NoError(t, err) {
+	assert.Nil(t, err)
-		t.Fatal()
+	assert.Equal(t, 10, len(result.(string)))
-	}
-	if !assert.Equal(t, 10, len(result.(string))) {
-		t.Fatal()
-	}
 
 	// call function with two argument
 	result, err = parser.callFunc("max", float64(10), 9.99)
-	if !assert.NoError(t, err) {
+	assert.Nil(t, err)
-		t.Fatal()
+	assert.Equal(t, float64(10), result.(float64))
-	}
-	if !assert.Equal(t, float64(10), result.(float64)) {
-		t.Fatal()
-	}
 }
 
 func TestLiteralEval(t *testing.T) {
@@ -548,12 +473,8 @@ func TestLiteralEval(t *testing.T) {
 
 	for _, data := range testData {
 		value, err := literalEval(data.expr)
-		if !assert.NoError(t, err) {
+		assert.Nil(t, err)
-			t.Fatal()
+		assert.Equal(t, data.expect, value)
-		}
-		if !assert.Equal(t, data.expect, value) {
-			t.Fatal()
-		}
 	}
 }
 
@@ -578,12 +499,8 @@ func TestParseFunctionArguments(t *testing.T) {
 
 	for _, data := range testData {
 		value, err := parseFunctionArguments(data.expr)
-		if !assert.NoError(t, err) {
+		assert.Nil(t, err)
-			t.Fatal()
+		assert.Equal(t, data.expect, value)
-		}
-		if !assert.Equal(t, data.expect, value) {
-			t.Fatal()
-		}
 	}
 }
 
@@ -607,12 +524,8 @@ func TestParseDataStringWithFunctions(t *testing.T) {
 	parser := NewParser()
 	for _, data := range testData1 {
 		value, err := parser.Parse(data.expr, variablesMapping)
-		if !assert.NoError(t, err) {
+		assert.Nil(t, err)
-			t.Fatal()
+		assert.Equal(t, data.expect, len(value.(string)))
-		}
-		if !assert.Equal(t, data.expect, len(value.(string))) {
-			t.Fatal()
-		}
 	}
 
 	testData2 := []struct {
@@ -626,12 +539,8 @@ func TestParseDataStringWithFunctions(t *testing.T) {
 
 	for _, data := range testData2 {
 		value, err := parser.Parse(data.expr, variablesMapping)
-		if !assert.NoError(t, err) {
+		assert.Nil(t, err)
-			t.Fatal()
+		assert.Equal(t, data.expect, value)
-		}
-		if !assert.Equal(t, data.expect, value) {
-			t.Fatal()
-		}
 	}
 }
 
@@ -652,9 +561,7 @@ func TestConvertString(t *testing.T) {
 
 	for _, data := range testData {
 		value := convertString(data.raw)
-		if !assert.Equal(t, data.expect, value) {
+		assert.Equal(t, data.expect, value)
-			t.Fatal()
-		}
 	}
 }
 
@@ -676,12 +583,8 @@ func TestParseVariables(t *testing.T) {
 	parser := NewParser()
 	for _, data := range testData {
 		value, err := parser.ParseVariables(data.rawVars)
-		if !assert.NoError(t, err) {
+		assert.Nil(t, err)
-			t.Fatal()
+		assert.Equal(t, data.expectVars, value)
-		}
-		if !assert.Equal(t, data.expectVars, value) {
-			t.Fatal()
-		}
 	}
 }
 
@@ -707,12 +610,8 @@ func TestParseVariablesAbnormal(t *testing.T) {
 	parser := NewParser()
 	for _, data := range testData {
 		value, err := parser.ParseVariables(data.rawVars)
-		if !assert.Error(t, err) {
+		assert.Error(t, err)
-			t.Fatal()
+		assert.Equal(t, data.expectVars, value)
-		}
-		if !assert.Equal(t, data.expectVars, value) {
-			t.Fatal()
-		}
 	}
 }
 
@@ -743,9 +642,7 @@ func TestExtractVariables(t *testing.T) {
 			varList = append(varList, varName)
 		}
 		sort.Strings(varList)
-		if !assert.Equal(t, data.expectVars, varList) {
+		assert.Equal(t, data.expectVars, varList)
-			t.Fatal()
-		}
 	}
 }
 
@@ -782,9 +679,7 @@ func TestFindallVariables(t *testing.T) {
 			varList = append(varList, varName)
 		}
 		sort.Strings(varList)
-		if !assert.Equal(t, data.expectVars, varList) {
+		assert.Equal(t, data.expectVars, varList)
-			t.Fatal()
-		}
 	}
 }
 
@@ -802,13 +697,9 @@ func TestSearchJmespath(t *testing.T) {
 	resp := http.Response{}
 	resp.Body = io.NopCloser(strings.NewReader(testText))
 	respObj, err := newHttpResponseObject(t, NewParser(), &resp)
-	if err != nil {
+	require.Nil(t, err)
-		t.Fatal()
-	}
 	for _, data := range testData {
-		if !assert.Equal(t, data.expected, respObj.searchJmespath(data.raw)) {
+		assert.Equal(t, data.expected, respObj.searchJmespath(data.raw))
-			t.Fatal()
-		}
 	}
 }
 
@@ -845,13 +736,9 @@ func TestSearchRegexp(t *testing.T) {
 	resp := http.Response{}
 	resp.Body = io.NopCloser(strings.NewReader(testText))
 	respObj, err := newHttpResponseObject(t, NewParser(), &resp)
-	if err != nil {
+	require.Nil(t, err)
-		t.Fatal()
-	}
 	for _, data := range testData {
-		if !assert.Equal(t, data.expected, respObj.searchRegexp(data.raw)) {
+		assert.Equal(t, data.expected, respObj.searchRegexp(data.raw))
-			t.Fatal()
-		}
 	}
 }
 
@@ -897,25 +784,13 @@ def Test5():	# exported function
     pass
 `
 	names, err := regexPyFunctionName.findAllFunctionNames(content)
-	if !assert.Nil(t, err) {
+	assert.Nil(t, err)
-		t.FailNow()
+	assert.Contains(t, names, "test_1")
-	}
+	assert.Contains(t, names, "Test5")
-	if !assert.Contains(t, names, "test_1") {
+	assert.Contains(t, names, "_test_2")
-		t.FailNow()
+	assert.NotContains(t, names, "__test_3")
-	}
-	if !assert.Contains(t, names, "Test5") {
-		t.FailNow()
-	}
-	if !assert.Contains(t, names, "_test_2") {
-		t.FailNow()
-	}
-	if !assert.NotContains(t, names, "__test_3") {
-		t.FailNow()
-	}
 	// commented out function
-	if !assert.NotContains(t, names, "test_4") {
+	assert.NotContains(t, names, "test_4")
-		t.FailNow()
-	}
 }
 
 func TestFindAllGoFunctionNames(t *testing.T) {
@@ -941,25 +816,13 @@ func _Test3() { // exported function
 // }
 `
 	names, err := regexGoFunctionName.findAllFunctionNames(content)
-	if !assert.Nil(t, err) {
+	assert.Nil(t, err)
-		t.FailNow()
+	assert.Contains(t, names, "Test1")
-	}
+	assert.Contains(t, names, "testFunc2")
-	if !assert.Contains(t, names, "Test1") {
+	assert.NotContains(t, names, "init")
-		t.FailNow()
+	assert.Contains(t, names, "_Test3")
-	}
-	if !assert.Contains(t, names, "testFunc2") {
-		t.FailNow()
-	}
-	if !assert.NotContains(t, names, "init") {
-		t.FailNow()
-	}
-	if !assert.Contains(t, names, "_Test3") {
-		t.FailNow()
-	}
 	// commented out function
-	if !assert.NotContains(t, names, "Test4") {
+	assert.NotContains(t, names, "Test4")
-		t.FailNow()
-	}
 }
 
 func TestFindAllGoFunctionNamesAbnormal(t *testing.T) {
@@ -973,7 +836,5 @@ func main() {	// should not define main() function
 }
 `
 	_, err := regexGoFunctionName.findAllFunctionNames(content)
-	if !assert.NotNil(t, err) {
+	assert.Error(t, err)
-		t.FailNow()
-	}
 }

tests/step_request_test.go

@@ -31,21 +31,15 @@ var (
 
 func TestRunRequestGetToStruct(t *testing.T) {
 	tStep := stepGET
-	if tStep.Request.Method != hrp.HTTP_GET {
+	assert.Equal(t, tStep.Request.Method, hrp.HTTP_GET)
-		t.Fatalf("tStep.Request.Method != GET")
+	assert.Equal(t, tStep.Request.URL, "/get")
-	}
+
-	if tStep.Request.URL != "/get" {
+	assert.Equal(t, tStep.Request.Params["foo1"], "bar1")
-		t.Fatalf("tStep.Request.URL != '/get'")
+	assert.Equal(t, tStep.Request.Params["foo2"], "bar2")
-	}
+
-	if tStep.Request.Params["foo1"] != "bar1" || tStep.Request.Params["foo2"] != "bar2" {
+	assert.Equal(t, tStep.Request.Headers["User-Agent"], "HttpRunnerPlus")
-		t.Fatalf("tStep.Request.Params mismatch")
+	assert.Equal(t, tStep.Request.Cookies["user"], "debugtalk")
-	}
+
-	if tStep.Request.Headers["User-Agent"] != "HttpRunnerPlus" {
-		t.Fatalf("tStep.Request.Headers mismatch")
-	}
-	if tStep.Request.Cookies["user"] != "debugtalk" {
-		t.Fatalf("tStep.Request.Cookies mismatch")
-	}
 	validator, ok := tStep.Validators[0].(hrp.Validator)
 	if !ok || validator.Check != "status_code" || validator.Expect != 200 {
 		t.Fatalf("tStep.Validators mismatch")
@@ -54,24 +48,16 @@ func TestRunRequestGetToStruct(t *testing.T) {
 
 func TestRunRequestPostDataToStruct(t *testing.T) {
 	tStep := stepPOSTData
-	if tStep.Request.Method != hrp.HTTP_POST {
+	assert.Equal(t, tStep.Request.Method, hrp.HTTP_POST)
-		t.Fatalf("tStep.Request.Method != POST")
+	assert.Equal(t, tStep.Request.URL, "/post")
-	}
+
-	if tStep.Request.URL != "/post" {
+	assert.Equal(t, tStep.Request.Params["foo1"], "bar1")
-		t.Fatalf("tStep.Request.URL != '/post'")
+	assert.Equal(t, tStep.Request.Params["foo2"], "bar2")
-	}
+
-	if tStep.Request.Params["foo1"] != "bar1" || tStep.Request.Params["foo2"] != "bar2" {
+	assert.Equal(t, tStep.Request.Headers["User-Agent"], "HttpRunnerPlus")
-		t.Fatalf("tStep.Request.Params mismatch")
+	assert.Equal(t, tStep.Request.Cookies["user"], "debugtalk")
-	}
+	assert.Equal(t, tStep.Request.Body, "a=1&b=2")
-	if tStep.Request.Headers["User-Agent"] != "HttpRunnerPlus" {
+
-		t.Fatalf("tStep.Request.Headers mismatch")
-	}
-	if tStep.Request.Cookies["user"] != "debugtalk" {
-		t.Fatalf("tStep.Request.Cookies mismatch")
-	}
-	if tStep.Request.Body != "a=1&b=2" {
-		t.Fatalf("tStep.Request.Data mismatch")
-	}
 	validator, ok := tStep.Validators[0].(hrp.Validator)
 	if !ok || validator.Check != "status_code" || validator.Expect != 200 {
 		t.Fatalf("tStep.Validators mismatch")
@@ -86,77 +72,33 @@ func TestRunRequestStatOn(t *testing.T) {
 	caseRunner, _ := hrp.NewRunner(t).SetHTTPStatOn().NewCaseRunner(testcase)
 	sessionRunner := caseRunner.NewSession()
 	summary, err := sessionRunner.Start(nil)
-	if err != nil {
+	assert.Nil(t, err)
-		t.Fatal()
-	}
 
 	stat := summary.Records[0].HttpStat
-	if !assert.GreaterOrEqual(t, stat["DNSLookup"], int64(0)) {
+	assert.GreaterOrEqual(t, stat["DNSLookup"], int64(0))
-		t.Fatal()
+	assert.Greater(t, stat["TCPConnection"], int64(0))
-	}
+	assert.Greater(t, stat["TLSHandshake"], int64(0))
-	if !assert.Greater(t, stat["TCPConnection"], int64(0)) {
+	assert.Greater(t, stat["ServerProcessing"], int64(0))
-		t.Fatal()
+	assert.GreaterOrEqual(t, stat["ContentTransfer"], int64(0))
-	}
+	assert.GreaterOrEqual(t, stat["NameLookup"], int64(0))
-	if !assert.Greater(t, stat["TLSHandshake"], int64(0)) {
+	assert.Greater(t, stat["Connect"], int64(0))
-		t.Fatal()
+	assert.Greater(t, stat["Pretransfer"], int64(0))
-	}
+	assert.Greater(t, stat["StartTransfer"], int64(0))
-	if !assert.Greater(t, stat["ServerProcessing"], int64(0)) {
+	assert.Greater(t, stat["Total"], int64(5))
-		t.Fatal()
+	assert.Less(t, stat["Total"]-summary.Records[0].Elapsed, int64(3))
-	}
-	if !assert.GreaterOrEqual(t, stat["ContentTransfer"], int64(0)) {
-		t.Fatal()
-	}
-	if !assert.GreaterOrEqual(t, stat["NameLookup"], int64(0)) {
-		t.Fatal()
-	}
-	if !assert.Greater(t, stat["Connect"], int64(0)) {
-		t.Fatal()
-	}
-	if !assert.Greater(t, stat["Pretransfer"], int64(0)) {
-		t.Fatal()
-	}
-	if !assert.Greater(t, stat["StartTransfer"], int64(0)) {
-		t.Fatal()
-	}
-	if !assert.Greater(t, stat["Total"], int64(5)) {
-		t.Fatal()
-	}
-	if !assert.Less(t, stat["Total"]-summary.Records[0].Elapsed, int64(3)) {
-		t.Fatal()
-	}
 
 	// reuse connection
 	stat = summary.Records[1].HttpStat
-	if !assert.Equal(t, int64(0), stat["DNSLookup"]) {
+	assert.Equal(t, int64(0), stat["DNSLookup"])
-		t.Fatal()
+	assert.Equal(t, int64(0), stat["TCPConnection"])
-	}
+	assert.Equal(t, int64(0), stat["TLSHandshake"])
-	if !assert.Equal(t, int64(0), stat["TCPConnection"]) {
+	assert.Greater(t, stat["ServerProcessing"], int64(1))
-		t.Fatal()
+	assert.Equal(t, int64(0), stat["NameLookup"])
-	}
+	assert.Equal(t, int64(0), stat["Connect"])
-	if !assert.Equal(t, int64(0), stat["TLSHandshake"]) {
+	assert.Equal(t, int64(0), stat["Pretransfer"])
-		t.Fatal()
+	assert.Greater(t, stat["StartTransfer"], int64(0))
-	}
+	assert.Greater(t, stat["Total"], int64(1))
-	if !assert.Greater(t, stat["ServerProcessing"], int64(1)) {
+	assert.Less(t, stat["Total"]-summary.Records[0].Elapsed, int64(100))
-		t.Fatal()
-	}
-	if !assert.Equal(t, int64(0), stat["NameLookup"]) {
-		t.Fatal()
-	}
-	if !assert.Equal(t, int64(0), stat["Connect"]) {
-		t.Fatal()
-	}
-	if !assert.Equal(t, int64(0), stat["Pretransfer"]) {
-		t.Fatal()
-	}
-	if !assert.Greater(t, stat["StartTransfer"], int64(0)) {
-		t.Fatal()
-	}
-	if !assert.Greater(t, stat["Total"], int64(1)) {
-		t.Fatal()
-	}
-	if !assert.Less(t, stat["Total"]-summary.Records[0].Elapsed, int64(100)) {
-		t.Fatal()
-	}
 }
 
 func TestRunCaseWithTimeout(t *testing.T) {
@@ -175,9 +117,7 @@ func TestRunCaseWithTimeout(t *testing.T) {
 		},
 	}
 	err := r.Run(testcase1)
-	if !assert.NoError(t, err) { // assert no error
+	assert.Nil(t, err)
-		t.FailNow()
-	}
 
 	testcase2 := &hrp.TestCase{
 		Config: hrp.NewConfig("TestCase2").
@@ -191,9 +131,7 @@ func TestRunCaseWithTimeout(t *testing.T) {
 		},
 	}
 	err = r.Run(testcase2)
-	if !assert.Error(t, err) { // assert error
+	assert.Error(t, err)
-		t.FailNow()
-	}
 
 	// step timeout
 	testcase3 := &hrp.TestCase{
@@ -209,7 +147,5 @@ func TestRunCaseWithTimeout(t *testing.T) {
 		},
 	}
 	err = r.Run(testcase3)
-	if !assert.NoError(t, err) {
+	assert.Nil(t, err)
-		t.FailNow()
-	}
 }