Fixed assert statements. (#16089)

integrations/api_admin_test.go

@@ -195,7 +195,7 @@ func TestAPIEditUser(t *testing.T) {
 	assert.EqualValues(t, "email is not allowed to be empty string", errMap["message"].(string))
 
 	user2 := models.AssertExistsAndLoadBean(t, &models.User{LoginName: "user2"}).(*models.User)
-	assert.Equal(t, false, user2.IsRestricted)
+	assert.False(t, user2.IsRestricted)
 	bTrue := true
 	req = NewRequestWithJSON(t, "PATCH", urlStr, api.EditUserOption{
 		// required
@@ -206,5 +206,5 @@ func TestAPIEditUser(t *testing.T) {
 	})
 	session.MakeRequest(t, req, http.StatusOK)
 	user2 = models.AssertExistsAndLoadBean(t, &models.User{LoginName: "user2"}).(*models.User)
-	assert.Equal(t, true, user2.IsRestricted)
+	assert.True(t, user2.IsRestricted)
 }

integrations/api_gpg_keys_test.go

@@ -78,42 +78,42 @@ func TestGPGKeys(t *testing.T) {
 
 		primaryKey1 := keys[0] //Primary key 1
 		assert.EqualValues(t, "38EA3BCED732982C", primaryKey1.KeyID)
-		assert.EqualValues(t, 1, len(primaryKey1.Emails))
+		assert.Len(t, primaryKey1.Emails, 1)
 		assert.EqualValues(t, "user2@example.com", primaryKey1.Emails[0].Email)
-		assert.EqualValues(t, true, primaryKey1.Emails[0].Verified)
+		assert.True(t, primaryKey1.Emails[0].Verified)
 
 		subKey := primaryKey1.SubsKey[0] //Subkey of 38EA3BCED732982C
 		assert.EqualValues(t, "70D7C694D17D03AD", subKey.KeyID)
-		assert.EqualValues(t, 0, len(subKey.Emails))
+		assert.Empty(t, subKey.Emails)
 
 		primaryKey2 := keys[1] //Primary key 2
 		assert.EqualValues(t, "FABF39739FE1E927", primaryKey2.KeyID)
-		assert.EqualValues(t, 1, len(primaryKey2.Emails))
+		assert.Len(t, primaryKey2.Emails, 1)
 		assert.EqualValues(t, "user21@example.com", primaryKey2.Emails[0].Email)
-		assert.EqualValues(t, false, primaryKey2.Emails[0].Verified)
+		assert.False(t, primaryKey2.Emails[0].Verified)
 
 		var key api.GPGKey
 		req = NewRequest(t, "GET", "/api/v1/user/gpg_keys/"+strconv.FormatInt(primaryKey1.ID, 10)+"?token="+token) //Primary key 1
 		resp = session.MakeRequest(t, req, http.StatusOK)
 		DecodeJSON(t, resp, &key)
 		assert.EqualValues(t, "38EA3BCED732982C", key.KeyID)
-		assert.EqualValues(t, 1, len(key.Emails))
+		assert.Len(t, key.Emails, 1)
 		assert.EqualValues(t, "user2@example.com", key.Emails[0].Email)
-		assert.EqualValues(t, true, key.Emails[0].Verified)
+		assert.True(t, key.Emails[0].Verified)
 
 		req = NewRequest(t, "GET", "/api/v1/user/gpg_keys/"+strconv.FormatInt(subKey.ID, 10)+"?token="+token) //Subkey of 38EA3BCED732982C
 		resp = session.MakeRequest(t, req, http.StatusOK)
 		DecodeJSON(t, resp, &key)
 		assert.EqualValues(t, "70D7C694D17D03AD", key.KeyID)
-		assert.EqualValues(t, 0, len(key.Emails))
+		assert.Empty(t, key.Emails)
 
 		req = NewRequest(t, "GET", "/api/v1/user/gpg_keys/"+strconv.FormatInt(primaryKey2.ID, 10)+"?token="+token) //Primary key 2
 		resp = session.MakeRequest(t, req, http.StatusOK)
 		DecodeJSON(t, resp, &key)
 		assert.EqualValues(t, "FABF39739FE1E927", key.KeyID)
-		assert.EqualValues(t, 1, len(key.Emails))
+		assert.Len(t, key.Emails, 1)
 		assert.EqualValues(t, "user21@example.com", key.Emails[0].Email)
-		assert.EqualValues(t, false, key.Emails[0].Verified)
+		assert.False(t, key.Emails[0].Verified)
 
 	})
 
@@ -124,7 +124,7 @@ func TestGPGKeys(t *testing.T) {
 			req := NewRequest(t, "GET", "/api/v1/repos/user2/repo16/branches/not-signed?token="+token)
 			resp := session.MakeRequest(t, req, http.StatusOK)
 			DecodeJSON(t, resp, &branch)
-			assert.EqualValues(t, false, branch.Commit.Verification.Verified)
+			assert.False(t, branch.Commit.Verification.Verified)
 		})
 
 		t.Run("SignedWithNotValidatedEmail", func(t *testing.T) {
@@ -132,7 +132,7 @@ func TestGPGKeys(t *testing.T) {
 			req := NewRequest(t, "GET", "/api/v1/repos/user2/repo16/branches/good-sign-not-yet-validated?token="+token)
 			resp := session.MakeRequest(t, req, http.StatusOK)
 			DecodeJSON(t, resp, &branch)
-			assert.EqualValues(t, false, branch.Commit.Verification.Verified)
+			assert.False(t, branch.Commit.Verification.Verified)
 		})
 
 		t.Run("SignedWithValidEmail", func(t *testing.T) {
@@ -140,7 +140,7 @@ func TestGPGKeys(t *testing.T) {
 			req := NewRequest(t, "GET", "/api/v1/repos/user2/repo16/branches/good-sign?token="+token)
 			resp := session.MakeRequest(t, req, http.StatusOK)
 			DecodeJSON(t, resp, &branch)
-			assert.EqualValues(t, true, branch.Commit.Verification.Verified)
+			assert.True(t, branch.Commit.Verification.Verified)
 		})
 	})
 }

integrations/api_issue_test.go

@@ -65,8 +65,8 @@ func TestAPICreateIssue(t *testing.T) {
 	resp := session.MakeRequest(t, req, http.StatusCreated)
 	var apiIssue api.Issue
 	DecodeJSON(t, resp, &apiIssue)
-	assert.Equal(t, apiIssue.Body, body)
-	assert.Equal(t, apiIssue.Title, title)
+	assert.Equal(t, body, apiIssue.Body)
+	assert.Equal(t, title, apiIssue.Title)
 
 	models.AssertExistsAndLoadBean(t, &models.Issue{
 		RepoID:     repoBefore.ID,

integrations/api_notification_test.go

@@ -45,14 +45,14 @@ func TestAPINotification(t *testing.T) {
 
 	assert.Len(t, apiNL, 3)
 	assert.EqualValues(t, 4, apiNL[0].ID)
-	assert.EqualValues(t, true, apiNL[0].Unread)
-	assert.EqualValues(t, false, apiNL[0].Pinned)
+	assert.True(t, apiNL[0].Unread)
+	assert.False(t, apiNL[0].Pinned)
 	assert.EqualValues(t, 3, apiNL[1].ID)
-	assert.EqualValues(t, false, apiNL[1].Unread)
-	assert.EqualValues(t, true, apiNL[1].Pinned)
+	assert.False(t, apiNL[1].Unread)
+	assert.True(t, apiNL[1].Pinned)
 	assert.EqualValues(t, 2, apiNL[2].ID)
-	assert.EqualValues(t, false, apiNL[2].Unread)
-	assert.EqualValues(t, false, apiNL[2].Pinned)
+	assert.False(t, apiNL[2].Unread)
+	assert.False(t, apiNL[2].Pinned)
 
 	// -- GET /repos/{owner}/{repo}/notifications --
 	req = NewRequest(t, "GET", fmt.Sprintf("/api/v1/repos/%s/%s/notifications?status-types=unread&token=%s", user2.Name, repo1.Name, token))
@@ -74,8 +74,8 @@ func TestAPINotification(t *testing.T) {
 	DecodeJSON(t, resp, &apiN)
 
 	assert.EqualValues(t, 5, apiN.ID)
-	assert.EqualValues(t, false, apiN.Pinned)
-	assert.EqualValues(t, true, apiN.Unread)
+	assert.False(t, apiN.Pinned)
+	assert.True(t, apiN.Unread)
 	assert.EqualValues(t, "issue4", apiN.Subject.Title)
 	assert.EqualValues(t, "Issue", apiN.Subject.Type)
 	assert.EqualValues(t, thread5.Issue.APIURL(), apiN.Subject.URL)

integrations/api_oauth2_apps_test.go

@@ -123,7 +123,7 @@ func testAPIGetOAuth2Application(t *testing.T) {
 	assert.EqualValues(t, existApp.ClientID, expectedApp.ClientID)
 	assert.Len(t, expectedApp.ClientID, 36)
 	assert.Empty(t, expectedApp.ClientSecret)
-	assert.EqualValues(t, len(expectedApp.RedirectURIs), 1)
+	assert.Len(t, expectedApp.RedirectURIs, 1)
 	assert.EqualValues(t, existApp.RedirectURIs[0], expectedApp.RedirectURIs[0])
 	models.AssertExistsAndLoadBean(t, &models.OAuth2Application{ID: expectedApp.ID, Name: expectedApp.Name})
 }
@@ -156,7 +156,7 @@ func testAPIUpdateOAuth2Application(t *testing.T) {
 	DecodeJSON(t, resp, &app)
 	expectedApp := app
 
-	assert.EqualValues(t, len(expectedApp.RedirectURIs), 2)
+	assert.Len(t, expectedApp.RedirectURIs, 2)
 	assert.EqualValues(t, expectedApp.RedirectURIs[0], appBody.RedirectURIs[0])
 	assert.EqualValues(t, expectedApp.RedirectURIs[1], appBody.RedirectURIs[1])
 	models.AssertExistsAndLoadBean(t, &models.OAuth2Application{ID: expectedApp.ID, Name: expectedApp.Name})

integrations/api_org_test.go

@@ -69,7 +69,7 @@ func TestAPIOrgCreate(t *testing.T) {
 		// user1 on this org is public
 		var users []*api.User
 		DecodeJSON(t, resp, &users)
-		assert.EqualValues(t, 1, len(users))
+		assert.Len(t, users, 1)
 		assert.EqualValues(t, "user1", users[0].UserName)
 	})
 }

integrations/api_pull_review_test.go

@@ -37,15 +37,15 @@ func TestAPIPullReview(t *testing.T) {
 	assert.EqualValues(t, 8, reviews[3].ID)
 	assert.EqualValues(t, "APPROVED", reviews[3].State)
 	assert.EqualValues(t, 0, reviews[3].CodeCommentsCount)
-	assert.EqualValues(t, true, reviews[3].Stale)
-	assert.EqualValues(t, false, reviews[3].Official)
+	assert.True(t, reviews[3].Stale)
+	assert.False(t, reviews[3].Official)
 
 	assert.EqualValues(t, 10, reviews[5].ID)
 	assert.EqualValues(t, "REQUEST_CHANGES", reviews[5].State)
 	assert.EqualValues(t, 1, reviews[5].CodeCommentsCount)
 	assert.EqualValues(t, -1, reviews[5].Reviewer.ID) // ghost user
-	assert.EqualValues(t, false, reviews[5].Stale)
-	assert.EqualValues(t, true, reviews[5].Official)
+	assert.False(t, reviews[5].Stale)
+	assert.True(t, reviews[5].Official)
 
 	// test GetPullReview
 	req = NewRequestf(t, http.MethodGet, "/api/v1/repos/%s/%s/pulls/%d/reviews/%d?token=%s", repo.OwnerName, repo.Name, pullIssue.Index, reviews[3].ID, token)
@@ -118,14 +118,14 @@ func TestAPIPullReview(t *testing.T) {
 	resp = session.MakeRequest(t, req, http.StatusOK)
 	DecodeJSON(t, resp, &review)
 	assert.EqualValues(t, 6, review.ID)
-	assert.EqualValues(t, true, review.Dismissed)
+	assert.True(t, review.Dismissed)
 
 	// test dismiss review
 	req = NewRequest(t, http.MethodPost, fmt.Sprintf("/api/v1/repos/%s/%s/pulls/%d/reviews/%d/undismissals?token=%s", repo.OwnerName, repo.Name, pullIssue.Index, review.ID, token))
 	resp = session.MakeRequest(t, req, http.StatusOK)
 	DecodeJSON(t, resp, &review)
 	assert.EqualValues(t, 6, review.ID)
-	assert.EqualValues(t, false, review.Dismissed)
+	assert.False(t, review.Dismissed)
 
 	// test DeletePullReview
 	req = NewRequestWithJSON(t, http.MethodPost, fmt.Sprintf("/api/v1/repos/%s/%s/pulls/%d/reviews?token=%s", repo.OwnerName, repo.Name, pullIssue.Index, token), &api.CreatePullReviewOptions{
@@ -151,15 +151,15 @@ func TestAPIPullReview(t *testing.T) {
 	assert.EqualValues(t, 11, reviews[0].ID)
 	assert.EqualValues(t, "REQUEST_REVIEW", reviews[0].State)
 	assert.EqualValues(t, 0, reviews[0].CodeCommentsCount)
-	assert.EqualValues(t, false, reviews[0].Stale)
-	assert.EqualValues(t, true, reviews[0].Official)
+	assert.False(t, reviews[0].Stale)
+	assert.True(t, reviews[0].Official)
 	assert.EqualValues(t, "test_team", reviews[0].ReviewerTeam.Name)
 
 	assert.EqualValues(t, 12, reviews[1].ID)
 	assert.EqualValues(t, "REQUEST_REVIEW", reviews[1].State)
 	assert.EqualValues(t, 0, reviews[0].CodeCommentsCount)
-	assert.EqualValues(t, false, reviews[1].Stale)
-	assert.EqualValues(t, true, reviews[1].Official)
+	assert.False(t, reviews[1].Stale)
+	assert.True(t, reviews[1].Official)
 	assert.EqualValues(t, 1, reviews[1].Reviewer.ID)
 }
 

integrations/api_repo_tags_test.go

@@ -28,7 +28,7 @@ func TestAPIReposGetTags(t *testing.T) {
 	var tags []*api.Tag
 	DecodeJSON(t, resp, &tags)
 
-	assert.EqualValues(t, 1, len(tags))
+	assert.Len(t, tags, 1)
 	assert.Equal(t, "v1.1", tags[0].Name)
 	assert.Equal(t, "65f1bf27bc3bf70f64657658635e66094edbcb4d", tags[0].Commit.SHA)
 	assert.Equal(t, setting.AppURL+"api/v1/repos/user2/repo1/git/commits/65f1bf27bc3bf70f64657658635e66094edbcb4d", tags[0].Commit.URL)

integrations/api_repo_teams_test.go

@@ -33,12 +33,12 @@ func TestAPIRepoTeams(t *testing.T) {
 	DecodeJSON(t, res, &teams)
 	if assert.Len(t, teams, 2) {
 		assert.EqualValues(t, "Owners", teams[0].Name)
-		assert.EqualValues(t, false, teams[0].CanCreateOrgRepo)
+		assert.False(t, teams[0].CanCreateOrgRepo)
 		assert.EqualValues(t, []string{"repo.code", "repo.issues", "repo.pulls", "repo.releases", "repo.wiki", "repo.ext_wiki", "repo.ext_issues"}, teams[0].Units)
 		assert.EqualValues(t, "owner", teams[0].Permission)
 
 		assert.EqualValues(t, "test_team", teams[1].Name)
-		assert.EqualValues(t, false, teams[1].CanCreateOrgRepo)
+		assert.False(t, teams[1].CanCreateOrgRepo)
 		assert.EqualValues(t, []string{"repo.issues"}, teams[1].Units)
 		assert.EqualValues(t, "write", teams[1].Permission)
 	}

integrations/api_repo_topic_test.go

@@ -88,7 +88,7 @@ func TestAPIRepoTopic(t *testing.T) {
 	req = NewRequest(t, "GET", url)
 	res = session.MakeRequest(t, req, http.StatusOK)
 	DecodeJSON(t, res, &topics)
-	assert.Equal(t, 25, len(topics.TopicNames))
+	assert.Len(t, topics.TopicNames, 25)
 
 	// Test writing more topics than allowed
 	newTopics = append(newTopics, "t26")
@@ -115,7 +115,7 @@ func TestAPIRepoTopic(t *testing.T) {
 	req = NewRequest(t, "GET", url)
 	res = session.MakeRequest(t, req, http.StatusOK)
 	DecodeJSON(t, res, &topics)
-	assert.Equal(t, 0, len(topics.TopicNames))
+	assert.Empty(t, topics.TopicNames)
 
 	// Test add a topic to repo with write access (requires repo admin access)
 	req = NewRequestf(t, "PUT", "/api/v1/repos/%s/%s/topics/%s?token=%s", user3.Name, repo3.Name, "topicName", token4)

integrations/api_team_test.go

@@ -148,7 +148,7 @@ func TestAPITeamSearch(t *testing.T) {
 	resp := session.MakeRequest(t, req, http.StatusOK)
 	DecodeJSON(t, resp, &results)
 	assert.NotEmpty(t, results.Data)
-	assert.Equal(t, 1, len(results.Data))
+	assert.Len(t, results.Data, 1)
 	assert.Equal(t, "test_team", results.Data[0].Name)
 
 	// no access if not organization member

integrations/org_test.go

@@ -33,7 +33,7 @@ func TestOrgRepos(t *testing.T) {
 				htmlDoc := NewHTMLParser(t, resp.Body)
 
 				sel := htmlDoc.doc.Find("a.name")
-				assert.EqualValues(t, len(repos), len(sel.Nodes))
+				assert.Len(t, repos, len(sel.Nodes))
 				for i := 0; i < len(repos); i++ {
 					assert.EqualValues(t, repos[i], strings.TrimSpace(sel.Eq(i).Text()))
 				}

integrations/repo_commits_test.go

@@ -66,7 +66,7 @@ func doTestRepoCommitWithStatus(t *testing.T, state string, classes ...string) {
 	doc = NewHTMLParser(t, resp.Body)
 	// Check if commit status is displayed in message column
 	sel := doc.doc.Find("#commits-table tbody tr td.message a.commit-statuses-trigger i.commit-status")
-	assert.Equal(t, sel.Length(), 1)
+	assert.Equal(t, 1, sel.Length())
 	for _, class := range classes {
 		assert.True(t, sel.HasClass(class))
 	}

integrations/repo_test.go

@@ -154,12 +154,12 @@ func TestViewRepoWithSymlinks(t *testing.T) {
 		file := strings.Trim(s.Find("A").Text(), " \t\n")
 		return fmt.Sprintf("%s: %s", file, cls)
 	})
-	assert.Equal(t, len(items), 5)
-	assert.Equal(t, items[0], "a: svg octicon-file-directory")
-	assert.Equal(t, items[1], "link_b: svg octicon-file-submodule")
-	assert.Equal(t, items[2], "link_d: svg octicon-file-symlink-file")
-	assert.Equal(t, items[3], "link_hi: svg octicon-file-symlink-file")
-	assert.Equal(t, items[4], "link_link: svg octicon-file-symlink-file")
+	assert.Len(t, items, 5)
+	assert.Equal(t, "a: svg octicon-file-directory", items[0])
+	assert.Equal(t, "link_b: svg octicon-file-submodule", items[1])
+	assert.Equal(t, "link_d: svg octicon-file-symlink-file", items[2])
+	assert.Equal(t, "link_hi: svg octicon-file-symlink-file", items[3])
+	assert.Equal(t, "link_link: svg octicon-file-symlink-file", items[4])
 }
 
 // TestViewAsRepoAdmin tests PR #2167

models/attachment_test.go

@@ -61,11 +61,11 @@ func TestGetByCommentOrIssueID(t *testing.T) {
 	// count of attachments from issue ID
 	attachments, err := GetAttachmentsByIssueID(1)
 	assert.NoError(t, err)
-	assert.Equal(t, 1, len(attachments))
+	assert.Len(t, attachments, 1)
 
 	attachments, err = GetAttachmentsByCommentID(1)
 	assert.NoError(t, err)
-	assert.Equal(t, 2, len(attachments))
+	assert.Len(t, attachments, 2)
 }
 
 func TestDeleteAttachments(t *testing.T) {
@@ -122,7 +122,7 @@ func TestGetAttachmentsByUUIDs(t *testing.T) {
 
 	attachList, err := GetAttachmentsByUUIDs(DefaultDBContext(), []string{"a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11", "a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a17", "not-existing-uuid"})
 	assert.NoError(t, err)
-	assert.Equal(t, 2, len(attachList))
+	assert.Len(t, attachList, 2)
 	assert.Equal(t, "a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11", attachList[0].UUID)
 	assert.Equal(t, "a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a17", attachList[1].UUID)
 	assert.Equal(t, int64(1), attachList[0].IssueID)

models/issue_stopwatch_test.go

@@ -67,7 +67,7 @@ func TestCreateOrStopIssueStopwatch(t *testing.T) {
 
 	assert.NoError(t, CreateOrStopIssueStopwatch(user3, issue1))
 	sw := AssertExistsAndLoadBean(t, &Stopwatch{UserID: 3, IssueID: 1}).(*Stopwatch)
-	assert.Equal(t, true, sw.CreatedUnix <= timeutil.TimeStampNow())
+	assert.LessOrEqual(t, sw.CreatedUnix, timeutil.TimeStampNow())
 
 	assert.NoError(t, CreateOrStopIssueStopwatch(user2, issue2))
 	AssertNotExistsBean(t, &Stopwatch{UserID: 2, IssueID: 2})

models/issue_watch_test.go

@@ -32,7 +32,7 @@ func TestGetIssueWatch(t *testing.T) {
 	iw, exists, err := GetIssueWatch(2, 2)
 	assert.True(t, exists)
 	assert.NoError(t, err)
-	assert.EqualValues(t, false, iw.IsWatching)
+	assert.False(t, iw.IsWatching)
 
 	_, exists, err = GetIssueWatch(3, 1)
 	assert.False(t, exists)

models/issue_xref_test.go

@@ -25,7 +25,7 @@ func TestXRef_AddCrossReferences(t *testing.T) {
 	ref := AssertExistsAndLoadBean(t, &Comment{IssueID: itarget.ID, RefIssueID: pr.ID, RefCommentID: 0}).(*Comment)
 	assert.Equal(t, CommentTypePullRef, ref.Type)
 	assert.Equal(t, pr.RepoID, ref.RefRepoID)
-	assert.Equal(t, true, ref.RefIsPull)
+	assert.True(t, ref.RefIsPull)
 	assert.Equal(t, references.XRefActionCloses, ref.RefAction)
 
 	// Comment on PR to reopen issue #1
@@ -34,7 +34,7 @@ func TestXRef_AddCrossReferences(t *testing.T) {
 	ref = AssertExistsAndLoadBean(t, &Comment{IssueID: itarget.ID, RefIssueID: pr.ID, RefCommentID: c.ID}).(*Comment)
 	assert.Equal(t, CommentTypeCommentRef, ref.Type)
 	assert.Equal(t, pr.RepoID, ref.RefRepoID)
-	assert.Equal(t, true, ref.RefIsPull)
+	assert.True(t, ref.RefIsPull)
 	assert.Equal(t, references.XRefActionReopens, ref.RefAction)
 
 	// Issue mentioning issue #1
@@ -43,7 +43,7 @@ func TestXRef_AddCrossReferences(t *testing.T) {
 	ref = AssertExistsAndLoadBean(t, &Comment{IssueID: itarget.ID, RefIssueID: i.ID, RefCommentID: 0}).(*Comment)
 	assert.Equal(t, CommentTypeIssueRef, ref.Type)
 	assert.Equal(t, pr.RepoID, ref.RefRepoID)
-	assert.Equal(t, false, ref.RefIsPull)
+	assert.False(t, ref.RefIsPull)
 	assert.Equal(t, references.XRefActionNone, ref.RefAction)
 
 	// Issue #4 to test against
@@ -55,7 +55,7 @@ func TestXRef_AddCrossReferences(t *testing.T) {
 	ref = AssertExistsAndLoadBean(t, &Comment{IssueID: itarget.ID, RefIssueID: i.ID, RefCommentID: 0}).(*Comment)
 	assert.Equal(t, CommentTypeIssueRef, ref.Type)
 	assert.Equal(t, i.RepoID, ref.RefRepoID)
-	assert.Equal(t, false, ref.RefIsPull)
+	assert.False(t, ref.RefIsPull)
 	assert.Equal(t, references.XRefActionNone, ref.RefAction)
 
 	// Cross-reference to issue #4 with no permission

models/oauth2_application_test.go

@@ -219,11 +219,11 @@ func TestOAuth2AuthorizationCode_GenerateRedirectURI(t *testing.T) {
 
 	redirect, err := code.GenerateRedirectURI("thestate")
 	assert.NoError(t, err)
-	assert.Equal(t, redirect.String(), "https://example.com/callback?code=thecode&state=thestate")
+	assert.Equal(t, "https://example.com/callback?code=thecode&state=thestate", redirect.String())
 
 	redirect, err = code.GenerateRedirectURI("")
 	assert.NoError(t, err)
-	assert.Equal(t, redirect.String(), "https://example.com/callback?code=thecode")
+	assert.Equal(t, "https://example.com/callback?code=thecode", redirect.String())
 }
 
 func TestOAuth2AuthorizationCode_Invalidate(t *testing.T) {

models/org_test.go

@@ -453,7 +453,7 @@ func TestAddOrgUser(t *testing.T) {
 		assert.NoError(t, AddOrgUser(orgID, userID))
 		ou := &OrgUser{OrgID: orgID, UID: userID}
 		AssertExistsAndLoadBean(t, ou)
-		assert.Equal(t, ou.IsPublic, isPublic)
+		assert.Equal(t, isPublic, ou.IsPublic)
 		org = AssertExistsAndLoadBean(t, &User{ID: orgID}).(*User)
 		assert.EqualValues(t, expectedNumMembers, org.NumMembers)
 	}
@@ -589,9 +589,9 @@ func TestHasOrgVisibleTypePublic(t *testing.T) {
 	test1 := HasOrgVisible(org, owner)
 	test2 := HasOrgVisible(org, user3)
 	test3 := HasOrgVisible(org, nil)
-	assert.Equal(t, test1, true) // owner of org
-	assert.Equal(t, test2, true) // user not a part of org
-	assert.Equal(t, test3, true) // logged out user
+	assert.True(t, test1) // owner of org
+	assert.True(t, test2) // user not a part of org
+	assert.True(t, test3) // logged out user
 }
 
 func TestHasOrgVisibleTypeLimited(t *testing.T) {
@@ -612,9 +612,9 @@ func TestHasOrgVisibleTypeLimited(t *testing.T) {
 	test1 := HasOrgVisible(org, owner)
 	test2 := HasOrgVisible(org, user3)
 	test3 := HasOrgVisible(org, nil)
-	assert.Equal(t, test1, true)  // owner of org
-	assert.Equal(t, test2, true)  // user not a part of org
-	assert.Equal(t, test3, false) // logged out user
+	assert.True(t, test1)  // owner of org
+	assert.True(t, test2)  // user not a part of org
+	assert.False(t, test3) // logged out user
 }
 
 func TestHasOrgVisibleTypePrivate(t *testing.T) {
@@ -635,9 +635,9 @@ func TestHasOrgVisibleTypePrivate(t *testing.T) {
 	test1 := HasOrgVisible(org, owner)
 	test2 := HasOrgVisible(org, user3)
 	test3 := HasOrgVisible(org, nil)
-	assert.Equal(t, test1, true)  // owner of org
-	assert.Equal(t, test2, false) // user not a part of org
-	assert.Equal(t, test3, false) // logged out user
+	assert.True(t, test1)  // owner of org
+	assert.False(t, test2) // user not a part of org
+	assert.False(t, test3) // logged out user
 }
 
 func TestGetUsersWhoCanCreateOrgRepo(t *testing.T) {

models/repo_generate_test.go

@@ -25,7 +25,7 @@ text/*.txt
 
 func TestGiteaTemplate(t *testing.T) {
 	gt := GiteaTemplate{Content: giteaTemplate}
-	assert.Equal(t, len(gt.Globs()), 3)
+	assert.Len(t, gt.Globs(), 3)
 
 	tt := []struct {
 		Path  string

models/repo_test.go

@@ -61,8 +61,8 @@ func TestMetas(t *testing.T) {
 	metas = repo.ComposeMetas()
 	assert.Contains(t, metas, "org")
 	assert.Contains(t, metas, "teams")
-	assert.Equal(t, metas["org"], "user3")
-	assert.Equal(t, metas["teams"], ",owners,team1,")
+	assert.Equal(t, "user3", metas["org"])
+	assert.Equal(t, ",owners,team1,", metas["teams"])
 }
 
 func TestGetRepositoryCount(t *testing.T) {
@@ -111,7 +111,7 @@ func TestUpdateRepositoryVisibilityChanged(t *testing.T) {
 	_, err = x.ID(3).Get(&act)
 
 	assert.NoError(t, err)
-	assert.Equal(t, true, act.IsPrivate)
+	assert.True(t, act.IsPrivate)
 }
 
 func TestGetUserFork(t *testing.T) {
@@ -199,13 +199,13 @@ func TestRepoGetReviewers(t *testing.T) {
 
 	reviewers, err := repo1.GetReviewers(2, 2)
 	assert.NoError(t, err)
-	assert.Equal(t, 4, len(reviewers))
+	assert.Len(t, reviewers, 4)
 
 	// test private repo
 	repo2 := AssertExistsAndLoadBean(t, &Repository{ID: 2}).(*Repository)
 	reviewers, err = repo2.GetReviewers(2, 2)
 	assert.NoError(t, err)
-	assert.Equal(t, 0, len(reviewers))
+	assert.Empty(t, reviewers)
 }
 
 func TestRepoGetReviewerTeams(t *testing.T) {
@@ -219,5 +219,5 @@ func TestRepoGetReviewerTeams(t *testing.T) {
 	repo3 := AssertExistsAndLoadBean(t, &Repository{ID: 3}).(*Repository)
 	teams, err = repo3.GetReviewerTeams()
 	assert.NoError(t, err)
-	assert.Equal(t, 2, len(teams))
+	assert.Len(t, teams, 2)
 }

models/topic_test.go

@@ -19,31 +19,31 @@ func TestAddTopic(t *testing.T) {
 
 	topics, err := FindTopics(&FindTopicOptions{})
 	assert.NoError(t, err)
-	assert.EqualValues(t, totalNrOfTopics, len(topics))
+	assert.Len(t, topics, totalNrOfTopics)
 
 	topics, err = FindTopics(&FindTopicOptions{
 		ListOptions: ListOptions{Page: 1, PageSize: 2},
 	})
 	assert.NoError(t, err)
-	assert.EqualValues(t, 2, len(topics))
+	assert.Len(t, topics, 2)
 
 	topics, err = FindTopics(&FindTopicOptions{
 		RepoID: 1,
 	})
 	assert.NoError(t, err)
-	assert.EqualValues(t, repo1NrOfTopics, len(topics))
+	assert.Len(t, topics, repo1NrOfTopics)
 
 	assert.NoError(t, SaveTopics(2, "golang"))
 	repo2NrOfTopics = 1
 	topics, err = FindTopics(&FindTopicOptions{})
 	assert.NoError(t, err)
-	assert.EqualValues(t, totalNrOfTopics, len(topics))
+	assert.Len(t, topics, totalNrOfTopics)
 
 	topics, err = FindTopics(&FindTopicOptions{
 		RepoID: 2,
 	})
 	assert.NoError(t, err)
-	assert.EqualValues(t, repo2NrOfTopics, len(topics))
+	assert.Len(t, topics, repo2NrOfTopics)
 
 	assert.NoError(t, SaveTopics(2, "golang", "gitea"))
 	repo2NrOfTopics = 2
@@ -54,13 +54,13 @@ func TestAddTopic(t *testing.T) {
 
 	topics, err = FindTopics(&FindTopicOptions{})
 	assert.NoError(t, err)
-	assert.EqualValues(t, totalNrOfTopics, len(topics))
+	assert.Len(t, topics, totalNrOfTopics)
 
 	topics, err = FindTopics(&FindTopicOptions{
 		RepoID: 2,
 	})
 	assert.NoError(t, err)
-	assert.EqualValues(t, repo2NrOfTopics, len(topics))
+	assert.Len(t, topics, repo2NrOfTopics)
 }
 
 func TestTopicValidator(t *testing.T) {

models/user_heatmap_test.go

@@ -52,8 +52,8 @@ func TestGetUserHeatmapDataByUser(t *testing.T) {
 		// Get the heatmap and compare
 		heatmap, err := GetUserHeatmapDataByUser(user, doer)
 		assert.NoError(t, err)
-		assert.Equal(t, len(actions), len(heatmap), "invalid action count: did the test data became too old?")
-		assert.Equal(t, tc.CountResult, len(heatmap), fmt.Sprintf("testcase %d", i))
+		assert.Len(t, heatmap, len(actions), "invalid action count: did the test data became too old?")
+		assert.Len(t, heatmap, tc.CountResult, fmt.Sprintf("testcase %d", i))
 
 		// Test JSON rendering
 		json := jsoniter.ConfigCompatibleWithStandardLibrary

models/user_mail_test.go

@@ -129,14 +129,14 @@ func TestMakeEmailPrimary(t *testing.T) {
 	}
 	err := MakeEmailPrimary(email)
 	assert.Error(t, err)
-	assert.Equal(t, ErrEmailNotExist.Error(), err.Error())
+	assert.EqualError(t, err, ErrEmailNotExist.Error())
 
 	email = &EmailAddress{
 		Email: "user11@example.com",
 	}
 	err = MakeEmailPrimary(email)
 	assert.Error(t, err)
-	assert.Equal(t, ErrEmailNotActivated.Error(), err.Error())
+	assert.EqualError(t, err, ErrEmailNotActivated.Error())
 
 	email = &EmailAddress{
 		Email: "user9999999@example.com",
@@ -232,6 +232,6 @@ func TestListEmails(t *testing.T) {
 	}
 	emails, count, err = SearchEmails(opts)
 	assert.NoError(t, err)
-	assert.Equal(t, 5, len(emails))
-	assert.True(t, count > int64(len(emails)))
+	assert.Len(t, emails, 5)
+	assert.Greater(t, count, int64(len(emails)))
 }

models/user_openid_test.go

@@ -15,15 +15,15 @@ func TestGetUserOpenIDs(t *testing.T) {
 
 	oids, err := GetUserOpenIDs(int64(1))
 	if assert.NoError(t, err) && assert.Len(t, oids, 2) {
-		assert.Equal(t, oids[0].URI, "https://user1.domain1.tld/")
+		assert.Equal(t, "https://user1.domain1.tld/", oids[0].URI)
 		assert.False(t, oids[0].Show)
-		assert.Equal(t, oids[1].URI, "http://user1.domain2.tld/")
+		assert.Equal(t, "http://user1.domain2.tld/", oids[1].URI)
 		assert.True(t, oids[1].Show)
 	}
 
 	oids, err = GetUserOpenIDs(int64(2))
 	if assert.NoError(t, err) && assert.Len(t, oids, 1) {
-		assert.Equal(t, oids[0].URI, "https://domain1.tld/user2/")
+		assert.Equal(t, "https://domain1.tld/user2/", oids[0].URI)
 		assert.True(t, oids[0].Show)
 	}
 }
@@ -38,12 +38,12 @@ func TestGetUserByOpenID(t *testing.T) {
 
 	user, err := GetUserByOpenID("https://user1.domain1.tld")
 	if assert.NoError(t, err) {
-		assert.Equal(t, user.ID, int64(1))
+		assert.Equal(t, int64(1), user.ID)
 	}
 
 	user, err = GetUserByOpenID("https://domain1.tld/user2/")
 	if assert.NoError(t, err) {
-		assert.Equal(t, user.ID, int64(2))
+		assert.Equal(t, int64(2), user.ID)
 	}
 }
 

models/user_test.go

@@ -386,14 +386,14 @@ func TestGetMaileableUsersByIDs(t *testing.T) {
 
 	results, err := GetMaileableUsersByIDs([]int64{1, 4}, false)
 	assert.NoError(t, err)
-	assert.Equal(t, 1, len(results))
+	assert.Len(t, results, 1)
 	if len(results) > 1 {
 		assert.Equal(t, results[0].ID, 1)
 	}
 
 	results, err = GetMaileableUsersByIDs([]int64{1, 4}, true)
 	assert.NoError(t, err)
-	assert.Equal(t, 2, len(results))
+	assert.Len(t, results, 2)
 	if len(results) > 2 {
 		assert.Equal(t, results[0].ID, 1)
 		assert.Equal(t, results[1].ID, 4)
@@ -457,7 +457,7 @@ ssh-dss AAAAB3NzaC1kc3MAAACBAOChCC7lf6Uo9n7BmZ6M8St19PZf4Tn59NriyboW2x/DZuYAz3ib
 		if err != nil {
 			continue
 		}
-		assert.Equal(t, kase.number, len(keys))
+		assert.Len(t, keys, kase.number)
 
 		for _, key := range keys {
 			assert.Contains(t, kase.keyContents, key.Content)

modules/auth/pam/pam_test.go

@@ -15,6 +15,6 @@ import (
 func TestPamAuth(t *testing.T) {
 	result, err := Auth("gitea", "user1", "false-pwd")
 	assert.Error(t, err)
-	assert.EqualValues(t, "Authentication failure", err.Error())
+	assert.EqualError(t, err, "Authentication failure")
 	assert.Len(t, result, 0)
 }

modules/base/tool_test.go

@@ -223,9 +223,9 @@ func TestInt64sToMap(t *testing.T) {
 
 func TestInt64sContains(t *testing.T) {
 	assert.Equal(t, map[int64]bool{}, Int64sToMap([]int64{}))
-	assert.Equal(t, true, Int64sContains([]int64{6, 44324, 4324, 32, 1, 2323}, 1))
-	assert.Equal(t, true, Int64sContains([]int64{2323}, 2323))
-	assert.Equal(t, false, Int64sContains([]int64{6, 44324, 4324, 32, 1, 2323}, 232))
+	assert.True(t, Int64sContains([]int64{6, 44324, 4324, 32, 1, 2323}, 1))
+	assert.True(t, Int64sContains([]int64{2323}, 2323))
+	assert.False(t, Int64sContains([]int64{6, 44324, 4324, 32, 1, 2323}, 232))
 }
 
 func TestIsLetter(t *testing.T) {
@@ -249,7 +249,7 @@ func TestIsLetter(t *testing.T) {
 
 func TestSetupGiteaRoot(t *testing.T) {
 	_ = os.Setenv("GITEA_ROOT", "test")
-	assert.EqualValues(t, "test", SetupGiteaRoot())
+	assert.Equal(t, "test", SetupGiteaRoot())
 	_ = os.Setenv("GITEA_ROOT", "")
 	assert.NotEqual(t, "test", SetupGiteaRoot())
 }

modules/git/parse_nogogit_test.go

@@ -58,7 +58,7 @@ func TestParseTreeEntries(t *testing.T) {
 	for _, testCase := range testCases {
 		entries, err := ParseTreeEntries([]byte(testCase.Input))
 		assert.NoError(t, err)
-		assert.EqualValues(t, len(testCase.Expected), len(entries))
+		assert.Len(t, entries, len(testCase.Expected))
 		for i, entry := range entries {
 			assert.EqualValues(t, testCase.Expected[i].ID, entry.ID)
 			assert.EqualValues(t, testCase.Expected[i].name, entry.name)

modules/git/repo_commit_test.go

@@ -72,9 +72,9 @@ func TestIsCommitInBranch(t *testing.T) {
 
 	result, err := bareRepo1.IsCommitInBranch("2839944139e0de9737a044f78b0e4b40d989a9e3", "branch1")
 	assert.NoError(t, err)
-	assert.Equal(t, true, result)
+	assert.True(t, result)
 
 	result, err = bareRepo1.IsCommitInBranch("2839944139e0de9737a044f78b0e4b40d989a9e3", "branch2")
 	assert.NoError(t, err)
-	assert.Equal(t, false, result)
+	assert.False(t, result)
 }

modules/git/tree_entry_test.go

@@ -71,33 +71,33 @@ func TestFollowLink(t *testing.T) {
 	// should be able to dereference to target
 	target, err := lnk.FollowLink()
 	assert.NoError(t, err)
-	assert.Equal(t, target.Name(), "hello")
+	assert.Equal(t, "hello", target.Name())
 	assert.False(t, target.IsLink())
-	assert.Equal(t, target.ID.String(), "b14df6442ea5a1b382985a6549b85d435376c351")
+	assert.Equal(t, "b14df6442ea5a1b382985a6549b85d435376c351", target.ID.String())
 
 	// should error when called on normal file
 	target, err = commit.Tree.GetTreeEntryByPath("file1.txt")
 	assert.NoError(t, err)
 	_, err = target.FollowLink()
-	assert.Equal(t, err.Error(), "file1.txt: not a symlink")
+	assert.EqualError(t, err, "file1.txt: not a symlink")
 
 	// should error for broken links
 	target, err = commit.Tree.GetTreeEntryByPath("foo/broken_link")
 	assert.NoError(t, err)
 	assert.True(t, target.IsLink())
 	_, err = target.FollowLink()
-	assert.Equal(t, err.Error(), "broken_link: broken link")
+	assert.EqualError(t, err, "broken_link: broken link")
 
 	// should error for external links
 	target, err = commit.Tree.GetTreeEntryByPath("foo/outside_repo")
 	assert.NoError(t, err)
 	assert.True(t, target.IsLink())
 	_, err = target.FollowLink()
-	assert.Equal(t, err.Error(), "outside_repo: points outside of repo")
+	assert.EqualError(t, err, "outside_repo: points outside of repo")
 
 	// testing fix for short link bug
 	target, err = commit.Tree.GetTreeEntryByPath("foo/link_short")
 	assert.NoError(t, err)
 	_, err = target.FollowLink()
-	assert.Equal(t, err.Error(), "link_short: broken link")
+	assert.EqualError(t, err, "link_short: broken link")
 }

modules/indexer/code/indexer_test.go

@@ -67,7 +67,7 @@ func testIndexer(name string, t *testing.T, indexer Indexer) {
 				total, res, langs, err := indexer.Search(kw.RepoIDs, "", kw.Keyword, 1, 10, false)
 				assert.NoError(t, err)
 				assert.EqualValues(t, len(kw.IDs), total)
-				assert.EqualValues(t, kw.Langs, len(langs))
+				assert.Len(t, langs, kw.Langs)
 
 				var ids = make([]int64, 0, len(res))
 				for _, hit := range res {

modules/lfs/http_client_test.go

@@ -56,7 +56,7 @@ func TestHTTPClientDownload(t *testing.T) {
 			assert.NoError(t, err)
 
 			assert.Equal(t, "download", batchRequest.Operation)
-			assert.Equal(t, 1, len(batchRequest.Objects))
+			assert.Len(t, batchRequest.Objects, 1)
 			assert.Equal(t, oid, batchRequest.Objects[0].Oid)
 			assert.Equal(t, size, batchRequest.Objects[0].Size)
 

modules/lfs/pointer_test.go

@@ -15,16 +15,16 @@ import (
 func TestStringContent(t *testing.T) {
 	p := Pointer{Oid: "4d7a214614ab2935c943f9e0ff69d22eadbb8f32b1258daaa5e2ca24d17e2393", Size: 1234}
 	expected := "version https://git-lfs.github.com/spec/v1\noid sha256:4d7a214614ab2935c943f9e0ff69d22eadbb8f32b1258daaa5e2ca24d17e2393\nsize 1234\n"
-	assert.Equal(t, p.StringContent(), expected)
+	assert.Equal(t, expected, p.StringContent())
 }
 
 func TestRelativePath(t *testing.T) {
 	p := Pointer{Oid: "4d7a214614ab2935c943f9e0ff69d22eadbb8f32b1258daaa5e2ca24d17e2393"}
 	expected := path.Join("4d", "7a", "214614ab2935c943f9e0ff69d22eadbb8f32b1258daaa5e2ca24d17e2393")
-	assert.Equal(t, p.RelativePath(), expected)
+	assert.Equal(t, expected, p.RelativePath())
 
 	p2 := Pointer{Oid: "4d7a"}
-	assert.Equal(t, p2.RelativePath(), "4d7a")
+	assert.Equal(t, "4d7a", p2.RelativePath())
 }
 
 func TestIsValid(t *testing.T) {
@@ -48,8 +48,8 @@ func TestGeneratePointer(t *testing.T) {
 	p, err := GeneratePointer(strings.NewReader("Gitea"))
 	assert.NoError(t, err)
 	assert.True(t, p.IsValid())
-	assert.Equal(t, p.Oid, "94cb57646c54a297c9807697e80a30946f79a4b82cb079d2606847825b1812cc")
-	assert.Equal(t, p.Size, int64(5))
+	assert.Equal(t, "94cb57646c54a297c9807697e80a30946f79a4b82cb079d2606847825b1812cc", p.Oid)
+	assert.Equal(t, int64(5), p.Size)
 }
 
 func TestReadPointerFromBuffer(t *testing.T) {
@@ -84,20 +84,20 @@ func TestReadPointerFromBuffer(t *testing.T) {
 	p, err = ReadPointerFromBuffer([]byte("version https://git-lfs.github.com/spec/v1\noid sha256:4d7a214614ab2935c943f9e0ff69d22eadbb8f32b1258daaa5e2ca24d17e2393\nsize 1234\n"))
 	assert.NoError(t, err)
 	assert.True(t, p.IsValid())
-	assert.Equal(t, p.Oid, "4d7a214614ab2935c943f9e0ff69d22eadbb8f32b1258daaa5e2ca24d17e2393")
-	assert.Equal(t, p.Size, int64(1234))
+	assert.Equal(t, "4d7a214614ab2935c943f9e0ff69d22eadbb8f32b1258daaa5e2ca24d17e2393", p.Oid)
+	assert.Equal(t, int64(1234), p.Size)
 
 	p, err = ReadPointerFromBuffer([]byte("version https://git-lfs.github.com/spec/v1\noid sha256:4d7a214614ab2935c943f9e0ff69d22eadbb8f32b1258daaa5e2ca24d17e2393\nsize 1234\ntest"))
 	assert.NoError(t, err)
 	assert.True(t, p.IsValid())
-	assert.Equal(t, p.Oid, "4d7a214614ab2935c943f9e0ff69d22eadbb8f32b1258daaa5e2ca24d17e2393")
-	assert.Equal(t, p.Size, int64(1234))
+	assert.Equal(t, "4d7a214614ab2935c943f9e0ff69d22eadbb8f32b1258daaa5e2ca24d17e2393", p.Oid)
+	assert.Equal(t, int64(1234), p.Size)
 }
 
 func TestReadPointer(t *testing.T) {
 	p, err := ReadPointer(strings.NewReader("version https://git-lfs.github.com/spec/v1\noid sha256:4d7a214614ab2935c943f9e0ff69d22eadbb8f32b1258daaa5e2ca24d17e2393\nsize 1234\n"))
 	assert.NoError(t, err)
 	assert.True(t, p.IsValid())
-	assert.Equal(t, p.Oid, "4d7a214614ab2935c943f9e0ff69d22eadbb8f32b1258daaa5e2ca24d17e2393")
-	assert.Equal(t, p.Size, int64(1234))
+	assert.Equal(t, "4d7a214614ab2935c943f9e0ff69d22eadbb8f32b1258daaa5e2ca24d17e2393", p.Oid)
+	assert.Equal(t, int64(1234), p.Size)
 }

modules/log/console_test.go

@@ -48,7 +48,7 @@ func TestConsoleLoggerMinimalConfig(t *testing.T) {
 		assert.Equal(t, prefix, realCW.Prefix)
 		assert.Equal(t, "", string(written))
 		cw.Close()
-		assert.Equal(t, false, closed)
+		assert.False(t, closed)
 
 	}
 }
@@ -97,20 +97,20 @@ func TestConsoleLogger(t *testing.T) {
 	expected := fmt.Sprintf("%s%s %s:%d:%s [%c] %s\n", prefix, dateString, event.filename, event.line, event.caller, strings.ToUpper(event.level.String())[0], event.msg)
 	cw.LogEvent(&event)
 	assert.Equal(t, expected, string(written))
-	assert.Equal(t, false, closed)
+	assert.False(t, closed)
 	written = written[:0]
 
 	event.level = DEBUG
 	expected = ""
 	cw.LogEvent(&event)
 	assert.Equal(t, expected, string(written))
-	assert.Equal(t, false, closed)
+	assert.False(t, closed)
 
 	event.level = TRACE
 	expected = ""
 	cw.LogEvent(&event)
 	assert.Equal(t, expected, string(written))
-	assert.Equal(t, false, closed)
+	assert.False(t, closed)
 
 	nonMatchEvent := Event{
 		level:    INFO,
@@ -124,15 +124,15 @@ func TestConsoleLogger(t *testing.T) {
 	expected = ""
 	cw.LogEvent(&nonMatchEvent)
 	assert.Equal(t, expected, string(written))
-	assert.Equal(t, false, closed)
+	assert.False(t, closed)
 
 	event.level = WARN
 	expected = fmt.Sprintf("%s%s %s:%d:%s [%c] %s\n", prefix, dateString, event.filename, event.line, event.caller, strings.ToUpper(event.level.String())[0], event.msg)
 	cw.LogEvent(&event)
 	assert.Equal(t, expected, string(written))
-	assert.Equal(t, false, closed)
+	assert.False(t, closed)
 	written = written[:0]
 
 	cw.Close()
-	assert.Equal(t, false, closed)
+	assert.False(t, closed)
 }

modules/log/file_test.go

@@ -30,7 +30,7 @@ func TestFileLoggerFails(t *testing.T) {
 
 	fileLogger := NewFileLogger()
 	//realFileLogger, ok := fileLogger.(*FileLogger)
-	//assert.Equal(t, true, ok)
+	//assert.True(t, ok)
 
 	// Fail if there is bad json
 	err = fileLogger.Init("{")
@@ -161,7 +161,7 @@ func TestCompressFileLogger(t *testing.T) {
 
 	fileLogger := NewFileLogger()
 	realFileLogger, ok := fileLogger.(*FileLogger)
-	assert.Equal(t, true, ok)
+	assert.True(t, ok)
 
 	location, _ := time.LoadLocation("EST")
 

modules/log/log_test.go

@@ -26,9 +26,9 @@ func baseConsoleTest(t *testing.T, logger *MultiChannelledLogger) (chan []byte,
 	channelledLog := m.GetEventLogger("console")
 	assert.NotEmpty(t, channelledLog)
 	realChanLog, ok := channelledLog.(*ChannelledLog)
-	assert.Equal(t, true, ok)
+	assert.True(t, ok)
 	realCL, ok := realChanLog.loggerProvider.(*ConsoleLogger)
-	assert.Equal(t, true, ok)
+	assert.True(t, ok)
 	assert.Equal(t, INFO, realCL.Level)
 	realCL.out = c
 
@@ -38,20 +38,20 @@ func baseConsoleTest(t *testing.T, logger *MultiChannelledLogger) (chan []byte,
 	logger.Log(0, INFO, format, args...)
 	line := <-written
 	assert.Contains(t, string(line), fmt.Sprintf(format, args...))
-	assert.Equal(t, false, <-closed)
+	assert.False(t, <-closed)
 
 	format = "test2: %s"
 	logger.Warn(format, args...)
 	line = <-written
 
 	assert.Contains(t, string(line), fmt.Sprintf(format, args...))
-	assert.Equal(t, false, <-closed)
+	assert.False(t, <-closed)
 
 	format = "testerror: %s"
 	logger.Error(format, args...)
 	line = <-written
 	assert.Contains(t, string(line), fmt.Sprintf(format, args...))
-	assert.Equal(t, false, <-closed)
+	assert.False(t, <-closed)
 	return written, closed
 }
 
@@ -63,7 +63,7 @@ func TestNewLoggerUnexported(t *testing.T) {
 	out := logger.MultiChannelledLog.GetEventLogger("console")
 	assert.NotEmpty(t, out)
 	chanlog, ok := out.(*ChannelledLog)
-	assert.Equal(t, true, ok)
+	assert.True(t, ok)
 	assert.Equal(t, "console", chanlog.provider)
 	assert.Equal(t, INFO, logger.GetLevel())
 	baseConsoleTest(t, logger)
@@ -74,11 +74,11 @@ func TestNewLoggger(t *testing.T) {
 	logger := NewLogger(0, "console", "console", fmt.Sprintf(`{"level":"%s"}`, level.String()))
 
 	assert.Equal(t, INFO, GetLevel())
-	assert.Equal(t, false, IsTrace())
-	assert.Equal(t, false, IsDebug())
-	assert.Equal(t, true, IsInfo())
-	assert.Equal(t, true, IsWarn())
-	assert.Equal(t, true, IsError())
+	assert.False(t, IsTrace())
+	assert.False(t, IsDebug())
+	assert.True(t, IsInfo())
+	assert.True(t, IsWarn())
+	assert.True(t, IsError())
 
 	written, closed := baseConsoleTest(t, logger)
 
@@ -88,17 +88,17 @@ func TestNewLoggger(t *testing.T) {
 	Log(0, INFO, format, args...)
 	line := <-written
 	assert.Contains(t, string(line), fmt.Sprintf(format, args...))
-	assert.Equal(t, false, <-closed)
+	assert.False(t, <-closed)
 
 	Info(format, args...)
 	line = <-written
 	assert.Contains(t, string(line), fmt.Sprintf(format, args...))
-	assert.Equal(t, false, <-closed)
+	assert.False(t, <-closed)
 
 	go DelLogger("console")
 	line = <-written
 	assert.Equal(t, "", string(line))
-	assert.Equal(t, true, <-closed)
+	assert.True(t, <-closed)
 }
 
 func TestNewLogggerRecreate(t *testing.T) {
@@ -106,11 +106,11 @@ func TestNewLogggerRecreate(t *testing.T) {
 	NewLogger(0, "console", "console", fmt.Sprintf(`{"level":"%s"}`, level.String()))
 
 	assert.Equal(t, INFO, GetLevel())
-	assert.Equal(t, false, IsTrace())
-	assert.Equal(t, false, IsDebug())
-	assert.Equal(t, true, IsInfo())
-	assert.Equal(t, true, IsWarn())
-	assert.Equal(t, true, IsError())
+	assert.False(t, IsTrace())
+	assert.False(t, IsDebug())
+	assert.True(t, IsInfo())
+	assert.True(t, IsWarn())
+	assert.True(t, IsError())
 
 	format := "test: %s"
 	args := []interface{}{"A"}
@@ -120,11 +120,11 @@ func TestNewLogggerRecreate(t *testing.T) {
 	NewLogger(0, "console", "console", fmt.Sprintf(`{"level":"%s"}`, level.String()))
 
 	assert.Equal(t, INFO, GetLevel())
-	assert.Equal(t, false, IsTrace())
-	assert.Equal(t, false, IsDebug())
-	assert.Equal(t, true, IsInfo())
-	assert.Equal(t, true, IsWarn())
-	assert.Equal(t, true, IsError())
+	assert.False(t, IsTrace())
+	assert.False(t, IsDebug())
+	assert.True(t, IsInfo())
+	assert.True(t, IsWarn())
+	assert.True(t, IsError())
 
 	Log(0, INFO, format, args...)
 
@@ -150,5 +150,5 @@ func TestNewNamedLogger(t *testing.T) {
 	go DelNamedLogger("test")
 	line := <-written
 	assert.Equal(t, "", string(line))
-	assert.Equal(t, true, <-closed)
+	assert.True(t, <-closed)
 }

modules/log/smtp_test.go

@@ -26,7 +26,7 @@ func TestSMTPLogger(t *testing.T) {
 
 	logger := NewSMTPLogger()
 	smtpLogger, ok := logger.(*SMTPLogger)
-	assert.Equal(t, true, ok)
+	assert.True(t, ok)
 
 	err := logger.Init(fmt.Sprintf("{\"prefix\":\"%s\",\"level\":\"%s\",\"flags\":%d,\"username\":\"%s\",\"password\":\"%s\",\"host\":\"%s\",\"subject\":\"%s\",\"sendTos\":[\"%s\",\"%s\"]}", prefix, level.String(), flags, username, password, host, subject, sendTos[0], sendTos[1]))
 	assert.NoError(t, err)

modules/log/writer_test.go

@@ -64,44 +64,44 @@ func TestBaseLogger(t *testing.T) {
 	expected := fmt.Sprintf("%s%s %s:%d:%s [%c] %s\n", prefix, dateString, event.filename, event.line, event.caller, strings.ToUpper(event.level.String())[0], event.msg)
 	b.LogEvent(&event)
 	assert.Equal(t, expected, string(written))
-	assert.Equal(t, false, closed)
+	assert.False(t, closed)
 	written = written[:0]
 
 	event.level = DEBUG
 	expected = ""
 	b.LogEvent(&event)
 	assert.Equal(t, expected, string(written))
-	assert.Equal(t, false, closed)
+	assert.False(t, closed)
 
 	event.level = TRACE
 	expected = ""
 	b.LogEvent(&event)
 	assert.Equal(t, expected, string(written))
-	assert.Equal(t, false, closed)
+	assert.False(t, closed)
 
 	event.level = WARN
 	expected = fmt.Sprintf("%s%s %s:%d:%s [%c] %s\n", prefix, dateString, event.filename, event.line, event.caller, strings.ToUpper(event.level.String())[0], event.msg)
 	b.LogEvent(&event)
 	assert.Equal(t, expected, string(written))
-	assert.Equal(t, false, closed)
+	assert.False(t, closed)
 	written = written[:0]
 
 	event.level = ERROR
 	expected = fmt.Sprintf("%s%s %s:%d:%s [%c] %s\n", prefix, dateString, event.filename, event.line, event.caller, strings.ToUpper(event.level.String())[0], event.msg)
 	b.LogEvent(&event)
 	assert.Equal(t, expected, string(written))
-	assert.Equal(t, false, closed)
+	assert.False(t, closed)
 	written = written[:0]
 
 	event.level = CRITICAL
 	expected = fmt.Sprintf("%s%s %s:%d:%s [%c] %s\n", prefix, dateString, event.filename, event.line, event.caller, strings.ToUpper(event.level.String())[0], event.msg)
 	b.LogEvent(&event)
 	assert.Equal(t, expected, string(written))
-	assert.Equal(t, false, closed)
+	assert.False(t, closed)
 	written = written[:0]
 
 	b.Close()
-	assert.Equal(t, true, closed)
+	assert.True(t, closed)
 }
 
 func TestBaseLoggerDated(t *testing.T) {
@@ -142,46 +142,46 @@ func TestBaseLoggerDated(t *testing.T) {
 	expected := fmt.Sprintf("%s%s %s:%d [%s] %s", prefix, dateString, "FILENAME", event.line, strings.ToUpper(event.level.String()), event.msg)
 	b.LogEvent(&event)
 	assert.Equal(t, expected, string(written))
-	assert.Equal(t, false, closed)
+	assert.False(t, closed)
 	written = written[:0]
 
 	event.level = INFO
 	expected = ""
 	b.LogEvent(&event)
 	assert.Equal(t, expected, string(written))
-	assert.Equal(t, false, closed)
+	assert.False(t, closed)
 	written = written[:0]
 
 	event.level = ERROR
 	expected = fmt.Sprintf("%s%s %s:%d [%s] %s", prefix, dateString, "FILENAME", event.line, strings.ToUpper(event.level.String()), event.msg)
 	b.LogEvent(&event)
 	assert.Equal(t, expected, string(written))
-	assert.Equal(t, false, closed)
+	assert.False(t, closed)
 	written = written[:0]
 
 	event.level = DEBUG
 	expected = ""
 	b.LogEvent(&event)
 	assert.Equal(t, expected, string(written))
-	assert.Equal(t, false, closed)
+	assert.False(t, closed)
 	written = written[:0]
 
 	event.level = CRITICAL
 	expected = fmt.Sprintf("%s%s %s:%d [%s] %s", prefix, dateString, "FILENAME", event.line, strings.ToUpper(event.level.String()), event.msg)
 	b.LogEvent(&event)
 	assert.Equal(t, expected, string(written))
-	assert.Equal(t, false, closed)
+	assert.False(t, closed)
 	written = written[:0]
 
 	event.level = TRACE
 	expected = ""
 	b.LogEvent(&event)
 	assert.Equal(t, expected, string(written))
-	assert.Equal(t, false, closed)
+	assert.False(t, closed)
 	written = written[:0]
 
 	b.Close()
-	assert.Equal(t, true, closed)
+	assert.True(t, closed)
 }
 
 func TestBaseLoggerMultiLineNoFlagsRegexp(t *testing.T) {
@@ -222,20 +222,20 @@ func TestBaseLoggerMultiLineNoFlagsRegexp(t *testing.T) {
 	expected := "TEST\n\tMESSAGE\n\tTEST\n"
 	b.LogEvent(&event)
 	assert.Equal(t, expected, string(written))
-	assert.Equal(t, false, closed)
+	assert.False(t, closed)
 	written = written[:0]
 
 	event.filename = "ELSEWHERE"
 
 	b.LogEvent(&event)
 	assert.Equal(t, "", string(written))
-	assert.Equal(t, false, closed)
+	assert.False(t, closed)
 	written = written[:0]
 
 	event.caller = "FILENAME"
 	b.LogEvent(&event)
 	assert.Equal(t, expected, string(written))
-	assert.Equal(t, false, closed)
+	assert.False(t, closed)
 	written = written[:0]
 
 	event = Event{
@@ -249,9 +249,8 @@ func TestBaseLoggerMultiLineNoFlagsRegexp(t *testing.T) {
 	expected = "TEST\n\tFILENAME\n\tTEST\n"
 	b.LogEvent(&event)
 	assert.Equal(t, expected, string(written))
-	assert.Equal(t, false, closed)
+	assert.False(t, closed)
 	written = written[:0]
-
 }
 
 func TestBrokenRegexp(t *testing.T) {
@@ -273,5 +272,5 @@ func TestBrokenRegexp(t *testing.T) {
 	b.NewWriterLogger(c)
 	assert.Empty(t, b.regexp)
 	b.Close()
-	assert.Equal(t, true, closed)
+	assert.True(t, closed)
 }

modules/markup/markdown/meta_test.go

@@ -18,7 +18,7 @@ func TestExtractMetadata(t *testing.T) {
 		var meta structs.IssueTemplate
 		body, err := ExtractMetadata(fmt.Sprintf("%s\n%s\n%s\n%s", sepTest, frontTest, sepTest, bodyTest), &meta)
 		assert.NoError(t, err)
-		assert.Equal(t, body, bodyTest)
+		assert.Equal(t, bodyTest, body)
 		assert.Equal(t, metaTest, meta)
 		assert.True(t, meta.Valid())
 	})
@@ -39,7 +39,7 @@ func TestExtractMetadata(t *testing.T) {
 		var meta structs.IssueTemplate
 		body, err := ExtractMetadata(fmt.Sprintf("%s\n%s\n%s", sepTest, frontTest, sepTest), &meta)
 		assert.NoError(t, err)
-		assert.Equal(t, body, "")
+		assert.Equal(t, "", body)
 		assert.Equal(t, metaTest, meta)
 		assert.True(t, meta.Valid())
 	})

modules/migrations/gitea_downloader_test.go

@@ -158,13 +158,13 @@ func TestGiteaDownloadRepo(t *testing.T) {
 
 	issues, isEnd, err := downloader.GetIssues(1, 50)
 	assert.NoError(t, err)
-	assert.EqualValues(t, 7, len(issues))
+	assert.Len(t, issues, 7)
 	assert.True(t, isEnd)
 	assert.EqualValues(t, "open", issues[0].State)
 
 	issues, isEnd, err = downloader.GetIssues(3, 2)
 	assert.NoError(t, err)
-	assert.EqualValues(t, 2, len(issues))
+	assert.Len(t, issues, 2)
 	assert.False(t, isEnd)
 
 	var (

modules/migrations/gitea_uploader_test.go

@@ -59,18 +59,18 @@ func TestGiteaUploadRepo(t *testing.T) {
 		State:  structs.StateOpen,
 	})
 	assert.NoError(t, err)
-	assert.EqualValues(t, 1, len(milestones))
+	assert.Len(t, milestones, 1)
 
 	milestones, err = models.GetMilestones(models.GetMilestonesOption{
 		RepoID: repo.ID,
 		State:  structs.StateClosed,
 	})
 	assert.NoError(t, err)
-	assert.EqualValues(t, 0, len(milestones))
+	assert.Empty(t, milestones)
 
 	labels, err := models.GetLabelsByRepoID(repo.ID, "", models.ListOptions{})
 	assert.NoError(t, err)
-	assert.EqualValues(t, 11, len(labels))
+	assert.Len(t, labels, 11)
 
 	releases, err := models.GetReleasesByRepoID(repo.ID, models.FindReleasesOptions{
 		ListOptions: models.ListOptions{
@@ -80,7 +80,7 @@ func TestGiteaUploadRepo(t *testing.T) {
 		IncludeTags: true,
 	})
 	assert.NoError(t, err)
-	assert.EqualValues(t, 8, len(releases))
+	assert.Len(t, releases, 8)
 
 	releases, err = models.GetReleasesByRepoID(repo.ID, models.FindReleasesOptions{
 		ListOptions: models.ListOptions{
@@ -90,7 +90,7 @@ func TestGiteaUploadRepo(t *testing.T) {
 		IncludeTags: false,
 	})
 	assert.NoError(t, err)
-	assert.EqualValues(t, 1, len(releases))
+	assert.Len(t, releases, 1)
 
 	issues, err := models.Issues(&models.IssuesOptions{
 		RepoIDs:  []int64{repo.ID},
@@ -98,16 +98,16 @@ func TestGiteaUploadRepo(t *testing.T) {
 		SortType: "oldest",
 	})
 	assert.NoError(t, err)
-	assert.EqualValues(t, 14, len(issues))
+	assert.Len(t, issues, 14)
 	assert.NoError(t, issues[0].LoadDiscussComments())
-	assert.EqualValues(t, 0, len(issues[0].Comments))
+	assert.Empty(t, issues[0].Comments)
 
 	pulls, _, err := models.PullRequests(repo.ID, &models.PullRequestsOptions{
 		SortType: "oldest",
 	})
 	assert.NoError(t, err)
-	assert.EqualValues(t, 34, len(pulls))
+	assert.Len(t, pulls, 34)
 	assert.NoError(t, pulls[0].LoadIssue())
 	assert.NoError(t, pulls[0].Issue.LoadDiscussComments())
-	assert.EqualValues(t, 2, len(pulls[0].Issue.Comments))
+	assert.Len(t, pulls[0].Issue.Comments, 2)
 }

modules/migrations/github_test.go

@@ -147,7 +147,7 @@ func TestGitHubDownloadRepo(t *testing.T) {
 	// downloader.GetIssues()
 	issues, isEnd, err := downloader.GetIssues(1, 2)
 	assert.NoError(t, err)
-	assert.EqualValues(t, 2, len(issues))
+	assert.Len(t, issues, 2)
 	assert.False(t, isEnd)
 
 	var (
@@ -242,7 +242,7 @@ func TestGitHubDownloadRepo(t *testing.T) {
 	// downloader.GetComments()
 	comments, err := downloader.GetComments(2)
 	assert.NoError(t, err)
-	assert.EqualValues(t, 2, len(comments))
+	assert.Len(t, comments, 2)
 	assert.EqualValues(t, []*base.Comment{
 		{
 			IssueIndex: 2,
@@ -273,7 +273,7 @@ func TestGitHubDownloadRepo(t *testing.T) {
 	// downloader.GetPullRequests()
 	prs, _, err := downloader.GetPullRequests(1, 2)
 	assert.NoError(t, err)
-	assert.EqualValues(t, 2, len(prs))
+	assert.Len(t, prs, 2)
 
 	closed1 = time.Date(2019, 11, 12, 21, 39, 27, 0, time.UTC)
 	var merged1 = time.Date(2019, 11, 12, 21, 39, 27, 0, time.UTC)

modules/migrations/gitlab_test.go

@@ -115,7 +115,7 @@ func TestGitlabDownloadRepo(t *testing.T) {
 
 	issues, isEnd, err := downloader.GetIssues(1, 2)
 	assert.NoError(t, err)
-	assert.EqualValues(t, 2, len(issues))
+	assert.Len(t, issues, 2)
 	assert.False(t, isEnd)
 
 	var (
@@ -206,7 +206,7 @@ func TestGitlabDownloadRepo(t *testing.T) {
 
 	comments, err := downloader.GetComments(2)
 	assert.NoError(t, err)
-	assert.EqualValues(t, 4, len(comments))
+	assert.Len(t, comments, 4)
 	assert.EqualValues(t, []*base.Comment{
 		{
 			IssueIndex: 2,

modules/migrations/gogs_test.go

@@ -80,7 +80,7 @@ func TestGogsDownloadRepo(t *testing.T) {
 	// downloader.GetIssues()
 	issues, isEnd, err := downloader.GetIssues(1, 8)
 	assert.NoError(t, err)
-	assert.EqualValues(t, 1, len(issues))
+	assert.Len(t, issues, 1)
 	assert.False(t, isEnd)
 
 	assert.EqualValues(t, []*base.Issue{
@@ -105,7 +105,7 @@ func TestGogsDownloadRepo(t *testing.T) {
 	// downloader.GetComments()
 	comments, err := downloader.GetComments(1)
 	assert.NoError(t, err)
-	assert.EqualValues(t, 1, len(comments))
+	assert.Len(t, comments, 1)
 	assert.EqualValues(t, []*base.Comment{
 		{
 			PosterName:  "lunny",

modules/password/password_test.go

@@ -54,7 +54,7 @@ func TestComplexity_Generate(t *testing.T) {
 		for i := 0; i < maxCount; i++ {
 			pwd, err := Generate(pwdLen)
 			assert.NoError(t, err)
-			assert.Equal(t, pwdLen, len(pwd))
+			assert.Len(t, pwd, pwdLen)
 			assert.True(t, IsComplexEnough(pwd), "Failed complexities with modes %+v for generated: %s", modes, pwd)
 		}
 	}

modules/queue/queue_channel_test.go

@@ -36,7 +36,7 @@ func TestChannelQueue(t *testing.T) {
 		}, &testData{})
 	assert.NoError(t, err)
 
-	assert.Equal(t, queue.(*ChannelQueue).WorkerPool.boostWorkers, 5)
+	assert.Equal(t, 5, queue.(*ChannelQueue).WorkerPool.boostWorkers)
 
 	go queue.Run(nilFn, nilFn)
 

modules/repository/commits_test.go

@@ -51,7 +51,7 @@ func TestPushCommits_ToAPIPayloadCommits(t *testing.T) {
 	repo := models.AssertExistsAndLoadBean(t, &models.Repository{ID: 16}).(*models.Repository)
 	payloadCommits, err := pushCommits.ToAPIPayloadCommits(repo.RepoPath(), "/user2/repo16")
 	assert.NoError(t, err)
-	assert.EqualValues(t, 3, len(payloadCommits))
+	assert.Len(t, payloadCommits, 3)
 
 	assert.Equal(t, "69554a6", payloadCommits[0].ID)
 	assert.Equal(t, "not signed commit", payloadCommits[0].Message)

modules/repository/create_test.go

@@ -21,7 +21,7 @@ func TestIncludesAllRepositoriesTeams(t *testing.T) {
 		team := models.AssertExistsAndLoadBean(t, &models.Team{ID: teamID}).(*models.Team)
 		assert.NoError(t, team.GetRepositories(&models.SearchTeamOptions{}), "%s: GetRepositories", team.Name)
 		assert.Len(t, team.Repos, team.NumRepos, "%s: len repo", team.Name)
-		assert.Equal(t, len(repoIds), len(team.Repos), "%s: repo count", team.Name)
+		assert.Len(t, team.Repos, len(repoIds), "%s: repo count", team.Name)
 		for i, rid := range repoIds {
 			if rid > 0 {
 				assert.True(t, team.HasRepository(rid), "%s: HasRepository(%d) %d", rid, i)

routers/repo/wiki_test.go

@@ -64,7 +64,7 @@ func assertPagesMetas(t *testing.T, expectedNames []string, metas interface{}) {
 	if !assert.True(t, ok) {
 		return
 	}
-	if !assert.EqualValues(t, len(expectedNames), len(pageMetas)) {
+	if !assert.Len(t, pageMetas, len(expectedNames)) {
 		return
 	}
 	for i, pageMeta := range pageMetas {

routers/user/home_test.go

@@ -33,9 +33,9 @@ func TestArchivedIssues(t *testing.T) {
 		IsArchived[repo.ID] = repo.IsArchived
 		NumIssues[repo.ID] = repo.NumIssues
 	}
-	assert.EqualValues(t, false, IsArchived[50])
+	assert.False(t, IsArchived[50])
 	assert.EqualValues(t, 1, NumIssues[50])
-	assert.EqualValues(t, true, IsArchived[51])
+	assert.True(t, IsArchived[51])
 	assert.EqualValues(t, 1, NumIssues[51])
 
 	// Act

services/archiver/archiver_test.go

@@ -35,7 +35,7 @@ func waitForCount(t *testing.T, num int) {
 		}
 	}
 
-	assert.Equal(t, num, len(archiveInProgress))
+	assert.Len(t, archiveInProgress, num)
 }
 
 func releaseOneEntry(t *testing.T, inFlight []*ArchiveRequest) {
@@ -128,7 +128,7 @@ func TestArchive_Basic(t *testing.T) {
 
 	// Sleep two seconds to make sure the queue doesn't change.
 	time.Sleep(2 * time.Second)
-	assert.Equal(t, 3, len(archiveInProgress))
+	assert.Len(t, archiveInProgress, 3)
 
 	// Release them all, they'll then stall at the archiveQueueReleaseCond while
 	// we examine the queue state.
@@ -160,7 +160,7 @@ func TestArchive_Basic(t *testing.T) {
 
 	// Queues should not have drained yet, because we haven't released them.
 	// Do so now.
-	assert.Equal(t, 3, len(archiveInProgress))
+	assert.Len(t, archiveInProgress, 3)
 
 	zipReq2 := DeriveRequestFrom(ctx, firstCommit+".zip")
 	// This zipReq should match what's sitting in the queue, as we haven't
@@ -174,15 +174,15 @@ func TestArchive_Basic(t *testing.T) {
 	ArchiveRepository(zipReq2)
 
 	// Make sure the queue hasn't grown any.
-	assert.Equal(t, 3, len(archiveInProgress))
+	assert.Len(t, archiveInProgress, 3)
 
 	// Make sure the queue drains properly
 	releaseOneEntry(t, inFlight)
-	assert.Equal(t, 2, len(archiveInProgress))
+	assert.Len(t, archiveInProgress, 2)
 	releaseOneEntry(t, inFlight)
-	assert.Equal(t, 1, len(archiveInProgress))
+	assert.Len(t, archiveInProgress, 1)
 	releaseOneEntry(t, inFlight)
-	assert.Equal(t, 0, len(archiveInProgress))
+	assert.Empty(t, archiveInProgress)
 
 	// Now we'll submit a request and TimedWaitForCompletion twice, before and
 	// after we release it.  We should trigger both the timeout and non-timeout
@@ -194,8 +194,8 @@ func TestArchive_Basic(t *testing.T) {
 
 	// Guaranteed to timeout; we haven't signalled the request to start..
 	completed, timedout = timedReq.TimedWaitForCompletion(ctx, 2*time.Second)
-	assert.Equal(t, false, completed)
-	assert.Equal(t, true, timedout)
+	assert.False(t, completed)
+	assert.True(t, timedout)
 
 	queueMutex.Lock()
 	archiveQueueStartCond.Broadcast()
@@ -203,8 +203,8 @@ func TestArchive_Basic(t *testing.T) {
 
 	// Shouldn't timeout, we've now signalled it and it's a small request.
 	completed, timedout = timedReq.TimedWaitForCompletion(ctx, 15*time.Second)
-	assert.Equal(t, true, completed)
-	assert.Equal(t, false, timedout)
+	assert.True(t, completed)
+	assert.False(t, timedout)
 
 	zipReq2 = DeriveRequestFrom(ctx, firstCommit+".zip")
 	// Now, we're guaranteed to have released the original zipReq from the queue.

services/gitdiff/csv_test.go

@@ -110,13 +110,13 @@ func TestCSVDiff(t *testing.T) {
 
 		result, err := CreateCsvDiff(diff.Files[0], baseReader, headReader)
 		assert.NoError(t, err)
-		assert.Equal(t, 1, len(result), "case %d: should be one section", n)
+		assert.Len(t, result, 1, "case %d: should be one section", n)
 
 		section := result[0]
-		assert.Equal(t, len(c.cells), len(section.Rows), "case %d: should be %d rows", n, len(c.cells))
+		assert.Len(t, section.Rows, len(c.cells), "case %d: should be %d rows", n, len(c.cells))
 
 		for i, row := range section.Rows {
-			assert.Equal(t, 2, len(row.Cells), "case %d: row %d should have two cells", n, i)
+			assert.Len(t, row.Cells, 2, "case %d: row %d should have two cells", n, i)
 			for j, cell := range row.Cells {
 				assert.Equal(t, c.cells[i][j], cell.Type, "case %d: row %d cell %d should be equal", n, i, j)
 			}

services/issue/assignee_test.go

@@ -33,5 +33,5 @@ func TestDeleteNotPassedAssignee(t *testing.T) {
 	// Check they're gone
 	assignees, err := models.GetAssigneesByIssue(issue)
 	assert.NoError(t, err)
-	assert.Equal(t, 0, len(assignees))
+	assert.Empty(t, assignees)
 }

services/release/release_test.go

@@ -221,7 +221,7 @@ func TestRelease_Update(t *testing.T) {
 
 	assert.NoError(t, UpdateRelease(user, gitRepo, release, []string{attach.UUID}, nil, nil))
 	assert.NoError(t, models.GetReleaseAttachments(release))
-	assert.EqualValues(t, 1, len(release.Attachments))
+	assert.Len(t, release.Attachments, 1)
 	assert.EqualValues(t, attach.UUID, release.Attachments[0].UUID)
 	assert.EqualValues(t, release.ID, release.Attachments[0].ReleaseID)
 	assert.EqualValues(t, attach.Name, release.Attachments[0].Name)
@@ -232,7 +232,7 @@ func TestRelease_Update(t *testing.T) {
 	}))
 	release.Attachments = nil
 	assert.NoError(t, models.GetReleaseAttachments(release))
-	assert.EqualValues(t, 1, len(release.Attachments))
+	assert.Len(t, release.Attachments, 1)
 	assert.EqualValues(t, attach.UUID, release.Attachments[0].UUID)
 	assert.EqualValues(t, release.ID, release.Attachments[0].ReleaseID)
 	assert.EqualValues(t, "test2.txt", release.Attachments[0].Name)
@@ -241,7 +241,7 @@ func TestRelease_Update(t *testing.T) {
 	assert.NoError(t, UpdateRelease(user, gitRepo, release, nil, []string{attach.UUID}, nil))
 	release.Attachments = nil
 	assert.NoError(t, models.GetReleaseAttachments(release))
-	assert.EqualValues(t, 0, len(release.Attachments))
+	assert.Empty(t, release.Attachments)
 }
 
 func TestRelease_createTag(t *testing.T) {