Update module github.com/golangci/golangci-lint/cmd/golangci-lint to v2 (forgejo) (#7367) Co-authored-by: Renovate Bot <[e-mail]> Co-committed-by: Renovate Bot <[e-mail]>

.golangci.yml

···
+version: "2"
+output:
+  sort-order:
+    - file
 linters:
-  enable-all: false
-  disable-all: true
-  fast: false
+  default: none
   enable:
     - bidichk
     - depguard
···
     - errcheck
     - forbidigo
     - gocritic
-    - gofmt
-    - gofumpt
-    - gosimple
     - govet
     - ineffassign
     - nakedret
     - nolintlint
     - revive
     - staticcheck
-    - stylecheck
     - testifylint
-    - typecheck
     - unconvert
-    - unused
     - unparam
+    - unused
     - usetesting
     - wastedassign
-
-run:
-  timeout: 10m
-
-output:
-  sort-results: true
-  sort-order: [file]
-  show-stats: true
-
-linters-settings:
-  stylecheck:
-    checks: ["all", "-ST1005", "-ST1003"]
-  nakedret:
-    max-func-lines: 0
-  gocritic:
-    disabled-checks:
-      - ifElseChain
-  revive:
-    severity: error
+  settings:
+    depguard:
+      rules:
+        main:
+          deny:
+            - pkg: encoding/json
+              desc: use gitea's modules/json instead of encoding/json
+            - pkg: github.com/unknwon/com
+              desc: use gitea's util and replacements
+            - pkg: io/ioutil
+              desc: use os or io instead
+            - pkg: golang.org/x/exp
+              desc: it's experimental and unreliable
+            - pkg: forgejo.org/modules/git/internal
+              desc: do not use the internal package, use AddXxx function instead
+            - pkg: gopkg.in/ini.v1
+              desc: do not use the ini package, use gitea's config system instead
+            - pkg: github.com/minio/sha256-simd
+              desc: use crypto/sha256 instead, see https://codeberg.org/forgejo/forgejo/pulls/1528
+    gocritic:
+      disabled-checks:
+        - ifElseChain
+    revive:
+      severity: error
+      rules:
+        - name: atomic
+        - name: bare-return
+        - name: blank-imports
+        - name: constant-logical-expr
+        - name: context-as-argument
+        - name: context-keys-type
+        - name: dot-imports
+        - name: duplicated-imports
+        - name: empty-lines
+        - name: error-naming
+        - name: error-return
+        - name: error-strings
+        - name: errorf
+        - name: exported
+        - name: identical-branches
+        - name: if-return
+        - name: increment-decrement
+        - name: indent-error-flow
+        - name: modifies-value-receiver
+        - name: package-comments
+        - name: range
+        - name: receiver-naming
+        - name: redefines-builtin-id
+        - name: string-of-int
+        - name: superfluous-else
+        - name: time-naming
+        - name: unconditional-recursion
+        - name: unexported-return
+        - name: unreachable-code
+        - name: var-declaration
+        - name: var-naming
+        - name: redefines-builtin-id
+          disabled: true
+    staticcheck:
+      checks:
+        - all
+    testifylint:
+      disable:
+        - go-require
+  exclusions:
+    generated: lax
+    presets:
+      - comments
+      - common-false-positives
+      - legacy
+      - std-error-handling
     rules:
-      - name: atomic
-      - name: bare-return
-      - name: blank-imports
-      - name: constant-logical-expr
-      - name: context-as-argument
-      - name: context-keys-type
-      - name: dot-imports
-      - name: duplicated-imports
-      - name: empty-lines
-      - name: error-naming
-      - name: error-return
-      - name: error-strings
-      - name: errorf
-      - name: exported
-      - name: identical-branches
-      - name: if-return
-      - name: increment-decrement
-      - name: indent-error-flow
-      - name: modifies-value-receiver
-      - name: package-comments
-      - name: range
-      - name: receiver-naming
-      - name: redefines-builtin-id
-      - name: string-of-int
-      - name: superfluous-else
-      - name: time-naming
-      - name: unconditional-recursion
-      - name: unexported-return
-      - name: unreachable-code
-      - name: var-declaration
-      - name: var-naming
-      - name: redefines-builtin-id
-        disabled: true
-  gofumpt:
-    extra-rules: true
-  depguard:
-    rules:
-      main:
-        deny:
-          - pkg: encoding/json
-            desc: use gitea's modules/json instead of encoding/json
-          - pkg: github.com/unknwon/com
-            desc: use gitea's util and replacements
-          - pkg: io/ioutil
-            desc: use os or io instead
-          - pkg: golang.org/x/exp
-            desc: it's experimental and unreliable
-          - pkg: forgejo.org/modules/git/internal
-            desc: do not use the internal package, use AddXxx function instead
-          - pkg: gopkg.in/ini.v1
-            desc: do not use the ini package, use gitea's config system instead
-          - pkg: github.com/minio/sha256-simd
-            desc: use crypto/sha256 instead, see https://codeberg.org/forgejo/forgejo/pulls/1528
-  testifylint:
-    disable:
-      - go-require
-
+      - linters:
+          - nolintlint
+        path: models/db/sql_postgres_with_schema.go
+      - linters:
+          - dupl
+          - errcheck
+          - gocyclo
+          - gosec
+          - staticcheck
+          - unparam
+        path: _test\.go
+      - linters:
+          - dupl
+          - errcheck
+          - gocyclo
+          - gosec
+        path: models/migrations/v
+      - linters:
+          - forbidigo
+        path: cmd
+      - linters:
+          - dupl
+        text: (?i)webhook
+      - linters:
+          - gocritic
+        text: (?i)`ID' should not be capitalized
+      - linters:
+          - deadcode
+          - unused
+        text: (?i)swagger
+      - linters:
+          - staticcheck
+        text: (?i)argument x is overwritten before first use
+      - linters:
+          - gocritic
+        text: '(?i)commentFormatting: put a space between `//` and comment text'
+      - linters:
+          - gocritic
+        text: '(?i)exitAfterDefer:'
+      - linters:
+          - staticcheck
+        text: "(ST1005|ST1003|QF1001):"
+    paths:
+      - node_modules
+      - public
+      - web_src
+      - third_party$
+      - builtin$
+      - examples$
 issues:
   max-issues-per-linter: 0
   max-same-issues: 0
-  exclude-dirs: [node_modules, public, web_src]
-  exclude-case-sensitive: true
-  exclude-rules:
-    - path: models/db/sql_postgres_with_schema.go
-      linters:
-        - nolintlint
-    - path: _test\.go
-      linters:
-        - gocyclo
-        - errcheck
-        - dupl
-        - gosec
-        - unparam
-        - staticcheck
-    - path: models/migrations/v
-      linters:
-        - gocyclo
-        - errcheck
-        - dupl
-        - gosec
-    - path: cmd
-      linters:
-        - forbidigo
-    - text: "webhook"
-      linters:
-        - dupl
-    - text: "`ID' should not be capitalized"
-      linters:
-        - gocritic
-    - text: "swagger"
-      linters:
-        - unused
-        - deadcode
-    - text: "argument x is overwritten before first use"
-      linters:
-        - staticcheck
-    - text: "commentFormatting: put a space between `//` and comment text"
-      linters:
-        - gocritic
-    - text: "exitAfterDefer:"
-      linters:
-        - gocritic
+formatters:
+  enable:
+    - gofmt
+    - gofumpt
+  settings:
+    gofumpt:
+      extra-rules: true
+  exclusions:
+    generated: lax
+    paths:
+      - node_modules
+      - public
+      - web_src
+      - third_party$
+      - builtin$
+      - examples$

Makefile

···
 AIR_PACKAGE ?= github.com/air-verse/air@v1 # renovate: datasource=go
 EDITORCONFIG_CHECKER_PACKAGE ?= github.com/editorconfig-checker/editorconfig-checker/v3/cmd/editorconfig-checker@v3.2.1 # renovate: datasource=go
 GOFUMPT_PACKAGE ?= mvdan.cc/gofumpt@v0.7.0 # renovate: datasource=go
-GOLANGCI_LINT_PACKAGE ?= github.com/golangci/golangci-lint/cmd/golangci-lint@v1.64.7 # renovate: datasource=go
+GOLANGCI_LINT_PACKAGE ?= github.com/golangci/golangci-lint/v2/cmd/golangci-lint@v2.0.2 # renovate: datasource=go
 GXZ_PACKAGE ?= github.com/ulikunitz/xz/cmd/gxz@v0.5.11 # renovate: datasource=go
 MISSPELL_PACKAGE ?= github.com/golangci/misspell/cmd/misspell@v0.6.0 # renovate: datasource=go
 SWAGGER_PACKAGE ?= github.com/go-swagger/go-swagger/cmd/swagger@v0.31.0 # renovate: datasource=go

build/lint-locale-usage/lint-locale-usage.go

···
 			Err:      err,
 		}
 	}
-	handler.handleTemplateFileNodes(fset, tmplParsed.Tree.Root.Nodes)
+	handler.handleTemplateFileNodes(fset, tmplParsed.Root.Nodes)
 	return nil
 }
 

build/lint-locale-usage/lint-locale-usage_test.go

···
 
 func TestUsagesParser(t *testing.T) {
 	t.Run("go, simple", func(t *testing.T) {
-		assert.EqualValues(t,
+		assert.Equal(t,
 			[]string{"what.an.example"},
 			HandleGoFileWrapped(t, "<g1>", "package main\nfunc Render(ctx *context.Context) string { return ctx.Tr(\"what.an.example\"); }\n"))
 	})
 
 	t.Run("template, simple", func(t *testing.T) {
-		assert.EqualValues(t,
+		assert.Equal(t,
 			[]string{"what.an.example"},
 			HandleTemplateFileWrapped(t, "<t1>", "{{ ctx.Locale.Tr \"what.an.example\" }}\n"))
 	})

build/lint-locale/lint-locale_test.go

···
 	t.Run("Remove tags", func(t *testing.T) {
 		assert.Empty(t, checkLocaleContent([]byte(`hidden_comment_types_description = Comment types checked here will not be shown inside issue pages. Checking "Label" for example removes all "<user> added/removed <label>" comments.`)))
 
-		assert.EqualValues(t, []string{"key: \x1b[31m<not-an-allowed-key>\x1b[0m REPLACED-TAG"}, checkLocaleContent([]byte(`key = "<not-an-allowed-key> <label>"`)))
-		assert.EqualValues(t, []string{"key: \x1b[31m<[e-mail]>\x1b[0m REPLACED-TAG"}, checkLocaleContent([]byte(`key = "<[e-mail]> <[e-mail]>"`)))
-		assert.EqualValues(t, []string{"key: \x1b[31m<tag>\x1b[0m REPLACED-TAG \x1b[31m</tag>\x1b[0m"}, checkLocaleContent([]byte(`key = "<tag> <[e-mail]> </tag>"`)))
+		assert.Equal(t, []string{"key: \x1b[31m<not-an-allowed-key>\x1b[0m REPLACED-TAG"}, checkLocaleContent([]byte(`key = "<not-an-allowed-key> <label>"`)))
+		assert.Equal(t, []string{"key: \x1b[31m<[e-mail]>\x1b[0m REPLACED-TAG"}, checkLocaleContent([]byte(`key = "<[e-mail]> <[e-mail]>"`)))
+		assert.Equal(t, []string{"key: \x1b[31m<tag>\x1b[0m REPLACED-TAG \x1b[31m</tag>\x1b[0m"}, checkLocaleContent([]byte(`key = "<tag> <[e-mail]> </tag>"`)))
 	})
 
 	t.Run("Specific exception", func(t *testing.T) {
···
 		assert.Empty(t, checkLocaleContent([]byte(`pulls.title_desc_one = wants to merge %[1]d commit from <code>%[2]s</code> into <code id="%[4]s">%[3]s</code>`)))
 		assert.Empty(t, checkLocaleContent([]byte(`editor.commit_directly_to_this_branch = Commit directly to the <strong class="%[2]s">%[1]s</strong> branch.`)))
 
-		assert.EqualValues(t, []string{"workflow.dispatch.trigger_found: This workflow has a \x1b[31m<d>\x1b[0mworkflow_dispatch\x1b[31m</d>\x1b[0m event trigger."}, checkLocaleContent([]byte(`workflow.dispatch.trigger_found = This workflow has a <d>workflow_dispatch</d> event trigger.`)))
-		assert.EqualValues(t, []string{"key: <code\x1b[31m id=\"branch_targe\"\x1b[0m>%[3]s</code>"}, checkLocaleContent([]byte(`key = <code id="branch_targe">%[3]s</code>`)))
-		assert.EqualValues(t, []string{"key: <a\x1b[31m class=\"ui sh\"\x1b[0m href=\"https://TO-BE-REPLACED.COM\">"}, checkLocaleContent([]byte(`key = <a class="ui sh" href="%[3]s">`)))
-		assert.EqualValues(t, []string{"key: <a\x1b[31m class=\"js-click-me\"\x1b[0m href=\"https://TO-BE-REPLACED.COM\">"}, checkLocaleContent([]byte(`key = <a class="js-click-me" href="%[3]s">`)))
-		assert.EqualValues(t, []string{"key: <strong\x1b[31m class=\"branch-target\"\x1b[0m>%[1]s</strong>"}, checkLocaleContent([]byte(`key = <strong class="branch-target">%[1]s</strong>`)))
+		assert.Equal(t, []string{"workflow.dispatch.trigger_found: This workflow has a \x1b[31m<d>\x1b[0mworkflow_dispatch\x1b[31m</d>\x1b[0m event trigger."}, checkLocaleContent([]byte(`workflow.dispatch.trigger_found = This workflow has a <d>workflow_dispatch</d> event trigger.`)))
+		assert.Equal(t, []string{"key: <code\x1b[31m id=\"branch_targe\"\x1b[0m>%[3]s</code>"}, checkLocaleContent([]byte(`key = <code id="branch_targe">%[3]s</code>`)))
+		assert.Equal(t, []string{"key: <a\x1b[31m class=\"ui sh\"\x1b[0m href=\"https://TO-BE-REPLACED.COM\">"}, checkLocaleContent([]byte(`key = <a class="ui sh" href="%[3]s">`)))
+		assert.Equal(t, []string{"key: <a\x1b[31m class=\"js-click-me\"\x1b[0m href=\"https://TO-BE-REPLACED.COM\">"}, checkLocaleContent([]byte(`key = <a class="js-click-me" href="%[3]s">`)))
+		assert.Equal(t, []string{"key: <strong\x1b[31m class=\"branch-target\"\x1b[0m>%[1]s</strong>"}, checkLocaleContent([]byte(`key = <strong class="branch-target">%[1]s</strong>`)))
 	})
 
 	t.Run("General safe tags", func(t *testing.T) {
···
 		assert.Empty(t, checkLocaleContent([]byte("sqlite_helper = File path for the SQLite3 database.<br>Enter an absolute path if you run Forgejo as a service.")))
 		assert.Empty(t, checkLocaleContent([]byte("hi_user_x = Hi <b>%s</b>,")))
 
-		assert.EqualValues(t, []string{"error404: The page you are trying to reach either <strong\x1b[31m title='aaa'\x1b[0m>does not exist</strong> or <strong>you are not authorized</strong> to view it."}, checkLocaleContent([]byte("error404 = The page you are trying to reach either <strong title='aaa'>does not exist</strong> or <strong>you are not authorized</strong> to view it.")))
+		assert.Equal(t, []string{"error404: The page you are trying to reach either <strong\x1b[31m title='aaa'\x1b[0m>does not exist</strong> or <strong>you are not authorized</strong> to view it."}, checkLocaleContent([]byte("error404 = The page you are trying to reach either <strong title='aaa'>does not exist</strong> or <strong>you are not authorized</strong> to view it.")))
 	})
 
 	t.Run("<a>", func(t *testing.T) {
···
 		assert.Empty(t, checkLocaleContent([]byte(`webauthn_desc = Security keys are hardware devices containing cryptographic keys. They can be used for two-factor authentication. Security keys must support the <a rel="noreferrer" target="_blank" href="%s">WebAuthn Authenticator</a> standard.`)))
 		assert.Empty(t, checkLocaleContent([]byte("issues.closed_at = `closed this issue <a id=\"%[1]s\" href=\"#%[1]s\">%[2]s</a>`")))
 
-		assert.EqualValues(t, []string{"key: \x1b[31m<a href=\"https://example.com\">\x1b[0m"}, checkLocaleContent([]byte(`key = <a href="https://example.com">`)))
-		assert.EqualValues(t, []string{"key: \x1b[31m<a href=\"javascript:alert('1')\">\x1b[0m"}, checkLocaleContent([]byte(`key = <a href="javascript:alert('1')">`)))
-		assert.EqualValues(t, []string{"key: <a href=\"https://TO-BE-REPLACED.COM\"\x1b[31m download\x1b[0m>"}, checkLocaleContent([]byte(`key = <a href="%s" download>`)))
-		assert.EqualValues(t, []string{"key: <a href=\"https://TO-BE-REPLACED.COM\"\x1b[31m target=\"_self\"\x1b[0m>"}, checkLocaleContent([]byte(`key = <a href="%s" target="_self">`)))
-		assert.EqualValues(t, []string{"key: \x1b[31m<a href=\"https://example.com/%s\">\x1b[0m"}, checkLocaleContent([]byte(`key = <a href="https://example.com/%s">`)))
-		assert.EqualValues(t, []string{"key: \x1b[31m<a href=\"https://example.com/?q=%s\">\x1b[0m"}, checkLocaleContent([]byte(`key = <a href="https://example.com/?q=%s">`)))
-		assert.EqualValues(t, []string{"key: \x1b[31m<a href=\"%s/open-redirect\">\x1b[0m"}, checkLocaleContent([]byte(`key = <a href="%s/open-redirect">`)))
-		assert.EqualValues(t, []string{"key: \x1b[31m<a href=\"%s?q=open-redirect\">\x1b[0m"}, checkLocaleContent([]byte(`key = <a href="%s?q=open-redirect">`)))
+		assert.Equal(t, []string{"key: \x1b[31m<a href=\"https://example.com\">\x1b[0m"}, checkLocaleContent([]byte(`key = <a href="https://example.com">`)))
+		assert.Equal(t, []string{"key: \x1b[31m<a href=\"javascript:alert('1')\">\x1b[0m"}, checkLocaleContent([]byte(`key = <a href="javascript:alert('1')">`)))
+		assert.Equal(t, []string{"key: <a href=\"https://TO-BE-REPLACED.COM\"\x1b[31m download\x1b[0m>"}, checkLocaleContent([]byte(`key = <a href="%s" download>`)))
+		assert.Equal(t, []string{"key: <a href=\"https://TO-BE-REPLACED.COM\"\x1b[31m target=\"_self\"\x1b[0m>"}, checkLocaleContent([]byte(`key = <a href="%s" target="_self">`)))
+		assert.Equal(t, []string{"key: \x1b[31m<a href=\"https://example.com/%s\">\x1b[0m"}, checkLocaleContent([]byte(`key = <a href="https://example.com/%s">`)))
+		assert.Equal(t, []string{"key: \x1b[31m<a href=\"https://example.com/?q=%s\">\x1b[0m"}, checkLocaleContent([]byte(`key = <a href="https://example.com/?q=%s">`)))
+		assert.Equal(t, []string{"key: \x1b[31m<a href=\"%s/open-redirect\">\x1b[0m"}, checkLocaleContent([]byte(`key = <a href="%s/open-redirect">`)))
+		assert.Equal(t, []string{"key: \x1b[31m<a href=\"%s?q=open-redirect\">\x1b[0m"}, checkLocaleContent([]byte(`key = <a href="%s?q=open-redirect">`)))
 	})
 
 	t.Run("Escaped HTML characters", func(t *testing.T) {
 		assert.Empty(t, checkLocaleContent([]byte("activity.git_stats_push_to_branch = `إلى %s و\"`")))
 
-		assert.EqualValues(t, []string{"key: و\x1b[31m&nbsp\x1b[0m\x1b[32m\u00a0\x1b[0m"}, checkLocaleContent([]byte(`key = و&nbsp;`)))
+		assert.Equal(t, []string{"key: و\x1b[31m&nbsp\x1b[0m\x1b[32m\u00a0\x1b[0m"}, checkLocaleContent([]byte(`key = و&nbsp;`)))
 	})
 }
 
···
 			}
 		}`)))
 
-		assert.EqualValues(t, []string{"settings.hidden_comment_types_description: \"\x1b[31m<not-an-allowed-key>\x1b[0m REPLACED-TAG\""}, checkLocaleNextContent([]byte(`{
+		assert.Equal(t, []string{"settings.hidden_comment_types_description: \"\x1b[31m<not-an-allowed-key>\x1b[0m REPLACED-TAG\""}, checkLocaleNextContent([]byte(`{
 			"settings": {
 				"hidden_comment_types_description": "\"<not-an-allowed-key> <label>\""
 			}
···
 			"settings.hidden_comment_types_description": "Comment types checked here will not be shown inside issue pages. Checking \"Label\" for example removes all \"<user> added/removed <label>\" comments."
 		}`)))
 
-		assert.EqualValues(t, []string{"settings.hidden_comment_types_description: \"\x1b[31m<not-an-allowed-key>\x1b[0m REPLACED-TAG\""}, checkLocaleNextContent([]byte(`{
+		assert.Equal(t, []string{"settings.hidden_comment_types_description: \"\x1b[31m<not-an-allowed-key>\x1b[0m REPLACED-TAG\""}, checkLocaleNextContent([]byte(`{
 			"settings.hidden_comment_types_description": "\"<not-an-allowed-key> <label>\""
 		}`)))
 	})

cmd/admin_auth_ldap_test.go

···
 				return nil
 			},
 			updateAuthSource: func(ctx context.Context, authSource *auth.Source) error {
-				assert.FailNow(t, "case %d: should not call updateAuthSource", n)
+				assert.FailNow(t, "should not call updateAuthSource", "case: %d", n)
 				return nil
 			},
 			getAuthSourceByID: func(ctx context.Context, id int64) (*auth.Source, error) {
-				assert.FailNow(t, "case %d: should not call getAuthSourceByID", n)
+				assert.FailNow(t, "should not call getAuthSourceByID", "case: %d", n)
 				return nil, nil
 			},
 		}
···
 				return nil
 			},
 			updateAuthSource: func(ctx context.Context, authSource *auth.Source) error {
-				assert.FailNow(t, "case %d: should not call updateAuthSource", n)
+				assert.FailNow(t, "should not call updateAuthSource", "case: %d", n)
 				return nil
 			},
 			getAuthSourceByID: func(ctx context.Context, id int64) (*auth.Source, error) {
-				assert.FailNow(t, "case %d: should not call getAuthSourceByID", n)
+				assert.FailNow(t, "should not call getAuthSourceByID", "case: %d", n)
 				return nil, nil
 			},
 		}
···
 				return nil
 			},
 			createAuthSource: func(ctx context.Context, authSource *auth.Source) error {
-				assert.FailNow(t, "case %d: should not call createAuthSource", n)
+				assert.FailNow(t, "should not call createAuthSource", "case: %d", n)
 				return nil
 			},
 			updateAuthSource: func(ctx context.Context, authSource *auth.Source) error {
···
 				return nil
 			},
 			createAuthSource: func(ctx context.Context, authSource *auth.Source) error {
-				assert.FailNow(t, "case %d: should not call createAuthSource", n)
+				assert.FailNow(t, "should not call createAuthSource", "case: %d", n)
 				return nil
 			},
 			updateAuthSource: func(ctx context.Context, authSource *auth.Source) error {

cmd/doctor.go

···
 	setupConsoleLogger(log.FATAL, log.CanColorStderr, os.Stderr)
 
 	logFile := ctx.String("log-file")
-	if logFile == "" {
+	switch logFile {
+	case "":
 		return // if no doctor log-file is set, do not show any log from default logger
-	} else if logFile == "-" {
+	case "-":
 		setupConsoleLogger(log.TRACE, colorize, os.Stdout)
-	} else {
+	default:
 		logFile, _ = filepath.Abs(logFile)
 		writeMode := log.WriterMode{Level: log.TRACE, WriterOption: log.WriterFileOption{FileName: logFile}}
 		writer, err := log.NewEventWriter("console-to-file", "file", writeMode)

cmd/hook.go

···
 		}
 	}
 
-	supportProcReceive := false
-	if git.CheckGitVersionAtLeast("2.29") == nil {
-		supportProcReceive = true
-	}
+	supportProcReceive := git.CheckGitVersionAtLeast("2.29") == nil
 
 	for scanner.Scan() {
 		// TODO: support news feeds for wiki

cmd/main.go

···
 	}
 	executable := filepath.Base(path)
 
-	var subCmdsStandalone []*cli.Command = make([]*cli.Command, 0, 10)
-	var subCmdWithConfig []*cli.Command = make([]*cli.Command, 0, 10)
-	var globalFlags []cli.Flag = make([]cli.Flag, 0, 10)
+	subCmdsStandalone := make([]*cli.Command, 0, 10)
+	subCmdWithConfig := make([]*cli.Command, 0, 10)
+	globalFlags := make([]cli.Flag, 0, 10)
 
 	//
 	// If the executable is forgejo-cli, provide a Forgejo specific CLI

cmd/main_test.go

···
 	r, err := runTestApp(app, "./gitea", "test-cmd")
 	require.Error(t, err)
 	assert.Equal(t, 1, r.ExitCode)
-	assert.Equal(t, "", r.Stdout)
+	assert.Empty(t, r.Stdout)
 	assert.Equal(t, "Command error: normal error\n", r.Stderr)
 
 	app = newTestApp(func(ctx *cli.Context) error { return cli.Exit("exit error", 2) })
 	r, err = runTestApp(app, "./gitea", "test-cmd")
 	require.Error(t, err)
 	assert.Equal(t, 2, r.ExitCode)
-	assert.Equal(t, "", r.Stdout)
+	assert.Empty(t, r.Stdout)
 	assert.Equal(t, "exit error\n", r.Stderr)
 
 	app = newTestApp(func(ctx *cli.Context) error { return nil })
···
 	require.Error(t, err)
 	assert.Equal(t, 1, r.ExitCode)
 	assert.Equal(t, "Incorrect Usage: flag provided but not defined: -no-such\n\n", r.Stdout)
-	assert.Equal(t, "", r.Stderr) // the cli package's strange behavior, the error message is not in stderr ....
+	assert.Empty(t, r.Stderr) // the cli package's strange behavior, the error message is not in stderr ....
 
 	app = newTestApp(func(ctx *cli.Context) error { return nil })
 	r, err = runTestApp(app, "./gitea", "test-cmd")
 	require.NoError(t, err)
 	assert.Equal(t, -1, r.ExitCode) // the cli.OsExiter is not called
-	assert.Equal(t, "", r.Stdout)
-	assert.Equal(t, "", r.Stderr)
+	assert.Empty(t, r.Stdout)
+	assert.Empty(t, r.Stderr)
 }

cmd/migrate_storage_test.go

···
 	entries, err := os.ReadDir(p)
 	require.NoError(t, err)
 	assert.Len(t, entries, 2)
-	assert.EqualValues(t, "01", entries[0].Name())
-	assert.EqualValues(t, "tmp", entries[1].Name())
+	assert.Equal(t, "01", entries[0].Name())
+	assert.Equal(t, "tmp", entries[1].Name())
 }
 
 func TestMigrateActionsArtifacts(t *testing.T) {

cmd/serv.go

···
 	}
 
 	if verb == lfsAuthenticateVerb {
-		if lfsVerb == "upload" {
+		switch lfsVerb {
+		case "upload":
 			requestedMode = perm.AccessModeWrite
-		} else if lfsVerb == "download" {
+		case "download":
 			requestedMode = perm.AccessModeRead
-		} else {
+		default:
 			return fail(ctx, "Unknown LFS verb", "Unknown lfs verb %s", lfsVerb)
 		}
 	}

models/actions/forgejo_test.go

···
 	version := "v1.2.3"
 	runner, err := RegisterRunner(db.DefaultContext, ownerID, repoID, token, &labels, name, version)
 	require.NoError(t, err)
-	assert.EqualValues(t, name, runner.Name)
+	assert.Equal(t, name, runner.Name)
 
-	assert.EqualValues(t, 1, subtle.ConstantTimeCompare([]byte(runner.TokenHash), []byte(auth_model.HashToken(token, runner.TokenSalt))), "the token cannot be verified with the same method as routers/api/actions/runner/interceptor.go as of 8228751c55d6a4263f0fec2932ca16181c09c97d")
+	assert.Equal(t, 1, subtle.ConstantTimeCompare([]byte(runner.TokenHash), []byte(auth_model.HashToken(token, runner.TokenSalt))), "the token cannot be verified with the same method as routers/api/actions/runner/interceptor.go as of 8228751c55d6a4263f0fec2932ca16181c09c97d")
 }
 
 // TestActions_RegisterRunner_TokenUpdate tests that a token's secret is updated
···
 	require.NoError(t, err)
 
 	// Check that the returned record has been updated, except for the labels
-	assert.EqualValues(t, ownerID, runner.OwnerID)
-	assert.EqualValues(t, repoID, runner.RepoID)
-	assert.EqualValues(t, name, runner.Name)
-	assert.EqualValues(t, version, runner.Version)
-	assert.EqualValues(t, labelsCopy, runner.AgentLabels)
+	assert.Equal(t, ownerID, runner.OwnerID)
+	assert.Equal(t, repoID, runner.RepoID)
+	assert.Equal(t, name, runner.Name)
+	assert.Equal(t, version, runner.Version)
+	assert.Equal(t, labelsCopy, runner.AgentLabels)
 
 	// Check that whatever is in the DB has been updated, except for the labels
 	after := unittest.AssertExistsAndLoadBean(t, &ActionRunner{ID: runner.ID})
-	assert.EqualValues(t, ownerID, after.OwnerID)
-	assert.EqualValues(t, repoID, after.RepoID)
-	assert.EqualValues(t, name, after.Name)
-	assert.EqualValues(t, version, after.Version)
-	assert.EqualValues(t, labelsCopy, after.AgentLabels)
+	assert.Equal(t, ownerID, after.OwnerID)
+	assert.Equal(t, repoID, after.RepoID)
+	assert.Equal(t, name, after.Name)
+	assert.Equal(t, version, after.Version)
+	assert.Equal(t, labelsCopy, after.AgentLabels)
 }
 
 func TestActions_RegisterRunner_CreateWithoutLabels(t *testing.T) {
···
 	require.NoError(t, err)
 
 	// Check that the returned record has been updated, except for the labels
-	assert.EqualValues(t, ownerID, runner.OwnerID)
-	assert.EqualValues(t, repoID, runner.RepoID)
-	assert.EqualValues(t, name, runner.Name)
-	assert.EqualValues(t, version, runner.Version)
-	assert.EqualValues(t, []string{}, runner.AgentLabels)
+	assert.Equal(t, ownerID, runner.OwnerID)
+	assert.Equal(t, repoID, runner.RepoID)
+	assert.Equal(t, name, runner.Name)
+	assert.Equal(t, version, runner.Version)
+	assert.Equal(t, []string{}, runner.AgentLabels)
 
 	// Check that whatever is in the DB has been updated, except for the labels
 	after := unittest.AssertExistsAndLoadBean(t, &ActionRunner{ID: runner.ID})
-	assert.EqualValues(t, ownerID, after.OwnerID)
-	assert.EqualValues(t, repoID, after.RepoID)
-	assert.EqualValues(t, name, after.Name)
-	assert.EqualValues(t, version, after.Version)
-	assert.EqualValues(t, []string{}, after.AgentLabels)
+	assert.Equal(t, ownerID, after.OwnerID)
+	assert.Equal(t, repoID, after.RepoID)
+	assert.Equal(t, name, after.Name)
+	assert.Equal(t, version, after.Version)
+	assert.Equal(t, []string{}, after.AgentLabels)
 }
 
 func TestActions_RegisterRunner_UpdateWithLabels(t *testing.T) {
···
 	require.NoError(t, err)
 
 	// Check that the returned record has been updated
-	assert.EqualValues(t, newOwnerID, runner.OwnerID)
-	assert.EqualValues(t, newRepoID, runner.RepoID)
-	assert.EqualValues(t, newName, runner.Name)
-	assert.EqualValues(t, newVersion, runner.Version)
-	assert.EqualValues(t, labelsCopy, runner.AgentLabels)
+	assert.Equal(t, newOwnerID, runner.OwnerID)
+	assert.Equal(t, newRepoID, runner.RepoID)
+	assert.Equal(t, newName, runner.Name)
+	assert.Equal(t, newVersion, runner.Version)
+	assert.Equal(t, labelsCopy, runner.AgentLabels)
 
 	// Check that whatever is in the DB has been updated
 	after := unittest.AssertExistsAndLoadBean(t, &ActionRunner{ID: recordID})
-	assert.EqualValues(t, newOwnerID, after.OwnerID)
-	assert.EqualValues(t, newRepoID, after.RepoID)
-	assert.EqualValues(t, newName, after.Name)
-	assert.EqualValues(t, newVersion, after.Version)
-	assert.EqualValues(t, labelsCopy, after.AgentLabels)
+	assert.Equal(t, newOwnerID, after.OwnerID)
+	assert.Equal(t, newRepoID, after.RepoID)
+	assert.Equal(t, newName, after.Name)
+	assert.Equal(t, newVersion, after.Version)
+	assert.Equal(t, labelsCopy, after.AgentLabels)
 }
 
 func TestActions_RegisterRunner_UpdateWithoutLabels(t *testing.T) {
···
 	require.NoError(t, err)
 
 	// Check that the returned record has been updated, except for the labels
-	assert.EqualValues(t, newOwnerID, runner.OwnerID)
-	assert.EqualValues(t, newRepoID, runner.RepoID)
-	assert.EqualValues(t, newName, runner.Name)
-	assert.EqualValues(t, newVersion, runner.Version)
-	assert.EqualValues(t, before.AgentLabels, runner.AgentLabels)
+	assert.Equal(t, newOwnerID, runner.OwnerID)
+	assert.Equal(t, newRepoID, runner.RepoID)
+	assert.Equal(t, newName, runner.Name)
+	assert.Equal(t, newVersion, runner.Version)
+	assert.Equal(t, before.AgentLabels, runner.AgentLabels)
 
 	// Check that whatever is in the DB has been updated, except for the labels
 	after := unittest.AssertExistsAndLoadBean(t, &ActionRunner{ID: recordID})
-	assert.EqualValues(t, newOwnerID, after.OwnerID)
-	assert.EqualValues(t, newRepoID, after.RepoID)
-	assert.EqualValues(t, newName, after.Name)
-	assert.EqualValues(t, newVersion, after.Version)
-	assert.EqualValues(t, before.AgentLabels, after.AgentLabels)
+	assert.Equal(t, newOwnerID, after.OwnerID)
+	assert.Equal(t, newRepoID, after.RepoID)
+	assert.Equal(t, newName, after.Name)
+	assert.Equal(t, newVersion, after.Version)
+	assert.Equal(t, before.AgentLabels, after.AgentLabels)
 }

models/actions/runner.go

···
 		return types.OwnerTypeRepository
 	}
 	if r.OwnerID != 0 {
-		if r.Owner.Type == user_model.UserTypeOrganization {
+		switch r.Owner.Type {
+		case user_model.UserTypeOrganization:
 			return types.OwnerTypeOrganization
-		} else if r.Owner.Type == user_model.UserTypeIndividual {
+		case user_model.UserTypeIndividual:
 			return types.OwnerTypeIndividual
 		}
 	}

models/actions/runner_token_test.go

···
 	token := unittest.AssertExistsAndLoadBean(t, &ActionRunnerToken{ID: 3})
 	expectedToken, err := GetLatestRunnerToken(db.DefaultContext, 1, 0)
 	require.NoError(t, err)
-	assert.EqualValues(t, expectedToken, token)
+	assert.Equal(t, expectedToken, token)
 }
 
 func TestNewRunnerToken(t *testing.T) {
···
 	require.NoError(t, err)
 	expectedToken, err := GetLatestRunnerToken(db.DefaultContext, 1, 0)
 	require.NoError(t, err)
-	assert.EqualValues(t, expectedToken, token)
+	assert.Equal(t, expectedToken, token)
 }
 
 func TestUpdateRunnerToken(t *testing.T) {
···
 	require.NoError(t, UpdateRunnerToken(db.DefaultContext, token))
 	expectedToken, err := GetLatestRunnerToken(db.DefaultContext, 1, 0)
 	require.NoError(t, err)
-	assert.EqualValues(t, expectedToken, token)
+	assert.Equal(t, expectedToken, token)
 }

models/activities/action_test.go

···
 	require.NoError(t, err)
 	if assert.Len(t, actions, 1) {
 		assert.EqualValues(t, 1, actions[0].ID)
-		assert.EqualValues(t, user.ID, actions[0].UserID)
+		assert.Equal(t, user.ID, actions[0].UserID)
 	}
 	assert.Equal(t, int64(1), count)
 
···
 	assert.Len(t, actions, 1)
 	if assert.Len(t, actions, 1) {
 		assert.EqualValues(t, 2, actions[0].ID)
-		assert.EqualValues(t, org.ID, actions[0].UserID)
+		assert.Equal(t, org.ID, actions[0].UserID)
 	}
 	assert.Equal(t, int64(1), count)
 
···
 
 	// load an issue
 	issue := unittest.AssertExistsAndLoadBean(t, &issue_model.Issue{ID: 4})
-	assert.NotEqualValues(t, issue.ID, issue.Index) // it needs to use different ID/Index to test the DeleteIssueActions to delete some actions by IssueIndex
+	assert.NotEqual(t, issue.ID, issue.Index) // it needs to use different ID/Index to test the DeleteIssueActions to delete some actions by IssueIndex
 
 	// insert a comment
 	err := db.Insert(db.DefaultContext, &issue_model.Comment{Type: issue_model.CommentTypeComment, IssueID: issue.ID})

models/activities/notification_list.go

···
 			return err
 		}
 		toNotify.AddMultiple(issueWatches...)
-		if !(issue.IsPull && issues_model.HasWorkInProgressPrefix(issue.Title)) {
+		if !issue.IsPull || !issues_model.HasWorkInProgressPrefix(issue.Title) {
 			repoWatches, err := repo_model.GetRepoWatchersIDs(ctx, issue.RepoID)
 			if err != nil {
 				return err

models/activities/notification_test.go

···
 	require.NoError(t, err)
 	if assert.Len(t, notfs, 3) {
 		assert.EqualValues(t, 5, notfs[0].ID)
-		assert.EqualValues(t, user.ID, notfs[0].UserID)
+		assert.Equal(t, user.ID, notfs[0].UserID)
 		assert.EqualValues(t, 4, notfs[1].ID)
-		assert.EqualValues(t, user.ID, notfs[1].UserID)
+		assert.Equal(t, user.ID, notfs[1].UserID)
 		assert.EqualValues(t, 2, notfs[2].ID)
-		assert.EqualValues(t, user.ID, notfs[2].UserID)
+		assert.Equal(t, user.ID, notfs[2].UserID)
 	}
 }
 
···
 	repo, err := notf.GetRepo(db.DefaultContext)
 	require.NoError(t, err)
 	assert.Equal(t, repo, notf.Repository)
-	assert.EqualValues(t, notf.RepoID, repo.ID)
+	assert.Equal(t, notf.RepoID, repo.ID)
 }
 
 func TestNotification_GetIssue(t *testing.T) {
···
 	issue, err := notf.GetIssue(db.DefaultContext)
 	require.NoError(t, err)
 	assert.Equal(t, issue, notf.Issue)
-	assert.EqualValues(t, notf.IssueID, issue.ID)
+	assert.Equal(t, notf.IssueID, issue.ID)
 }
 
 func TestGetNotificationCount(t *testing.T) {
···
 
 	nt, err := activities_model.GetIssueNotification(db.DefaultContext, user.ID, issue.ID)
 	require.NoError(t, err)
-	assert.EqualValues(t, activities_model.NotificationStatusRead, nt.Status)
+	assert.Equal(t, activities_model.NotificationStatusRead, nt.Status)
 }

models/activities/repo_activity_test.go

···
 	stats, err := GetActivityStats(db.DefaultContext, repo, time.Unix(0, 0), true, true, true, true)
 	require.NoError(t, err)
 
-	assert.EqualValues(t, 2, stats.ActiveIssueCount())
-	assert.EqualValues(t, 2, stats.OpenedIssueCount())
-	assert.EqualValues(t, 0, stats.ClosedIssueCount())
-	assert.EqualValues(t, 3, stats.ActivePRCount())
+	assert.Equal(t, 2, stats.ActiveIssueCount())
+	assert.Equal(t, 2, stats.OpenedIssueCount())
+	assert.Equal(t, 0, stats.ClosedIssueCount())
+	assert.Equal(t, 3, stats.ActivePRCount())
 }

models/asymkey/gpg_key_test.go

···
 	require.NoError(t, err)
 	assert.Len(t, keys, 1)
 	assert.Len(t, keys[0].Emails, 1)
-	assert.EqualValues(t, "[e-mail]", keys[0].Emails[0].Email)
+	assert.Equal(t, "[e-mail]", keys[0].Emails[0].Email)
 
 	primaryKeyID := "D68172F48E9C5283"
 	// Assert primary key

models/asymkey/ssh_key_test.go

···
 				keyTypeN, lengthN, err := SSHNativeParsePublicKey(tc.content)
 				require.NoError(t, err)
 				assert.Equal(t, tc.keyType, keyTypeN)
-				assert.EqualValues(t, tc.length, lengthN)
+				assert.Equal(t, tc.length, lengthN)
 			})
 			if tc.skipSSHKeygen {
 				return
···
 				if err != nil {
 					// Some servers do not support ecdsa format.
 					if !strings.Contains(err.Error(), "line 1 too long:") {
-						assert.FailNow(t, "%v", err)
+						require.NoError(t, err)
 					}
 				}
 				assert.Equal(t, tc.keyType, keyTypeK)
-				assert.EqualValues(t, tc.length, lengthK)
+				assert.Equal(t, tc.length, lengthK)
 			})
 			t.Run("SSHParseKeyNative", func(t *testing.T) {
 				keyTypeK, lengthK, err := SSHNativeParsePublicKey(tc.content)
 				if err != nil {
-					assert.FailNow(t, "%v", err)
+					require.NoError(t, err)
 				}
 				assert.Equal(t, tc.keyType, keyTypeK)
-				assert.EqualValues(t, tc.length, lengthK)
+				assert.Equal(t, tc.length, lengthK)
 			})
 		})
 	}

models/auth/oauth2_test.go

···
 	assert.NotNil(t, grant)
 	assert.Equal(t, int64(2), grant.UserID)
 	assert.Equal(t, int64(1), grant.ApplicationID)
-	assert.Equal(t, "", grant.Scope)
+	assert.Empty(t, grant.Scope)
 }
 
 //////////////////// Grant
···
 func TestBuiltinApplicationsClientIDs(t *testing.T) {
 	clientIDs := auth_model.BuiltinApplicationsClientIDs()
 	slices.Sort(clientIDs)
-	assert.EqualValues(t, []string{"a4792ccc-144e-407e-86c9-5e7d8d9c3269", "d57cb8c4-630c-4168-8324-ec79935e18d4", "e90ee53c-94e2-48ac-9358-a874fb9e0662"}, clientIDs)
+	assert.Equal(t, []string{"a4792ccc-144e-407e-86c9-5e7d8d9c3269", "d57cb8c4-630c-4168-8324-ec79935e18d4", "e90ee53c-94e2-48ac-9358-a874fb9e0662"}, clientIDs)
 }
 
 func TestOrphanedOAuth2Applications(t *testing.T) {

models/auth/session_test.go

···
 		// New session is created.
 		sess, err := auth.ReadSession(db.DefaultContext, key)
 		require.NoError(t, err)
-		assert.EqualValues(t, key, sess.Key)
+		assert.Equal(t, key, sess.Key)
 		assert.Empty(t, sess.Data)
 		assert.EqualValues(t, now.Unix(), sess.Expiry)
 
···
 		// Ensure data is updated and expiry is set from the update session call.
 		sess, err := auth.ReadSession(db.DefaultContext, key)
 		require.NoError(t, err)
-		assert.EqualValues(t, key, sess.Key)
-		assert.EqualValues(t, data, sess.Data)
+		assert.Equal(t, key, sess.Key)
+		assert.Equal(t, data, sess.Data)
 		assert.EqualValues(t, now.Unix(), sess.Expiry)
 
 		timeutil.MockSet(now)

models/db/engine_test.go

···
 
 	countAfter, err := db.GetEngine(db.DefaultContext).Count(&issues_model.PullRequest{})
 	require.NoError(t, err)
-	assert.EqualValues(t, countBefore, countAfter)
+	assert.Equal(t, countBefore, countAfter)
 }
 
 func TestPrimaryKeys(t *testing.T) {

models/db/list_test.go

···
 
 	repoUnits, newCnt, err := db.FindAndCount[repo_model.RepoUnit](db.DefaultContext, opts)
 	require.NoError(t, err)
-	assert.EqualValues(t, cnt, newCnt)
+	assert.Equal(t, cnt, newCnt)
 	assert.Len(t, repoUnits, repoUnitCount)
 }

models/dbfs/dbfs_test.go

···
 
 	n, err := f.Write([]byte("0123456789")) // blocks: 0123 4567 89
 	require.NoError(t, err)
-	assert.EqualValues(t, 10, n)
+	assert.Equal(t, 10, n)
 
 	_, err = f.Seek(0, io.SeekStart)
 	require.NoError(t, err)
 
 	buf, err := io.ReadAll(f)
 	require.NoError(t, err)
-	assert.EqualValues(t, 10, n)
-	assert.EqualValues(t, "0123456789", string(buf))
+	assert.Equal(t, 10, n)
+	assert.Equal(t, "0123456789", string(buf))
 
 	// write some new data
 	_, err = f.Seek(1, io.SeekStart)
···
 	// read from offset
 	buf, err = io.ReadAll(f)
 	require.NoError(t, err)
-	assert.EqualValues(t, "9", string(buf))
+	assert.Equal(t, "9", string(buf))
 
 	// read all
 	_, err = f.Seek(0, io.SeekStart)
 	require.NoError(t, err)
 	buf, err = io.ReadAll(f)
 	require.NoError(t, err)
-	assert.EqualValues(t, "0bcdefghi9", string(buf))
+	assert.Equal(t, "0bcdefghi9", string(buf))
 
 	// write to new size
 	_, err = f.Seek(-1, io.SeekEnd)
···
 	require.NoError(t, err)
 	buf, err = io.ReadAll(f)
 	require.NoError(t, err)
-	assert.EqualValues(t, "0bcdefghiJKLMNOP", string(buf))
+	assert.Equal(t, "0bcdefghiJKLMNOP", string(buf))
 
 	// write beyond EOF and fill with zero
 	_, err = f.Seek(5, io.SeekCurrent)
···
 	require.NoError(t, err)
 	buf, err = io.ReadAll(f)
 	require.NoError(t, err)
-	assert.EqualValues(t, "0bcdefghiJKLMNOP\x00\x00\x00\x00\x00xyzu", string(buf))
+	assert.Equal(t, "0bcdefghiJKLMNOP\x00\x00\x00\x00\x00xyzu", string(buf))
 
 	// write to the block with zeros
 	_, err = f.Seek(-6, io.SeekCurrent)
···
 	require.NoError(t, err)
 	buf, err = io.ReadAll(f)
 	require.NoError(t, err)
-	assert.EqualValues(t, "0bcdefghiJKLMNOP\x00\x00\x00ABCDzu", string(buf))
+	assert.Equal(t, "0bcdefghiJKLMNOP\x00\x00\x00ABCDzu", string(buf))
 
 	require.NoError(t, f.Close())
 
···
 	require.NoError(t, err)
 	stat, err := f.Stat()
 	require.NoError(t, err)
-	assert.EqualValues(t, "test.txt", stat.Name())
+	assert.Equal(t, "test.txt", stat.Name())
 	assert.EqualValues(t, 0, stat.Size())
 	_, err = f.Write([]byte("0123456789"))
 	require.NoError(t, err)
···
 
 	line, err := f2r.ReadString('\n')
 	require.NoError(t, err)
-	assert.EqualValues(t, "line 1\n", line)
+	assert.Equal(t, "line 1\n", line)
 	_, err = f2r.ReadString('\n')
 	require.ErrorIs(t, err, io.EOF)
 
···
 
 	line, err = f2r.ReadString('\n')
 	require.NoError(t, err)
-	assert.EqualValues(t, "line 2\n", line)
+	assert.Equal(t, "line 2\n", line)
 	_, err = f2r.ReadString('\n')
 	require.ErrorIs(t, err, io.EOF)
 }
···
 
 	buf, err := io.ReadAll(fr)
 	require.NoError(t, err)
-	assert.EqualValues(t, "111333", string(buf))
+	assert.Equal(t, "111333", string(buf))
 }

models/forgejo/semver/semver_test.go

···
 	require.NoError(t, SetVersionString(ctx, newVersion.String()))
 	databaseVersion, err := GetVersion(ctx)
 	require.NoError(t, err)
-	assert.EqualValues(t, newVersion.String(), databaseVersion.String())
+	assert.Equal(t, newVersion.String(), databaseVersion.String())
 	assert.True(t, newVersion.Equal(databaseVersion))
 }
 
···
 
 	v, err := GetVersion(ctx)
 	require.NoError(t, err)
-	assert.EqualValues(t, "1.0.0", v.String())
+	assert.Equal(t, "1.0.0", v.String())
 
 	_, err = e.Exec("drop table forgejo_sem_ver")
 	require.NoError(t, err)
 
 	v, err = GetVersion(ctx)
 	require.NoError(t, err)
-	assert.EqualValues(t, "1.0.0", v.String())
+	assert.Equal(t, "1.0.0", v.String())
 }

models/forgejo_migrations/v1_22/v8_test.go

···
 	require.NoError(t, err)
 	assert.Len(t, releases, 3)
 
-	assert.Equal(t, "", releases[0].Note)
+	assert.Empty(t, releases[0].Note)
 	assert.Equal(t, "A message.\n", releases[1].Note)
 	assert.Equal(t, "no signature present here", releases[2].Note)
 }

models/git/branch_test.go

···
 func TestAddDeletedBranch(t *testing.T) {
 	require.NoError(t, unittest.PrepareTestDatabase())
 	repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 1})
-	assert.EqualValues(t, git.Sha1ObjectFormat.Name(), repo.ObjectFormatName)
+	assert.Equal(t, git.Sha1ObjectFormat.Name(), repo.ObjectFormatName)
 	firstBranch := unittest.AssertExistsAndLoadBean(t, &git_model.Branch{ID: 1})
 
 	assert.True(t, firstBranch.IsDeleted)

models/git/lfs_test.go

···
 			return nil
 		})
 		require.NoError(t, err)
-		assert.EqualValues(t, expected, cases)
+		assert.Equal(t, expected, cases)
 	})
 
 	t.Run("Low batch size", func(t *testing.T) {
···
 			return nil
 		})
 		require.NoError(t, err)
-		assert.EqualValues(t, expected, cases)
+		assert.Equal(t, expected, cases)
 	})
 }
 
···
 			return nil
 		}, &IterateLFSMetaObjectsForRepoOptions{})
 		require.NoError(t, err)
-		assert.EqualValues(t, expectedIDs, actualIDs)
+		assert.Equal(t, expectedIDs, actualIDs)
 	})
 
 	t.Run("Low batch size", func(t *testing.T) {
···
 			return nil
 		}, &IterateLFSMetaObjectsForRepoOptions{})
 		require.NoError(t, err)
-		assert.EqualValues(t, expectedIDs, actualIDs)
+		assert.Equal(t, expectedIDs, actualIDs)
 
 		t.Run("Batch handles updates", func(t *testing.T) {
 			actualIDs := []int64{}
···
 				return nil
 			}, &IterateLFSMetaObjectsForRepoOptions{})
 			require.NoError(t, err)
-			assert.EqualValues(t, expectedIDs, actualIDs)
+			assert.Equal(t, expectedIDs, actualIDs)
 		})
 	})
 }

models/git/protected_branch_list_test.go

···
 				require.Error(t, fmt.Errorf("no matched rules but expected %s[%d]", kase.Rules[kase.ExpectedMatchIdx], kase.ExpectedMatchIdx))
 			}
 		} else {
-			assert.EqualValues(t, kase.Rules[kase.ExpectedMatchIdx], matchedPB.RuleName)
+			assert.Equal(t, kase.Rules[kase.ExpectedMatchIdx], matchedPB.RuleName)
 		}
 	}
 }

models/git/protected_branch_test.go

···
 
 	for _, kase := range kases {
 		pb := ProtectedBranch{RuleName: kase.Rule}
-		assert.EqualValues(t, kase.ExpectedMatch, pb.Match(kase.BranchName), "%s - %s", kase.BranchName, kase.Rule)
+		assert.Equal(t, kase.ExpectedMatch, pb.Match(kase.BranchName), "%s - %s", kase.BranchName, kase.Rule)
 	}
 }

models/issues/action_aggregator.go

···
 	}
 	agg.EndInd = index
 
-	if c.Type == CommentTypeClose {
+	switch c.Type {
+	case CommentTypeClose:
 		agg.IsClosed = true
-	} else if c.Type == CommentTypeReopen {
+	case CommentTypeReopen:
 		agg.IsClosed = false
-	} else if c.Type == CommentTypeReviewRequest {
+	case CommentTypeReviewRequest:
 		if c.AssigneeID > 0 {
 			req := RequestReviewTarget{User: c.Assignee}
 			if c.RemovedAssignee {
···
 		for _, r := range c.AddedRequestReview {
 			agg.addReviewRequest(r)
 		}
-	} else if c.Type == CommentTypeLabel {
+	case CommentTypeLabel:
 		if c.Content == "1" {
 			agg.addLabel(c.Label)
 		} else {
 			agg.delLabel(c.Label)
 		}
-	} else if c.Type == CommentTypeAggregator {
+	case CommentTypeAggregator:
 		agg.Merge(c.Aggregator)
 	}
 }

models/issues/comment_test.go

···
 	require.NoError(t, err)
 	then := time.Now().Unix()
 
-	assert.EqualValues(t, issues_model.CommentTypeComment, comment.Type)
-	assert.EqualValues(t, "Hello", comment.Content)
-	assert.EqualValues(t, issue.ID, comment.IssueID)
-	assert.EqualValues(t, doer.ID, comment.PosterID)
+	assert.Equal(t, issues_model.CommentTypeComment, comment.Type)
+	assert.Equal(t, "Hello", comment.Content)
+	assert.Equal(t, issue.ID, comment.IssueID)
+	assert.Equal(t, doer.ID, comment.PosterID)
 	unittest.AssertInt64InRange(t, now, then, int64(comment.CreatedUnix))
 	unittest.AssertExistsAndLoadBean(t, comment) // assert actually added to DB
 
···
 	require.NoError(t, err)
 
 	issueModified := unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: 1})
-	assert.EqualValues(t, issue.NumComments+1, issueModified.NumComments)
+	assert.Equal(t, issue.NumComments+1, issueModified.NumComments)
 
 	unittest.CheckConsistencyFor(t, &issues_model.Issue{})
 }
···
 
 	require.NoError(t, issues_model.UpdateIssueNumComments(db.DefaultContext, issue2.ID))
 	issue2 = unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: 2})
-	assert.EqualValues(t, 1, issue2.NumComments)
+	assert.Equal(t, 1, issue2.NumComments)
 }

models/issues/issue.go

···
 	err = sess.Find(&issueDeps)
 
 	for _, depInfo := range issueDeps {
-		depInfo.Issue.Repo = &depInfo.Repository
+		depInfo.Repo = &depInfo.Repository
 	}
 
 	return issueDeps, err
···
 		Find(&issueDeps)
 
 	for _, depInfo := range issueDeps {
-		depInfo.Issue.Repo = &depInfo.Repository
+		depInfo.Repo = &depInfo.Repository
 	}
 
 	return issueDeps, err

models/issues/issue_list_test.go

···
 	require.NoError(t, err)
 	assert.Len(t, repos, 2)
 	for _, issue := range issueList {
-		assert.EqualValues(t, issue.RepoID, issue.Repo.ID)
+		assert.Equal(t, issue.RepoID, issue.Repo.ID)
 	}
 }
 
···
 
 	require.NoError(t, issueList.LoadAttributes(db.DefaultContext))
 	for _, issue := range issueList {
-		assert.EqualValues(t, issue.RepoID, issue.Repo.ID)
+		assert.Equal(t, issue.RepoID, issue.Repo.ID)
 		for _, label := range issue.Labels {
-			assert.EqualValues(t, issue.RepoID, label.RepoID)
+			assert.Equal(t, issue.RepoID, label.RepoID)
 			unittest.AssertExistsAndLoadBean(t, &issues_model.IssueLabel{IssueID: issue.ID, LabelID: label.ID})
 		}
 		if issue.PosterID > 0 {
-			assert.EqualValues(t, issue.PosterID, issue.Poster.ID)
+			assert.Equal(t, issue.PosterID, issue.Poster.ID)
 		}
 		if issue.AssigneeID > 0 {
-			assert.EqualValues(t, issue.AssigneeID, issue.Assignee.ID)
+			assert.Equal(t, issue.AssigneeID, issue.Assignee.ID)
 		}
 		if issue.MilestoneID > 0 {
-			assert.EqualValues(t, issue.MilestoneID, issue.Milestone.ID)
+			assert.Equal(t, issue.MilestoneID, issue.Milestone.ID)
 		}
 		if issue.IsPull {
-			assert.EqualValues(t, issue.ID, issue.PullRequest.IssueID)
+			assert.Equal(t, issue.ID, issue.PullRequest.IssueID)
 		}
 		for _, attachment := range issue.Attachments {
-			assert.EqualValues(t, issue.ID, attachment.IssueID)
+			assert.Equal(t, issue.ID, attachment.IssueID)
 		}
 		for _, comment := range issue.Comments {
-			assert.EqualValues(t, issue.ID, comment.IssueID)
+			assert.Equal(t, issue.ID, comment.IssueID)
 		}
 		if issue.ID == int64(1) {
 			assert.Equal(t, int64(400), issue.TotalTrackedTime)

models/issues/issue_project_test.go

···
 
 			issuesNum, err := issues.NumIssuesInProject(db.DefaultContext, orgProject, user2, org, optional.None[bool]())
 			require.NoError(t, err)
-			assert.EqualValues(t, 2, issuesNum)
+			assert.Equal(t, 2, issuesNum)
 
 			issuesNum, err = issues.NumIssuesInProject(db.DefaultContext, orgProject, user2, org, optional.Some(true))
 			require.NoError(t, err)
-			assert.EqualValues(t, 0, issuesNum)
+			assert.Equal(t, 0, issuesNum)
 
 			issuesNum, err = issues.NumIssuesInProject(db.DefaultContext, orgProject, user2, org, optional.Some(false))
 			require.NoError(t, err)
-			assert.EqualValues(t, 2, issuesNum)
+			assert.Equal(t, 2, issuesNum)
 		})
 
 		t.Run("Anonymous user", func(t *testing.T) {
···
 
 			issuesNum, err := issues.NumIssuesInProject(db.DefaultContext, orgProject, nil, org, optional.None[bool]())
 			require.NoError(t, err)
-			assert.EqualValues(t, 1, issuesNum)
+			assert.Equal(t, 1, issuesNum)
 
 			issuesNum, err = issues.NumIssuesInProject(db.DefaultContext, orgProject, nil, org, optional.Some(true))
 			require.NoError(t, err)
-			assert.EqualValues(t, 0, issuesNum)
+			assert.Equal(t, 0, issuesNum)
 
 			issuesNum, err = issues.NumIssuesInProject(db.DefaultContext, orgProject, nil, org, optional.Some(false))
 			require.NoError(t, err)
-			assert.EqualValues(t, 1, issuesNum)
+			assert.Equal(t, 1, issuesNum)
 		})
 	})
 
···
 
 			issuesNum, err := issues.NumIssuesInProject(db.DefaultContext, userProject, user2, nil, optional.None[bool]())
 			require.NoError(t, err)
-			assert.EqualValues(t, 2, issuesNum)
+			assert.Equal(t, 2, issuesNum)
 
 			issuesNum, err = issues.NumIssuesInProject(db.DefaultContext, userProject, user2, nil, optional.Some(true))
 			require.NoError(t, err)
-			assert.EqualValues(t, 0, issuesNum)
+			assert.Equal(t, 0, issuesNum)
 
 			issuesNum, err = issues.NumIssuesInProject(db.DefaultContext, userProject, user2, nil, optional.Some(false))
 			require.NoError(t, err)
-			assert.EqualValues(t, 2, issuesNum)
+			assert.Equal(t, 2, issuesNum)
 		})
 
 		t.Run("Anonymous user", func(t *testing.T) {
···
 
 			issuesNum, err := issues.NumIssuesInProject(db.DefaultContext, userProject, nil, nil, optional.None[bool]())
 			require.NoError(t, err)
-			assert.EqualValues(t, 1, issuesNum)
+			assert.Equal(t, 1, issuesNum)
 
 			issuesNum, err = issues.NumIssuesInProject(db.DefaultContext, userProject, nil, nil, optional.Some(true))
 			require.NoError(t, err)
-			assert.EqualValues(t, 0, issuesNum)
+			assert.Equal(t, 0, issuesNum)
 
 			issuesNum, err = issues.NumIssuesInProject(db.DefaultContext, userProject, nil, nil, optional.Some(false))
 			require.NoError(t, err)
-			assert.EqualValues(t, 1, issuesNum)
+			assert.Equal(t, 1, issuesNum)
 		})
 	})
 }
···
 
 		issuesNum, err := issues.NumIssuesInProject(db.DefaultContext, orgProject, user29, org, optional.None[bool]())
 		require.NoError(t, err)
-		assert.EqualValues(t, 1, issuesNum)
+		assert.Equal(t, 1, issuesNum)
 
 		issuesNum, err = issues.NumIssuesInProject(db.DefaultContext, orgProject, user29, org, optional.Some(true))
 		require.NoError(t, err)
-		assert.EqualValues(t, 0, issuesNum)
+		assert.Equal(t, 0, issuesNum)
 
 		issuesNum, err = issues.NumIssuesInProject(db.DefaultContext, orgProject, user29, org, optional.Some(false))
 		require.NoError(t, err)
-		assert.EqualValues(t, 1, issuesNum)
+		assert.Equal(t, 1, issuesNum)
 	})
 
 	t.Run("Full access", func(t *testing.T) {
···
 
 		issuesNum, err := issues.NumIssuesInProject(db.DefaultContext, orgProject, user2, org, optional.None[bool]())
 		require.NoError(t, err)
-		assert.EqualValues(t, 2, issuesNum)
+		assert.Equal(t, 2, issuesNum)
 
 		issuesNum, err = issues.NumIssuesInProject(db.DefaultContext, orgProject, user2, org, optional.Some(true))
 		require.NoError(t, err)
-		assert.EqualValues(t, 0, issuesNum)
+		assert.Equal(t, 0, issuesNum)
 
 		issuesNum, err = issues.NumIssuesInProject(db.DefaultContext, orgProject, user2, org, optional.Some(false))
 		require.NoError(t, err)
-		assert.EqualValues(t, 2, issuesNum)
+		assert.Equal(t, 2, issuesNum)
 	})
 }

models/issues/issue_test.go

···
 	then := time.Now().Unix()
 
 	updatedIssue := unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: issue.ID})
-	assert.EqualValues(t, newTitle, updatedIssue.Title)
-	assert.EqualValues(t, prevContent, updatedIssue.Content)
+	assert.Equal(t, newTitle, updatedIssue.Title)
+	assert.Equal(t, prevContent, updatedIssue.Content)
 	unittest.AssertInt64InRange(t, now, then, int64(updatedIssue.UpdatedUnix))
 }
 
···
 		require.NoError(t, err)
 		if assert.Len(t, issues, len(test.ExpectedIssueIDs)) {
 			for i, issue := range issues {
-				assert.EqualValues(t, test.ExpectedIssueIDs[i], issue.ID)
+				assert.Equal(t, test.ExpectedIssueIDs[i], issue.ID)
 			}
 		}
 	}
···
 		has, err := db.GetEngine(db.DefaultContext).ID(issue.ID).Get(&newIssue)
 		require.NoError(t, err)
 		assert.True(t, has)
-		assert.EqualValues(t, issue.Title, newIssue.Title)
-		assert.EqualValues(t, issue.Content, newIssue.Content)
+		assert.Equal(t, issue.Title, newIssue.Title)
+		assert.Equal(t, issue.Content, newIssue.Content)
 		if expectIndex > 0 {
-			assert.EqualValues(t, expectIndex, newIssue.Index)
+			assert.Equal(t, expectIndex, newIssue.Index)
 		}
 	})
 	return &newIssue
···
 			ids[i] = user.ID
 		}
 		sort.Slice(ids, func(i, j int) bool { return ids[i] < ids[j] })
-		assert.EqualValues(t, expected, ids)
+		assert.Equal(t, expected, ids)
 	}
 
 	// Public repo, existing user
···
 
 	for _, issue := range issueList {
 		require.NoError(t, issue.LoadAttributes(db.DefaultContext))
-		assert.EqualValues(t, issue.RepoID, issue.Repo.ID)
+		assert.Equal(t, issue.RepoID, issue.Repo.ID)
 		for _, label := range issue.Labels {
-			assert.EqualValues(t, issue.RepoID, label.RepoID)
+			assert.Equal(t, issue.RepoID, label.RepoID)
 			unittest.AssertExistsAndLoadBean(t, &issues_model.IssueLabel{IssueID: issue.ID, LabelID: label.ID})
 		}
 		if issue.PosterID > 0 {
-			assert.EqualValues(t, issue.PosterID, issue.Poster.ID)
+			assert.Equal(t, issue.PosterID, issue.Poster.ID)
 		}
 		if issue.AssigneeID > 0 {
-			assert.EqualValues(t, issue.AssigneeID, issue.Assignee.ID)
+			assert.Equal(t, issue.AssigneeID, issue.Assignee.ID)
 		}
 		if issue.MilestoneID > 0 {
-			assert.EqualValues(t, issue.MilestoneID, issue.Milestone.ID)
+			assert.Equal(t, issue.MilestoneID, issue.Milestone.ID)
 		}
 		if issue.IsPull {
-			assert.EqualValues(t, issue.ID, issue.PullRequest.IssueID)
+			assert.Equal(t, issue.ID, issue.PullRequest.IssueID)
 		}
 		for _, attachment := range issue.Attachments {
-			assert.EqualValues(t, issue.ID, attachment.IssueID)
+			assert.Equal(t, issue.ID, attachment.IssueID)
 		}
 		for _, comment := range issue.Comments {
-			assert.EqualValues(t, issue.ID, comment.IssueID)
+			assert.Equal(t, issue.ID, comment.IssueID)
 		}
 		if issue.ID == int64(1) {
 			assert.Equal(t, int64(400), issue.TotalTrackedTime)

models/issues/label_test.go

···
 	require.NoError(t, unittest.PrepareTestDatabase())
 	label := unittest.AssertExistsAndLoadBean(t, &issues_model.Label{ID: 1})
 	label.CalOpenIssues()
-	assert.EqualValues(t, 2, label.NumOpenIssues)
+	assert.Equal(t, 2, label.NumOpenIssues)
 }
 
 func TestLabel_LoadSelectedLabelsAfterClick(t *testing.T) {
···
 		require.NoError(t, err)
 		assert.Len(t, labels, len(expectedIssueIDs))
 		for i, label := range labels {
-			assert.EqualValues(t, expectedIssueIDs[i], label.ID)
+			assert.Equal(t, expectedIssueIDs[i], label.ID)
 		}
 	}
 	testSuccess(1, "leastissues", []int64{2, 1})
···
 		require.NoError(t, err)
 		assert.Len(t, labels, len(expectedIssueIDs))
 		for i, label := range labels {
-			assert.EqualValues(t, expectedIssueIDs[i], label.ID)
+			assert.Equal(t, expectedIssueIDs[i], label.ID)
 		}
 	}
 	testSuccess(3, "leastissues", []int64{3, 4})
···
 	label.Name = update.Name
 	require.NoError(t, issues_model.UpdateLabel(db.DefaultContext, update))
 	newLabel := unittest.AssertExistsAndLoadBean(t, &issues_model.Label{ID: 1})
-	assert.EqualValues(t, label.ID, newLabel.ID)
-	assert.EqualValues(t, label.Color, newLabel.Color)
-	assert.EqualValues(t, label.Name, newLabel.Name)
-	assert.EqualValues(t, label.Description, newLabel.Description)
+	assert.Equal(t, label.ID, newLabel.ID)
+	assert.Equal(t, label.Color, newLabel.Color)
+	assert.Equal(t, label.Name, newLabel.Name)
+	assert.Equal(t, label.Description, newLabel.Description)
 	assert.EqualValues(t, 0, newLabel.ArchivedUnix)
 	unittest.CheckConsistencyFor(t, &issues_model.Label{}, &repo_model.Repository{})
 }
···
 		Content:  "1",
 	})
 	label = unittest.AssertExistsAndLoadBean(t, &issues_model.Label{ID: 2})
-	assert.EqualValues(t, prevNumIssues+1, label.NumIssues)
+	assert.Equal(t, prevNumIssues+1, label.NumIssues)
 
 	// re-add existing IssueLabel
 	require.NoError(t, issues_model.NewIssueLabel(db.DefaultContext, issue, label, doer))
···
 	})
 	unittest.AssertExistsAndLoadBean(t, &issues_model.IssueLabel{IssueID: issue.ID, LabelID: label1.ID})
 	label1 = unittest.AssertExistsAndLoadBean(t, &issues_model.Label{ID: 1})
-	assert.EqualValues(t, 3, label1.NumIssues)
-	assert.EqualValues(t, 1, label1.NumClosedIssues)
+	assert.Equal(t, 3, label1.NumIssues)
+	assert.Equal(t, 1, label1.NumClosedIssues)
 	label2 = unittest.AssertExistsAndLoadBean(t, &issues_model.Label{ID: 2})
-	assert.EqualValues(t, 1, label2.NumIssues)
-	assert.EqualValues(t, 1, label2.NumClosedIssues)
+	assert.Equal(t, 1, label2.NumIssues)
+	assert.Equal(t, 1, label2.NumClosedIssues)
 
 	// corner case: test empty slice
 	require.NoError(t, issues_model.NewIssueLabels(db.DefaultContext, issue, []*issues_model.Label{}, doer))
···
 			LabelID:  labelID,
 		}, `content=""`)
 		label = unittest.AssertExistsAndLoadBean(t, &issues_model.Label{ID: labelID})
-		assert.EqualValues(t, expectedNumIssues, label.NumIssues)
-		assert.EqualValues(t, expectedNumClosedIssues, label.NumClosedIssues)
+		assert.Equal(t, expectedNumIssues, label.NumIssues)
+		assert.Equal(t, expectedNumClosedIssues, label.NumClosedIssues)
 	}
 	testSuccess(1, 1, 2)
 	testSuccess(2, 5, 2)

models/issues/milestone_test.go

···
 
 		assert.Len(t, milestones, n)
 		for _, milestone := range milestones {
-			assert.EqualValues(t, repoID, milestone.RepoID)
+			assert.Equal(t, repoID, milestone.RepoID)
 		}
 	}
 	test(1, api.StateOpen)
···
 	milestone.Content = "newMilestoneContent"
 	require.NoError(t, issues_model.UpdateMilestone(db.DefaultContext, milestone, milestone.IsClosed))
 	milestone = unittest.AssertExistsAndLoadBean(t, &issues_model.Milestone{ID: 1})
-	assert.EqualValues(t, "newMilestoneName", milestone.Name)
+	assert.Equal(t, "newMilestoneName", milestone.Name)
 	unittest.CheckConsistencyFor(t, &issues_model.Milestone{})
 }
 
···
 	require.NoError(t, err)
 	unittest.AssertExistsAndLoadBean(t, ms)
 	repoModified := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: repo.ID})
-	assert.EqualValues(t, repo.NumMilestones+1, repoModified.NumMilestones)
+	assert.Equal(t, repo.NumMilestones+1, repoModified.NumMilestones)
 
 	unittest.CheckConsistencyFor(t, &issues_model.Milestone{})
 }

models/issues/pull_test.go

···
 
 	countAfter, err := db.GetEngine(db.DefaultContext).Count(&issues_model.PullRequest{})
 	require.NoError(t, err)
-	assert.EqualValues(t, countBefore, countAfter)
+	assert.Equal(t, countBefore, countAfter)
 }
 
 func TestParseCodeOwnersLine(t *testing.T) {
···
 	setting.Repository.PullRequest.DefaultMergeMessageOfficialApproversOnly = false
 	approvers := pr.GetApprovers(db.DefaultContext)
 	expected := "Reviewed-by: User Five <[e-mail]>\nReviewed-by: Org Six <[e-mail]>\n"
-	assert.EqualValues(t, expected, approvers)
+	assert.Equal(t, expected, approvers)
 }
 
 func TestGetPullRequestByMergedCommit(t *testing.T) {

models/issues/stopwatch_test.go

···
 
 	uidStopwatches, err := issues_model.GetUIDsAndStopwatch(db.DefaultContext)
 	require.NoError(t, err)
-	assert.EqualValues(t, map[int64][]*issues_model.Stopwatch{
+	assert.Equal(t, map[int64][]*issues_model.Stopwatch{
 		1: {
 			{
 				ID:          1,

models/migrations/migrations_test.go

···
 
 	assert.EqualValues(t, 71, migrationIDNumberToDBVersion(70))
 
-	assert.EqualValues(t, []*migration{{idNumber: 70}, {idNumber: 71}}, getPendingMigrations(70, preparedMigrations))
-	assert.EqualValues(t, []*migration{{idNumber: 71}}, getPendingMigrations(71, preparedMigrations))
-	assert.EqualValues(t, []*migration{}, getPendingMigrations(72, preparedMigrations))
+	assert.Equal(t, []*migration{{idNumber: 70}, {idNumber: 71}}, getPendingMigrations(70, preparedMigrations))
+	assert.Equal(t, []*migration{{idNumber: 71}}, getPendingMigrations(71, preparedMigrations))
+	assert.Equal(t, []*migration{}, getPendingMigrations(72, preparedMigrations))
 }

models/migrations/v1_15/v181_test.go

···
 		require.NoError(t, err)
 		assert.True(t, has)
 		assert.True(t, emailAddress.IsPrimary)
-		assert.EqualValues(t, user.IsActive, emailAddress.IsActivated)
-		assert.EqualValues(t, user.ID, emailAddress.UID)
+		assert.Equal(t, user.IsActive, emailAddress.IsActivated)
+		assert.Equal(t, user.ID, emailAddress.UID)
 	}
 }

models/migrations/v1_16/v189_test.go

···
 				return
 			}
 
-			assert.EqualValues(t, expected, converted, "UnwrapLDAPSourceCfg failed for %d", source.ID)
-			assert.EqualValues(t, source.ID%2 == 0, source.IsActive, "UnwrapLDAPSourceCfg failed for %d", source.ID)
+			assert.Equal(t, expected, converted, "UnwrapLDAPSourceCfg failed for %d", source.ID)
+			assert.Equal(t, source.ID%2 == 0, source.IsActive, "UnwrapLDAPSourceCfg failed for %d", source.ID)
 		}
 	}
 }

models/migrations/v1_16/v193_test.go

···
 		has, err := x.ID(attach.IssueID).Get(&issue)
 		require.NoError(t, err)
 		assert.True(t, has)
-		assert.EqualValues(t, attach.RepoID, issue.RepoID)
+		assert.Equal(t, attach.RepoID, issue.RepoID)
 	}
 
 	var releaseAttachments []*NewAttachment
···
 		has, err := x.ID(attach.ReleaseID).Get(&release)
 		require.NoError(t, err)
 		assert.True(t, has)
-		assert.EqualValues(t, attach.RepoID, release.RepoID)
+		assert.Equal(t, attach.RepoID, release.RepoID)
 	}
 }

models/migrations/v1_16/v210_test.go

···
 	err = x.Table("webauthn_credential").Select("id, credential_id").Asc("id").Find(&got)
 	require.NoError(t, err)
 
-	assert.EqualValues(t, expected, got)
+	assert.Equal(t, expected, got)
 }

models/migrations/v1_19/v233_test.go

···
 		assert.Equal(t, e.Meta, got[i].Meta)
 
 		if e.HeaderAuthorization == "" {
-			assert.Equal(t, "", got[i].HeaderAuthorizationEncrypted)
+			assert.Empty(t, got[i].HeaderAuthorizationEncrypted)
 		} else {
 			cipherhex := got[i].HeaderAuthorizationEncrypted
 			cleartext, err := secret.DecryptSecret(setting.SecretKey, cipherhex)

models/migrations/v1_20/v259_test.go

···
 	tokens := make([]AccessToken, 0)
 	err = x.Find(&tokens)
 	require.NoError(t, err)
-	assert.Equal(t, len(tests), len(tokens))
+	assert.Len(t, tokens, len(tests))
 
 	// sort the tokens (insertion order by auto-incrementing primary key)
 	sort.Slice(tokens, func(i, j int) bool {

models/migrations/v1_22/v286_test.go

···
 	ok, err := x.ID(2).Get(repo)
 	require.NoError(t, err)
 	assert.True(t, ok)
-	assert.EqualValues(t, "sha1", repo.ObjectFormatName)
+	assert.Equal(t, "sha1", repo.ObjectFormatName)
 
 	repo = new(Repository)
 	ok, err = x.ID(id).Get(repo)
 	require.NoError(t, err)
 	assert.True(t, ok)
-	assert.EqualValues(t, "sha256", repo.ObjectFormatName)
+	assert.Equal(t, "sha256", repo.ObjectFormatName)
 }

models/org_team_test.go

···
 	assert.True(t, strings.HasPrefix(team.Description, "A long description!"))
 
 	access := unittest.AssertExistsAndLoadBean(t, &access_model.Access{UserID: 4, RepoID: 3})
-	assert.EqualValues(t, perm.AccessModeAdmin, access.Mode)
+	assert.Equal(t, perm.AccessModeAdmin, access.Mode)
 
 	unittest.CheckConsistencyFor(t, &organization.Team{ID: team.ID})
 }

models/org_test.go

···
 		require.NoError(t, RemoveOrgUser(db.DefaultContext, orgID, userID))
 		unittest.AssertNotExistsBean(t, &organization.OrgUser{OrgID: orgID, UID: userID})
 		org = unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: orgID})
-		assert.EqualValues(t, expectedNumMembers, org.NumMembers)
+		assert.Equal(t, expectedNumMembers, org.NumMembers)
 	}
 	testSuccess(3, 4)
 	testSuccess(3, 4)

models/organization/org.go

···
 }
 
 func (opts FindOrgMembersOpts) PublicOnly() bool {
-	return opts.Doer == nil || !(opts.IsDoerMember || opts.Doer.IsAdmin)
+	return opts.Doer == nil || (!opts.IsDoerMember && !opts.Doer.IsAdmin)
 }
 
 // CountOrgMembers counts the organization's members
···
 		sess.And("is_public = ?", true)
 	}
 
-	if opts.ListOptions.PageSize > 0 {
+	if opts.PageSize > 0 {
 		sess = db.SetSessionPagination(sess, opts)
 
 		ous := make([]*OrgUser, 0, opts.PageSize)

models/organization/org_list_test.go

···
 	if assert.Len(t, orgs, 1) {
 		assert.EqualValues(t, 3, orgs[0].ID)
 		// repo_id: 3 is in the team, 32 is public, 5 is private with no team
-		assert.EqualValues(t, 2, orgs[0].NumRepos)
+		assert.Equal(t, 2, orgs[0].NumRepos)
 	}
 }
 

models/organization/org_test.go

···
 	test := func(orgID, userID int64, expected bool) {
 		isOwner, err := organization.IsOrganizationOwner(db.DefaultContext, orgID, userID)
 		require.NoError(t, err)
-		assert.EqualValues(t, expected, isOwner)
+		assert.Equal(t, expected, isOwner)
 	}
 	test(3, 2, true)
 	test(3, 3, false)
···
 	test := func(orgID, userID int64, expected bool) {
 		isMember, err := organization.IsOrganizationMember(db.DefaultContext, orgID, userID)
 		require.NoError(t, err)
-		assert.EqualValues(t, expected, isMember)
+		assert.Equal(t, expected, isMember)
 	}
 	test(3, 2, true)
 	test(3, 3, false)
···
 	test := func(orgID, userID int64, expected bool) {
 		isMember, err := organization.IsPublicMembership(db.DefaultContext, orgID, userID)
 		require.NoError(t, err)
-		assert.EqualValues(t, expected, isMember)
+		assert.Equal(t, expected, isMember)
 	}
 	test(3, 2, true)
 	test(3, 3, false)
···
 	sort.Slice(orgUsers, func(i, j int) bool {
 		return orgUsers[i].ID < orgUsers[j].ID
 	})
-	assert.EqualValues(t, []*organization.OrgUser{{
+	assert.Equal(t, []*organization.OrgUser{{
 		ID:       1,
 		OrgID:    3,
 		UID:      2,
···
 		require.NoError(t, err)
 		count, err := env.CountRepos()
 		require.NoError(t, err)
-		assert.EqualValues(t, expectedCount, count)
+		assert.Equal(t, expectedCount, count)
 	}
 	testSuccess(2, 3)
 	testSuccess(4, 2)
···
 	user := &user_model.User{ID: 1001}
 	t.Run("Anonymous", func(t *testing.T) {
 		t.Run("Public", func(t *testing.T) {
-			assert.EqualValues(t, perm.AccessModeRead, publicOrg.UnitPermission(db.DefaultContext, nil, unit.TypeCode))
+			assert.Equal(t, perm.AccessModeRead, publicOrg.UnitPermission(db.DefaultContext, nil, unit.TypeCode))
 		})
 		t.Run("Limited", func(t *testing.T) {
-			assert.EqualValues(t, perm.AccessModeNone, limitedOrg.UnitPermission(db.DefaultContext, nil, unit.TypeCode))
+			assert.Equal(t, perm.AccessModeNone, limitedOrg.UnitPermission(db.DefaultContext, nil, unit.TypeCode))
 		})
 		t.Run("Private", func(t *testing.T) {
-			assert.EqualValues(t, perm.AccessModeNone, privateOrg.UnitPermission(db.DefaultContext, nil, unit.TypeCode))
+			assert.Equal(t, perm.AccessModeNone, privateOrg.UnitPermission(db.DefaultContext, nil, unit.TypeCode))
 		})
 	})
 
 	t.Run("Logged in", func(t *testing.T) {
 		t.Run("Public", func(t *testing.T) {
-			assert.EqualValues(t, perm.AccessModeRead, publicOrg.UnitPermission(db.DefaultContext, user, unit.TypeCode))
+			assert.Equal(t, perm.AccessModeRead, publicOrg.UnitPermission(db.DefaultContext, user, unit.TypeCode))
 		})
 		t.Run("Limited", func(t *testing.T) {
-			assert.EqualValues(t, perm.AccessModeRead, limitedOrg.UnitPermission(db.DefaultContext, user, unit.TypeCode))
+			assert.Equal(t, perm.AccessModeRead, limitedOrg.UnitPermission(db.DefaultContext, user, unit.TypeCode))
 		})
 		t.Run("Private", func(t *testing.T) {
-			assert.EqualValues(t, perm.AccessModeNone, privateOrg.UnitPermission(db.DefaultContext, user, unit.TypeCode))
+			assert.Equal(t, perm.AccessModeNone, privateOrg.UnitPermission(db.DefaultContext, user, unit.TypeCode))
 		})
 	})
 }

models/organization/org_user_test.go

···
 		unittest.AssertExistsAndLoadBean(t, ou)
 		assert.Equal(t, isPublic, ou.IsPublic)
 		org = unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: orgID})
-		assert.EqualValues(t, expectedNumMembers, org.NumMembers)
+		assert.Equal(t, expectedNumMembers, org.NumMembers)
 	}
 
 	setting.Service.DefaultOrgMemberVisible = false

models/organization/team_test.go

···
 	testSuccess := func(orgID int64, name string) {
 		team, err := organization.GetTeam(db.DefaultContext, orgID, name)
 		require.NoError(t, err)
-		assert.EqualValues(t, orgID, team.OrgID)
+		assert.Equal(t, orgID, team.OrgID)
 		assert.Equal(t, name, team.Name)
 	}
 	testSuccess(3, "Owners")
···
 	testSuccess := func(teamID int64) {
 		team, err := organization.GetTeamByID(db.DefaultContext, teamID)
 		require.NoError(t, err)
-		assert.EqualValues(t, teamID, team.ID)
+		assert.Equal(t, teamID, team.ID)
 	}
 	testSuccess(1)
 	testSuccess(2)
···
 		teams, err := organization.GetUserOrgTeams(db.DefaultContext, orgID, userID)
 		require.NoError(t, err)
 		for _, team := range teams {
-			assert.EqualValues(t, orgID, team.OrgID)
+			assert.Equal(t, orgID, team.OrgID)
 			unittest.AssertExistsAndLoadBean(t, &organization.TeamUser{TeamID: team.ID, UID: userID})
 		}
 	}

models/perm/access/access.go

···
 		return fmt.Errorf("getCollaborations: %w", err)
 	}
 	for _, c := range collaborators {
-		if c.User.IsGhost() {
+		if c.IsGhost() {
 			continue
 		}
 		updateUserAccess(accessMap, c.User, c.Collaboration.Mode)

models/project/column_test.go

···
 	columnsAfter, err := project1.GetColumns(db.DefaultContext)
 	require.NoError(t, err)
 	assert.Len(t, columnsAfter, 3)
-	assert.EqualValues(t, columns[1].ID, columnsAfter[0].ID)
-	assert.EqualValues(t, columns[2].ID, columnsAfter[1].ID)
-	assert.EqualValues(t, columns[0].ID, columnsAfter[2].ID)
+	assert.Equal(t, columns[1].ID, columnsAfter[0].ID)
+	assert.Equal(t, columns[2].ID, columnsAfter[1].ID)
+	assert.Equal(t, columns[0].ID, columnsAfter[2].ID)
 }
 
 func Test_NewColumn(t *testing.T) {

models/project/project_test.go

···
 			OrderBy: GetSearchOrderByBySortType(tt.sortType),
 		})
 		require.NoError(t, err)
-		assert.EqualValues(t, int64(6), count)
+		assert.Equal(t, int64(6), count)
 		if assert.Len(t, projects, 6) {
 			for i := range projects {
-				assert.EqualValues(t, tt.wants[i], projects[i].ID)
+				assert.Equal(t, tt.wants[i], projects[i].ID)
 			}
 		}
 	}

models/repo/collaboration_test.go

···
 		require.NoError(t, err)
 		assert.Len(t, collaborators, int(expectedLen))
 		for _, collaborator := range collaborators {
-			assert.EqualValues(t, collaborator.User.ID, collaborator.Collaboration.UserID)
-			assert.EqualValues(t, repoID, collaborator.Collaboration.RepoID)
+			assert.Equal(t, collaborator.User.ID, collaborator.Collaboration.UserID)
+			assert.Equal(t, repoID, collaborator.Collaboration.RepoID)
 		}
 	}
 	test(1)
···
 	require.NoError(t, err)
 	assert.Len(t, collaborators2, 1)
 
-	assert.NotEqualValues(t, collaborators1[0].ID, collaborators2[0].ID)
+	assert.NotEqual(t, collaborators1[0].ID, collaborators2[0].ID)
 }
 
 func TestRepository_IsCollaborator(t *testing.T) {
···
 	require.NoError(t, repo_model.ChangeCollaborationAccessMode(db.DefaultContext, repo, 4, perm.AccessModeAdmin))
 
 	collaboration := unittest.AssertExistsAndLoadBean(t, &repo_model.Collaboration{RepoID: repo.ID, UserID: 4})
-	assert.EqualValues(t, perm.AccessModeAdmin, collaboration.Mode)
+	assert.Equal(t, perm.AccessModeAdmin, collaboration.Mode)
 
 	access := unittest.AssertExistsAndLoadBean(t, &access_model.Access{UserID: 4, RepoID: repo.ID})
-	assert.EqualValues(t, perm.AccessModeAdmin, access.Mode)
+	assert.Equal(t, perm.AccessModeAdmin, access.Mode)
 
 	require.NoError(t, repo_model.ChangeCollaborationAccessMode(db.DefaultContext, repo, 4, perm.AccessModeAdmin))
 

models/repo/pushmirror_test.go

···
 	t.Run("Normal retrieval", func(t *testing.T) {
 		actualPrivateKey, err := m.Privatekey()
 		require.NoError(t, err)
-		assert.EqualValues(t, privateKey, actualPrivateKey)
+		assert.Equal(t, privateKey, actualPrivateKey)
 	})
 
 	t.Run("Incorrect retrieval", func(t *testing.T) {

models/repo/repo.go

···
 		return ru
 	}
 
-	if tp == unit.TypeExternalWiki {
+	switch tp {
+	case unit.TypeExternalWiki:
 		return &RepoUnit{
 			Type:   tp,
 			Config: new(ExternalWikiConfig),
 		}
-	} else if tp == unit.TypeExternalTracker {
+	case unit.TypeExternalTracker:
 		return &RepoUnit{
 			Type:   tp,
 			Config: new(ExternalTrackerConfig),
 		}
-	} else if tp == unit.TypePullRequests {
+	case unit.TypePullRequests:
 		return &RepoUnit{
 			Type:   tp,
 			Config: new(PullRequestsConfig),
 		}
-	} else if tp == unit.TypeIssues {
+	case unit.TypeIssues:
 		return &RepoUnit{
 			Type:   tp,
 			Config: new(IssuesConfig),
 		}
-	} else if tp == unit.TypeActions {
+	case unit.TypeActions:
 		return &RepoUnit{
 			Type:   tp,
 			Config: new(ActionsConfig),

models/repo/repo_list_test.go

···
 		require.NoError(t, err)
 
 		slices.Sort(repoIDs)
-		assert.EqualValues(t, testCase.repoIDs, repoIDs)
+		assert.Equal(t, testCase.repoIDs, repoIDs)
 	}
 }

models/repo/repo_unit_test.go

···
 func TestActionsConfig(t *testing.T) {
 	cfg := &ActionsConfig{}
 	cfg.DisableWorkflow("test1.yaml")
-	assert.EqualValues(t, []string{"test1.yaml"}, cfg.DisabledWorkflows)
+	assert.Equal(t, []string{"test1.yaml"}, cfg.DisabledWorkflows)
 
 	cfg.DisableWorkflow("test1.yaml")
-	assert.EqualValues(t, []string{"test1.yaml"}, cfg.DisabledWorkflows)
+	assert.Equal(t, []string{"test1.yaml"}, cfg.DisabledWorkflows)
 
 	cfg.EnableWorkflow("test1.yaml")
-	assert.EqualValues(t, []string{}, cfg.DisabledWorkflows)
+	assert.Equal(t, []string{}, cfg.DisabledWorkflows)
 
 	cfg.EnableWorkflow("test1.yaml")
-	assert.EqualValues(t, []string{}, cfg.DisabledWorkflows)
+	assert.Equal(t, []string{}, cfg.DisabledWorkflows)
 
 	cfg.DisableWorkflow("test1.yaml")
 	cfg.DisableWorkflow("test2.yaml")
 	cfg.DisableWorkflow("test3.yaml")
-	assert.EqualValues(t, "test1.yaml,test2.yaml,test3.yaml", cfg.ToString())
+	assert.Equal(t, "test1.yaml,test2.yaml,test3.yaml", cfg.ToString())
 }
 
 func TestRepoUnitAccessMode(t *testing.T) {

models/repo/topic_test.go

···
 	repo2NrOfTopics = 2
 	totalNrOfTopics++
 	topic := unittest.AssertExistsAndLoadBean(t, &repo_model.Topic{Name: "gitea"})
-	assert.EqualValues(t, 1, topic.RepoCount)
+	assert.Equal(t, 1, topic.RepoCount)
 
 	topics, _, err = repo_model.FindTopics(db.DefaultContext, &repo_model.FindTopicOptions{})
 	require.NoError(t, err)

models/repo/watch_test.go

···
 	// One watchers are inactive, thus minus 1
 	assert.Len(t, watches, repo.NumWatches-1)
 	for _, watch := range watches {
-		assert.EqualValues(t, repo.ID, watch.RepoID)
+		assert.Equal(t, repo.ID, watch.RepoID)
 	}
 
 	watches, err = repo_model.GetWatchers(db.DefaultContext, unittest.NonexistentID)

models/repo_test.go

···
 
 	issue2 := unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: 2})
 	assert.NotNil(t, issue2)
-	assert.EqualValues(t, 0, issue2.NumComments) // the fixture data is wrong, but we don't fix it here
+	assert.Equal(t, 0, issue2.NumComments) // the fixture data is wrong, but we don't fix it here
 
 	require.NoError(t, repoStatsCorrectIssueNumComments(db.DefaultContext, 2))
 	// reload the issue
 	issue2 = unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: 2})
-	assert.EqualValues(t, 1, issue2.NumComments)
+	assert.Equal(t, 1, issue2.NumComments)
 }

models/repo_transfer_test.go

···
 	pendingTransferIDs, err := GetPendingTransferIDs(db.DefaultContext, reciepient.ID, doer.ID)
 	require.NoError(t, err)
 	if assert.Len(t, pendingTransferIDs, 1) {
-		assert.EqualValues(t, pendingTransfer.ID, pendingTransferIDs[0])
+		assert.Equal(t, pendingTransfer.ID, pendingTransferIDs[0])
 	}
 }

models/system/setting_test.go

···
 
 	rev, settings, err := system.GetAllSettings(db.DefaultContext)
 	require.NoError(t, err)
-	assert.EqualValues(t, 1, rev)
+	assert.Equal(t, 1, rev)
 	assert.Len(t, settings, 1) // there is only one "revision" key
 
 	err = system.SetSettings(db.DefaultContext, map[string]string{keyName: "true"})
 	require.NoError(t, err)
 	rev, settings, err = system.GetAllSettings(db.DefaultContext)
 	require.NoError(t, err)
-	assert.EqualValues(t, 2, rev)
+	assert.Equal(t, 2, rev)
 	assert.Len(t, settings, 2)
-	assert.EqualValues(t, "true", settings[keyName])
+	assert.Equal(t, "true", settings[keyName])
 
 	err = system.SetSettings(db.DefaultContext, map[string]string{keyName: "false"})
 	require.NoError(t, err)
 	rev, settings, err = system.GetAllSettings(db.DefaultContext)
 	require.NoError(t, err)
-	assert.EqualValues(t, 3, rev)
+	assert.Equal(t, 3, rev)
 	assert.Len(t, settings, 2)
-	assert.EqualValues(t, "false", settings[keyName])
+	assert.Equal(t, "false", settings[keyName])
 
 	// setting the same value should not trigger DuplicateKey error, and the "version" should be increased
 	err = system.SetSettings(db.DefaultContext, map[string]string{keyName: "false"})
···
 	rev, settings, err = system.GetAllSettings(db.DefaultContext)
 	require.NoError(t, err)
 	assert.Len(t, settings, 2)
-	assert.EqualValues(t, 4, rev)
+	assert.Equal(t, 4, rev)
 }

models/unittest/consistency.go

···
 	require.NoError(t, err)
 	f := consistencyCheckMap[tb.Name]
 	if f == nil {
-		assert.FailNow(t, "unknown bean type: %#v", bean)
+		assert.FailNow(t, "unknown bean type", "%#v", bean)
 	}
 	f(t, bean)
 }
···
 		AssertCountByCond(t, "follow", builder.Eq{"user_id": user.int("ID")}, user.int("NumFollowing"))
 		AssertCountByCond(t, "follow", builder.Eq{"follow_id": user.int("ID")}, user.int("NumFollowers"))
 		if user.int("Type") != modelsUserTypeOrganization {
-			assert.EqualValues(t, 0, user.int("NumMembers"), "Unexpected number of members for user id: %d", user.int("ID"))
-			assert.EqualValues(t, 0, user.int("NumTeams"), "Unexpected number of teams for user id: %d", user.int("ID"))
+			assert.Equal(t, 0, user.int("NumMembers"), "Unexpected number of members for user id: %d", user.int("ID"))
+			assert.Equal(t, 0, user.int("NumTeams"), "Unexpected number of teams for user id: %d", user.int("ID"))
 		}
 	}
 
···
 		assert.EqualValues(t, issue.int("NumComments"), actual, "Unexpected number of comments for issue id: %d", issue.int("ID"))
 		if issue.bool("IsPull") {
 			prRow := AssertExistsAndLoadMap(t, "pull_request", builder.Eq{"issue_id": issue.int("ID")})
-			assert.EqualValues(t, parseInt(prRow["index"]), issue.int("Index"), "Unexpected index for issue id: %d", issue.int("ID"))
+			assert.Equal(t, parseInt(prRow["index"]), issue.int("Index"), "Unexpected index for issue id: %d", issue.int("ID"))
 		}
 	}
 
···
 		pr := reflectionWrap(bean)
 		issueRow := AssertExistsAndLoadMap(t, "issue", builder.Eq{"id": pr.int("IssueID")})
 		assert.True(t, parseBool(issueRow["is_pull"]))
-		assert.EqualValues(t, parseInt(issueRow["index"]), pr.int("Index"), "Unexpected index for pull request id: %d", pr.int("ID"))
+		assert.Equal(t, parseInt(issueRow["index"]), pr.int("Index"), "Unexpected index for pull request id: %d", pr.int("ID"))
 	}
 
 	checkForMilestoneConsistency := func(t *testing.T, bean any) {

models/unittest/mock_http.go

···
 			for headerName, headerValues := range response.Header {
 				for _, headerValue := range headerValues {
 					if !slices.Contains(ignoredHeaders, strings.ToLower(headerName)) {
-						_, err := fixtureWriter.WriteString(fmt.Sprintf("%s: %s\n", headerName, headerValue))
+						_, err := fmt.Fprintf(fixtureWriter, "%s: %s\n", headerName, headerValue)
 						require.NoError(t, err, "writing the header of the HTTP response to the fixture file failed")
 					}
 				}

models/user/search.go

···
 		cond = builder.Eq{"type": opts.Type}
 	}
 	if opts.IncludeReserved {
-		if opts.Type == UserTypeIndividual {
+		switch opts.Type {
+		case UserTypeIndividual:
 			cond = cond.Or(builder.Eq{"type": UserTypeUserReserved}).Or(
 				builder.Eq{"type": UserTypeBot},
 			).Or(
 				builder.Eq{"type": UserTypeRemoteUser},
 			)
-		} else if opts.Type == UserTypeOrganization {
+		case UserTypeOrganization:
 			cond = cond.Or(builder.Eq{"type": UserTypeOrganizationReserved})
 		}
 	}

models/user/setting_test.go

···
 	settings, err := user_model.GetSettings(db.DefaultContext, 99, []string{keyName})
 	require.NoError(t, err)
 	assert.Len(t, settings, 1)
-	assert.EqualValues(t, newSetting.SettingValue, settings[keyName].SettingValue)
+	assert.Equal(t, newSetting.SettingValue, settings[keyName].SettingValue)
 
 	settingValue, err := user_model.GetUserSetting(db.DefaultContext, 99, keyName)
 	require.NoError(t, err)
-	assert.EqualValues(t, newSetting.SettingValue, settingValue)
+	assert.Equal(t, newSetting.SettingValue, settingValue)
 
 	settingValue, err = user_model.GetUserSetting(db.DefaultContext, 99, "no_such")
 	require.NoError(t, err)
-	assert.EqualValues(t, "", settingValue)
+	assert.Empty(t, settingValue)
 
 	// updated setting
 	updatedSetting := &user_model.Setting{UserID: 99, SettingKey: keyName, SettingValue: "Updated"}
···
 	settings, err = user_model.GetUserAllSettings(db.DefaultContext, 99)
 	require.NoError(t, err)
 	assert.Len(t, settings, 1)
-	assert.EqualValues(t, updatedSetting.SettingValue, settings[updatedSetting.SettingKey].SettingValue)
+	assert.Equal(t, updatedSetting.SettingValue, settings[updatedSetting.SettingKey].SettingValue)
 
 	// delete setting
 	err = user_model.DeleteUserSetting(db.DefaultContext, 99, keyName)

models/user/user.go

···
 	u.MaxRepoCreation = -1
 	u.Theme = setting.UI.DefaultTheme
 	u.IsRestricted = setting.Service.DefaultUserIsRestricted
-	u.IsActive = !(setting.Service.RegisterEmailConfirm || setting.Service.RegisterManualConfirm)
+	u.IsActive = !setting.Service.RegisterEmailConfirm && !setting.Service.RegisterManualConfirm
 
 	// Ensure consistency of the dates.
 	if u.UpdatedUnix < u.CreatedUnix {

models/user/user_test.go

···
 		cassText := fmt.Sprintf("ids: %v, opts: %v", expectedUserOrOrgIDs, opts)
 		if assert.Len(t, users, len(expectedUserOrOrgIDs), "case: %s", cassText) {
 			for i, expectedID := range expectedUserOrOrgIDs {
-				assert.EqualValues(t, expectedID, users[i].ID, "case: %s", cassText)
+				assert.Equal(t, expectedID, users[i].ID, "case: %s", cassText)
 			}
 		}
 	}
···
 		{ID: 2, Visibility: structs.VisibleTypePrivate}: true,
 	}
 	for kase, expected := range kases {
-		assert.EqualValues(t, expected, nil == user_model.ValidateUser(kase))
+		assert.Equal(t, expected, nil == user_model.ValidateUser(kase))
 	}
 }
 
···
 	for _, testCase := range testCases {
 		normalizedName, err := user_model.NormalizeUserName(testCase.Input)
 		require.NoError(t, err)
-		assert.EqualValues(t, testCase.Expected, normalizedName)
+		assert.Equal(t, testCase.Expected, normalizedName)
 		if testCase.IsNormalizedValid {
 			require.NoError(t, user_model.IsUsableUsername(normalizedName))
 		} else {
···
 	for _, testCase := range testCases {
 		t.Run(testCase.result, func(t *testing.T) {
 			testUser := &user_model.User{FullName: testCase.fullName, Email: testCase.mail}
-			assert.EqualValues(t, testCase.result, testUser.EmailTo())
+			assert.Equal(t, testCase.result, testUser.EmailTo())
 		})
 	}
 
 	t.Run("Override user's email", func(t *testing.T) {
 		testUser := &user_model.User{FullName: "Christine Jorgensen", Email: "[e-mail]"}
-		assert.EqualValues(t, `"Christine Jorgensen" <[e-mail]>`, testUser.EmailTo("[e-mail]"))
+		assert.Equal(t, `"Christine Jorgensen" <[e-mail]>`, testUser.EmailTo("[e-mail]"))
 	})
 }
 
···
 	authToken, err := auth.FindAuthToken(db.DefaultContext, lookupKey, auth.UserActivation)
 	require.NoError(t, err)
 	assert.False(t, authToken.IsExpired())
-	assert.EqualValues(t, authToken.HashedValidator, auth.HashValidator(rawValidator))
+	assert.Equal(t, authToken.HashedValidator, auth.HashValidator(rawValidator))
 
 	authToken.Expiry = authToken.Expiry.Add(-int64(setting.Service.ActiveCodeLives) * 60)
 	assert.True(t, authToken.IsExpired())
···
 	t.Run("No delete", func(t *testing.T) {
 		u, _, err := user_model.VerifyUserAuthorizationToken(db.DefaultContext, code, auth.UserActivation)
 		require.NoError(t, err)
-		assert.EqualValues(t, user.ID, u.ID)
+		assert.Equal(t, user.ID, u.ID)
 
 		authToken, err := auth.FindAuthToken(db.DefaultContext, lookupKey, auth.UserActivation)
 		require.NoError(t, err)
···
 	t.Run("Delete", func(t *testing.T) {
 		u, deleteToken, err := user_model.VerifyUserAuthorizationToken(db.DefaultContext, code, auth.UserActivation)
 		require.NoError(t, err)
-		assert.EqualValues(t, user.ID, u.ID)
+		assert.Equal(t, user.ID, u.ID)
 		require.NoError(t, deleteToken())
 
 		authToken, err := auth.FindAuthToken(db.DefaultContext, lookupKey, auth.UserActivation)
···
 		user.Pronouns = ""
 		user.KeepPronounsPrivate = false
 
-		assert.Equal(t, "", user.GetPronouns(false))
+		assert.Empty(t, user.GetPronouns(false))
 	})
 	t.Run("EmptyPronounsIfSetButPrivateAndNotLoggedIn", func(t *testing.T) {
 		user := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: 1})
 		user.Pronouns = "any"
 		user.KeepPronounsPrivate = true
 
-		assert.Equal(t, "", user.GetPronouns(false))
+		assert.Empty(t, user.GetPronouns(false))
 	})
 	t.Run("ReturnPronounsIfSetAndNotPrivateAndNotLoggedIn", func(t *testing.T) {
 		user := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: 1})

models/webhook/hooktask.go

···
 func CleanupHookTaskTable(ctx context.Context, cleanupType HookTaskCleanupType, olderThan time.Duration, numberToKeep int) error {
 	log.Trace("Doing: CleanupHookTaskTable")
 
-	if cleanupType == OlderThan {
+	switch cleanupType {
+	case OlderThan:
 		deleteOlderThan := time.Now().Add(-olderThan).UnixNano()
 		deletes, err := db.GetEngine(ctx).
 			Where("is_delivered = ? and delivered < ?", true, deleteOlderThan).
···
 			return err
 		}
 		log.Trace("Deleted %d rows from hook_task", deletes)
-	} else if cleanupType == PerWebhook {
+	case PerWebhook:
 		hookIDs := make([]int64, 0, 10)
 		err := db.GetEngine(ctx).
 			Table("webhook").

models/webhook/webhook.go

···
 // HasCreateEvent returns true if hook enabled create event.
 func (w *Webhook) HasCreateEvent() bool {
 	return w.SendEverything ||
-		(w.ChooseEvents && w.HookEvents.Create)
+		(w.ChooseEvents && w.Create)
 }
 
 // HasDeleteEvent returns true if hook enabled delete event.
 func (w *Webhook) HasDeleteEvent() bool {
 	return w.SendEverything ||
-		(w.ChooseEvents && w.HookEvents.Delete)
+		(w.ChooseEvents && w.Delete)
 }
 
 // HasForkEvent returns true if hook enabled fork event.
 func (w *Webhook) HasForkEvent() bool {
 	return w.SendEverything ||
-		(w.ChooseEvents && w.HookEvents.Fork)
+		(w.ChooseEvents && w.Fork)
 }
 
 // HasIssuesEvent returns true if hook enabled issues event.
 func (w *Webhook) HasIssuesEvent() bool {
 	return w.SendEverything ||
-		(w.ChooseEvents && w.HookEvents.Issues)
+		(w.ChooseEvents && w.Issues)
 }
 
 // HasIssuesAssignEvent returns true if hook enabled issues assign event.
 func (w *Webhook) HasIssuesAssignEvent() bool {
 	return w.SendEverything ||
-		(w.ChooseEvents && w.HookEvents.IssueAssign)
+		(w.ChooseEvents && w.IssueAssign)
 }
 
 // HasIssuesLabelEvent returns true if hook enabled issues label event.
 func (w *Webhook) HasIssuesLabelEvent() bool {
 	return w.SendEverything ||
-		(w.ChooseEvents && w.HookEvents.IssueLabel)
+		(w.ChooseEvents && w.IssueLabel)
 }
 
 // HasIssuesMilestoneEvent returns true if hook enabled issues milestone event.
 func (w *Webhook) HasIssuesMilestoneEvent() bool {
 	return w.SendEverything ||
-		(w.ChooseEvents && w.HookEvents.IssueMilestone)
+		(w.ChooseEvents && w.IssueMilestone)
 }
 
 // HasIssueCommentEvent returns true if hook enabled issue_comment event.
 func (w *Webhook) HasIssueCommentEvent() bool {
 	return w.SendEverything ||
-		(w.ChooseEvents && w.HookEvents.IssueComment)
+		(w.ChooseEvents && w.IssueComment)
 }
 
 // HasPushEvent returns true if hook enabled push event.
 func (w *Webhook) HasPushEvent() bool {
 	return w.PushOnly || w.SendEverything ||
-		(w.ChooseEvents && w.HookEvents.Push)
+		(w.ChooseEvents && w.Push)
 }
 
 // HasPullRequestEvent returns true if hook enabled pull request event.
 func (w *Webhook) HasPullRequestEvent() bool {
 	return w.SendEverything ||
-		(w.ChooseEvents && w.HookEvents.PullRequest)
+		(w.ChooseEvents && w.PullRequest)
 }
 
 // HasPullRequestAssignEvent returns true if hook enabled pull request assign event.
 func (w *Webhook) HasPullRequestAssignEvent() bool {
 	return w.SendEverything ||
-		(w.ChooseEvents && w.HookEvents.PullRequestAssign)
+		(w.ChooseEvents && w.PullRequestAssign)
 }
 
 // HasPullRequestLabelEvent returns true if hook enabled pull request label event.
 func (w *Webhook) HasPullRequestLabelEvent() bool {
 	return w.SendEverything ||
-		(w.ChooseEvents && w.HookEvents.PullRequestLabel)
+		(w.ChooseEvents && w.PullRequestLabel)
 }
 
 // HasPullRequestMilestoneEvent returns true if hook enabled pull request milestone event.
 func (w *Webhook) HasPullRequestMilestoneEvent() bool {
 	return w.SendEverything ||
-		(w.ChooseEvents && w.HookEvents.PullRequestMilestone)
+		(w.ChooseEvents && w.PullRequestMilestone)
 }
 
 // HasPullRequestCommentEvent returns true if hook enabled pull_request_comment event.
 func (w *Webhook) HasPullRequestCommentEvent() bool {
 	return w.SendEverything ||
-		(w.ChooseEvents && w.HookEvents.PullRequestComment)
+		(w.ChooseEvents && w.PullRequestComment)
 }
 
 // HasPullRequestApprovedEvent returns true if hook enabled pull request review event.
 func (w *Webhook) HasPullRequestApprovedEvent() bool {
 	return w.SendEverything ||
-		(w.ChooseEvents && w.HookEvents.PullRequestReview)
+		(w.ChooseEvents && w.PullRequestReview)
 }
 
 // HasPullRequestRejectedEvent returns true if hook enabled pull request review event.
 func (w *Webhook) HasPullRequestRejectedEvent() bool {
 	return w.SendEverything ||
-		(w.ChooseEvents && w.HookEvents.PullRequestReview)
+		(w.ChooseEvents && w.PullRequestReview)
 }
 
 // HasPullRequestReviewCommentEvent returns true if hook enabled pull request review event.
 func (w *Webhook) HasPullRequestReviewCommentEvent() bool {
 	return w.SendEverything ||
-		(w.ChooseEvents && w.HookEvents.PullRequestReview)
+		(w.ChooseEvents && w.PullRequestReview)
 }
 
 // HasPullRequestSyncEvent returns true if hook enabled pull request sync event.
 func (w *Webhook) HasPullRequestSyncEvent() bool {
 	return w.SendEverything ||
-		(w.ChooseEvents && w.HookEvents.PullRequestSync)
+		(w.ChooseEvents && w.PullRequestSync)
 }
 
 // HasWikiEvent returns true if hook enabled wiki event.
 func (w *Webhook) HasWikiEvent() bool {
 	return w.SendEverything ||
-		(w.ChooseEvents && w.HookEvent.Wiki)
+		(w.ChooseEvents && w.Wiki)
 }
 
 // HasReleaseEvent returns if hook enabled release event.
 func (w *Webhook) HasReleaseEvent() bool {
 	return w.SendEverything ||
-		(w.ChooseEvents && w.HookEvents.Release)
+		(w.ChooseEvents && w.Release)
 }
 
 // HasRepositoryEvent returns if hook enabled repository event.
 func (w *Webhook) HasRepositoryEvent() bool {
 	return w.SendEverything ||
-		(w.ChooseEvents && w.HookEvents.Repository)
+		(w.ChooseEvents && w.Repository)
 }
 
 // HasPackageEvent returns if hook enabled package event.
 func (w *Webhook) HasPackageEvent() bool {
 	return w.SendEverything ||
-		(w.ChooseEvents && w.HookEvents.Package)
+		(w.ChooseEvents && w.Package)
 }
 
 // HasPullRequestReviewRequestEvent returns true if hook enabled pull request review request event.
 func (w *Webhook) HasPullRequestReviewRequestEvent() bool {
 	return w.SendEverything ||
-		(w.ChooseEvents && w.HookEvents.PullRequestReviewRequest)
+		(w.ChooseEvents && w.PullRequestReviewRequest)
 }
 
 // EventCheckers returns event checkers

modules/assetfs/layered_test.go

···
 	require.NoError(t, err)
 	bs, err := io.ReadAll(f)
 	require.NoError(t, err)
-	assert.EqualValues(t, "f1", string(bs))
+	assert.Equal(t, "f1", string(bs))
 	_ = f.Close()
 
 	assertRead := func(expected string, expectedErr error, elems ...string) {
···
 
 	files, err := assets.ListFiles(".", true)
 	require.NoError(t, err)
-	assert.EqualValues(t, []string{"f1", "f2", "fa"}, files)
+	assert.Equal(t, []string{"f1", "f2", "fa"}, files)
 
 	files, err = assets.ListFiles(".", false)
 	require.NoError(t, err)
-	assert.EqualValues(t, []string{"d1", "d2", "da"}, files)
+	assert.Equal(t, []string{"d1", "d2", "da"}, files)
 
 	files, err = assets.ListFiles(".")
 	require.NoError(t, err)
-	assert.EqualValues(t, []string{"d1", "d2", "da", "f1", "f2", "fa"}, files)
+	assert.Equal(t, []string{"d1", "d2", "da", "f1", "f2", "fa"}, files)
 
 	files, err = assets.ListAllFiles(".", true)
 	require.NoError(t, err)
-	assert.EqualValues(t, []string{"d1/f", "d2/f", "da/f", "f1", "f2", "fa"}, files)
+	assert.Equal(t, []string{"d1/f", "d2/f", "da/f", "f1", "f2", "fa"}, files)
 
 	files, err = assets.ListAllFiles(".", false)
 	require.NoError(t, err)
-	assert.EqualValues(t, []string{"d1", "d2", "da", "da/sub1", "da/sub2"}, files)
+	assert.Equal(t, []string{"d1", "d2", "da", "da/sub1", "da/sub2"}, files)
 
 	files, err = assets.ListAllFiles(".")
 	require.NoError(t, err)
-	assert.EqualValues(t, []string{
+	assert.Equal(t, []string{
 		"d1", "d1/f",
 		"d2", "d2/f",
 		"da", "da/f", "da/sub1", "da/sub2",
···
 	}, files)
 
 	assert.Empty(t, assets.GetFileLayerName("no-such"))
-	assert.EqualValues(t, "l1", assets.GetFileLayerName("f1"))
-	assert.EqualValues(t, "l2", assets.GetFileLayerName("f2"))
+	assert.Equal(t, "l1", assets.GetFileLayerName("f1"))
+	assert.Equal(t, "l2", assets.GetFileLayerName("f2"))
 }

modules/avatar/avatar_test.go

···
 	assert.NotEqual(t, origin, result)
 	decoded, err := png.Decode(bytes.NewReader(result))
 	require.NoError(t, err)
-	assert.EqualValues(t, scaledSize, decoded.Bounds().Max.X)
-	assert.EqualValues(t, scaledSize, decoded.Bounds().Max.Y)
+	assert.Equal(t, scaledSize, decoded.Bounds().Max.X)
+	assert.Equal(t, scaledSize, decoded.Bounds().Max.Y)
 
 	// if origin image is smaller than the default size, use the origin image
 	origin = newImgData(1)

modules/avatar/hash_test.go

···
 	var buff bytes.Buffer
 	png.Encode(&buff, myImage)
 
-	assert.EqualValues(t, "9ddb5bac41d57e72aa876321d0c09d71090c05f94bc625303801be2f3240d2cb", avatar.HashAvatar(1, buff.Bytes()))
-	assert.EqualValues(t, "9a5d44e5d637b9582a976676e8f3de1dccd877c2fe3e66ca3fab1629f2f47609", avatar.HashAvatar(8, buff.Bytes()))
-	assert.EqualValues(t, "ed7399158672088770de6f5211ce15528ebd675e92fc4fc060c025f4b2794ccb", avatar.HashAvatar(1024, buff.Bytes()))
-	assert.EqualValues(t, "161178642c7d59eb25a61dddced5e6b66eae1c70880d5f148b1b497b767e72d9", avatar.HashAvatar(1024, []byte{}))
+	assert.Equal(t, "9ddb5bac41d57e72aa876321d0c09d71090c05f94bc625303801be2f3240d2cb", avatar.HashAvatar(1, buff.Bytes()))
+	assert.Equal(t, "9a5d44e5d637b9582a976676e8f3de1dccd877c2fe3e66ca3fab1629f2f47609", avatar.HashAvatar(8, buff.Bytes()))
+	assert.Equal(t, "ed7399158672088770de6f5211ce15528ebd675e92fc4fc060c025f4b2794ccb", avatar.HashAvatar(1024, buff.Bytes()))
+	assert.Equal(t, "161178642c7d59eb25a61dddced5e6b66eae1c70880d5f148b1b497b767e72d9", avatar.HashAvatar(1024, []byte{}))
 }

modules/base/tool_test.go

···
 }
 
 func TestTruncateString(t *testing.T) {
-	assert.Equal(t, "", TruncateString("foobar", 0))
+	assert.Empty(t, TruncateString("foobar", 0))
 	assert.Equal(t, "f", TruncateString("foobar", 1))
 	assert.Equal(t, "fo", TruncateString("foobar", 2))
 	assert.Equal(t, "foo", TruncateString("foobar", 3))
···
 	assert.Equal(t, "1.3k", FormatNumberSI(int64(1317)))
 	assert.Equal(t, "21.3M", FormatNumberSI(21317675))
 	assert.Equal(t, "45.7G", FormatNumberSI(45721317675))
-	assert.Equal(t, "", FormatNumberSI("test"))
+	assert.Empty(t, FormatNumberSI("test"))
 }

modules/cache/cache_test.go

···
 		return "", fmt.Errorf("some error")
 	})
 	require.Error(t, err)
-	assert.Equal(t, "", data)
+	assert.Empty(t, data)
 
 	data, err = GetString("key", func() (string, error) {
 		return "", nil
 	})
 	require.NoError(t, err)
-	assert.Equal(t, "", data)
+	assert.Empty(t, data)
 
 	data, err = GetString("key", func() (string, error) {
 		return "some data", nil
 	})
 	require.NoError(t, err)
-	assert.Equal(t, "", data)
+	assert.Empty(t, data)
 	Remove("key")
 
 	data, err = GetString("key", func() (string, error) {

modules/cache/context_test.go

···
 	SetContextData(ctx, field, "my_config1", 1)
 	v = GetContextData(ctx, field, "my_config1")
 	assert.NotNil(t, v)
-	assert.EqualValues(t, 1, v.(int))
+	assert.Equal(t, 1, v.(int))
 
 	RemoveContextData(ctx, field, "my_config1")
 	RemoveContextData(ctx, field, "my_config2") // remove a non-exist key
···
 		return 1, nil
 	})
 	require.NoError(t, err)
-	assert.EqualValues(t, 1, vInt)
+	assert.Equal(t, 1, vInt)
 
 	v = GetContextData(ctx, field, "my_config1")
 	assert.EqualValues(t, 1, v)

modules/charset/ambiguous_gen_test.go

···
 func TestAmbiguousCharacters(t *testing.T) {
 	for locale, ambiguous := range AmbiguousCharacters {
 		assert.Equal(t, locale, ambiguous.Locale)
-		assert.Equal(t, len(ambiguous.Confusable), len(ambiguous.With))
+		assert.Len(t, ambiguous.With, len(ambiguous.Confusable))
 		assert.True(t, sort.SliceIsSorted(ambiguous.Confusable, func(i, j int) bool {
 			return ambiguous.Confusable[i] < ambiguous.Confusable[j]
 		}))

modules/charset/charset_test.go

···
 		input += "// Выключаем"
 		rd := ToUTF8WithFallbackReader(bytes.NewReader([]byte(input)), ConvertOpts{})
 		r, _ := io.ReadAll(rd)
-		assert.EqualValuesf(t, input, string(r), "testing string len=%d", testLen)
+		assert.Equalf(t, input, string(r), "testing string len=%d", testLen)
 	}
 
 	truncatedOneByteExtension := failFastBytes

modules/charset/escape_stream.go

···
 	e.escaped.Escaped = true
 	e.escaped.HasBadRunes = true
 
-	if err := e.PassthroughHTMLStreamer.StartTag("span", html.Attribute{
+	if err := e.StartTag("span", html.Attribute{
 		Key: "class",
 		Val: "broken-code-point",
 	}); err != nil {
···
 		return err
 	}
 
-	return e.PassthroughHTMLStreamer.EndTag("span")
+	return e.EndTag("span")
 }
 
 func (e *escapeStreamer) ambiguousRune(r, c rune) error {
 	e.escaped.Escaped = true
 	e.escaped.HasAmbiguous = true
 
-	if err := e.PassthroughHTMLStreamer.StartTag("span", html.Attribute{
+	if err := e.StartTag("span", html.Attribute{
 		Key: "class",
 		Val: "ambiguous-code-point",
 	}, html.Attribute{
···
 	}); err != nil {
 		return err
 	}
-	if err := e.PassthroughHTMLStreamer.StartTag("span", html.Attribute{
+	if err := e.StartTag("span", html.Attribute{
 		Key: "class",
 		Val: "char",
 	}); err != nil {
···
 	if err := e.PassthroughHTMLStreamer.Text(string(r)); err != nil {
 		return err
 	}
-	if err := e.PassthroughHTMLStreamer.EndTag("span"); err != nil {
+	if err := e.EndTag("span"); err != nil {
 		return err
 	}
 
-	return e.PassthroughHTMLStreamer.EndTag("span")
+	return e.EndTag("span")
 }
 
 func (e *escapeStreamer) invisibleRune(r rune) error {
 	e.escaped.Escaped = true
 	e.escaped.HasInvisible = true
 
-	if err := e.PassthroughHTMLStreamer.StartTag("span", html.Attribute{
+	if err := e.StartTag("span", html.Attribute{
 		Key: "class",
 		Val: "escaped-code-point",
 	}, html.Attribute{
···
 	}); err != nil {
 		return err
 	}
-	if err := e.PassthroughHTMLStreamer.StartTag("span", html.Attribute{
+	if err := e.StartTag("span", html.Attribute{
 		Key: "class",
 		Val: "char",
 	}); err != nil {
···
 	if err := e.PassthroughHTMLStreamer.Text(string(r)); err != nil {
 		return err
 	}
-	if err := e.PassthroughHTMLStreamer.EndTag("span"); err != nil {
+	if err := e.EndTag("span"); err != nil {
 		return err
 	}
 
-	return e.PassthroughHTMLStreamer.EndTag("span")
+	return e.EndTag("span")
 }
 
 type runeCountType struct {

modules/charset/escape_test.go

···
 	assert.EqualValues(t, `a<span class="escaped-code-point" data-escaped="[U+00A0]"><span class="char"> </span></span>test`, out)
 
 	_, out = EscapeControlHTML(input, &translation.MockLocale{}, testContext)
-	assert.EqualValues(t, input, out)
+	assert.Equal(t, input, out)
 }

modules/container/set_test.go

···
 		called++
 		assert.True(t, slices.Contains(values, value))
 	}
-	assert.EqualValues(t, len(values), called)
+	assert.Equal(t, len(values), called)
 
 	s = SetOf("key6", "key7")
 	assert.False(t, s.Contains("key1"))

modules/csv/csv_test.go

···
 	for n, c := range cases {
 		rd, err := CreateReaderAndDetermineDelimiter(nil, strings.NewReader(decodeSlashes(t, c.csv)))
 		require.NoError(t, err, "case %d: should not throw error: %v\n", n, err)
-		assert.EqualValues(t, c.expectedDelimiter, rd.Comma, "case %d: delimiter should be '%c', got '%c'", n, c.expectedDelimiter, rd.Comma)
+		assert.Equal(t, c.expectedDelimiter, rd.Comma, "case %d: delimiter should be '%c', got '%c'", n, c.expectedDelimiter, rd.Comma)
 		rows, err := rd.ReadAll()
 		require.NoError(t, err, "case %d: should not throw error: %v\n", n, err)
-		assert.EqualValues(t, c.expectedRows, rows, "case %d: rows should be equal", n)
+		assert.Equal(t, c.expectedRows, rows, "case %d: rows should be equal", n)
 	}
 }
 
···
 			Ctx:          git.DefaultContext,
 			RelativePath: c.filename,
 		}, []byte(decodeSlashes(t, c.csv)))
-		assert.EqualValues(t, c.expectedDelimiter, delimiter, "case %d: delimiter should be equal, expected '%c' got '%c'", n, c.expectedDelimiter, delimiter)
+		assert.Equal(t, c.expectedDelimiter, delimiter, "case %d: delimiter should be equal, expected '%c' got '%c'", n, c.expectedDelimiter, delimiter)
 	}
 }
 
···
 
 	for n, c := range cases {
 		modifiedText := removeQuotedString(decodeSlashes(t, c.text))
-		assert.EqualValues(t, c.expectedText, modifiedText, "case %d: modified text should be equal", n)
+		assert.Equal(t, c.expectedText, modifiedText, "case %d: modified text should be equal", n)
 	}
 }
 
···
 
 	for n, c := range cases {
 		delimiter := guessDelimiter([]byte(decodeSlashes(t, c.csv)))
-		assert.EqualValues(t, c.expectedDelimiter, delimiter, "case %d: delimiter should be equal, expected '%c' got '%c'", n, c.expectedDelimiter, delimiter)
+		assert.Equal(t, c.expectedDelimiter, delimiter, "case %d: delimiter should be equal, expected '%c' got '%c'", n, c.expectedDelimiter, delimiter)
 	}
 }
 
···
 
 	for n, c := range cases {
 		delimiter := guessFromBeforeAfterQuotes([]byte(decodeSlashes(t, c.csv)))
-		assert.EqualValues(t, c.expectedDelimiter, delimiter, "case %d: delimiter should be equal, expected '%c' got '%c'", n, c.expectedDelimiter, delimiter)
+		assert.Equal(t, c.expectedDelimiter, delimiter, "case %d: delimiter should be equal, expected '%c' got '%c'", n, c.expectedDelimiter, delimiter)
 	}
 }
 
···
 			require.Error(t, err, "case %d: expected an error to be returned", n)
 		} else {
 			require.NoError(t, err, "case %d: no error was expected, got error: %v", n, err)
-			assert.EqualValues(t, c.expectedMessage, message, "case %d: messages should be equal, expected '%s' got '%s'", n, c.expectedMessage, message)
+			assert.Equal(t, c.expectedMessage, message, "case %d: messages should be equal, expected '%s' got '%s'", n, c.expectedMessage, message)
 		}
 	}
 }

modules/git/command_test.go

···
 
 func TestCommandString(t *testing.T) {
 	cmd := NewCommandContextNoGlobals(t.Context(), "a", "-m msg", "it's a test", `say "hello"`)
-	assert.EqualValues(t, cmd.prog+` a "-m msg" "it's a test" "say \"hello\""`, cmd.String())
+	assert.Equal(t, cmd.prog+` a "-m msg" "it's a test" "say \"hello\""`, cmd.String())
 
 	cmd = NewCommandContextNoGlobals(t.Context(), "url: https://a:b@c/")
-	assert.EqualValues(t, cmd.prog+` "url: https://sanitized-credential@c/"`, cmd.toString(true))
+	assert.Equal(t, cmd.prog+` "url: https://sanitized-credential@c/"`, cmd.toString(true))
 }
 
 func TestGrepOnlyFunction(t *testing.T) {

modules/git/commit.go

···
 	}
 	var exitError *exec.ExitError
 	if errors.As(err, &exitError) {
-		if exitError.ProcessState.ExitCode() == 1 && len(exitError.Stderr) == 0 {
+		if exitError.ExitCode() == 1 && len(exitError.Stderr) == 0 {
 			return false, nil
 		}
 	}

modules/git/commit_sha256_test.go

···
 		return
 	}
 	assert.EqualValues(t, sha, commitFromReader.ID)
-	assert.EqualValues(t, `-----BEGIN PGP SIGNATURE-----
+	assert.Equal(t, `-----BEGIN PGP SIGNATURE-----
 
 iQIrBAABCgAtFiEES+fB08xlgTrzSdQvhkUIsBsmec8FAmU/wKoPHGFtYWplckBz
 dXNlLmRlAAoJEIZFCLAbJnnP4s4PQIJATa++WPzR6/H4etT7bsOGoMyguEJYyWOd
···
 =xybZ
 -----END PGP SIGNATURE-----
 `, commitFromReader.Signature.Signature)
-	assert.EqualValues(t, `tree e7f9e96dd79c09b078cac8b303a7d3b9d65ff9b734e86060a4d20409fd379f9e
+	assert.Equal(t, `tree e7f9e96dd79c09b078cac8b303a7d3b9d65ff9b734e86060a4d20409fd379f9e
 parent 26e9ccc29fad747e9c5d9f4c9ddeb7eff61cc45ef6a8dc258cbeb181afc055e8
 author Adam Majer <[e-mail]> 1698676906 +0100
 committer Adam Majer <[e-mail]> 1698676906 +0100
 
 signed commit`, commitFromReader.Signature.Payload)
-	assert.EqualValues(t, "Adam Majer <[e-mail]>", commitFromReader.Author.String())
+	assert.Equal(t, "Adam Majer <[e-mail]>", commitFromReader.Author.String())
 
 	commitFromReader2, err := CommitFromReader(gitRepo, sha, strings.NewReader(commitString+"\n\n"))
 	require.NoError(t, err)
 	commitFromReader.CommitMessage += "\n\n"
 	commitFromReader.Signature.Payload += "\n\n"
-	assert.EqualValues(t, commitFromReader, commitFromReader2)
+	assert.Equal(t, commitFromReader, commitFromReader2)
 }
 
 func TestHasPreviousCommitSha256(t *testing.T) {

modules/git/commit_test.go

···
 	require.NoError(t, err)
 	require.NotNil(t, commitFromReader)
 	assert.EqualValues(t, sha, commitFromReader.ID)
-	assert.EqualValues(t, `-----BEGIN PGP SIGNATURE-----
+	assert.Equal(t, `-----BEGIN PGP SIGNATURE-----
 
 iQIzBAABCAAdFiEEWPb2jX6FS2mqyJRQLmK0HJOGlEMFAl00zmEACgkQLmK0HJOG
 lEMDFBAAhQKKqLD1VICygJMEB8t1gBmNLgvziOLfpX4KPWdPtBk3v/QJ7OrfMrVK
···
 =FRsO
 -----END PGP SIGNATURE-----
 `, commitFromReader.Signature.Signature)
-	assert.EqualValues(t, `tree f1a6cb52b2d16773290cefe49ad0684b50a4f930
+	assert.Equal(t, `tree f1a6cb52b2d16773290cefe49ad0684b50a4f930
 parent 37991dec2c8e592043f47155ce4808d4580f9123
 author silverwind <[e-mail]> 1563741793 +0200
 committer silverwind <[e-mail]> 1563741793 +0200
 
 empty commit`, commitFromReader.Signature.Payload)
-	assert.EqualValues(t, "silverwind <[e-mail]>", commitFromReader.Author.String())
+	assert.Equal(t, "silverwind <[e-mail]>", commitFromReader.Author.String())
 
 	commitFromReader2, err := CommitFromReader(gitRepo, sha, strings.NewReader(commitString+"\n\n"))
 	require.NoError(t, err)
 	commitFromReader.CommitMessage += "\n\n"
 	commitFromReader.Signature.Payload += "\n\n"
-	assert.EqualValues(t, commitFromReader, commitFromReader2)
+	assert.Equal(t, commitFromReader, commitFromReader2)
 }
 
 func TestCommitWithEncodingFromReader(t *testing.T) {
···
 	require.NoError(t, err)
 	require.NotNil(t, commitFromReader)
 	assert.EqualValues(t, sha, commitFromReader.ID)
-	assert.EqualValues(t, `-----BEGIN PGP SIGNATURE-----
+	assert.Equal(t, `-----BEGIN PGP SIGNATURE-----
 
 iQGzBAABCgAdFiEE9HRrbqvYxPT8PXbefPSEkrowAa8FAmYGg7IACgkQfPSEkrow
 Aa9olwv+P0HhtCM6CRvlUmPaqswRsDPNR4i66xyXGiSxdI9V5oJL7HLiQIM7KrFR
···
 =r3UU
 -----END PGP SIGNATURE-----
 `, commitFromReader.Signature.Signature)
-	assert.EqualValues(t, `tree ca3fad42080dd1a6d291b75acdfc46e5b9b307e5
+	assert.Equal(t, `tree ca3fad42080dd1a6d291b75acdfc46e5b9b307e5
 parent 47b24e7ab977ed31c5a39989d570847d6d0052af
 author KN4CK3R <[e-mail]> 1711702962 +0100
 committer KN4CK3R <[e-mail]> 1711702962 +0100
 encoding ISO-8859-1
 
 ISO-8859-1`, commitFromReader.Signature.Payload)
-	assert.EqualValues(t, "KN4CK3R <[e-mail]>", commitFromReader.Author.String())
+	assert.Equal(t, "KN4CK3R <[e-mail]>", commitFromReader.Author.String())
 
 	commitFromReader2, err := CommitFromReader(gitRepo, sha, strings.NewReader(commitString+"\n\n"))
 	require.NoError(t, err)
 	commitFromReader.CommitMessage += "\n\n"
 	commitFromReader.Signature.Payload += "\n\n"
-	assert.EqualValues(t, commitFromReader, commitFromReader2)
+	assert.Equal(t, commitFromReader, commitFromReader2)
 }
 
 func TestHasPreviousCommit(t *testing.T) {

modules/git/diff_test.go

···
 
 func TestParseDiffHunkString(t *testing.T) {
 	leftLine, leftHunk, rightLine, rightHunk := ParseDiffHunkString("@@ -19,3 +19,5 @@ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER")
-	assert.EqualValues(t, 19, leftLine)
-	assert.EqualValues(t, 3, leftHunk)
-	assert.EqualValues(t, 19, rightLine)
-	assert.EqualValues(t, 5, rightHunk)
+	assert.Equal(t, 19, leftLine)
+	assert.Equal(t, 3, leftHunk)
+	assert.Equal(t, 19, rightLine)
+	assert.Equal(t, 5, rightHunk)
 }

modules/git/error.go

···
 		err.Message = ""
 		return
 	}
-	for {
-		if len(err.StdErr) <= i+8 {
-			break
-		}
+	for len(err.StdErr) > i+8 {
 		if err.StdErr[i:i+8] != "remote: " {
 			break
 		}

modules/git/log_name_status.go

···
 		g.buffull = false
 		g.next, err = g.rd.ReadSlice('\x00')
 		if err != nil {
-			if err == bufio.ErrBufferFull {
+			switch err {
+			case bufio.ErrBufferFull:
 				g.buffull = true
-			} else if err == io.EOF {
+			case io.EOF:
 				return nil, nil
-			} else {
+			default:
 				return nil, err
 			}
 		}
···
 	if bytes.Equal(g.next, []byte("commit\000")) {
 		g.next, err = g.rd.ReadSlice('\x00')
 		if err != nil {
-			if err == bufio.ErrBufferFull {
+			switch err {
+			case bufio.ErrBufferFull:
 				g.buffull = true
-			} else if err == io.EOF {
+			case io.EOF:
 				return nil, nil
-			} else {
+			default:
 				return nil, err
 			}
 		}
···
 		}
 	}
 
-	if err == io.EOF || !(g.next[0] == '\n' || g.next[0] == '\000') {
+	if err == io.EOF || (g.next[0] != '\n' && g.next[0] != '\000') {
 		return &ret, nil
 	}
 
···
 		}
 		g.next, err = g.rd.ReadSlice('\x00')
 		if err != nil {
-			if err == bufio.ErrBufferFull {
+			switch err {
+			case bufio.ErrBufferFull:
 				g.buffull = true
-			} else if err == io.EOF {
+			case io.EOF:
 				return &ret, nil
-			} else {
+			default:
 				return nil, err
 			}
 		}

modules/git/parse_test.go

···
 		require.NoError(t, err)
 		assert.Len(t, entries, len(testCase.Expected))
 		for i, entry := range entries {
-			assert.EqualValues(t, testCase.Expected[i], entry)
+			assert.Equal(t, testCase.Expected[i], entry)
 		}
 	}
 }
···
 		require.NoError(t, err)
 		assert.Len(t, entries, len(testCase.Expected))
 		for i, entry := range entries {
-			assert.EqualValues(t, testCase.Expected[i], entry)
+			assert.Equal(t, testCase.Expected[i], entry)
 		}
 	}
 }

modules/git/pushoptions/pushoptions_test.go

···
 	options.Parse(fmt.Sprintf("%v", RepoPrivate))
 	actual := options.Map()
 	expected := map[string]string{string(RepoPrivate): "true"}
-	assert.EqualValues(t, expected, actual)
-	assert.EqualValues(t, expected, NewFromMap(&actual).Map())
+	assert.Equal(t, expected, actual)
+	assert.Equal(t, expected, NewFromMap(&actual).Map())
 }
 
 func TestChangeRepositorySettings(t *testing.T) {
···
 
 		val, ok := options.GetString(RepoPrivate)
 		assert.False(t, ok)
-		assert.Equal(t, "", val)
+		assert.Empty(t, val)
 
 		assert.True(t, options.GetBool(RepoPrivate, true))
 		assert.False(t, options.GetBool(RepoPrivate, false))

modules/git/repo_attribute_test.go

···
 		cloneStats, err := gitRepo.GitAttributes(commitID, "i-am-a-python.p", LinguistAttributes...)
 		require.NoError(t, err)
 
-		assert.EqualValues(t, cloneStats, bareStats)
+		assert.Equal(t, cloneStats, bareStats)
 		refStats := cloneStats
 
 		t.Run("GitAttributeChecker/"+commitID+"/SupportBare", func(t *testing.T) {
···
 
 			bareStats, err := bareChecker.CheckPath("i-am-a-python.p")
 			require.NoError(t, err)
-			assert.EqualValues(t, refStats, bareStats)
+			assert.Equal(t, refStats, bareStats)
 		})
 		t.Run("GitAttributeChecker/"+commitID+"/NoBareSupport", func(t *testing.T) {
 			defer test.MockVariableValue(&SupportCheckAttrOnBare, false)()
···
 			cloneStats, err := cloneChecker.CheckPath("i-am-a-python.p")
 			require.NoError(t, err)
 
-			assert.EqualValues(t, refStats, cloneStats)
+			assert.Equal(t, refStats, cloneStats)
 		})
 	}
 }
···
 
 	attr, err := gitRepo.GitAttributes("8fee858da5796dfb37704761701bb8e800ad9ef3", "i-am-a-python.p", LinguistAttributes...)
 	require.NoError(t, err)
-	assert.EqualValues(t, map[string]GitAttribute{
+	assert.Equal(t, map[string]GitAttribute{
 		"gitlab-language":        "unspecified",
 		"linguist-detectable":    "unspecified",
 		"linguist-documentation": "unspecified",
···
 
 	attr, err = gitRepo.GitAttributes("341fca5b5ea3de596dc483e54c2db28633cd2f97", "i-am-a-python.p", LinguistAttributes...)
 	require.NoError(t, err)
-	assert.EqualValues(t, map[string]GitAttribute{
+	assert.Equal(t, map[string]GitAttribute{
 		"gitlab-language":        "unspecified",
 		"linguist-detectable":    "unspecified",
 		"linguist-documentation": "unspecified",
···
 	t.Run("none is specified", func(t *testing.T) {
 		language, err := gitRepo.GitAttributeFirst("8fee858da5796dfb37704761701bb8e800ad9ef3", "i-am-a-python.p", "linguist-detectable", "gitlab-language", "non-existing")
 		require.NoError(t, err)
-		assert.Equal(t, "", language.String())
+		assert.Empty(t, language.String())
 	})
 }
 
 func TestGitAttributeStruct(t *testing.T) {
-	assert.Equal(t, "", GitAttribute("").String())
-	assert.Equal(t, "", GitAttribute("unspecified").String())
+	assert.Empty(t, GitAttribute("").String())
+	assert.Empty(t, GitAttribute("unspecified").String())
 
 	assert.Equal(t, "python", GitAttribute("python").String())
 

modules/git/repo_base_test.go

···
 			sha, typ, size, err := ReadBatchLine(r)
 			require.NoError(t, err)
 			assert.Equal(t, "commit", typ)
-			assert.EqualValues(t, []byte("95bb4d39648ee7e325106df01a621c530863a653"), sha)
+			assert.Equal(t, []byte("95bb4d39648ee7e325106df01a621c530863a653"), sha)
 			assert.EqualValues(t, 144, size)
 		})
 
···
 		sha, typ, size, err := ReadBatchLine(r)
 		require.NoError(t, err)
 		assert.Equal(t, "commit", typ)
-		assert.EqualValues(t, []byte("95bb4d39648ee7e325106df01a621c530863a653"), sha)
+		assert.Equal(t, []byte("95bb4d39648ee7e325106df01a621c530863a653"), sha)
 		assert.EqualValues(t, 144, size)
 	})
 
···
 			sha, typ, size, err := ReadBatchLine(r)
 			require.NoError(t, err)
 			assert.Equal(t, "tag", typ)
-			assert.EqualValues(t, []byte("3ad28a9149a2864384548f3d17ed7f38014c9e8a"), sha)
+			assert.Equal(t, []byte("3ad28a9149a2864384548f3d17ed7f38014c9e8a"), sha)
 			assert.EqualValues(t, 807, size)
 		})
 
···
 		sha, typ, size, err := ReadBatchLine(r)
 		require.NoError(t, err)
 		assert.Equal(t, "tag", typ)
-		assert.EqualValues(t, []byte("3ad28a9149a2864384548f3d17ed7f38014c9e8a"), sha)
+		assert.Equal(t, []byte("3ad28a9149a2864384548f3d17ed7f38014c9e8a"), sha)
 		assert.EqualValues(t, 807, size)
 	})
 

modules/git/repo_branch_test.go

···
 
 	require.NoError(t, err)
 	assert.Len(t, branches, 2)
-	assert.EqualValues(t, 3, countAll)
+	assert.Equal(t, 3, countAll)
 	assert.ElementsMatch(t, []string{"master", "branch2"}, branches)
 
 	branches, countAll, err = bareRepo1.GetBranchNames(0, 0)
 
 	require.NoError(t, err)
 	assert.Len(t, branches, 3)
-	assert.EqualValues(t, 3, countAll)
+	assert.Equal(t, 3, countAll)
 	assert.ElementsMatch(t, []string{"master", "branch2", "branch1"}, branches)
 
 	branches, countAll, err = bareRepo1.GetBranchNames(5, 1)
 
 	require.NoError(t, err)
 	assert.Empty(t, branches)
-	assert.EqualValues(t, 3, countAll)
+	assert.Equal(t, 3, countAll)
 	assert.ElementsMatch(t, []string{}, branches)
 }
 
···
 	// refs/pull/1/head
 	branches, err = bareRepo5.GetRefsBySha("c83380d7056593c51a699d12b9c00627bd5743e9", PullPrefix)
 	require.NoError(t, err)
-	assert.EqualValues(t, []string{"refs/pull/1/head"}, branches)
+	assert.Equal(t, []string{"refs/pull/1/head"}, branches)
 
 	branches, err = bareRepo5.GetRefsBySha("d8e0bbb45f200e67d9a784ce55bd90821af45ebd", BranchPrefix)
 	require.NoError(t, err)
-	assert.EqualValues(t, []string{"refs/heads/master", "refs/heads/master-clone"}, branches)
+	assert.Equal(t, []string{"refs/heads/master", "refs/heads/master-clone"}, branches)
 
 	branches, err = bareRepo5.GetRefsBySha("58a4bcc53ac13e7ff76127e0fb518b5262bf09af", BranchPrefix)
 	require.NoError(t, err)
-	assert.EqualValues(t, []string{"refs/heads/test-patch-1"}, branches)
+	assert.Equal(t, []string{"refs/heads/test-patch-1"}, branches)
 }
 
 func BenchmarkGetRefsBySha(b *testing.B) {

modules/git/repo_commit_test.go

···
 
 	aTagID, err := bareRepo1.GetTagCommitID(aTagName)
 	require.NoError(t, err)
-	assert.NotEqualValues(t, aTagCommitID, aTagID)
+	assert.NotEqual(t, aTagCommitID, aTagID)
 
 	lTagID, err := bareRepo1.GetTagCommitID(lTagName)
 	require.NoError(t, err)
-	assert.EqualValues(t, lTagCommitID, lTagID)
+	assert.Equal(t, lTagCommitID, lTagID)
 
 	aTag, err := bareRepo1.GetTagCommit(aTagName)
 	require.NoError(t, err)
-	assert.EqualValues(t, aTagCommitID, aTag.ID.String())
+	assert.Equal(t, aTagCommitID, aTag.ID.String())
 
 	lTag, err := bareRepo1.GetTagCommit(lTagName)
 	require.NoError(t, err)
-	assert.EqualValues(t, lTagCommitID, lTag.ID.String())
+	assert.Equal(t, lTagCommitID, lTag.ID.String())
 }
 
 func TestCommitsByRange(t *testing.T) {

modules/git/repo_language_stats.go

···
 			sizes[language] += f.Size()
 		} else if len(sizes) == 0 && (firstExcludedLanguage == "" || firstExcludedLanguage == language) {
 			// Only consider Programming or Markup languages as fallback
-			if !(langType == enry.Programming || langType == enry.Markup) {
+			if langType != enry.Programming && langType != enry.Markup {
 				continue
 			}
 			firstExcludedLanguage = language

modules/git/repo_language_stats_test.go

···
 	stats, err := gitRepo.GetLanguageStats("8fee858da5796dfb37704761701bb8e800ad9ef3")
 	require.NoError(t, err)
 
-	assert.EqualValues(t, map[string]int64{
+	assert.Equal(t, map[string]int64{
 		"Python": 134,
 		"Java":   112,
 	}, stats)
 }
 
 func TestMergeLanguageStats(t *testing.T) {
-	assert.EqualValues(t, map[string]int64{
+	assert.Equal(t, map[string]int64{
 		"PHP":    1,
 		"python": 10,
 		"JAVA":   700,

modules/git/repo_ref.go

···
 // refType should only be a literal "branch" or "tag" and nothing else
 func (repo *Repository) ListOccurrences(ctx context.Context, refType, commitSHA string) ([]string, error) {
 	cmd := NewCommand(ctx)
-	if refType == "branch" {
+	switch refType {
+	case "branch":
 		cmd.AddArguments("branch")
-	} else if refType == "tag" {
+	case "tag":
 		cmd.AddArguments("tag")
-	} else {
+	default:
 		return nil, util.NewInvalidArgumentErrorf(`can only use "branch" or "tag" for refType, but got %q`, refType)
 	}
 	stdout, _, err := cmd.AddArguments("--no-color", "--sort=-creatordate", "--contains").AddDynamicArguments(commitSHA).RunStdString(&RunOpts{Dir: repo.Path})

modules/git/repo_stats_test.go

···
 	assert.EqualValues(t, 10, code.Additions)
 	assert.EqualValues(t, 1, code.Deletions)
 	assert.Len(t, code.Authors, 3)
-	assert.EqualValues(t, "[e-mail]", code.Authors[1].Email)
+	assert.Equal(t, "[e-mail]", code.Authors[1].Email)
 	assert.EqualValues(t, 3, code.Authors[1].Commits)
 	assert.EqualValues(t, 5, code.Authors[0].Commits)
 }

modules/git/repo_tag_test.go

···
 	}
 	assert.Len(t, tags, 2)
 	assert.Len(t, tags, total)
-	assert.EqualValues(t, "signed-tag", tags[0].Name)
-	assert.EqualValues(t, "36f97d9a96457e2bab511db30fe2db03893ebc64", tags[0].ID.String())
-	assert.EqualValues(t, "tag", tags[0].Type)
-	assert.EqualValues(t, time.Date(2022, time.November, 13, 16, 40, 20, 0, time.FixedZone("", 3600)), tags[0].Tagger.When)
-	assert.EqualValues(t, "test", tags[1].Name)
-	assert.EqualValues(t, "3ad28a9149a2864384548f3d17ed7f38014c9e8a", tags[1].ID.String())
-	assert.EqualValues(t, "tag", tags[1].Type)
-	assert.EqualValues(t, time.Date(2018, time.June, 16, 20, 13, 18, 0, time.FixedZone("", -25200)), tags[1].Tagger.When)
+	assert.Equal(t, "signed-tag", tags[0].Name)
+	assert.Equal(t, "36f97d9a96457e2bab511db30fe2db03893ebc64", tags[0].ID.String())
+	assert.Equal(t, "tag", tags[0].Type)
+	assert.Equal(t, time.Date(2022, time.November, 13, 16, 40, 20, 0, time.FixedZone("", 3600)), tags[0].Tagger.When)
+	assert.Equal(t, "test", tags[1].Name)
+	assert.Equal(t, "3ad28a9149a2864384548f3d17ed7f38014c9e8a", tags[1].ID.String())
+	assert.Equal(t, "tag", tags[1].Type)
+	assert.Equal(t, time.Date(2018, time.June, 16, 20, 13, 18, 0, time.FixedZone("", -25200)), tags[1].Tagger.When)
 }
 
 func TestRepository_GetTag(t *testing.T) {
 	bareRepo1Path := filepath.Join(testReposDir, "repo1_bare")
 
 	clonedPath, err := cloneRepo(t, bareRepo1Path)
-	if err != nil {
-		require.NoError(t, err)
-		return
-	}
+	require.NoError(t, err)
 
 	bareRepo1, err := openRepositoryWithDefaultContext(clonedPath)
-	if err != nil {
-		require.NoError(t, err)
-		return
-	}
+	require.NoError(t, err)
 	defer bareRepo1.Close()
 
 	// LIGHTWEIGHT TAGS
···
 
 	// Create the lightweight tag
 	err = bareRepo1.CreateTag(lTagName, lTagCommitID)
-	if err != nil {
-		require.NoError(t, err, "Unable to create the lightweight tag: %s for ID: %s. Error: %v", lTagName, lTagCommitID, err)
-		return
-	}
+	require.NoError(t, err, "Unable to create the lightweight tag: %s for ID: %s. Error: %v", lTagName, lTagCommitID, err)
 
 	// and try to get the Tag for lightweight tag
 	lTag, err := bareRepo1.GetTag(lTagName)
-	if err != nil {
-		require.NoError(t, err)
-		return
-	}
-	if lTag == nil {
-		assert.NotNil(t, lTag)
-		assert.FailNow(t, "nil lTag: %s", lTagName)
-	}
-	assert.EqualValues(t, lTagName, lTag.Name)
-	assert.EqualValues(t, lTagCommitID, lTag.ID.String())
-	assert.EqualValues(t, lTagCommitID, lTag.Object.String())
-	assert.EqualValues(t, "commit", lTag.Type)
+	require.NoError(t, err)
+	require.NotNil(t, lTag)
+	assert.Equal(t, lTagName, lTag.Name)
+	assert.Equal(t, lTagCommitID, lTag.ID.String())
+	assert.Equal(t, lTagCommitID, lTag.Object.String())
+	assert.Equal(t, "commit", lTag.Type)
 
 	// ANNOTATED TAGS
 	aTagCommitID := "8006ff9adbf0cb94da7dad9e537e53817f9fa5c0"
···
 
 	// Create the annotated tag
 	err = bareRepo1.CreateAnnotatedTag(aTagName, aTagMessage, aTagCommitID)
-	if err != nil {
-		require.NoError(t, err, "Unable to create the annotated tag: %s for ID: %s. Error: %v", aTagName, aTagCommitID, err)
-		return
-	}
+	require.NoError(t, err, "Unable to create the annotated tag: %s for ID: %s. Error: %v", aTagName, aTagCommitID, err)
 
 	// Now try to get the tag for the annotated Tag
 	aTagID, err := bareRepo1.GetTagID(aTagName)
-	if err != nil {
-		require.NoError(t, err)
-		return
-	}
+	require.NoError(t, err)
 
 	aTag, err := bareRepo1.GetTag(aTagName)
-	if err != nil {
-		require.NoError(t, err)
-		return
-	}
-	if aTag == nil {
-		assert.NotNil(t, aTag)
-		assert.FailNow(t, "nil aTag: %s", aTagName)
-	}
-	assert.EqualValues(t, aTagName, aTag.Name)
-	assert.EqualValues(t, aTagID, aTag.ID.String())
+	require.NoError(t, err)
+	require.NotNil(t, aTag)
+	assert.Equal(t, aTagName, aTag.Name)
+	assert.Equal(t, aTagID, aTag.ID.String())
 	assert.NotEqual(t, aTagID, aTag.Object.String())
-	assert.EqualValues(t, aTagCommitID, aTag.Object.String())
-	assert.EqualValues(t, "tag", aTag.Type)
+	assert.Equal(t, aTagCommitID, aTag.Object.String())
+	assert.Equal(t, "tag", aTag.Type)
 
 	// RELEASE TAGS
 
···
 	rTagName := "release/" + lTagName
 
 	err = bareRepo1.CreateTag(rTagName, rTagCommitID)
-	if err != nil {
-		require.NoError(t, err, "Unable to create the  tag: %s for ID: %s. Error: %v", rTagName, rTagCommitID, err)
-		return
-	}
+	require.NoError(t, err, "Unable to create the  tag: %s for ID: %s. Error: %v", rTagName, rTagCommitID, err)
 
 	rTagID, err := bareRepo1.GetTagID(rTagName)
-	if err != nil {
-		require.NoError(t, err)
-		return
-	}
-	assert.EqualValues(t, rTagCommitID, rTagID)
+	require.NoError(t, err)
+	assert.Equal(t, rTagCommitID, rTagID)
 
 	oTagID, err := bareRepo1.GetTagID(lTagName)
-	if err != nil {
-		require.NoError(t, err)
-		return
-	}
-	assert.EqualValues(t, lTagCommitID, oTagID)
+	require.NoError(t, err)
+	assert.Equal(t, lTagCommitID, oTagID)
 }
 
 func TestRepository_GetAnnotatedTag(t *testing.T) {
···
 		return
 	}
 	assert.NotNil(t, tag)
-	assert.EqualValues(t, aTagName, tag.Name)
-	assert.EqualValues(t, aTagID, tag.ID.String())
-	assert.EqualValues(t, "tag", tag.Type)
+	assert.Equal(t, aTagName, tag.Name)
+	assert.Equal(t, aTagID, tag.ID.String())
+	assert.Equal(t, "tag", tag.Type)
 
 	// Annotated tag's Commit ID should fail
 	tag2, err := bareRepo1.GetAnnotatedTag(aTagCommitID)

modules/git/repo_tree.go

···
 		if err != nil {
 			return nil, err
 		}
-		commit.Tree.ResolvedID = resolvedID
+		commit.ResolvedID = resolvedID
 		return &commit.Tree, nil
 	case "commit":
 		commit, err := CommitFromReader(repo, id, io.LimitReader(rd, size))
···
 		if _, err := rd.Discard(1); err != nil {
 			return nil, err
 		}
-		commit.Tree.ResolvedID = commit.ID
+		commit.ResolvedID = commit.ID
 		return &commit.Tree, nil
 	case "tree":
 		tree := NewTree(repo, id)

modules/git/signature_test.go

···
 	}
 	for _, test := range tests {
 		got := parseSignatureFromCommitLine(test.line)
-		assert.EqualValues(t, test.want, got)
+		assert.Equal(t, test.want, got)
 	}
 }

modules/git/submodule_test.go

···
 	}
 
 	for _, kase := range kases {
-		assert.EqualValues(t, kase.expect, getRefURL(kase.refURL, kase.prefixURL, kase.parentPath, kase.SSHDomain))
+		assert.Equal(t, kase.expect, getRefURL(kase.refURL, kase.prefixURL, kase.parentPath, kase.SSHDomain))
 	}
 }

modules/git/tag_test.go

···
 	for _, test := range testData {
 		tag, err := parseTagData(Sha1ObjectFormat, test.data)
 		require.NoError(t, err)
-		assert.EqualValues(t, test.tag.ID, tag.ID)
-		assert.EqualValues(t, test.tag.Object, tag.Object)
-		assert.EqualValues(t, test.tag.Name, tag.Name)
-		assert.EqualValues(t, test.tag.Message, tag.Message)
-		assert.EqualValues(t, test.tag.Type, tag.Type)
+		assert.Equal(t, test.tag.ID, tag.ID)
+		assert.Equal(t, test.tag.Object, tag.Object)
+		assert.Equal(t, test.tag.Name, tag.Name)
+		assert.Equal(t, test.tag.Message, tag.Message)
+		assert.Equal(t, test.tag.Type, tag.Type)
 		if test.tag.Signature != nil && assert.NotNil(t, tag.Signature) {
-			assert.EqualValues(t, test.tag.Signature.Signature, tag.Signature.Signature)
-			assert.EqualValues(t, test.tag.Signature.Payload, tag.Signature.Payload)
+			assert.Equal(t, test.tag.Signature.Signature, tag.Signature.Signature)
+			assert.Equal(t, test.tag.Signature.Payload, tag.Signature.Payload)
 		} else {
 			assert.Nil(t, tag.Signature)
 		}
 		if test.tag.Tagger != nil && assert.NotNil(t, tag.Tagger) {
-			assert.EqualValues(t, test.tag.Tagger.Name, tag.Tagger.Name)
-			assert.EqualValues(t, test.tag.Tagger.Email, tag.Tagger.Email)
-			assert.EqualValues(t, test.tag.Tagger.When.Unix(), tag.Tagger.When.Unix())
+			assert.Equal(t, test.tag.Tagger.Name, tag.Tagger.Name)
+			assert.Equal(t, test.tag.Tagger.Email, tag.Tagger.Email)
+			assert.Equal(t, test.tag.Tagger.When.Unix(), tag.Tagger.When.Unix())
 		} else {
 			assert.Nil(t, tag.Tagger)
 		}

modules/git/tree_test.go

···
 
 	commitID, err := repo.GetBranchCommitID("master")
 	require.NoError(t, err)
-	assert.EqualValues(t, "544d8f7a3b15927cddf2299b4b562d6ebd71b6a7", commitID)
+	assert.Equal(t, "544d8f7a3b15927cddf2299b4b562d6ebd71b6a7", commitID)
 
 	commit, err := repo.GetTreePathLatestCommit("master", "blame.txt")
 	require.NoError(t, err)
 	assert.NotNil(t, commit)
-	assert.EqualValues(t, "45fb6cbc12f970b04eacd5cd4165edd11c8d7376", commit.ID.String())
+	assert.Equal(t, "45fb6cbc12f970b04eacd5cd4165edd11c8d7376", commit.ID.String())
 }

modules/git/url/url_test.go

···
 		t.Run(kase.kase, func(t *testing.T) {
 			u, err := Parse(kase.kase)
 			require.NoError(t, err)
-			assert.EqualValues(t, kase.expected.extraMark, u.extraMark)
-			assert.EqualValues(t, *kase.expected, *u)
+			assert.Equal(t, kase.expected.extraMark, u.extraMark)
+			assert.Equal(t, *kase.expected, *u)
 		})
 	}
 }

modules/graceful/releasereopen/releasereopen_test.go

···
 	_ = m.Register(t3)
 
 	require.NoError(t, m.ReleaseReopen())
-	assert.EqualValues(t, 1, t1.count)
-	assert.EqualValues(t, 1, t2.count)
-	assert.EqualValues(t, 1, t3.count)
+	assert.Equal(t, 1, t1.count)
+	assert.Equal(t, 1, t2.count)
+	assert.Equal(t, 1, t3.count)
 
 	c2()
 
 	require.NoError(t, m.ReleaseReopen())
-	assert.EqualValues(t, 2, t1.count)
-	assert.EqualValues(t, 1, t2.count)
-	assert.EqualValues(t, 2, t3.count)
+	assert.Equal(t, 2, t1.count)
+	assert.Equal(t, 1, t2.count)
+	assert.Equal(t, 2, t3.count)
 }

modules/graceful/server.go

···
 		if minDeadline.After(w.deadline) {
 			w.deadline = minDeadline
 		}
-		_ = w.Conn.SetWriteDeadline(w.deadline)
+		_ = w.SetWriteDeadline(w.deadline)
 	}
 	return w.Conn.Write(p)
 }

modules/graceful/server_hooks.go

···
 		return
 	}
 	log.Warn("Forcefully shutting down parent")
-	for {
-		if srv.getState() == stateTerminate {
-			break
-		}
+	for srv.getState() != stateTerminate {
 		srv.wg.Done()
 
 		// Give other goroutines a chance to finish before we forcibly stop them.

modules/highlight/highlight_test.go

···
 		t.Run(tt.name, func(t *testing.T) {
 			out, lexerName, err := File(tt.name, "", []byte(tt.code))
 			require.NoError(t, err)
-			assert.EqualValues(t, tt.want, out)
+			assert.Equal(t, tt.want, out)
 			assert.Equal(t, tt.lexerName, lexerName)
 		})
 	}
···
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			out := PlainText([]byte(tt.code))
-			assert.EqualValues(t, tt.want, out)
+			assert.Equal(t, tt.want, out)
 		})
 	}
 }

modules/indexer/code/elasticsearch/elasticsearch_test.go

···
 
 func TestIndexPos(t *testing.T) {
 	startIdx, endIdx := indexPos("test index start and end", "start", "end")
-	assert.EqualValues(t, 11, startIdx)
-	assert.EqualValues(t, 24, endIdx)
+	assert.Equal(t, 11, startIdx)
+	assert.Equal(t, 24, endIdx)
 }

modules/indexer/code/indexer_test.go

···
 				ids := make([]int64, 0, len(res))
 				for _, hit := range res {
 					ids = append(ids, hit.RepoID)
-					assert.EqualValues(t, "# repo1\n\nDescription for repo1", hit.Content)
+					assert.Equal(t, "# repo1\n\nDescription for repo1", hit.Content)
 				}
-				assert.EqualValues(t, kw.IDs, ids)
+				assert.Equal(t, kw.IDs, ids)
 			})
 		}
 
···
 		if idx != nil {
 			idx.Close()
 		}
-		assert.FailNow(t, "Unable to create bleve indexer Error: %v", err)
+		require.NoError(t, err)
 	}
 	defer idx.Close()
 
···
 		if indexer != nil {
 			indexer.Close()
 		}
-		assert.FailNow(t, "Unable to init ES indexer Error: %v", err)
+		assert.FailNow(t, "Unable to init ES indexer", "error: %v", err)
 	}
 
 	defer indexer.Close()

modules/indexer/internal/bleve/metadata_test.go

···
 
 	meta, err = readIndexMetadata(dir)
 	require.NoError(t, err)
-	assert.EqualValues(t, 24, meta.Version)
+	assert.Equal(t, 24, meta.Version)
 }

modules/indexer/issues/internal/tests/tests.go

···
 		Name:          "default",
 		SearchOptions: &internal.SearchOptions{},
 		Expected: func(t *testing.T, data map[int64]*internal.IndexerData, result *internal.SearchResult) {
-			assert.Equal(t, len(data), len(result.Hits))
+			assert.Len(t, result.Hits, len(data))
 			assert.Equal(t, len(data), int(result.Total))
 		},
 	},
···
 			SortBy:    internal.SortByCreatedDesc,
 		},
 		Expected: func(t *testing.T, data map[int64]*internal.IndexerData, result *internal.SearchResult) {
-			assert.Equal(t, len(data), len(result.Hits))
+			assert.Len(t, result.Hits, len(data))
 			assert.Equal(t, len(data), int(result.Total))
 			for i, v := range result.Hits {
 				if i < len(result.Hits)-1 {
···
 			SortBy:    internal.SortByUpdatedDesc,
 		},
 		Expected: func(t *testing.T, data map[int64]*internal.IndexerData, result *internal.SearchResult) {
-			assert.Equal(t, len(data), len(result.Hits))
+			assert.Len(t, result.Hits, len(data))
 			assert.Equal(t, len(data), int(result.Total))
 			for i, v := range result.Hits {
 				if i < len(result.Hits)-1 {
···
 			SortBy:    internal.SortByCommentsDesc,
 		},
 		Expected: func(t *testing.T, data map[int64]*internal.IndexerData, result *internal.SearchResult) {
-			assert.Equal(t, len(data), len(result.Hits))
+			assert.Len(t, result.Hits, len(data))
 			assert.Equal(t, len(data), int(result.Total))
 			for i, v := range result.Hits {
 				if i < len(result.Hits)-1 {
···
 			SortBy:    internal.SortByDeadlineDesc,
 		},
 		Expected: func(t *testing.T, data map[int64]*internal.IndexerData, result *internal.SearchResult) {
-			assert.Equal(t, len(data), len(result.Hits))
+			assert.Len(t, result.Hits, len(data))
 			assert.Equal(t, len(data), int(result.Total))
 			for i, v := range result.Hits {
 				if i < len(result.Hits)-1 {
···
 			SortBy:    internal.SortByScore,
 		},
 		Expected: func(t *testing.T, data map[int64]*internal.IndexerData, result *internal.SearchResult) {
-			assert.Equal(t, len(data), len(result.Hits))
+			assert.Len(t, result.Hits, len(data))
 			assert.Equal(t, len(data), int(result.Total))
 			for i, v := range result.Hits {
 				if i < len(result.Hits)-1 {
···
 			SortBy:    internal.SortByCreatedAsc,
 		},
 		Expected: func(t *testing.T, data map[int64]*internal.IndexerData, result *internal.SearchResult) {
-			assert.Equal(t, len(data), len(result.Hits))
+			assert.Len(t, result.Hits, len(data))
 			assert.Equal(t, len(data), int(result.Total))
 			for i, v := range result.Hits {
 				if i < len(result.Hits)-1 {
···
 			SortBy:    internal.SortByUpdatedAsc,
 		},
 		Expected: func(t *testing.T, data map[int64]*internal.IndexerData, result *internal.SearchResult) {
-			assert.Equal(t, len(data), len(result.Hits))
+			assert.Len(t, result.Hits, len(data))
 			assert.Equal(t, len(data), int(result.Total))
 			for i, v := range result.Hits {
 				if i < len(result.Hits)-1 {
···
 			SortBy:    internal.SortByCommentsAsc,
 		},
 		Expected: func(t *testing.T, data map[int64]*internal.IndexerData, result *internal.SearchResult) {
-			assert.Equal(t, len(data), len(result.Hits))
+			assert.Len(t, result.Hits, len(data))
 			assert.Equal(t, len(data), int(result.Total))
 			for i, v := range result.Hits {
 				if i < len(result.Hits)-1 {
···
 			SortBy:    internal.SortByDeadlineAsc,
 		},
 		Expected: func(t *testing.T, data map[int64]*internal.IndexerData, result *internal.SearchResult) {
-			assert.Equal(t, len(data), len(result.Hits))
+			assert.Len(t, result.Hits, len(data))
 			assert.Equal(t, len(data), int(result.Total))
 			for i, v := range result.Hits {
 				if i < len(result.Hits)-1 {

modules/indexer/issues/meilisearch/meilisearch_test.go

···
 	}
 	hits, err := convertHits(validResponse)
 	require.NoError(t, err)
-	assert.EqualValues(t, []internal.Match{{ID: 11}, {ID: 22}, {ID: 33}}, hits)
+	assert.Equal(t, []internal.Match{{ID: 11}, {ID: 22}, {ID: 33}}, hits)
 }
 
 func TestDoubleQuoteKeyword(t *testing.T) {
-	assert.EqualValues(t, "", doubleQuoteKeyword(""))
-	assert.EqualValues(t, `"a" "b" "c"`, doubleQuoteKeyword("a b c"))
-	assert.EqualValues(t, `"a" "d" "g"`, doubleQuoteKeyword("a  d g"))
-	assert.EqualValues(t, `"a" "d" "g"`, doubleQuoteKeyword("a  d g"))
-	assert.EqualValues(t, `"a" "d" "g"`, doubleQuoteKeyword(`a  "" "d" """g`))
+	assert.Empty(t, doubleQuoteKeyword(""))
+	assert.Equal(t, `"a" "b" "c"`, doubleQuoteKeyword("a b c"))
+	assert.Equal(t, `"a" "d" "g"`, doubleQuoteKeyword("a  d g"))
+	assert.Equal(t, `"a" "d" "g"`, doubleQuoteKeyword("a  d g"))
+	assert.Equal(t, `"a" "d" "g"`, doubleQuoteKeyword(`a  "" "d" """g`))
 }

modules/issue/template/template.go

···
 				}
 				for _, visibleType := range visibilityList {
 					visibleType, ok := visibleType.(string)
-					if !ok || !(visibleType == "form" || visibleType == "content") {
+					if !ok || (visibleType != "form" && visibleType != "content") {
 						return position.Errorf("'visible' list can only contain strings of 'form' and 'content'")
 					}
 				}

modules/issue/template/template_test.go

···
 				t.Fatal(err)
 			}
 			if got := RenderToMarkdown(template, tt.args.values); got != tt.want {
-				assert.EqualValues(t, tt.want, got)
+				assert.Equal(t, tt.want, got)
 			}
 		})
 	}

modules/keying/keying_test.go

···
 		cipherText2 := key.Encrypt(plainText, []byte{0x05, 0x06})
 
 		// Ensure ciphertexts don't have an deterministic output.
-		assert.NotEqualValues(t, cipherText, cipherText2)
+		assert.NotEqual(t, cipherText, cipherText2)
 	})
 
 	t.Run("Decrypt", func(t *testing.T) {
···
 		t.Run("Successful", func(t *testing.T) {
 			convertedPlainText, err := key.Decrypt(cipherText, []byte{0x05, 0x06})
 			require.NoError(t, err)
-			assert.EqualValues(t, plainText, convertedPlainText)
+			assert.Equal(t, plainText, convertedPlainText)
 		})
 
 		t.Run("Not enough additional data", func(t *testing.T) {
···
 }
 
 func TestKeyingColumnAndID(t *testing.T) {
-	assert.EqualValues(t, []byte{0x74, 0x61, 0x62, 0x6c, 0x65, 0x3a, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, keying.ColumnAndID("table", math.MinInt64))
-	assert.EqualValues(t, []byte{0x74, 0x61, 0x62, 0x6c, 0x65, 0x3a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}, keying.ColumnAndID("table", -1))
-	assert.EqualValues(t, []byte{0x74, 0x61, 0x62, 0x6c, 0x65, 0x3a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, keying.ColumnAndID("table", 0))
-	assert.EqualValues(t, []byte{0x74, 0x61, 0x62, 0x6c, 0x65, 0x3a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01}, keying.ColumnAndID("table", 1))
-	assert.EqualValues(t, []byte{0x74, 0x61, 0x62, 0x6c, 0x65, 0x3a, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}, keying.ColumnAndID("table", math.MaxInt64))
+	assert.Equal(t, []byte{0x74, 0x61, 0x62, 0x6c, 0x65, 0x3a, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, keying.ColumnAndID("table", math.MinInt64))
+	assert.Equal(t, []byte{0x74, 0x61, 0x62, 0x6c, 0x65, 0x3a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}, keying.ColumnAndID("table", -1))
+	assert.Equal(t, []byte{0x74, 0x61, 0x62, 0x6c, 0x65, 0x3a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, keying.ColumnAndID("table", 0))
+	assert.Equal(t, []byte{0x74, 0x61, 0x62, 0x6c, 0x65, 0x3a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01}, keying.ColumnAndID("table", 1))
+	assert.Equal(t, []byte{0x74, 0x61, 0x62, 0x6c, 0x65, 0x3a, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}, keying.ColumnAndID("table", math.MaxInt64))
 
-	assert.EqualValues(t, []byte{0x74, 0x61, 0x62, 0x6c, 0x65, 0x32, 0x3a, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, keying.ColumnAndID("table2", math.MinInt64))
-	assert.EqualValues(t, []byte{0x74, 0x61, 0x62, 0x6c, 0x65, 0x32, 0x3a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}, keying.ColumnAndID("table2", -1))
-	assert.EqualValues(t, []byte{0x74, 0x61, 0x62, 0x6c, 0x65, 0x32, 0x3a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, keying.ColumnAndID("table2", 0))
-	assert.EqualValues(t, []byte{0x74, 0x61, 0x62, 0x6c, 0x65, 0x32, 0x3a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01}, keying.ColumnAndID("table2", 1))
-	assert.EqualValues(t, []byte{0x74, 0x61, 0x62, 0x6c, 0x65, 0x32, 0x3a, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}, keying.ColumnAndID("table2", math.MaxInt64))
+	assert.Equal(t, []byte{0x74, 0x61, 0x62, 0x6c, 0x65, 0x32, 0x3a, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, keying.ColumnAndID("table2", math.MinInt64))
+	assert.Equal(t, []byte{0x74, 0x61, 0x62, 0x6c, 0x65, 0x32, 0x3a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}, keying.ColumnAndID("table2", -1))
+	assert.Equal(t, []byte{0x74, 0x61, 0x62, 0x6c, 0x65, 0x32, 0x3a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, keying.ColumnAndID("table2", 0))
+	assert.Equal(t, []byte{0x74, 0x61, 0x62, 0x6c, 0x65, 0x32, 0x3a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01}, keying.ColumnAndID("table2", 1))
+	assert.Equal(t, []byte{0x74, 0x61, 0x62, 0x6c, 0x65, 0x32, 0x3a, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}, keying.ColumnAndID("table2", math.MaxInt64))
 }

modules/lfs/content_store.go

···
 
 // Exists returns true if the object exists in the content store.
 func (s *ContentStore) Exists(pointer Pointer) (bool, error) {
-	_, err := s.ObjectStorage.Stat(pointer.RelativePath())
+	_, err := s.Stat(pointer.RelativePath())
 	if err != nil {
 		if os.IsNotExist(err) {
 			return false, nil
···
 // Verify returns true if the object exists in the content store and size is correct.
 func (s *ContentStore) Verify(pointer Pointer) (bool, error) {
 	p := pointer.RelativePath()
-	fi, err := s.ObjectStorage.Stat(p)
+	fi, err := s.Stat(p)
 	if os.IsNotExist(err) || (err == nil && fi.Size() != pointer.Size) {
 		return false, nil
 	} else if err != nil {

modules/log/event_writer_base.go

···
 			case io.WriterTo:
 				_, err = msg.WriteTo(b.OutputWriteCloser)
 			default:
-				_, err = b.OutputWriteCloser.Write([]byte(fmt.Sprint(msg)))
+				_, err = fmt.Fprint(b.OutputWriteCloser, msg)
 			}
 			if err != nil {
 				FallbackErrorf("unable to write log message of %q (%v): %v", b.Name, err, event.Msg)

modules/log/flags_test.go

···
 )
 
 func TestFlags(t *testing.T) {
-	assert.EqualValues(t, Ldefault, Flags{}.Bits())
+	assert.Equal(t, Ldefault, Flags{}.Bits())
 	assert.EqualValues(t, 0, FlagsFromString("").Bits())
-	assert.EqualValues(t, Lgopid, FlagsFromString("", Lgopid).Bits())
+	assert.Equal(t, Lgopid, FlagsFromString("", Lgopid).Bits())
 	assert.EqualValues(t, 0, FlagsFromString("none", Lgopid).Bits())
-	assert.EqualValues(t, Ldate|Ltime, FlagsFromString("date,time", Lgopid).Bits())
+	assert.Equal(t, Ldate|Ltime, FlagsFromString("date,time", Lgopid).Bits())
 
-	assert.EqualValues(t, "stdflags", FlagsFromString("stdflags").String())
-	assert.EqualValues(t, "medfile", FlagsFromString("medfile").String())
+	assert.Equal(t, "stdflags", FlagsFromString("stdflags").String())
+	assert.Equal(t, "medfile", FlagsFromString("medfile").String())
 
 	bs, err := json.Marshal(FlagsFromString("utc,level"))
 	require.NoError(t, err)
-	assert.EqualValues(t, `"level,utc"`, string(bs))
+	assert.Equal(t, `"level,utc"`, string(bs))
 	var flags Flags
 	require.NoError(t, json.Unmarshal(bs, &flags))
-	assert.EqualValues(t, LUTC|Llevel, flags.Bits())
+	assert.Equal(t, LUTC|Llevel, flags.Bits())
 }

modules/log/groutinelabel_test.go

···
 	pprof.Do(t.Context(), pprof.Labels(), func(ctx context.Context) {
 		currentLabels := getGoroutineLabels()
 		pprof.ForLabels(ctx, func(key, value string) bool {
-			assert.EqualValues(t, value, currentLabels[key])
+			assert.Equal(t, value, currentLabels[key])
 			return true
 		})
 
 		pprof.Do(ctx, pprof.Labels("Test_getGoroutineLabels", "Test_getGoroutineLabels_child1"), func(ctx context.Context) {
 			currentLabels := getGoroutineLabels()
 			pprof.ForLabels(ctx, func(key, value string) bool {
-				assert.EqualValues(t, value, currentLabels[key])
+				assert.Equal(t, value, currentLabels[key])
 				return true
 			})
 			if assert.NotNil(t, currentLabels) {
-				assert.EqualValues(t, "Test_getGoroutineLabels_child1", currentLabels["Test_getGoroutineLabels"])
+				assert.Equal(t, "Test_getGoroutineLabels_child1", currentLabels["Test_getGoroutineLabels"])
 			}
 		})
 	})

modules/log/logger_test.go

···
 
 	dump := logger.DumpWriters()
 	assert.Empty(t, dump)
-	assert.EqualValues(t, NONE, logger.GetLevel())
+	assert.Equal(t, NONE, logger.GetLevel())
 	assert.False(t, logger.IsEnabled())
 
 	w1 := newDummyWriter("dummy-1", DEBUG, 0)
 	logger.AddWriters(w1)
-	assert.EqualValues(t, DEBUG, logger.GetLevel())
+	assert.Equal(t, DEBUG, logger.GetLevel())
 
 	w2 := newDummyWriter("dummy-2", WARN, 200*time.Millisecond)
 	logger.AddWriters(w2)
-	assert.EqualValues(t, DEBUG, logger.GetLevel())
+	assert.Equal(t, DEBUG, logger.GetLevel())
 
 	dump = logger.DumpWriters()
 	assert.Len(t, dump, 2)

modules/markup/common/footnote.go

···
 			html.RenderAttributes(w, node, html.GlobalAttributeFilter)
 		}
 		_ = w.WriteByte('>')
-		if r.Config.XHTML {
+		if r.XHTML {
 			_, _ = w.WriteString("\n<hr />\n")
 		} else {
 			_, _ = w.WriteString("\n<hr>\n")

modules/markup/common/linkify.go

···
 		} else if lastChar == ')' {
 			closing := 0
 			for i := m[1] - 1; i >= m[0]; i-- {
-				if line[i] == ')' {
+				switch line[i] {
+				case ')':
 					closing++
-				} else if line[i] == '(' {
+				case '(':
 					closing--
 				}
 			}

modules/markup/console/console_test.go

···
 		err := render.Render(&markup.RenderContext{Ctx: git.DefaultContext},
 			strings.NewReader(k), &buf)
 		require.NoError(t, err)
-		assert.EqualValues(t, v, buf.String())
+		assert.Equal(t, v, buf.String())
 	}
 }

modules/markup/csv/csv_test.go

···
 		err := render.Render(&markup.RenderContext{Ctx: git.DefaultContext},
 			strings.NewReader(k), &buf)
 		require.NoError(t, err)
-		assert.EqualValues(t, v, buf.String())
+		assert.Equal(t, v, buf.String())
 	}
 }

modules/markup/html.go

···
 	// Add user-content- to IDs and "#" links if they don't already have them
 	for idx, attr := range node.Attr {
 		val := strings.TrimPrefix(attr.Val, "#")
-		notHasPrefix := !(strings.HasPrefix(val, "user-content-") || blackfridayExtRegex.MatchString(val))
+		notHasPrefix := !strings.HasPrefix(val, "user-content-") && !blackfridayExtRegex.MatchString(val)
 
 		if attr.Key == "id" && notHasPrefix {
 			node.Attr[idx].Val = "user-content-" + attr.Val

modules/markup/markdown/goldmark.go

···
 		if entering {
 			_, err = w.WriteString("<div")
 			if err == nil {
-				_, err = w.WriteString(fmt.Sprintf(` lang=%q`, val))
+				_, err = fmt.Fprintf(w, ` lang=%q`, val)
 			}
 			if err == nil {
 				_, err = w.WriteRune('>')
···
 		return ast.WalkContinue, nil
 	}
 
-	_, err := w.WriteString(fmt.Sprintf(`<i class="icon %s"></i>`, name))
+	_, err := fmt.Fprintf(w, `<i class="icon %s"></i>`, name)
 	if err != nil {
 		return ast.WalkStop, err
 	}

modules/markup/markdown/math/inline_parser.go

···
 		suceedingCharacter := line[pos]
 		// check valid ending character
 		if !isPunctuation(suceedingCharacter) &&
-			!(suceedingCharacter == ' ') &&
-			!(suceedingCharacter == '\n') &&
+			(suceedingCharacter != ' ') &&
+			(suceedingCharacter != '\n') &&
 			!isBracket(suceedingCharacter) {
 			return nil
 		}
···
 
 	// trim first space and last space
 	first := node.FirstChild().(*ast.Text)
-	if !(!first.Segment.IsEmpty() && block.Source()[first.Segment.Start] == ' ') {
+	if first.Segment.IsEmpty() || block.Source()[first.Segment.Start] != ' ' {
 		return
 	}
 
 	last := node.LastChild().(*ast.Text)
-	if !(!last.Segment.IsEmpty() && block.Source()[last.Segment.Stop-1] == ' ') {
+	if last.Segment.IsEmpty() || block.Source()[last.Segment.Stop-1] != ' ' {
 		return
 	}
 

modules/markup/markdown/meta_test.go

···
 		var meta IssueTemplate
 		body, err := ExtractMetadata(fmt.Sprintf("%s\n%s\n%s", sepTest, frontTest, sepTest), &meta)
 		require.NoError(t, err)
-		assert.Equal(t, "", body)
+		assert.Empty(t, body)
 		assert.Equal(t, metaTest, meta)
 		assert.True(t, meta.Valid())
 	})
···
 		var meta IssueTemplate
 		body, err := ExtractMetadataBytes([]byte(fmt.Sprintf("%s\n%s\n%s", sepTest, frontTest, sepTest)), &meta)
 		require.NoError(t, err)
-		assert.Equal(t, "", string(body))
+		assert.Empty(t, string(body))
 		assert.Equal(t, metaTest, meta)
 		assert.True(t, meta.Valid())
 	})

modules/markup/markdown/transform_codespan.go

···
 					r.Writer.RawWrite(w, value)
 				}
 			case *ColorPreview:
-				_, _ = w.WriteString(fmt.Sprintf(`<span class="color-preview" style="background-color: %v"></span>`, string(v.Color)))
+				_, _ = fmt.Fprintf(w, `<span class="color-preview" style="background-color: %v"></span>`, string(v.Color))
 			}
 		}
 		return ast.WalkSkipChildren, nil

modules/markup/mdstripper/mdstripper.go

···
 	}
 
 	var sep string
-	if parts[3] == "issues" {
+	switch parts[3] {
+	case "issues":
 		sep = "#"
-	} else if parts[3] == "pulls" {
+	case "pulls":
 		sep = "!"
-	} else {
+	default:
 		// Process out of band
 		r.links = append(r.links, linkStr)
 		return

modules/markup/mdstripper/mdstripper_test.go

···
 				lines = append(lines, line)
 			}
 		}
-		assert.EqualValues(t, test.expectedText, lines)
-		assert.EqualValues(t, test.expectedLinks, links)
+		assert.Equal(t, test.expectedText, lines)
+		assert.Equal(t, test.expectedLinks, links)
 	}
 }

modules/optional/serialization_test.go

···
 		t.Run(tc.name, func(t *testing.T) {
 			b, err := json.Marshal(tc.obj)
 			require.NoError(t, err)
-			assert.EqualValues(t, tc.want, string(b), "gitea json module returned unexpected")
+			assert.Equal(t, tc.want, string(b), "gitea json module returned unexpected")
 
 			b, err = std_json.Marshal(tc.obj)
 			require.NoError(t, err)
-			assert.EqualValues(t, tc.want, string(b), "std json module returned unexpected")
+			assert.Equal(t, tc.want, string(b), "std json module returned unexpected")
 		})
 	}
 }
···
 			var obj1 testSerializationStruct
 			err := json.Unmarshal([]byte(tc.data), &obj1)
 			require.NoError(t, err)
-			assert.EqualValues(t, tc.want, obj1, "gitea json module returned unexpected")
+			assert.Equal(t, tc.want, obj1, "gitea json module returned unexpected")
 
 			var obj2 testSerializationStruct
 			err = std_json.Unmarshal([]byte(tc.data), &obj2)
 			require.NoError(t, err)
-			assert.EqualValues(t, tc.want, obj2, "std json module returned unexpected")
+			assert.Equal(t, tc.want, obj2, "std json module returned unexpected")
 		})
 	}
 }
···
 		t.Run(tc.name, func(t *testing.T) {
 			b, err := yaml.Marshal(tc.obj)
 			require.NoError(t, err)
-			assert.EqualValues(t, tc.want, string(b), "yaml module returned unexpected")
+			assert.Equal(t, tc.want, string(b), "yaml module returned unexpected")
 		})
 	}
 }
···
 			var obj testSerializationStruct
 			err := yaml.Unmarshal([]byte(tc.data), &obj)
 			require.NoError(t, err)
-			assert.EqualValues(t, tc.want, obj, "yaml module returned unexpected")
+			assert.Equal(t, tc.want, obj, "yaml module returned unexpected")
 		})
 	}
 }

modules/packages/cargo/parser_test.go

···
 		assert.Equal(t, []string{author}, cp.Metadata.Authors)
 		assert.Len(t, cp.Metadata.Dependencies, 2)
 		assert.Equal(t, "dep", cp.Metadata.Dependencies[0].Name)
-		assert.EqualValues(t, "v4l2-sys-mit", cp.Metadata.Dependencies[1].Name)
-		assert.EqualValues(t, "v4l2-sys", *cp.Metadata.Dependencies[1].Package)
+		assert.Equal(t, "v4l2-sys-mit", cp.Metadata.Dependencies[1].Name)
+		assert.Equal(t, "v4l2-sys", *cp.Metadata.Dependencies[1].Package)
 		assert.Equal(t, homepage, cp.Metadata.ProjectURL)
 		assert.Equal(t, license, cp.Metadata.License)
 		content, _ := io.ReadAll(cp.Content)

modules/process/manager_stacktraces_test.go

···
 	t.Run("No flat with no system process", func(t *testing.T) {
 		processes, processCount, _, err := GetManager().ProcessStacktraces(false, true)
 		require.NoError(t, err)
-		assert.EqualValues(t, 4, processCount)
+		assert.Equal(t, 4, processCount)
 		assert.Len(t, processes, 2)
 
-		assert.EqualValues(t, "Children normal process", processes[0].Description)
-		assert.EqualValues(t, NormalProcessType, processes[0].Type)
+		assert.Equal(t, "Children normal process", processes[0].Description)
+		assert.Equal(t, NormalProcessType, processes[0].Type)
 		assert.Empty(t, processes[0].ParentPID)
 		assert.Len(t, processes[0].Children, 1)
 
-		assert.EqualValues(t, "Children process", processes[0].Children[0].Description)
-		assert.EqualValues(t, processes[0].PID, processes[0].Children[0].ParentPID)
+		assert.Equal(t, "Children process", processes[0].Children[0].Description)
+		assert.Equal(t, processes[0].PID, processes[0].Children[0].ParentPID)
 
-		assert.EqualValues(t, "Normal process", processes[1].Description)
-		assert.EqualValues(t, NormalProcessType, processes[1].Type)
+		assert.Equal(t, "Normal process", processes[1].Description)
+		assert.Equal(t, NormalProcessType, processes[1].Type)
 		assert.Empty(t, processes[1].ParentPID)
 		assert.Empty(t, processes[1].Children)
 	})
···
 	t.Run("Flat with no system process", func(t *testing.T) {
 		processes, processCount, _, err := GetManager().ProcessStacktraces(true, true)
 		require.NoError(t, err)
-		assert.EqualValues(t, 4, processCount)
+		assert.Equal(t, 4, processCount)
 		assert.Len(t, processes, 3)
 
-		assert.EqualValues(t, "Children process", processes[0].Description)
-		assert.EqualValues(t, NormalProcessType, processes[0].Type)
-		assert.EqualValues(t, processes[1].PID, processes[0].ParentPID)
+		assert.Equal(t, "Children process", processes[0].Description)
+		assert.Equal(t, NormalProcessType, processes[0].Type)
+		assert.Equal(t, processes[1].PID, processes[0].ParentPID)
 		assert.Empty(t, processes[0].Children)
 
-		assert.EqualValues(t, "Children normal process", processes[1].Description)
-		assert.EqualValues(t, NormalProcessType, processes[1].Type)
+		assert.Equal(t, "Children normal process", processes[1].Description)
+		assert.Equal(t, NormalProcessType, processes[1].Type)
 		assert.Empty(t, processes[1].ParentPID)
 		assert.Empty(t, processes[1].Children)
 
-		assert.EqualValues(t, "Normal process", processes[2].Description)
-		assert.EqualValues(t, NormalProcessType, processes[2].Type)
+		assert.Equal(t, "Normal process", processes[2].Description)
+		assert.Equal(t, NormalProcessType, processes[2].Type)
 		assert.Empty(t, processes[2].ParentPID)
 		assert.Empty(t, processes[2].Children)
 	})
···
 	t.Run("System process", func(t *testing.T) {
 		processes, processCount, _, err := GetManager().ProcessStacktraces(false, false)
 		require.NoError(t, err)
-		assert.EqualValues(t, 4, processCount)
+		assert.Equal(t, 4, processCount)
 		assert.Len(t, processes, 4)
 
-		assert.EqualValues(t, "System process", processes[0].Description)
-		assert.EqualValues(t, SystemProcessType, processes[0].Type)
+		assert.Equal(t, "System process", processes[0].Description)
+		assert.Equal(t, SystemProcessType, processes[0].Type)
 		assert.Empty(t, processes[0].ParentPID)
 		assert.Empty(t, processes[0].Children)
 
-		assert.EqualValues(t, "Children normal process", processes[1].Description)
-		assert.EqualValues(t, NormalProcessType, processes[1].Type)
+		assert.Equal(t, "Children normal process", processes[1].Description)
+		assert.Equal(t, NormalProcessType, processes[1].Type)
 		assert.Empty(t, processes[1].ParentPID)
 		assert.Len(t, processes[1].Children, 1)
 
-		assert.EqualValues(t, "Normal process", processes[2].Description)
-		assert.EqualValues(t, NormalProcessType, processes[2].Type)
+		assert.Equal(t, "Normal process", processes[2].Description)
+		assert.Equal(t, NormalProcessType, processes[2].Type)
 		assert.Empty(t, processes[2].ParentPID)
 		assert.Empty(t, processes[2].Children)
 
 		// This is the "main" pid, testing code always runs in a goroutine.
-		assert.EqualValues(t, "(unassociated)", processes[3].Description)
-		assert.EqualValues(t, NoneProcessType, processes[3].Type)
+		assert.Equal(t, "(unassociated)", processes[3].Description)
+		assert.Equal(t, NoneProcessType, processes[3].Type)
 		assert.Empty(t, processes[3].ParentPID)
 		assert.Empty(t, processes[3].Children)
 	})

modules/queue/base_test.go

···
 		_ = q.RemoveAll(ctx)
 		cnt, err := q.Len(ctx)
 		require.NoError(t, err)
-		assert.EqualValues(t, 0, cnt)
+		assert.Equal(t, 0, cnt)
 
 		// push the first item
 		err = q.PushItem(ctx, []byte("foo"))
···
 
 		cnt, err = q.Len(ctx)
 		require.NoError(t, err)
-		assert.EqualValues(t, 1, cnt)
+		assert.Equal(t, 1, cnt)
 
 		// push a duplicate item
 		err = q.PushItem(ctx, []byte("foo"))
···
 		has, err := q.HasItem(ctx, []byte("foo"))
 		require.NoError(t, err)
 		if !isUnique {
-			assert.EqualValues(t, 2, cnt)
+			assert.Equal(t, 2, cnt)
 			assert.False(t, has) // non-unique queues don't check for duplicates
 		} else {
-			assert.EqualValues(t, 1, cnt)
+			assert.Equal(t, 1, cnt)
 			assert.True(t, has)
 		}
 
···
 		// pop the first item (and the duplicate if non-unique)
 		it, err := q.PopItem(ctx)
 		require.NoError(t, err)
-		assert.EqualValues(t, "foo", string(it))
+		assert.Equal(t, "foo", string(it))
 
 		if !isUnique {
 			it, err = q.PopItem(ctx)
 			require.NoError(t, err)
-			assert.EqualValues(t, "foo", string(it))
+			assert.Equal(t, "foo", string(it))
 		}
 
 		// pop another item
 		it, err = q.PopItem(ctx)
 		require.NoError(t, err)
-		assert.EqualValues(t, "bar", string(it))
+		assert.Equal(t, "bar", string(it))
 
 		// pop an empty queue (timeout, cancel)
 		ctxTimed, cancel := context.WithTimeout(ctx, 10*time.Millisecond)
···
 		// remove all
 		cnt, err = q.Len(ctx)
 		require.NoError(t, err)
-		assert.EqualValues(t, cfg.Length, cnt)
+		assert.Equal(t, cfg.Length, cnt)
 
 		_ = q.RemoveAll(ctx)
 
 		cnt, err = q.Len(ctx)
 		require.NoError(t, err)
-		assert.EqualValues(t, 0, cnt)
+		assert.Equal(t, 0, cnt)
 	})
 }
 
···
 
 	cnt, err := q.Len(ctx)
 	require.NoError(t, err)
-	assert.EqualValues(t, 0, cnt)
+	assert.Equal(t, 0, cnt)
 
 	has, err := q.HasItem(ctx, []byte("foo"))
 	require.NoError(t, err)

modules/queue/manager_test.go

···
 	assert.Equal(t, filepath.Join(setting.AppDataPath, "queues/common"), q.baseConfig.DataFullDir)
 	assert.Equal(t, 100000, q.baseConfig.Length)
 	assert.Equal(t, 20, q.batchLength)
-	assert.Equal(t, "", q.baseConfig.ConnStr)
+	assert.Empty(t, q.baseConfig.ConnStr)
 	assert.Equal(t, "default_queue", q.baseConfig.QueueFullName)
 	assert.Equal(t, "default_queue_unique", q.baseConfig.SetFullName)
 	assert.NotZero(t, q.GetWorkerMaxNumber())
···
 	assert.Equal(t, filepath.Join(setting.AppDataPath, "queues/dir2"), q2.baseConfig.DataFullDir)
 	assert.Equal(t, 102, q2.baseConfig.Length)
 	assert.Equal(t, 22, q2.batchLength)
-	assert.Equal(t, "", q2.baseConfig.ConnStr)
+	assert.Empty(t, q2.baseConfig.ConnStr)
 	assert.Equal(t, "sub_q2", q2.baseConfig.QueueFullName)
 	assert.Equal(t, "sub_q2_u2", q2.baseConfig.SetFullName)
 	assert.Equal(t, 123, q2.GetWorkerMaxNumber())

modules/queue/workerqueue_test.go

···
 		ok := true
 		for i := 0; i < queueSetting.Length; i++ {
 			if i%2 == 0 {
-				ok = ok && assert.EqualValues(t, 2, m[i], "test %s: item %d", t.Name(), i)
+				ok = ok && assert.Equal(t, 2, m[i], "test %s: item %d", t.Name(), i)
 			} else {
-				ok = ok && assert.EqualValues(t, 1, m[i], "test %s: item %d", t.Name(), i)
+				ok = ok && assert.Equal(t, 1, m[i], "test %s: item %d", t.Name(), i)
 			}
 		}
 		if !ok {
···
 
 	assert.NotEmpty(t, tasksQ1)
 	assert.NotEmpty(t, tasksQ2)
-	assert.EqualValues(t, testCount, len(tasksQ1)+len(tasksQ2))
+	assert.Equal(t, testCount, len(tasksQ1)+len(tasksQ2))
 }
 
 func TestWorkerPoolQueueActiveWorkers(t *testing.T) {
···
 	}
 
 	time.Sleep(50 * time.Millisecond)
-	assert.EqualValues(t, 1, q.GetWorkerNumber())
-	assert.EqualValues(t, 1, q.GetWorkerActiveNumber())
+	assert.Equal(t, 1, q.GetWorkerNumber())
+	assert.Equal(t, 1, q.GetWorkerActiveNumber())
 	time.Sleep(500 * time.Millisecond)
-	assert.EqualValues(t, 1, q.GetWorkerNumber())
-	assert.EqualValues(t, 0, q.GetWorkerActiveNumber())
+	assert.Equal(t, 1, q.GetWorkerNumber())
+	assert.Equal(t, 0, q.GetWorkerActiveNumber())
 	time.Sleep(workerIdleDuration)
-	assert.EqualValues(t, 1, q.GetWorkerNumber()) // there is at least one worker after the queue begins working
+	assert.Equal(t, 1, q.GetWorkerNumber()) // there is at least one worker after the queue begins working
 	stop()
 
 	q, _ = newWorkerPoolQueueForTest("test-workpoolqueue", setting.QueueSettings{Type: "channel", BatchLength: 1, MaxWorkers: 3, Length: 100}, handler, false)
···
 	}
 
 	time.Sleep(50 * time.Millisecond)
-	assert.EqualValues(t, 3, q.GetWorkerNumber())
-	assert.EqualValues(t, 3, q.GetWorkerActiveNumber())
+	assert.Equal(t, 3, q.GetWorkerNumber())
+	assert.Equal(t, 3, q.GetWorkerActiveNumber())
 	time.Sleep(500 * time.Millisecond)
-	assert.EqualValues(t, 3, q.GetWorkerNumber())
-	assert.EqualValues(t, 0, q.GetWorkerActiveNumber())
+	assert.Equal(t, 3, q.GetWorkerNumber())
+	assert.Equal(t, 0, q.GetWorkerActiveNumber())
 	time.Sleep(workerIdleDuration)
-	assert.EqualValues(t, 1, q.GetWorkerNumber()) // there is at least one worker after the queue begins working
+	assert.Equal(t, 1, q.GetWorkerNumber()) // there is at least one worker after the queue begins working
 	stop()
 }
 
···
 	}
 	<-handlerCalled
 	time.Sleep(200 * time.Millisecond) // wait for a while to make sure all workers are active
-	assert.EqualValues(t, 4, q.GetWorkerActiveNumber())
+	assert.Equal(t, 4, q.GetWorkerActiveNumber())
 	stop() // stop triggers shutdown
-	assert.EqualValues(t, 0, q.GetWorkerActiveNumber())
+	assert.Equal(t, 0, q.GetWorkerActiveNumber())
 
 	// no item was ever handled, so we still get all of them again
 	q, _ = newWorkerPoolQueueForTest("test-workpoolqueue", qs, handler, false)
-	assert.EqualValues(t, 20, q.GetQueueItemNumber())
+	assert.Equal(t, 20, q.GetQueueItemNumber())
 }
 
 func TestWorkerPoolQueueWorkerIdleReset(t *testing.T) {

modules/references/references.go

···
 				continue
 			}
 			var sep string
-			if parts[3] == "issues" {
+			switch parts[3] {
+			case "issues":
 				sep = "#"
-			} else if parts[3] == "pulls" {
+			case "pulls":
 				sep = "!"
-			} else {
+			default:
 				continue
 			}
 			// Note: closing/reopening keywords not supported with URLs

modules/references/references_test.go

···
 	contentBytes := []byte(test)
 	convertFullHTMLReferencesToShortRefs(re, &contentBytes)
 	result := string(contentBytes)
-	assert.EqualValues(t, expect, result)
+	assert.Equal(t, expect, result)
 }
 
 func TestFindAllIssueReferences(t *testing.T) {
···
 		}
 		expref := rawToIssueReferenceList(expraw)
 		refs := FindAllIssueReferencesMarkdown(fixture.input)
-		assert.EqualValues(t, expref, refs, "[%s] Failed to parse: {%s}", context, fixture.input)
+		assert.Equal(t, expref, refs, "[%s] Failed to parse: {%s}", context, fixture.input)
 		rawrefs := findAllIssueReferencesMarkdown(fixture.input)
-		assert.EqualValues(t, expraw, rawrefs, "[%s] Failed to parse: {%s}", context, fixture.input)
+		assert.Equal(t, expraw, rawrefs, "[%s] Failed to parse: {%s}", context, fixture.input)
 	}
 
 	// Restore for other tests that may rely on the original value
···
 
 func TestFindAllMentions(t *testing.T) {
 	res := FindAllMentionsBytes([]byte("@tasha, @mike; @lucy: @john"))
-	assert.EqualValues(t, []RefSpan{
+	assert.Equal(t, []RefSpan{
 		{Start: 0, End: 6},
 		{Start: 8, End: 13},
 		{Start: 15, End: 20},
···
 			res := pat.FindAllStringSubmatch(test.match, -1)
 			assert.Len(t, res, 1)
 			assert.Len(t, res[0], 2)
-			assert.EqualValues(t, test.expected, res[0][1])
+			assert.Equal(t, test.expected, res[0][1])
 		}
 	}
 }

modules/regexplru/regexplru_test.go

···
 	require.NoError(t, err)
 	assert.True(t, r.MatchString("a"))
 
-	assert.EqualValues(t, 1, lruCache.Len())
+	assert.Equal(t, 1, lruCache.Len())
 
 	_, err = GetCompiled("(")
 	require.Error(t, err)
-	assert.EqualValues(t, 2, lruCache.Len())
+	assert.Equal(t, 2, lruCache.Len())
 }

modules/repository/branch_test.go

···
 	assert.Equal(t, "sha1", repo.ObjectFormatName)
 	branch, err := git_model.GetBranch(db.DefaultContext, 1, "master")
 	require.NoError(t, err)
-	assert.EqualValues(t, "master", branch.Name)
+	assert.Equal(t, "master", branch.Name)
 }

modules/repository/commits_test.go

···
 	assert.Equal(t, "user2", payloadCommits[0].Committer.UserName)
 	assert.Equal(t, "User2", payloadCommits[0].Author.Name)
 	assert.Equal(t, "user2", payloadCommits[0].Author.UserName)
-	assert.EqualValues(t, []string{}, payloadCommits[0].Added)
-	assert.EqualValues(t, []string{}, payloadCommits[0].Removed)
-	assert.EqualValues(t, []string{"readme.md"}, payloadCommits[0].Modified)
+	assert.Equal(t, []string{}, payloadCommits[0].Added)
+	assert.Equal(t, []string{}, payloadCommits[0].Removed)
+	assert.Equal(t, []string{"readme.md"}, payloadCommits[0].Modified)
 
 	assert.Equal(t, "27566bd", payloadCommits[1].ID)
 	assert.Equal(t, "good signed commit (with not yet validated email)", payloadCommits[1].Message)
···
 	assert.Equal(t, "user2", payloadCommits[1].Committer.UserName)
 	assert.Equal(t, "User2", payloadCommits[1].Author.Name)
 	assert.Equal(t, "user2", payloadCommits[1].Author.UserName)
-	assert.EqualValues(t, []string{}, payloadCommits[1].Added)
-	assert.EqualValues(t, []string{}, payloadCommits[1].Removed)
-	assert.EqualValues(t, []string{"readme.md"}, payloadCommits[1].Modified)
+	assert.Equal(t, []string{}, payloadCommits[1].Added)
+	assert.Equal(t, []string{}, payloadCommits[1].Removed)
+	assert.Equal(t, []string{"readme.md"}, payloadCommits[1].Modified)
 
 	assert.Equal(t, "5099b81", payloadCommits[2].ID)
 	assert.Equal(t, "good signed commit", payloadCommits[2].Message)
···
 	assert.Equal(t, "user2", payloadCommits[2].Committer.UserName)
 	assert.Equal(t, "User2", payloadCommits[2].Author.Name)
 	assert.Equal(t, "user2", payloadCommits[2].Author.UserName)
-	assert.EqualValues(t, []string{"readme.md"}, payloadCommits[2].Added)
-	assert.EqualValues(t, []string{}, payloadCommits[2].Removed)
-	assert.EqualValues(t, []string{}, payloadCommits[2].Modified)
+	assert.Equal(t, []string{"readme.md"}, payloadCommits[2].Added)
+	assert.Equal(t, []string{}, payloadCommits[2].Removed)
+	assert.Equal(t, []string{}, payloadCommits[2].Modified)
 
 	assert.Equal(t, "69554a6", headCommit.ID)
 	assert.Equal(t, "not signed commit", headCommit.Message)
···
 	assert.Equal(t, "user2", headCommit.Committer.UserName)
 	assert.Equal(t, "User2", headCommit.Author.Name)
 	assert.Equal(t, "user2", headCommit.Author.UserName)
-	assert.EqualValues(t, []string{}, headCommit.Added)
-	assert.EqualValues(t, []string{}, headCommit.Removed)
-	assert.EqualValues(t, []string{"readme.md"}, headCommit.Modified)
+	assert.Equal(t, []string{}, headCommit.Added)
+	assert.Equal(t, []string{}, headCommit.Removed)
+	assert.Equal(t, []string{"readme.md"}, headCommit.Modified)
 }
 
 func TestPushCommits_AvatarLink(t *testing.T) {

modules/repository/create.go

···
 	}
 	units := make([]repo_model.RepoUnit, 0, len(defaultUnits))
 	for _, tp := range defaultUnits {
-		if tp == unit.TypeIssues {
+		switch tp {
+		case unit.TypeIssues:
 			units = append(units, repo_model.RepoUnit{
 				RepoID: repo.ID,
 				Type:   tp,
···
 					EnableDependencies:               setting.Service.DefaultEnableDependencies,
 				},
 			})
-		} else if tp == unit.TypePullRequests {
+		case unit.TypePullRequests:
 			units = append(units, repo_model.RepoUnit{
 				RepoID: repo.ID,
 				Type:   tp,
···
 					AllowRebaseUpdate:  true,
 				},
 			})
-		} else {
+		default:
 			units = append(units, repo_model.RepoUnit{
 				RepoID: repo.ID,
 				Type:   tp,

modules/repository/create_test.go

···
 
 	size, err := getDirectorySize(repo.RepoPath())
 	require.NoError(t, err)
-	assert.EqualValues(t, size, repo.Size)
+	assert.Equal(t, size, repo.Size)
 }

modules/repository/init_test.go

···
 		all:    []string{"a", "a.yaml", "a.yml"},
 		custom: nil,
 	})
-	assert.EqualValues(t, []string{"a.yaml"}, files, "yaml file should win")
+	assert.Equal(t, []string{"a.yaml"}, files, "yaml file should win")
 
 	files = mergeCustomLabelFiles(optionFileList{
 		all:    []string{"a", "a.yaml"},
 		custom: []string{"a"},
 	})
-	assert.EqualValues(t, []string{"a"}, files, "custom file should win")
+	assert.Equal(t, []string{"a"}, files, "custom file should win")
 
 	files = mergeCustomLabelFiles(optionFileList{
 		all:    []string{"a", "a.yml", "a.yaml"},
 		custom: []string{"a", "a.yml"},
 	})
-	assert.EqualValues(t, []string{"a.yml"}, files, "custom yml file should win if no yaml")
+	assert.Equal(t, []string{"a.yml"}, files, "custom yml file should win if no yaml")
 }

modules/repository/license.go

···
 
 	// Some special placeholders for specific licenses.
 	// It's unsafe to apply them to all licenses.
-	if name == "0BSD" {
+	switch name {
+	case "0BSD":
 		return &licensePlaceholder{
 			Owner:     []string{"AUTHOR"},
 			Email:     []string{"EMAIL"},
···
 		}
 
 		// Other special placeholders can be added here.
-	} else if name == "BSD-4-Clause" {
+	case "BSD-4-Clause":
 		ret.Owner = append(ret.Owner, "COPYRIGHT HOLDER")
 		ret.Owner = append(ret.Owner, "the organization")
 	}

modules/repository/repo_test.go

···
 
 	inserts, deletes, updates := calcSync(gitTags, dbReleases)
 	if assert.Len(t, inserts, 1, "inserts") {
-		assert.EqualValues(t, *gitTags[2], *inserts[0], "inserts equal")
+		assert.Equal(t, *gitTags[2], *inserts[0], "inserts equal")
 	}
 
 	if assert.Len(t, deletes, 1, "deletes") {
···
 	}
 
 	if assert.Len(t, updates, 1, "updates") {
-		assert.EqualValues(t, *gitTags[1], *updates[0], "updates equal")
+		assert.Equal(t, *gitTags[1], *updates[0], "updates equal")
 	}
 }

modules/setting/actions_test.go

···
 	require.NoError(t, loadActionsFrom(cfg))
 
 	assert.EqualValues(t, "minio", Actions.LogStorage.Type)
-	assert.EqualValues(t, "actions_log/", Actions.LogStorage.MinioConfig.BasePath)
+	assert.Equal(t, "actions_log/", Actions.LogStorage.MinioConfig.BasePath)
 	assert.EqualValues(t, "minio", Actions.ArtifactStorage.Type)
-	assert.EqualValues(t, "actions_artifacts/", Actions.ArtifactStorage.MinioConfig.BasePath)
+	assert.Equal(t, "actions_artifacts/", Actions.ArtifactStorage.MinioConfig.BasePath)
 
 	iniStr = `
 [storage.actions_log]
···
 	require.NoError(t, loadActionsFrom(cfg))
 
 	assert.EqualValues(t, "minio", Actions.LogStorage.Type)
-	assert.EqualValues(t, "actions_log/", Actions.LogStorage.MinioConfig.BasePath)
+	assert.Equal(t, "actions_log/", Actions.LogStorage.MinioConfig.BasePath)
 	assert.EqualValues(t, "local", Actions.ArtifactStorage.Type)
-	assert.EqualValues(t, "actions_artifacts", filepath.Base(Actions.ArtifactStorage.Path))
+	assert.Equal(t, "actions_artifacts", filepath.Base(Actions.ArtifactStorage.Path))
 
 	iniStr = `
 [storage.actions_log]
···
 	require.NoError(t, loadActionsFrom(cfg))
 
 	assert.EqualValues(t, "minio", Actions.LogStorage.Type)
-	assert.EqualValues(t, "actions_log/", Actions.LogStorage.MinioConfig.BasePath)
+	assert.Equal(t, "actions_log/", Actions.LogStorage.MinioConfig.BasePath)
 	assert.EqualValues(t, "local", Actions.ArtifactStorage.Type)
-	assert.EqualValues(t, "actions_artifacts", filepath.Base(Actions.ArtifactStorage.Path))
+	assert.Equal(t, "actions_artifacts", filepath.Base(Actions.ArtifactStorage.Path))
 
 	iniStr = `
 [storage.actions_artifacts]
···
 	require.NoError(t, loadActionsFrom(cfg))
 
 	assert.EqualValues(t, "local", Actions.LogStorage.Type)
-	assert.EqualValues(t, "actions_log", filepath.Base(Actions.LogStorage.Path))
+	assert.Equal(t, "actions_log", filepath.Base(Actions.LogStorage.Path))
 	assert.EqualValues(t, "minio", Actions.ArtifactStorage.Type)
-	assert.EqualValues(t, "actions_artifacts/", Actions.ArtifactStorage.MinioConfig.BasePath)
+	assert.Equal(t, "actions_artifacts/", Actions.ArtifactStorage.MinioConfig.BasePath)
 
 	iniStr = `
 [storage.actions_artifacts]
···
 	require.NoError(t, loadActionsFrom(cfg))
 
 	assert.EqualValues(t, "local", Actions.LogStorage.Type)
-	assert.EqualValues(t, "actions_log", filepath.Base(Actions.LogStorage.Path))
+	assert.Equal(t, "actions_log", filepath.Base(Actions.LogStorage.Path))
 	assert.EqualValues(t, "minio", Actions.ArtifactStorage.Type)
-	assert.EqualValues(t, "actions_artifacts/", Actions.ArtifactStorage.MinioConfig.BasePath)
+	assert.Equal(t, "actions_artifacts/", Actions.ArtifactStorage.MinioConfig.BasePath)
 
 	iniStr = ``
 	cfg, err = NewConfigProviderFromData(iniStr)
···
 	require.NoError(t, loadActionsFrom(cfg))
 
 	assert.EqualValues(t, "local", Actions.LogStorage.Type)
-	assert.EqualValues(t, "actions_log", filepath.Base(Actions.LogStorage.Path))
+	assert.Equal(t, "actions_log", filepath.Base(Actions.LogStorage.Path))
 	assert.EqualValues(t, "local", Actions.ArtifactStorage.Type)
-	assert.EqualValues(t, "actions_artifacts", filepath.Base(Actions.ArtifactStorage.Path))
+	assert.Equal(t, "actions_artifacts", filepath.Base(Actions.ArtifactStorage.Path))
 }
 
 func Test_getDefaultActionsURLForActions(t *testing.T) {
···
 			require.NoError(t, err)
 			require.NoError(t, loadActionsFrom(cfg))
 
-			assert.EqualValues(t, tt.wantURL, Actions.DefaultActionsURL.URL())
+			assert.Equal(t, tt.wantURL, Actions.DefaultActionsURL.URL())
 		})
 	}
 }

modules/setting/admin_test.go

···
 	loadAdminFrom(cfg)
 
 	assert.True(t, Admin.DisableRegularOrgCreation)
-	assert.EqualValues(t, "z", Admin.DefaultEmailNotification)
+	assert.Equal(t, "z", Admin.DefaultEmailNotification)
 	assert.True(t, Admin.SendNotificationEmailOnNewUser)
-	assert.EqualValues(t, container.SetOf("a", "b"), Admin.UserDisabledFeatures)
-	assert.EqualValues(t, container.SetOf("x", "y"), Admin.ExternalUserDisableFeatures)
+	assert.Equal(t, container.SetOf("a", "b"), Admin.UserDisabledFeatures)
+	assert.Equal(t, container.SetOf("x", "y"), Admin.ExternalUserDisableFeatures)
 }

modules/setting/attachment_test.go

···
 	require.NoError(t, loadAttachmentFrom(cfg))
 
 	assert.EqualValues(t, "minio", Attachment.Storage.Type)
-	assert.EqualValues(t, "my_minio:9000", Attachment.Storage.MinioConfig.Endpoint)
-	assert.EqualValues(t, "gitea-attachment", Attachment.Storage.MinioConfig.Bucket)
-	assert.EqualValues(t, "attachments/", Attachment.Storage.MinioConfig.BasePath)
+	assert.Equal(t, "my_minio:9000", Attachment.Storage.MinioConfig.Endpoint)
+	assert.Equal(t, "gitea-attachment", Attachment.Storage.MinioConfig.Bucket)
+	assert.Equal(t, "attachments/", Attachment.Storage.MinioConfig.BasePath)
 }
 
 func Test_getStorageTypeSectionOverridesStorageSection(t *testing.T) {
···
 	require.NoError(t, loadAttachmentFrom(cfg))
 
 	assert.EqualValues(t, "minio", Attachment.Storage.Type)
-	assert.EqualValues(t, "gitea-minio", Attachment.Storage.MinioConfig.Bucket)
-	assert.EqualValues(t, "attachments/", Attachment.Storage.MinioConfig.BasePath)
+	assert.Equal(t, "gitea-minio", Attachment.Storage.MinioConfig.Bucket)
+	assert.Equal(t, "attachments/", Attachment.Storage.MinioConfig.BasePath)
 }
 
 func Test_getStorageSpecificOverridesStorage(t *testing.T) {
···
 	require.NoError(t, loadAttachmentFrom(cfg))
 
 	assert.EqualValues(t, "minio", Attachment.Storage.Type)
-	assert.EqualValues(t, "gitea-attachment", Attachment.Storage.MinioConfig.Bucket)
-	assert.EqualValues(t, "attachments/", Attachment.Storage.MinioConfig.BasePath)
+	assert.Equal(t, "gitea-attachment", Attachment.Storage.MinioConfig.Bucket)
+	assert.Equal(t, "attachments/", Attachment.Storage.MinioConfig.BasePath)
 }
 
 func Test_getStorageGetDefaults(t *testing.T) {
···
 	require.NoError(t, loadAttachmentFrom(cfg))
 
 	// default storage is local, so bucket is empty
-	assert.EqualValues(t, "", Attachment.Storage.MinioConfig.Bucket)
+	assert.Empty(t, Attachment.Storage.MinioConfig.Bucket)
 }
 
 func Test_getStorageInheritNameSectionType(t *testing.T) {
···
 	storage := Attachment.Storage
 
 	assert.EqualValues(t, "minio", storage.Type)
-	assert.EqualValues(t, "gitea", storage.MinioConfig.Bucket)
+	assert.Equal(t, "gitea", storage.MinioConfig.Bucket)
 }
 
 func Test_AttachmentStorage1(t *testing.T) {
···
 
 	require.NoError(t, loadAttachmentFrom(cfg))
 	assert.EqualValues(t, "minio", Attachment.Storage.Type)
-	assert.EqualValues(t, "gitea", Attachment.Storage.MinioConfig.Bucket)
-	assert.EqualValues(t, "attachments/", Attachment.Storage.MinioConfig.BasePath)
+	assert.Equal(t, "gitea", Attachment.Storage.MinioConfig.Bucket)
+	assert.Equal(t, "attachments/", Attachment.Storage.MinioConfig.BasePath)
 }

modules/setting/config_env_test.go

···
 
 	ok, section, key = decodeEnvSectionKey("SEC")
 	assert.False(t, ok)
-	assert.Equal(t, "", section)
-	assert.Equal(t, "", key)
+	assert.Empty(t, section)
+	assert.Empty(t, key)
 }
 
 func TestDecodeEnvironmentKey(t *testing.T) {
···
 
 	ok, section, key, file := decodeEnvironmentKey(prefix, suffix, "SEC__KEY")
 	assert.False(t, ok)
-	assert.Equal(t, "", section)
-	assert.Equal(t, "", key)
+	assert.Empty(t, section)
+	assert.Empty(t, key)
 	assert.False(t, file)
 
 	ok, section, key, file = decodeEnvironmentKey(prefix, suffix, "GITEA__SEC")
 	assert.False(t, ok)
-	assert.Equal(t, "", section)
-	assert.Equal(t, "", key)
+	assert.Empty(t, section)
+	assert.Empty(t, key)
 	assert.False(t, file)
 
 	ok, section, key, file = decodeEnvironmentKey(prefix, suffix, "GITEA____KEY")
 	assert.True(t, ok)
-	assert.Equal(t, "", section)
+	assert.Empty(t, section)
 	assert.Equal(t, "KEY", key)
 	assert.False(t, file)
 
···
 	// but it could be fixed in the future by adding a new suffix like "__VALUE" (no such key VALUE is used in Gitea either)
 	ok, section, key, file = decodeEnvironmentKey(prefix, suffix, "GITEA__SEC__FILE")
 	assert.False(t, ok)
-	assert.Equal(t, "", section)
-	assert.Equal(t, "", key)
+	assert.Empty(t, section)
+	assert.Empty(t, key)
 	assert.True(t, file)
 
 	ok, section, key, file = decodeEnvironmentKey(prefix, suffix, "GITEA__SEC__KEY__FILE")

modules/setting/config_provider_test.go

···
 
 	// test default behavior
 	assert.Equal(t, "123", ConfigSectionKeyString(sec, "key"))
-	assert.Equal(t, "", ConfigSectionKeyString(secSub, "key"))
+	assert.Empty(t, ConfigSectionKeyString(secSub, "key"))
 	assert.Equal(t, "def", ConfigSectionKeyString(secSub, "key", "def"))
 
 	assert.Equal(t, "123", ConfigInheritedKeyString(secSub, "key"))
 
 	// Workaround for ini package's BuggyKeyOverwritten behavior
-	assert.Equal(t, "", ConfigSectionKeyString(sec, "empty"))
-	assert.Equal(t, "", ConfigSectionKeyString(secSub, "empty"))
+	assert.Empty(t, ConfigSectionKeyString(sec, "empty"))
+	assert.Empty(t, ConfigSectionKeyString(secSub, "empty"))
 	assert.Equal(t, "def", ConfigInheritedKey(secSub, "empty").MustString("def"))
 	assert.Equal(t, "def", ConfigInheritedKey(secSub, "empty").MustString("xyz"))
-	assert.Equal(t, "", ConfigSectionKeyString(sec, "empty"))
+	assert.Empty(t, ConfigSectionKeyString(sec, "empty"))
 	assert.Equal(t, "def", ConfigSectionKeyString(secSub, "empty"))
 }
 

modules/setting/cron_test.go

···
 	_, err = getCronSettings(cfg, "test", extended)
 	require.NoError(t, err)
 	assert.True(t, extended.Base)
-	assert.EqualValues(t, "white rabbit", extended.Second)
+	assert.Equal(t, "white rabbit", extended.Second)
 	assert.True(t, extended.Extend)
 }

modules/setting/forgejo_storage_test.go

···
 	cfg, err := NewConfigProviderFromData(iniStr)
 	require.NoError(t, err, iniStr)
 	require.NoError(t, loadCommonSettingsFrom(cfg), iniStr)
-	assert.EqualValues(t, testSectionToPath(storageType, section), testStorageGetPath(*storage), iniStr)
-	assert.EqualValues(t, storageType, (*storage).Type, iniStr)
+	assert.Equal(t, testSectionToPath(storageType, section), testStorageGetPath(*storage), iniStr)
+	assert.Equal(t, storageType, (*storage).Type, iniStr)
 }

modules/setting/git_test.go

···
 `)
 	require.NoError(t, err)
 	loadGitFrom(cfg)
-	assert.EqualValues(t, "1", GitConfig.Options["a.b"])
-	assert.EqualValues(t, "histogram", GitConfig.Options["diff.algorithm"])
+	assert.Equal(t, "1", GitConfig.Options["a.b"])
+	assert.Equal(t, "histogram", GitConfig.Options["diff.algorithm"])
 
 	cfg, err = NewConfigProviderFromData(`
 [git.config]
···
 `)
 	require.NoError(t, err)
 	loadGitFrom(cfg)
-	assert.EqualValues(t, "other", GitConfig.Options["diff.algorithm"])
+	assert.Equal(t, "other", GitConfig.Options["diff.algorithm"])
 }
 
 func TestGitReflog(t *testing.T) {
···
 	require.NoError(t, err)
 	loadGitFrom(cfg)
 
-	assert.EqualValues(t, "true", GitConfig.GetOption("core.logAllRefUpdates"))
-	assert.EqualValues(t, "90", GitConfig.GetOption("gc.reflogExpire"))
+	assert.Equal(t, "true", GitConfig.GetOption("core.logAllRefUpdates"))
+	assert.Equal(t, "90", GitConfig.GetOption("gc.reflogExpire"))
 
 	// custom reflog config by legacy options
 	cfg, err = NewConfigProviderFromData(`
···
 	require.NoError(t, err)
 	loadGitFrom(cfg)
 
-	assert.EqualValues(t, "false", GitConfig.GetOption("core.logAllRefUpdates"))
-	assert.EqualValues(t, "123", GitConfig.GetOption("gc.reflogExpire"))
+	assert.Equal(t, "false", GitConfig.GetOption("core.logAllRefUpdates"))
+	assert.Equal(t, "123", GitConfig.GetOption("gc.reflogExpire"))
 }

modules/setting/incoming_email_test.go

···
 
 		loadIncomingEmailFrom(cfg)
 
-		assert.EqualValues(t, "[e-mail]", IncomingEmail.Username)
-		assert.EqualValues(t, "y0u'll n3v3r gUess th1S!!1", IncomingEmail.Password)
+		assert.Equal(t, "[e-mail]", IncomingEmail.Username)
+		assert.Equal(t, "y0u'll n3v3r gUess th1S!!1", IncomingEmail.Password)
 	})
 
 	t.Run("Port settings", func(t *testing.T) {
···
 
 			loadIncomingEmailFrom(cfg)
 
-			assert.EqualValues(t, 143, IncomingEmail.Port)
+			assert.Equal(t, 143, IncomingEmail.Port)
 		})
 
 		t.Run("no port, with tls", func(t *testing.T) {
···
 
 			loadIncomingEmailFrom(cfg)
 
-			assert.EqualValues(t, 993, IncomingEmail.Port)
+			assert.Equal(t, 993, IncomingEmail.Port)
 		})
 
 		t.Run("port overrides tls", func(t *testing.T) {
···
 
 			loadIncomingEmailFrom(cfg)
 
-			assert.EqualValues(t, 1993, IncomingEmail.Port)
+			assert.Equal(t, 1993, IncomingEmail.Port)
 		})
 	})
 }

modules/setting/lfs_test.go

···
 	require.NoError(t, loadLFSFrom(cfg))
 
 	assert.EqualValues(t, "minio", LFS.Storage.Type)
-	assert.EqualValues(t, "lfs/", LFS.Storage.MinioConfig.BasePath)
+	assert.Equal(t, "lfs/", LFS.Storage.MinioConfig.BasePath)
 
 	iniStr = `
 [server]
···
 	require.NoError(t, loadLFSFrom(cfg))
 
 	assert.EqualValues(t, "minio", LFS.Storage.Type)
-	assert.EqualValues(t, "lfs/", LFS.Storage.MinioConfig.BasePath)
+	assert.Equal(t, "lfs/", LFS.Storage.MinioConfig.BasePath)
 
 	iniStr = `
 [lfs]
···
 	require.NoError(t, loadLFSFrom(cfg))
 
 	assert.EqualValues(t, "minio", LFS.Storage.Type)
-	assert.EqualValues(t, "lfs/", LFS.Storage.MinioConfig.BasePath)
+	assert.Equal(t, "lfs/", LFS.Storage.MinioConfig.BasePath)
 
 	iniStr = `
 [lfs]
···
 	require.NoError(t, loadLFSFrom(cfg))
 
 	assert.EqualValues(t, "minio", LFS.Storage.Type)
-	assert.EqualValues(t, "my_lfs/", LFS.Storage.MinioConfig.BasePath)
+	assert.Equal(t, "my_lfs/", LFS.Storage.MinioConfig.BasePath)
 }
 
 func Test_LFSStorage1(t *testing.T) {
···
 
 	require.NoError(t, loadLFSFrom(cfg))
 	assert.EqualValues(t, "minio", LFS.Storage.Type)
-	assert.EqualValues(t, "gitea", LFS.Storage.MinioConfig.Bucket)
-	assert.EqualValues(t, "lfs/", LFS.Storage.MinioConfig.BasePath)
+	assert.Equal(t, "gitea", LFS.Storage.MinioConfig.Bucket)
+	assert.Equal(t, "lfs/", LFS.Storage.MinioConfig.BasePath)
 }
 
 func Test_LFSClientServerConfigs(t *testing.T) {
···
 	assert.NoError(t, err)
 
 	assert.NoError(t, loadLFSFrom(cfg))
-	assert.EqualValues(t, 100, LFS.MaxBatchSize)
-	assert.EqualValues(t, 20, LFSClient.BatchSize)
-	assert.EqualValues(t, 8, LFSClient.BatchOperationConcurrency)
+	assert.Equal(t, 100, LFS.MaxBatchSize)
+	assert.Equal(t, 20, LFSClient.BatchSize)
+	assert.Equal(t, 8, LFSClient.BatchOperationConcurrency)
 
 	iniStr = `
 [lfs_client]
···
 	assert.NoError(t, err)
 
 	assert.NoError(t, loadLFSFrom(cfg))
-	assert.EqualValues(t, 50, LFSClient.BatchSize)
-	assert.EqualValues(t, 10, LFSClient.BatchOperationConcurrency)
+	assert.Equal(t, 50, LFSClient.BatchSize)
+	assert.Equal(t, 10, LFSClient.BatchOperationConcurrency)
 }

modules/setting/mailer_test.go

···
 			// Check mailer setting
 			loadMailerFrom(cfg)
 
-			assert.EqualValues(t, kase.SMTPAddr, MailService.SMTPAddr)
-			assert.EqualValues(t, kase.SMTPPort, MailService.SMTPPort)
+			assert.Equal(t, kase.SMTPAddr, MailService.SMTPAddr)
+			assert.Equal(t, kase.SMTPPort, MailService.SMTPPort)
 		})
 	}
 
···
 
 		loadMailerFrom(cfg)
 
-		assert.EqualValues(t, "[e-mail]", MailService.User)
-		assert.EqualValues(t, "y0u'll n3v3r gUess th1S!!1", MailService.Passwd)
+		assert.Equal(t, "[e-mail]", MailService.User)
+		assert.Equal(t, "y0u'll n3v3r gUess th1S!!1", MailService.Passwd)
 	})
 }

modules/setting/oauth2_test.go

···
 	actual := GetGeneralTokenSigningSecret()
 	expected, _ := generate.DecodeJwtSecret("BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB")
 	assert.Len(t, actual, 32)
-	assert.EqualValues(t, expected, actual)
+	assert.Equal(t, expected, actual)
 }
 
 func TestGetGeneralSigningSecretSave(t *testing.T) {

modules/setting/packages_test.go

···
 	require.NoError(t, loadPackagesFrom(cfg))
 
 	assert.EqualValues(t, "minio", Packages.Storage.Type)
-	assert.EqualValues(t, "packages/", Packages.Storage.MinioConfig.BasePath)
+	assert.Equal(t, "packages/", Packages.Storage.MinioConfig.BasePath)
 
 	// we can also configure packages storage directly
 	iniStr = `
···
 	require.NoError(t, loadPackagesFrom(cfg))
 
 	assert.EqualValues(t, "minio", Packages.Storage.Type)
-	assert.EqualValues(t, "packages/", Packages.Storage.MinioConfig.BasePath)
+	assert.Equal(t, "packages/", Packages.Storage.MinioConfig.BasePath)
 
 	// or we can indicate the storage type in the packages section
 	iniStr = `
···
 	require.NoError(t, loadPackagesFrom(cfg))
 
 	assert.EqualValues(t, "minio", Packages.Storage.Type)
-	assert.EqualValues(t, "packages/", Packages.Storage.MinioConfig.BasePath)
+	assert.Equal(t, "packages/", Packages.Storage.MinioConfig.BasePath)
 
 	// or we can indicate the storage type  and minio base path in the packages section
 	iniStr = `
···
 	require.NoError(t, loadPackagesFrom(cfg))
 
 	assert.EqualValues(t, "minio", Packages.Storage.Type)
-	assert.EqualValues(t, "my_packages/", Packages.Storage.MinioConfig.BasePath)
+	assert.Equal(t, "my_packages/", Packages.Storage.MinioConfig.BasePath)
 }
 
 func Test_PackageStorage1(t *testing.T) {
···
 	storage := Packages.Storage
 
 	assert.EqualValues(t, "minio", storage.Type)
-	assert.EqualValues(t, "gitea", storage.MinioConfig.Bucket)
-	assert.EqualValues(t, "packages/", storage.MinioConfig.BasePath)
+	assert.Equal(t, "gitea", storage.MinioConfig.Bucket)
+	assert.Equal(t, "packages/", storage.MinioConfig.BasePath)
 	assert.True(t, storage.MinioConfig.ServeDirect)
 }
 
···
 	storage := Packages.Storage
 
 	assert.EqualValues(t, "minio", storage.Type)
-	assert.EqualValues(t, "gitea", storage.MinioConfig.Bucket)
-	assert.EqualValues(t, "packages/", storage.MinioConfig.BasePath)
+	assert.Equal(t, "gitea", storage.MinioConfig.Bucket)
+	assert.Equal(t, "packages/", storage.MinioConfig.BasePath)
 	assert.True(t, storage.MinioConfig.ServeDirect)
 }
 
···
 	storage := Packages.Storage
 
 	assert.EqualValues(t, "minio", storage.Type)
-	assert.EqualValues(t, "gitea", storage.MinioConfig.Bucket)
-	assert.EqualValues(t, "my_packages/", storage.MinioConfig.BasePath)
+	assert.Equal(t, "gitea", storage.MinioConfig.Bucket)
+	assert.Equal(t, "my_packages/", storage.MinioConfig.BasePath)
 	assert.True(t, storage.MinioConfig.ServeDirect)
 }
 
···
 	storage := Packages.Storage
 
 	assert.EqualValues(t, "minio", storage.Type)
-	assert.EqualValues(t, "gitea", storage.MinioConfig.Bucket)
-	assert.EqualValues(t, "my_packages/", storage.MinioConfig.BasePath)
+	assert.Equal(t, "gitea", storage.MinioConfig.Bucket)
+	assert.Equal(t, "my_packages/", storage.MinioConfig.BasePath)
 	assert.True(t, storage.MinioConfig.ServeDirect)
 }

modules/setting/repository_archive_test.go

···
 	require.NoError(t, loadRepoArchiveFrom(cfg))
 
 	assert.EqualValues(t, "minio", RepoArchive.Storage.Type)
-	assert.EqualValues(t, "repo-archive/", RepoArchive.Storage.MinioConfig.BasePath)
+	assert.Equal(t, "repo-archive/", RepoArchive.Storage.MinioConfig.BasePath)
 
 	// we can also configure packages storage directly
 	iniStr = `
···
 	require.NoError(t, loadRepoArchiveFrom(cfg))
 
 	assert.EqualValues(t, "minio", RepoArchive.Storage.Type)
-	assert.EqualValues(t, "repo-archive/", RepoArchive.Storage.MinioConfig.BasePath)
+	assert.Equal(t, "repo-archive/", RepoArchive.Storage.MinioConfig.BasePath)
 
 	// or we can indicate the storage type in the packages section
 	iniStr = `
···
 	require.NoError(t, loadRepoArchiveFrom(cfg))
 
 	assert.EqualValues(t, "minio", RepoArchive.Storage.Type)
-	assert.EqualValues(t, "repo-archive/", RepoArchive.Storage.MinioConfig.BasePath)
+	assert.Equal(t, "repo-archive/", RepoArchive.Storage.MinioConfig.BasePath)
 
 	// or we can indicate the storage type  and minio base path in the packages section
 	iniStr = `
···
 	require.NoError(t, loadRepoArchiveFrom(cfg))
 
 	assert.EqualValues(t, "minio", RepoArchive.Storage.Type)
-	assert.EqualValues(t, "my_archive/", RepoArchive.Storage.MinioConfig.BasePath)
+	assert.Equal(t, "my_archive/", RepoArchive.Storage.MinioConfig.BasePath)
 }
 
 func Test_RepoArchiveStorage(t *testing.T) {
···
 	storage := RepoArchive.Storage
 
 	assert.EqualValues(t, "minio", storage.Type)
-	assert.EqualValues(t, "gitea", storage.MinioConfig.Bucket)
+	assert.Equal(t, "gitea", storage.MinioConfig.Bucket)
 
 	iniStr = `
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
···
 	storage = RepoArchive.Storage
 
 	assert.EqualValues(t, "minio", storage.Type)
-	assert.EqualValues(t, "gitea", storage.MinioConfig.Bucket)
+	assert.Equal(t, "gitea", storage.MinioConfig.Bucket)
 }

modules/setting/server_test.go

···
 	require.NoError(t, err)
 	loadServerFrom(cfg)
 
-	assert.EqualValues(t, "@forgejo", HTTPAddr)
+	assert.Equal(t, "@forgejo", HTTPAddr)
 }

modules/setting/service.go

···
 		}
 		Service.EmailDomainBlockList = append(Service.EmailDomainBlockList, toAdd...)
 	}
-	Service.ShowRegistrationButton = sec.Key("SHOW_REGISTRATION_BUTTON").MustBool(!(Service.DisableRegistration || Service.AllowOnlyExternalRegistration))
+	Service.ShowRegistrationButton = sec.Key("SHOW_REGISTRATION_BUTTON").MustBool(!Service.DisableRegistration && !Service.AllowOnlyExternalRegistration)
 	Service.EnableInternalSignIn = sec.Key("ENABLE_INTERNAL_SIGNIN").MustBool(true)
 	Service.ShowMilestonesDashboardPage = sec.Key("SHOW_MILESTONES_DASHBOARD_PAGE").MustBool(true)
 	Service.RequireSignInView = sec.Key("REQUIRE_SIGNIN_VIEW").MustBool()

modules/setting/storage.go

···
 	targetSec, _ := rootCfg.GetSection(storageSectionName + "." + name)
 	if targetSec != nil {
 		targetType := targetSec.Key("STORAGE_TYPE").String()
-		switch {
-		case targetType == "":
+		switch targetType {
+		case "":
 			if targetSec.Key("PATH").String() == "" { // both storage type and path are empty, use default
 				return getDefaultStorageSection(rootCfg), targetSecIsDefault, nil
 			}

modules/setting/storage_test.go

···
 	require.NoError(t, err)
 
 	require.NoError(t, loadAttachmentFrom(cfg))
-	assert.EqualValues(t, "gitea-attachment", Attachment.Storage.MinioConfig.Bucket)
-	assert.EqualValues(t, "attachments/", Attachment.Storage.MinioConfig.BasePath)
+	assert.Equal(t, "gitea-attachment", Attachment.Storage.MinioConfig.Bucket)
+	assert.Equal(t, "attachments/", Attachment.Storage.MinioConfig.BasePath)
 
 	require.NoError(t, loadLFSFrom(cfg))
-	assert.EqualValues(t, "gitea-lfs", LFS.Storage.MinioConfig.Bucket)
-	assert.EqualValues(t, "lfs/", LFS.Storage.MinioConfig.BasePath)
+	assert.Equal(t, "gitea-lfs", LFS.Storage.MinioConfig.Bucket)
+	assert.Equal(t, "lfs/", LFS.Storage.MinioConfig.BasePath)
 
 	require.NoError(t, loadAvatarsFrom(cfg))
-	assert.EqualValues(t, "gitea-storage", Avatar.Storage.MinioConfig.Bucket)
-	assert.EqualValues(t, "avatars/", Avatar.Storage.MinioConfig.BasePath)
+	assert.Equal(t, "gitea-storage", Avatar.Storage.MinioConfig.Bucket)
+	assert.Equal(t, "avatars/", Avatar.Storage.MinioConfig.BasePath)
 }
 
 func Test_getStorageUseOtherNameAsType(t *testing.T) {
···
 	require.NoError(t, err)
 
 	require.NoError(t, loadAttachmentFrom(cfg))
-	assert.EqualValues(t, "gitea-storage", Attachment.Storage.MinioConfig.Bucket)
-	assert.EqualValues(t, "attachments/", Attachment.Storage.MinioConfig.BasePath)
+	assert.Equal(t, "gitea-storage", Attachment.Storage.MinioConfig.Bucket)
+	assert.Equal(t, "attachments/", Attachment.Storage.MinioConfig.BasePath)
 
 	require.NoError(t, loadLFSFrom(cfg))
-	assert.EqualValues(t, "gitea-storage", LFS.Storage.MinioConfig.Bucket)
-	assert.EqualValues(t, "lfs/", LFS.Storage.MinioConfig.BasePath)
+	assert.Equal(t, "gitea-storage", LFS.Storage.MinioConfig.Bucket)
+	assert.Equal(t, "lfs/", LFS.Storage.MinioConfig.BasePath)
 }
 
 func Test_getStorageInheritStorageType(t *testing.T) {
···
 
 	require.NoError(t, loadPackagesFrom(cfg))
 	assert.EqualValues(t, "minio", Packages.Storage.Type)
-	assert.EqualValues(t, "gitea", Packages.Storage.MinioConfig.Bucket)
-	assert.EqualValues(t, "packages/", Packages.Storage.MinioConfig.BasePath)
+	assert.Equal(t, "gitea", Packages.Storage.MinioConfig.Bucket)
+	assert.Equal(t, "packages/", Packages.Storage.MinioConfig.BasePath)
 
 	require.NoError(t, loadRepoArchiveFrom(cfg))
 	assert.EqualValues(t, "minio", RepoArchive.Storage.Type)
-	assert.EqualValues(t, "gitea", RepoArchive.Storage.MinioConfig.Bucket)
-	assert.EqualValues(t, "repo-archive/", RepoArchive.Storage.MinioConfig.BasePath)
+	assert.Equal(t, "gitea", RepoArchive.Storage.MinioConfig.Bucket)
+	assert.Equal(t, "repo-archive/", RepoArchive.Storage.MinioConfig.BasePath)
 
 	require.NoError(t, loadActionsFrom(cfg))
 	assert.EqualValues(t, "minio", Actions.LogStorage.Type)
-	assert.EqualValues(t, "gitea", Actions.LogStorage.MinioConfig.Bucket)
-	assert.EqualValues(t, "actions_log/", Actions.LogStorage.MinioConfig.BasePath)
+	assert.Equal(t, "gitea", Actions.LogStorage.MinioConfig.Bucket)
+	assert.Equal(t, "actions_log/", Actions.LogStorage.MinioConfig.BasePath)
 
 	assert.EqualValues(t, "minio", Actions.ArtifactStorage.Type)
-	assert.EqualValues(t, "gitea", Actions.ArtifactStorage.MinioConfig.Bucket)
-	assert.EqualValues(t, "actions_artifacts/", Actions.ArtifactStorage.MinioConfig.BasePath)
+	assert.Equal(t, "gitea", Actions.ArtifactStorage.MinioConfig.Bucket)
+	assert.Equal(t, "actions_artifacts/", Actions.ArtifactStorage.MinioConfig.BasePath)
 
 	require.NoError(t, loadAvatarsFrom(cfg))
 	assert.EqualValues(t, "minio", Avatar.Storage.Type)
-	assert.EqualValues(t, "gitea", Avatar.Storage.MinioConfig.Bucket)
-	assert.EqualValues(t, "avatars/", Avatar.Storage.MinioConfig.BasePath)
+	assert.Equal(t, "gitea", Avatar.Storage.MinioConfig.Bucket)
+	assert.Equal(t, "avatars/", Avatar.Storage.MinioConfig.BasePath)
 
 	require.NoError(t, loadRepoAvatarFrom(cfg))
 	assert.EqualValues(t, "minio", RepoAvatar.Storage.Type)
-	assert.EqualValues(t, "gitea", RepoAvatar.Storage.MinioConfig.Bucket)
-	assert.EqualValues(t, "repo-avatars/", RepoAvatar.Storage.MinioConfig.BasePath)
+	assert.Equal(t, "gitea", RepoAvatar.Storage.MinioConfig.Bucket)
+	assert.Equal(t, "repo-avatars/", RepoAvatar.Storage.MinioConfig.BasePath)
 }
 
 type testLocalStoragePathCase struct {
···
 
 		assert.EqualValues(t, "local", storage.Type)
 		assert.True(t, filepath.IsAbs(storage.Path))
-		assert.EqualValues(t, filepath.Clean(c.expectedPath), filepath.Clean(storage.Path))
+		assert.Equal(t, filepath.Clean(c.expectedPath), filepath.Clean(storage.Path))
 	}
 }
 
···
 
 	require.NoError(t, loadRepoArchiveFrom(cfg))
 	cp := RepoArchive.Storage.ToShadowCopy()
-	assert.EqualValues(t, "******", cp.MinioConfig.AccessKeyID)
-	assert.EqualValues(t, "******", cp.MinioConfig.SecretAccessKey)
+	assert.Equal(t, "******", cp.MinioConfig.AccessKeyID)
+	assert.Equal(t, "******", cp.MinioConfig.SecretAccessKey)
 }
 
 func Test_getStorageConfiguration24(t *testing.T) {
···
 `)
 	require.NoError(t, err)
 	require.NoError(t, loadRepoArchiveFrom(cfg))
-	assert.EqualValues(t, "my_access_key", RepoArchive.Storage.MinioConfig.AccessKeyID)
-	assert.EqualValues(t, "my_secret_key", RepoArchive.Storage.MinioConfig.SecretAccessKey)
+	assert.Equal(t, "my_access_key", RepoArchive.Storage.MinioConfig.AccessKeyID)
+	assert.Equal(t, "my_secret_key", RepoArchive.Storage.MinioConfig.SecretAccessKey)
 	assert.True(t, RepoArchive.Storage.MinioConfig.UseSSL)
-	assert.EqualValues(t, "repo-archive/", RepoArchive.Storage.MinioConfig.BasePath)
+	assert.Equal(t, "repo-archive/", RepoArchive.Storage.MinioConfig.BasePath)
 }
 
 func Test_getStorageConfiguration28(t *testing.T) {
···
 `)
 	require.NoError(t, err)
 	require.NoError(t, loadRepoArchiveFrom(cfg))
-	assert.EqualValues(t, "my_access_key", RepoArchive.Storage.MinioConfig.AccessKeyID)
-	assert.EqualValues(t, "my_secret_key", RepoArchive.Storage.MinioConfig.SecretAccessKey)
+	assert.Equal(t, "my_access_key", RepoArchive.Storage.MinioConfig.AccessKeyID)
+	assert.Equal(t, "my_secret_key", RepoArchive.Storage.MinioConfig.SecretAccessKey)
 	assert.True(t, RepoArchive.Storage.MinioConfig.UseSSL)
-	assert.EqualValues(t, "/prefix/repo-archive/", RepoArchive.Storage.MinioConfig.BasePath)
+	assert.Equal(t, "/prefix/repo-archive/", RepoArchive.Storage.MinioConfig.BasePath)
 
 	cfg, err = NewConfigProviderFromData(`
 [storage]
···
 `)
 	require.NoError(t, err)
 	require.NoError(t, loadLFSFrom(cfg))
-	assert.EqualValues(t, "my_access_key", LFS.Storage.MinioConfig.AccessKeyID)
-	assert.EqualValues(t, "my_secret_key", LFS.Storage.MinioConfig.SecretAccessKey)
+	assert.Equal(t, "my_access_key", LFS.Storage.MinioConfig.AccessKeyID)
+	assert.Equal(t, "my_secret_key", LFS.Storage.MinioConfig.SecretAccessKey)
 	assert.True(t, LFS.Storage.MinioConfig.UseSSL)
-	assert.EqualValues(t, "/lfs", LFS.Storage.MinioConfig.BasePath)
+	assert.Equal(t, "/lfs", LFS.Storage.MinioConfig.BasePath)
 
 	cfg, err = NewConfigProviderFromData(`
 [storage]
···
 `)
 	require.NoError(t, err)
 	require.NoError(t, loadLFSFrom(cfg))
-	assert.EqualValues(t, "my_access_key", LFS.Storage.MinioConfig.AccessKeyID)
-	assert.EqualValues(t, "my_secret_key", LFS.Storage.MinioConfig.SecretAccessKey)
+	assert.Equal(t, "my_access_key", LFS.Storage.MinioConfig.AccessKeyID)
+	assert.Equal(t, "my_secret_key", LFS.Storage.MinioConfig.SecretAccessKey)
 	assert.True(t, LFS.Storage.MinioConfig.UseSSL)
-	assert.EqualValues(t, "/lfs", LFS.Storage.MinioConfig.BasePath)
+	assert.Equal(t, "/lfs", LFS.Storage.MinioConfig.BasePath)
 }

modules/storage/local_test.go

···
 		t.Run(k.path, func(t *testing.T) {
 			l := LocalStorage{dir: k.localDir}
 
-			assert.EqualValues(t, k.expected, l.buildLocalPath(k.path))
+			assert.Equal(t, k.expected, l.buildLocalPath(k.path))
 		})
 	}
 }

modules/storage/minio.go

···
 }
 
 func (m minioFileInfo) Name() string {
-	return path.Base(m.ObjectInfo.Key)
+	return path.Base(m.Key)
 }
 
 func (m minioFileInfo) Size() int64 {
···
 }
 
 func (m minioFileInfo) IsDir() bool {
-	return strings.HasSuffix(m.ObjectInfo.Key, "/")
+	return strings.HasSuffix(m.Key, "/")
 }
 
 func (m minioFileInfo) Mode() os.FileMode {

modules/storage/minio_test.go

···
 
 func TestMinioStoragePath(t *testing.T) {
 	m := &MinioStorage{basePath: ""}
-	assert.Equal(t, "", m.buildMinioPath("/"))
-	assert.Equal(t, "", m.buildMinioPath("."))
+	assert.Empty(t, m.buildMinioPath("/"))
+	assert.Empty(t, m.buildMinioPath("."))
 	assert.Equal(t, "a", m.buildMinioPath("/a"))
 	assert.Equal(t, "a/b", m.buildMinioPath("/a/b/"))
-	assert.Equal(t, "", m.buildMinioDirPrefix(""))
+	assert.Empty(t, m.buildMinioDirPrefix(""))
 	assert.Equal(t, "a/", m.buildMinioDirPrefix("/a/"))
 
 	m = &MinioStorage{basePath: "/"}
-	assert.Equal(t, "", m.buildMinioPath("/"))
-	assert.Equal(t, "", m.buildMinioPath("."))
+	assert.Empty(t, m.buildMinioPath("/"))
+	assert.Empty(t, m.buildMinioPath("."))
 	assert.Equal(t, "a", m.buildMinioPath("/a"))
 	assert.Equal(t, "a/b", m.buildMinioPath("/a/b/"))
-	assert.Equal(t, "", m.buildMinioDirPrefix(""))
+	assert.Empty(t, m.buildMinioDirPrefix(""))
 	assert.Equal(t, "a/", m.buildMinioDirPrefix("/a/"))
 
 	m = &MinioStorage{basePath: "/base"}

modules/structs/repo_file.go

···
 
 // Branch returns branch name
 func (o *CreateFileOptions) Branch() string {
-	return o.FileOptions.BranchName
+	return o.BranchName
 }
 
 // DeleteFileOptions options for deleting files (used for other File structs below)
···
 
 // Branch returns branch name
 func (o *DeleteFileOptions) Branch() string {
-	return o.FileOptions.BranchName
+	return o.BranchName
 }
 
 // UpdateFileOptions options for updating files
···
 
 // Branch returns branch name
 func (o *UpdateFileOptions) Branch() string {
-	return o.FileOptions.BranchName
+	return o.BranchName
 }
 
 // ChangeFileOperation for creating, updating or deleting a file
···
 
 // Branch returns branch name
 func (o *ChangeFilesOptions) Branch() string {
-	return o.FileOptions.BranchName
+	return o.BranchName
 }
 
 // FileOptionInterface provides a unified interface for the different file options

modules/system/appstate_test.go

···
 
 	item1 := new(testItem1)
 	require.NoError(t, as.Get(db.DefaultContext, item1))
-	assert.Equal(t, "", item1.Val1)
-	assert.EqualValues(t, 0, item1.Val2)
+	assert.Empty(t, item1.Val1)
+	assert.Equal(t, 0, item1.Val2)
 
 	item1 = new(testItem1)
 	item1.Val1 = "a"
···
 	item1 = new(testItem1)
 	require.NoError(t, as.Get(db.DefaultContext, item1))
 	assert.Equal(t, "a", item1.Val1)
-	assert.EqualValues(t, 2, item1.Val2)
+	assert.Equal(t, 2, item1.Val2)
 
 	item2 = new(testItem2)
 	require.NoError(t, as.Get(db.DefaultContext, item2))

modules/templates/htmlrenderer_test.go

···
 		_, err = tmpl.Parse(s)
 		require.Error(t, err)
 		msg := h(err)
-		assert.EqualValues(t, strings.TrimSpace(expect), strings.TrimSpace(msg))
+		assert.Equal(t, strings.TrimSpace(expect), strings.TrimSpace(msg))
 	}
 
 	test("{{", p.handleGenericTemplateError, `
···
 ----------------------------------------------------------------------
 `
 	actualMsg := p.handleExpectedEndError(errors.New("template: test:1: expected end; found XXX"))
-	assert.EqualValues(t, strings.TrimSpace(expectedMsg), strings.TrimSpace(actualMsg))
+	assert.Equal(t, strings.TrimSpace(expectedMsg), strings.TrimSpace(actualMsg))
 }

modules/templates/scopedtmpl/scopedtmpl.go

···
 				collectTemplates(nodeList.Nodes)
 			} else if node.Type() == parse.NodeIf {
 				nodeIf := node.(*parse.IfNode)
-				collectTemplates(nodeIf.BranchNode.List.Nodes)
-				if nodeIf.BranchNode.ElseList != nil {
-					collectTemplates(nodeIf.BranchNode.ElseList.Nodes)
+				collectTemplates(nodeIf.List.Nodes)
+				if nodeIf.ElseList != nil {
+					collectTemplates(nodeIf.ElseList.Nodes)
 				}
 			} else if node.Type() == parse.NodeRange {
 				nodeRange := node.(*parse.RangeNode)
-				collectTemplates(nodeRange.BranchNode.List.Nodes)
-				if nodeRange.BranchNode.ElseList != nil {
-					collectTemplates(nodeRange.BranchNode.ElseList.Nodes)
+				collectTemplates(nodeRange.List.Nodes)
+				if nodeRange.ElseList != nil {
+					collectTemplates(nodeRange.ElseList.Nodes)
 				}
 			} else if node.Type() == parse.NodeWith {
 				nodeWith := node.(*parse.WithNode)
-				collectTemplates(nodeWith.BranchNode.List.Nodes)
-				if nodeWith.BranchNode.ElseList != nil {
-					collectTemplates(nodeWith.BranchNode.ElseList.Nodes)
+				collectTemplates(nodeWith.List.Nodes)
+				if nodeWith.ElseList != nil {
+					collectTemplates(nodeWith.ElseList.Nodes)
 				}
 			}
 		}

modules/templates/util_misc.go

···
 	} else {
 		// if sort arg is in url test if it correlates with column header sort arguments
 		// the direction of the arrow should indicate the "current sort order", up means ASC(normal), down means DESC(rev)
-		if urlSort == normSort {
+		switch urlSort {
+		case normSort:
 			// the table is sorted with this header normal
 			return svg.RenderHTML("octicon-triangle-up", 16)
-		} else if urlSort == revSort {
+		case revSort:
 			// the table is sorted with this header reverse
 			return svg.RenderHTML("octicon-triangle-down", 16)
 		}

modules/templates/util_render_test.go

···
 
 func TestApostrophesInMentions(t *testing.T) {
 	rendered := RenderMarkdownToHtml(t.Context(), "@mention-user's comment")
-	assert.EqualValues(t, template.HTML("<p><a href=\"/mention-user\" class=\"mention\" rel=\"nofollow\">@mention-user</a>&#39;s comment</p>\n"), rendered)
+	assert.Equal(t, template.HTML("<p><a href=\"/mention-user\" class=\"mention\" rel=\"nofollow\">@mention-user</a>&#39;s comment</p>\n"), rendered)
 }
 
 func TestNonExistantUserMention(t *testing.T) {
 	rendered := RenderMarkdownToHtml(t.Context(), "@ThisUserDoesNotExist @mention-user")
-	assert.EqualValues(t, template.HTML("<p>@ThisUserDoesNotExist <a href=\"/mention-user\" class=\"mention\" rel=\"nofollow\">@mention-user</a></p>\n"), rendered)
+	assert.Equal(t, template.HTML("<p>@ThisUserDoesNotExist <a href=\"/mention-user\" class=\"mention\" rel=\"nofollow\">@mention-user</a></p>\n"), rendered)
 }
 
 func TestRenderCommitBody(t *testing.T) {

modules/templates/util_test.go

···
 	for _, c := range cases {
 		got, err := dict(c.args...)
 		require.NoError(t, err)
-		assert.EqualValues(t, c.want, got)
+		assert.Equal(t, c.want, got)
 	}
 
 	bads := []struct {

modules/templates/vars/vars_test.go

···
 	for _, kase := range kases {
 		t.Run(kase.tmpl, func(t *testing.T) {
 			res, err := Expand(kase.tmpl, kase.data)
-			assert.EqualValues(t, kase.out, res)
+			assert.Equal(t, kase.out, res)
 			if kase.error {
 				require.Error(t, err)
 			} else {

modules/timeutil/since.go

···
 	}
 
 	var timeStr, diffStr string
-	for {
-		if diff == 0 {
-			break
-		}
-
+	for diff != 0 {
 		diff, diffStr = computeTimeDiffFloor(diff, lang)
 		timeStr += ", " + diffStr
 	}

modules/translation/i18n/i18n_test.go

···
 
 	found = lang1.HasKey("no-such")
 	assert.False(t, found)
-	assert.EqualValues(t, "no-such", lang1.TrString("no-such"))
+	assert.Equal(t, "no-such", lang1.TrString("no-such"))
 	require.NoError(t, ls.Close())
 }
 

modules/translation/i18n/localestore.go

···
 		case string:
 			// Check whether we are adding a plural form to the parent object, or a new nested JSON object.
 
-			if key == "zero" || key == "one" || key == "two" || key == "few" || key == "many" {
+			switch key {
+			case "zero", "one", "two", "few", "many":
 				locale.newStyleMessages[prefix+PluralFormSeparator+key] = v
-			} else if key == "other" {
+			case "other":
 				locale.newStyleMessages[prefix] = v
-			} else {
+			default:
 				locale.newStyleMessages[fullkey] = v
 			}
 

modules/translation/translation_test.go

···
 func TestTrSize(t *testing.T) {
 	l := NewLocale("")
 	size := int64(1)
-	assert.EqualValues(t, "1 munits.data.b", l.TrSize(size).String())
+	assert.Equal(t, "1 munits.data.b", l.TrSize(size).String())
 	size *= 2048
-	assert.EqualValues(t, "2 munits.data.kib", l.TrSize(size).String())
+	assert.Equal(t, "2 munits.data.kib", l.TrSize(size).String())
 	size *= 2048
-	assert.EqualValues(t, "4 munits.data.mib", l.TrSize(size).String())
+	assert.Equal(t, "4 munits.data.mib", l.TrSize(size).String())
 	size *= 2048
-	assert.EqualValues(t, "8 munits.data.gib", l.TrSize(size).String())
+	assert.Equal(t, "8 munits.data.gib", l.TrSize(size).String())
 	size *= 2048
-	assert.EqualValues(t, "16 munits.data.tib", l.TrSize(size).String())
+	assert.Equal(t, "16 munits.data.tib", l.TrSize(size).String())
 	size *= 2048
-	assert.EqualValues(t, "32 munits.data.pib", l.TrSize(size).String())
+	assert.Equal(t, "32 munits.data.pib", l.TrSize(size).String())
 	size *= 128
-	assert.EqualValues(t, "4 munits.data.eib", l.TrSize(size).String())
+	assert.Equal(t, "4 munits.data.eib", l.TrSize(size).String())
 }
 
 func TestPrettyNumber(t *testing.T) {
···
 	allLangMap["id-ID"] = &LangType{Lang: "id-ID", Name: "Bahasa Indonesia"}
 
 	l := NewLocale("id-ID")
-	assert.EqualValues(t, "1.000.000", l.PrettyNumber(1000000))
-	assert.EqualValues(t, "1.000.000,1", l.PrettyNumber(1000000.1))
-	assert.EqualValues(t, "1.000.000", l.PrettyNumber("1000000"))
-	assert.EqualValues(t, "1.000.000", l.PrettyNumber("1000000.0"))
-	assert.EqualValues(t, "1.000.000,1", l.PrettyNumber("1000000.1"))
+	assert.Equal(t, "1.000.000", l.PrettyNumber(1000000))
+	assert.Equal(t, "1.000.000,1", l.PrettyNumber(1000000.1))
+	assert.Equal(t, "1.000.000", l.PrettyNumber("1000000"))
+	assert.Equal(t, "1.000.000", l.PrettyNumber("1000000.0"))
+	assert.Equal(t, "1.000.000,1", l.PrettyNumber("1000000.1"))
 
 	l = NewLocale("nosuch")
-	assert.EqualValues(t, "1,000,000", l.PrettyNumber(1000000))
-	assert.EqualValues(t, "1,000,000.1", l.PrettyNumber(1000000.1))
+	assert.Equal(t, "1,000,000", l.PrettyNumber(1000000))
+	assert.Equal(t, "1,000,000.1", l.PrettyNumber(1000000.1))
 }
 
 func TestGetPluralRule(t *testing.T) {

modules/util/paginate_test.go

···
 	stringSlice := []string{"a", "b", "c", "d", "e"}
 	result, ok := PaginateSlice(stringSlice, 1, 2).([]string)
 	assert.True(t, ok)
-	assert.EqualValues(t, []string{"a", "b"}, result)
+	assert.Equal(t, []string{"a", "b"}, result)
 
 	result, ok = PaginateSlice(stringSlice, 100, 2).([]string)
 	assert.True(t, ok)
-	assert.EqualValues(t, []string{}, result)
+	assert.Equal(t, []string{}, result)
 
 	result, ok = PaginateSlice(stringSlice, 3, 2).([]string)
 	assert.True(t, ok)
-	assert.EqualValues(t, []string{"e"}, result)
+	assert.Equal(t, []string{"e"}, result)
 
 	result, ok = PaginateSlice(stringSlice, 1, 0).([]string)
 	assert.True(t, ok)
-	assert.EqualValues(t, []string{"a", "b", "c", "d", "e"}, result)
+	assert.Equal(t, []string{"a", "b", "c", "d", "e"}, result)
 
 	result, ok = PaginateSlice(stringSlice, 1, -1).([]string)
 	assert.True(t, ok)
-	assert.EqualValues(t, []string{"a", "b", "c", "d", "e"}, result)
+	assert.Equal(t, []string{"a", "b", "c", "d", "e"}, result)
 
 	type Test struct {
 		Val int
···
 	testVar := []*Test{{Val: 2}, {Val: 3}, {Val: 4}}
 	testVar, ok = PaginateSlice(testVar, 1, 50).([]*Test)
 	assert.True(t, ok)
-	assert.EqualValues(t, []*Test{{Val: 2}, {Val: 3}, {Val: 4}}, testVar)
+	assert.Equal(t, []*Test{{Val: 2}, {Val: 3}, {Val: 4}}, testVar)
 
 	testVar, ok = PaginateSlice(testVar, 2, 2).([]*Test)
 	assert.True(t, ok)
-	assert.EqualValues(t, []*Test{{Val: 4}}, testVar)
+	assert.Equal(t, []*Test{{Val: 4}}, testVar)
 }

modules/util/path.go

···
 		elems[i] = path.Clean("/" + e)
 	}
 	p := path.Join(elems...)
-	if p == "" {
+	switch p {
+	case "":
 		return ""
-	} else if p == "/" {
+	case "/":
 		return "."
 	}
 	return p[1:]

modules/util/util_test.go

···
 
 	publicKey, privateKey, err := util.GenerateSSHKeypair()
 	require.NoError(t, err)
-	assert.EqualValues(t, testPublicKey, string(publicKey))
-	assert.EqualValues(t, testPrivateKey, string(privateKey))
+	assert.Equal(t, testPublicKey, string(publicKey))
+	assert.Equal(t, testPrivateKey, string(privateKey))
 }
 
 func TestOptionalArg(t *testing.T) {

modules/validation/email_test.go

···
 	}
 	for kase, err := range kases {
 		t.Run(kase, func(t *testing.T) {
-			assert.EqualValues(t, err, ValidateEmail(kase))
+			assert.Equal(t, err, ValidateEmail(kase))
 		})
 	}
 }

modules/web/route_test.go

···
 	r := NewRoute()
 	r.Get("/{username}/{reponame}/{type:issues|pulls}", func(resp http.ResponseWriter, req *http.Request) {
 		username := chi.URLParam(req, "username")
-		assert.EqualValues(t, "gitea", username)
+		assert.Equal(t, "gitea", username)
 		reponame := chi.URLParam(req, "reponame")
-		assert.EqualValues(t, "gitea", reponame)
+		assert.Equal(t, "gitea", reponame)
 		tp := chi.URLParam(req, "type")
-		assert.EqualValues(t, "issues", tp)
+		assert.Equal(t, "issues", tp)
 	})
 
 	req, err := http.NewRequest("GET", "http://localhost:8000/gitea/gitea/issues", nil)
 	require.NoError(t, err)
 	r.ServeHTTP(recorder, req)
-	assert.EqualValues(t, http.StatusOK, recorder.Code)
+	assert.Equal(t, http.StatusOK, recorder.Code)
 }
 
 func TestRoute2(t *testing.T) {
···
 		r.Group("", func() {
 			r.Get("/{type:issues|pulls}", func(resp http.ResponseWriter, req *http.Request) {
 				username := chi.URLParam(req, "username")
-				assert.EqualValues(t, "gitea", username)
+				assert.Equal(t, "gitea", username)
 				reponame := chi.URLParam(req, "reponame")
-				assert.EqualValues(t, "gitea", reponame)
+				assert.Equal(t, "gitea", reponame)
 				tp := chi.URLParam(req, "type")
-				assert.EqualValues(t, "issues", tp)
+				assert.Equal(t, "issues", tp)
 				hit = 0
 			})
 
 			r.Get("/{type:issues|pulls}/{index}", func(resp http.ResponseWriter, req *http.Request) {
 				username := chi.URLParam(req, "username")
-				assert.EqualValues(t, "gitea", username)
+				assert.Equal(t, "gitea", username)
 				reponame := chi.URLParam(req, "reponame")
-				assert.EqualValues(t, "gitea", reponame)
+				assert.Equal(t, "gitea", reponame)
 				tp := chi.URLParam(req, "type")
-				assert.EqualValues(t, "issues", tp)
+				assert.Equal(t, "issues", tp)
 				index := chi.URLParam(req, "index")
-				assert.EqualValues(t, "1", index)
+				assert.Equal(t, "1", index)
 				hit = 1
 			})
 		}, func(resp http.ResponseWriter, req *http.Request) {
···
 		r.Group("/issues/{index}", func() {
 			r.Get("/view", func(resp http.ResponseWriter, req *http.Request) {
 				username := chi.URLParam(req, "username")
-				assert.EqualValues(t, "gitea", username)
+				assert.Equal(t, "gitea", username)
 				reponame := chi.URLParam(req, "reponame")
-				assert.EqualValues(t, "gitea", reponame)
+				assert.Equal(t, "gitea", reponame)
 				index := chi.URLParam(req, "index")
-				assert.EqualValues(t, "1", index)
+				assert.Equal(t, "1", index)
 				hit = 2
 			})
 		})
···
 	req, err := http.NewRequest("GET", "http://localhost:8000/gitea/gitea/issues", nil)
 	require.NoError(t, err)
 	r.ServeHTTP(recorder, req)
-	assert.EqualValues(t, http.StatusOK, recorder.Code)
-	assert.EqualValues(t, 0, hit)
+	assert.Equal(t, http.StatusOK, recorder.Code)
+	assert.Equal(t, 0, hit)
 
 	req, err = http.NewRequest("GET", "http://localhost:8000/gitea/gitea/issues/1", nil)
 	require.NoError(t, err)
 	r.ServeHTTP(recorder, req)
-	assert.EqualValues(t, http.StatusOK, recorder.Code)
-	assert.EqualValues(t, 1, hit)
+	assert.Equal(t, http.StatusOK, recorder.Code)
+	assert.Equal(t, 1, hit)
 
 	req, err = http.NewRequest("GET", "http://localhost:8000/gitea/gitea/issues/1?stop=100", nil)
 	require.NoError(t, err)
 	r.ServeHTTP(recorder, req)
-	assert.EqualValues(t, http.StatusOK, recorder.Code)
-	assert.EqualValues(t, 100, hit)
+	assert.Equal(t, http.StatusOK, recorder.Code)
+	assert.Equal(t, 100, hit)
 
 	req, err = http.NewRequest("GET", "http://localhost:8000/gitea/gitea/issues/1/view", nil)
 	require.NoError(t, err)
 	r.ServeHTTP(recorder, req)
-	assert.EqualValues(t, http.StatusOK, recorder.Code)
-	assert.EqualValues(t, 2, hit)
+	assert.Equal(t, http.StatusOK, recorder.Code)
+	assert.Equal(t, 2, hit)
 }
 
 func TestRoute3(t *testing.T) {
···
 	req, err := http.NewRequest("GET", "http://localhost:8000/api/v1/repos/gitea/gitea/branch_protections", nil)
 	require.NoError(t, err)
 	r.ServeHTTP(recorder, req)
-	assert.EqualValues(t, http.StatusOK, recorder.Code)
-	assert.EqualValues(t, 0, hit)
+	assert.Equal(t, http.StatusOK, recorder.Code)
+	assert.Equal(t, 0, hit)
 
 	req, err = http.NewRequest("POST", "http://localhost:8000/api/v1/repos/gitea/gitea/branch_protections", nil)
 	require.NoError(t, err)
 	r.ServeHTTP(recorder, req)
-	assert.EqualValues(t, http.StatusOK, recorder.Code, http.StatusOK)
-	assert.EqualValues(t, 1, hit)
+	assert.Equal(t, http.StatusOK, recorder.Code, http.StatusOK)
+	assert.Equal(t, 1, hit)
 
 	req, err = http.NewRequest("GET", "http://localhost:8000/api/v1/repos/gitea/gitea/branch_protections/master", nil)
 	require.NoError(t, err)
 	r.ServeHTTP(recorder, req)
-	assert.EqualValues(t, http.StatusOK, recorder.Code)
-	assert.EqualValues(t, 2, hit)
+	assert.Equal(t, http.StatusOK, recorder.Code)
+	assert.Equal(t, 2, hit)
 
 	req, err = http.NewRequest("PATCH", "http://localhost:8000/api/v1/repos/gitea/gitea/branch_protections/master", nil)
 	require.NoError(t, err)
 	r.ServeHTTP(recorder, req)
-	assert.EqualValues(t, http.StatusOK, recorder.Code)
-	assert.EqualValues(t, 3, hit)
+	assert.Equal(t, http.StatusOK, recorder.Code)
+	assert.Equal(t, 3, hit)
 
 	req, err = http.NewRequest("DELETE", "http://localhost:8000/api/v1/repos/gitea/gitea/branch_protections/master", nil)
 	require.NoError(t, err)
 	r.ServeHTTP(recorder, req)
-	assert.EqualValues(t, http.StatusOK, recorder.Code)
-	assert.EqualValues(t, 4, hit)
+	assert.Equal(t, http.StatusOK, recorder.Code)
+	assert.Equal(t, 4, hit)
 }

modules/web/routemock_test.go

···
 	require.NoError(t, err)
 	r.ServeHTTP(recorder, req)
 	assert.Len(t, recorder.Header(), 3)
-	assert.EqualValues(t, "m1", recorder.Header().Get("X-Test-Middleware1"))
-	assert.EqualValues(t, "m2", recorder.Header().Get("X-Test-Middleware2"))
-	assert.EqualValues(t, "h", recorder.Header().Get("X-Test-Handler"))
+	assert.Equal(t, "m1", recorder.Header().Get("X-Test-Middleware1"))
+	assert.Equal(t, "m2", recorder.Header().Get("X-Test-Middleware2"))
+	assert.Equal(t, "h", recorder.Header().Get("X-Test-Handler"))
 	RouteMockReset()
 
 	// mock at "mock-point"
···
 	require.NoError(t, err)
 	r.ServeHTTP(recorder, req)
 	assert.Len(t, recorder.Header(), 2)
-	assert.EqualValues(t, "m1", recorder.Header().Get("X-Test-Middleware1"))
-	assert.EqualValues(t, "a", recorder.Header().Get("X-Test-MockPoint"))
+	assert.Equal(t, "m1", recorder.Header().Get("X-Test-Middleware1"))
+	assert.Equal(t, "a", recorder.Header().Get("X-Test-MockPoint"))
 	RouteMockReset()
 
 	// mock at MockAfterMiddlewares
···
 	require.NoError(t, err)
 	r.ServeHTTP(recorder, req)
 	assert.Len(t, recorder.Header(), 3)
-	assert.EqualValues(t, "m1", recorder.Header().Get("X-Test-Middleware1"))
-	assert.EqualValues(t, "m2", recorder.Header().Get("X-Test-Middleware2"))
-	assert.EqualValues(t, "b", recorder.Header().Get("X-Test-MockPoint"))
+	assert.Equal(t, "m1", recorder.Header().Get("X-Test-Middleware1"))
+	assert.Equal(t, "m2", recorder.Header().Get("X-Test-Middleware2"))
+	assert.Equal(t, "b", recorder.Header().Get("X-Test-MockPoint"))
 	RouteMockReset()
 }

routers/api/actions/artifactsv4.go

···
 	mac.Write([]byte(endp))
 	mac.Write([]byte(expires))
 	mac.Write([]byte(artifactName))
-	mac.Write([]byte(fmt.Sprint(taskID)))
-	mac.Write([]byte(fmt.Sprint(artifactID)))
+	fmt.Fprint(mac, taskID)
+	fmt.Fprint(mac, artifactID)
 	return mac.Sum(nil)
 }
 

routers/api/packages/api.go

···
 			if ok { // it's a personal access token but not oauth2 token
 				scopeMatched := false
 				var err error
-				if accessMode == perm.AccessModeRead {
+				switch accessMode {
+				case perm.AccessModeRead:
 					scopeMatched, err = scope.HasScope(auth_model.AccessTokenScopeReadPackage)
 					if err != nil {
 						ctx.Error(http.StatusInternalServerError, "HasScope", err.Error())
 						return
 					}
-				} else if accessMode == perm.AccessModeWrite {
+				case perm.AccessModeWrite:
 					scopeMatched, err = scope.HasScope(auth_model.AccessTokenScopeWritePackage)
 					if err != nil {
 						ctx.Error(http.StatusInternalServerError, "HasScope", err.Error())

routers/api/packages/chef/auth.go

···
 	version := m[1]
 
 	m = algorithmPattern.FindStringSubmatch(hdr)
-	if len(m) == 2 && m[1] != "sha1" && !(m[1] == "sha256" && version == "1.3") {
+	if len(m) == 2 && m[1] != "sha1" && (m[1] != "sha256" || version != "1.3") {
 		return "", util.NewInvalidArgumentErrorf("unsupported algorithm")
 	}
 

routers/api/packages/chef/chef.go

···
 		})
 	}
 
-	skip, _ := opts.Paginator.GetSkipTake()
+	skip, _ := opts.GetSkipTake()
 
 	ctx.JSON(http.StatusOK, &Result{
 		Start: skip,

routers/api/packages/nuget/auth.go

···
 func (a *Auth) Verify(req *http.Request, w http.ResponseWriter, store auth.DataStore, sess auth.SessionStore) (*user_model.User, error) {
 	token, err := auth_model.GetAccessTokenBySHA(req.Context(), req.Header.Get("X-NuGet-ApiKey"))
 	if err != nil {
-		if !(auth_model.IsErrAccessTokenNotExist(err) || auth_model.IsErrAccessTokenEmpty(err)) {
+		if !auth_model.IsErrAccessTokenNotExist(err) && !auth_model.IsErrAccessTokenEmpty(err) {
 			log.Error("GetAccessTokenBySHA: %v", err)
 			return nil, err
 		}

routers/api/v1/api.go

···
 			}
 
 			if task.IsForkPullRequest {
-				ctx.Repo.Permission.AccessMode = perm.AccessModeRead
+				ctx.Repo.AccessMode = perm.AccessModeRead
 			} else {
-				ctx.Repo.Permission.AccessMode = perm.AccessModeWrite
+				ctx.Repo.AccessMode = perm.AccessModeWrite
 			}
 
 			if err := ctx.Repo.Repository.LoadUnits(ctx); err != nil {
 				ctx.Error(http.StatusInternalServerError, "LoadUnits", err)
 				return
 			}
-			ctx.Repo.Permission.Units = ctx.Repo.Repository.Units
-			ctx.Repo.Permission.UnitsMode = make(map[unit.Type]perm.AccessMode)
+			ctx.Repo.Units = ctx.Repo.Repository.Units
+			ctx.Repo.UnitsMode = make(map[unit.Type]perm.AccessMode)
 			for _, u := range ctx.Repo.Repository.Units {
-				ctx.Repo.Permission.UnitsMode[u.Type] = ctx.Repo.Permission.AccessMode
+				ctx.Repo.UnitsMode[u.Type] = ctx.Repo.AccessMode
 			}
 		} else {
 			ctx.Repo.Permission, err = access_model.GetUserRepoPermission(ctx, repo, ctx.Doer)
···
 }
 
 func mustAllowPulls(ctx *context.APIContext) {
-	if !(ctx.Repo.Repository.CanEnablePulls() && ctx.Repo.CanRead(unit.TypePullRequests)) {
+	if !ctx.Repo.Repository.CanEnablePulls() || !ctx.Repo.CanRead(unit.TypePullRequests) {
 		if ctx.Repo.Repository.CanEnablePulls() && log.IsTrace() {
 			if ctx.IsSigned {
 				log.Trace("Permission Denied: User %-v cannot read %-v in Repo %-v\n"+
···
 
 func mustEnableIssuesOrPulls(ctx *context.APIContext) {
 	if !ctx.Repo.CanRead(unit.TypeIssues) &&
-		!(ctx.Repo.Repository.CanEnablePulls() && ctx.Repo.CanRead(unit.TypePullRequests)) {
+		(!ctx.Repo.Repository.CanEnablePulls() || !ctx.Repo.CanRead(unit.TypePullRequests)) {
 		if ctx.Repo.Repository.CanEnablePulls() && log.IsTrace() {
 			if ctx.IsSigned {
 				log.Trace("Permission Denied: User %-v cannot read %-v and %-v in Repo %-v\n"+
···
 func individualPermsChecker(ctx *context.APIContext) {
 	// org permissions have been checked in context.OrgAssignment(), but individual permissions haven't been checked.
 	if ctx.ContextUser.IsIndividual() {
-		switch {
-		case ctx.ContextUser.Visibility == api.VisibleTypePrivate:
+		switch ctx.ContextUser.Visibility {
+		case api.VisibleTypePrivate:
 			if ctx.Doer == nil || (ctx.ContextUser.ID != ctx.Doer.ID && !ctx.Doer.IsAdmin) {
 				ctx.NotFound("Visit Project", nil)
 				return
 			}
-		case ctx.ContextUser.Visibility == api.VisibleTypeLimited:
+		case api.VisibleTypeLimited:
 			if ctx.Doer == nil {
 				ctx.NotFound("Visit Project", nil)
 				return

routers/api/v1/repo/branch.go

···
 			ctx.Error(http.StatusInternalServerError, "GetCommit", err)
 			return
 		}
-	} else if len(opt.OldBranchName) > 0 { //nolint
-		if ctx.Repo.GitRepo.IsBranchExist(opt.OldBranchName) { //nolint
-			oldCommit, err = ctx.Repo.GitRepo.GetBranchCommit(opt.OldBranchName) //nolint
+	} else if len(opt.OldBranchName) > 0 { //nolint:staticcheck
+		if ctx.Repo.GitRepo.IsBranchExist(opt.OldBranchName) { //nolint:staticcheck
+			oldCommit, err = ctx.Repo.GitRepo.GetBranchCommit(opt.OldBranchName) //nolint:staticcheck
 			if err != nil {
 				ctx.Error(http.StatusInternalServerError, "GetBranchCommit", err)
 				return

routers/api/v1/repo/file.go

···
 
 // canReadFiles returns true if repository is readable and user has proper access level.
 func canReadFiles(r *context.Repository) bool {
-	return r.Permission.CanRead(unit.TypeCode)
+	return r.CanRead(unit.TypeCode)
 }
 
 func base64Reader(s string) (io.ReadSeeker, error) {

routers/api/v1/repo/hook_test.go

···
 	defer ctx.Repo.GitRepo.Close()
 	contexttest.LoadRepoCommit(t, ctx)
 	TestHook(ctx)
-	assert.EqualValues(t, http.StatusNoContent, ctx.Resp.Status())
+	assert.Equal(t, http.StatusNoContent, ctx.Resp.Status())
 
 	unittest.AssertExistsAndLoadBean(t, &webhook.HookTask{
 		HookID: 1,

routers/api/v1/repo/issue_dependency.go

···
 	}
 
 	// 1. We must be able to read this issue
-	if !ctx.Repo.Permission.CanReadIssuesOrPulls(issue.IsPull) {
+	if !ctx.Repo.CanReadIssuesOrPulls(issue.IsPull) {
 		ctx.NotFound()
 		return
 	}
···
 		limit = setting.API.MaxResponseItems
 	}
 
-	canWrite := ctx.Repo.Permission.CanWriteIssuesOrPulls(issue.IsPull)
+	canWrite := ctx.Repo.CanWriteIssuesOrPulls(issue.IsPull)
 
 	blockerIssues := make([]*issues_model.Issue, 0, limit)
 
···
 		}
 
 		// check permission
-		if !perm.CanReadIssuesOrPulls(blocker.Issue.IsPull) {
+		if !perm.CanReadIssuesOrPulls(blocker.IsPull) {
 			if !canWrite {
 				hiddenBlocker := &issues_model.DependencyInfo{
 					Issue: issues_model.Issue{
···
 			} else {
 				confidentialBlocker := &issues_model.DependencyInfo{
 					Issue: issues_model.Issue{
-						RepoID:   blocker.Issue.RepoID,
+						RepoID:   blocker.RepoID,
 						Index:    blocker.Index,
 						Title:    blocker.Title,
 						IsClosed: blocker.IsClosed,
 						IsPull:   blocker.IsPull,
 					},
 					Repository: repo_model.Repository{
-						ID:        blocker.Issue.Repo.ID,
-						Name:      blocker.Issue.Repo.Name,
-						OwnerName: blocker.Issue.Repo.OwnerName,
+						ID:        blocker.Repo.ID,
+						Name:      blocker.Repo.Name,
+						OwnerName: blocker.Repo.OwnerName,
 					},
 				}
-				confidentialBlocker.Issue.Repo = &confidentialBlocker.Repository
+				confidentialBlocker.Repo = &confidentialBlocker.Repository
 				blocker = confidentialBlocker
 			}
 		}
···
 		return
 	}
 
-	if !ctx.Repo.Permission.CanReadIssuesOrPulls(issue.IsPull) {
+	if !ctx.Repo.CanReadIssuesOrPulls(issue.IsPull) {
 		ctx.NotFound()
 		return
 	}
···
 			repoPerms[depMeta.RepoID] = perm
 		}
 
-		if !perm.CanReadIssuesOrPulls(depMeta.Issue.IsPull) {
+		if !perm.CanReadIssuesOrPulls(depMeta.IsPull) {
 			continue
 		}
 
-		depMeta.Issue.Repo = &depMeta.Repository
+		depMeta.Repo = &depMeta.Repository
 		issues = append(issues, &depMeta.Issue)
 	}
 

routers/api/v1/repo/repo_test.go

···
 	web.SetForm(ctx, &opts)
 	Edit(ctx)
 
-	assert.EqualValues(t, http.StatusOK, ctx.Resp.Status())
+	assert.Equal(t, http.StatusOK, ctx.Resp.Status())
 	unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{
 		ID: 1,
 	}, unittest.Cond("name = ? AND is_archived = 1", *opts.Name))
···
 
 	web.SetForm(ctx, &opts)
 	Edit(ctx)
-	assert.EqualValues(t, http.StatusOK, ctx.Resp.Status())
+	assert.Equal(t, http.StatusOK, ctx.Resp.Status())
 
 	unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{
 		ID: 1,

routers/api/v1/user/key.go

···
 
 // appendPrivateInformation appends the owner and key type information to api.PublicKey
 func appendPrivateInformation(ctx std_ctx.Context, apiKey *api.PublicKey, key *asymkey_model.PublicKey, defaultUser *user_model.User) (*api.PublicKey, error) {
-	if key.Type == asymkey_model.KeyTypeDeploy {
+	switch key.Type {
+	case asymkey_model.KeyTypeDeploy:
 		apiKey.KeyType = "deploy"
-	} else if key.Type == asymkey_model.KeyTypeUser {
+	case asymkey_model.KeyTypeUser:
 		apiKey.KeyType = "user"
 
 		if defaultUser.ID == key.OwnerID {
···
 			}
 			apiKey.Owner = convert.ToUser(ctx, user, user)
 		}
-	} else {
+	default:
 		apiKey.KeyType = "unknown"
 	}
 	apiKey.ReadOnly = key.Mode == perm.AccessModeRead

routers/api/v1/user/repo.go

···
 		results[i] = convert.ToRepo(ctx, repo, permission)
 	}
 
-	ctx.SetLinkHeader(int(count), opts.ListOptions.PageSize)
+	ctx.SetLinkHeader(int(count), opts.PageSize)
 	ctx.SetTotalCountHeader(count)
 	ctx.JSON(http.StatusOK, &results)
 }

routers/install/routes_test.go

···
 	w := httptest.NewRecorder()
 	req := httptest.NewRequest("GET", "/", nil)
 	r.ServeHTTP(w, req)
-	assert.EqualValues(t, 200, w.Code)
+	assert.Equal(t, 200, w.Code)
 	assert.Contains(t, w.Body.String(), `class="page-content install"`)
 
 	w = httptest.NewRecorder()
 	req = httptest.NewRequest("GET", "/no-such", nil)
 	r.ServeHTTP(w, req)
-	assert.EqualValues(t, 404, w.Code)
+	assert.Equal(t, 404, w.Code)
 
 	w = httptest.NewRecorder()
 	req = httptest.NewRequest("GET", "/assets/img/gitea.svg", nil)
 	r.ServeHTTP(w, req)
-	assert.EqualValues(t, 200, w.Code)
+	assert.Equal(t, 200, w.Code)
 }
 
 func TestMain(m *testing.M) {

routers/private/hook_post_receive_test.go

···
 	pr, err = issues_model.GetPullRequestByID(db.DefaultContext, pr.ID)
 	require.NoError(t, err)
 	assert.True(t, pr.HasMerged)
-	assert.EqualValues(t, "01234567", pr.MergedCommitID)
+	assert.Equal(t, "01234567", pr.MergedCommitID)
 
 	unittest.AssertNotExistsBean(t, &pull_model.AutoMerge{ID: autoMerge.ID})
 }

routers/private/hook_pre_receive.go

···
 		return nil
 	}
 
-	ok, err := quota_model.EvaluateForUser(ctx, ctx.PrivateContext.Repo.Repository.OwnerID, quota_model.LimitSubjectSizeReposAll)
+	ok, err := quota_model.EvaluateForUser(ctx, ctx.Repo.Repository.OwnerID, quota_model.LimitSubjectSizeReposAll)
 	if err != nil {
 		log.Error("quota_model.EvaluateForUser: %v", err)
 		ctx.JSON(http.StatusInternalServerError, private.Response{
···
 
 	baseBranchName := refFullName.ForBranchName()
 
-	baseBranchExist := false
-	if ctx.Repo.GitRepo.IsBranchExist(baseBranchName) {
-		baseBranchExist = true
-	}
+	baseBranchExist := ctx.Repo.GitRepo.IsBranchExist(baseBranchName)
 
 	if !baseBranchExist {
 		for p, v := range baseBranchName {

routers/web/admin/admin_test.go

···
 	}
 
 	for _, k := range kases {
-		assert.EqualValues(t, k.Result, shadowPassword(k.Provider, k.CfgItem))
+		assert.Equal(t, k.Result, shadowPassword(k.Provider, k.CfgItem))
 	}
 }
 

routers/web/auth/auth.go

···
 func createUserInContext(ctx *context.Context, tpl base.TplName, form any, u *user_model.User, overwrites *user_model.CreateUserOverwriteOptions, gothUser *goth.User, allowLink bool) (ok bool) {
 	if err := user_model.CreateUser(ctx, u, overwrites); err != nil {
 		if allowLink && (user_model.IsErrUserAlreadyExist(err) || user_model.IsErrEmailAlreadyUsed(err)) {
-			if setting.OAuth2Client.AccountLinking == setting.OAuth2AccountLinkingAuto {
+			switch setting.OAuth2Client.AccountLinking {
+			case setting.OAuth2AccountLinkingAuto:
 				var user *user_model.User
 				user = &user_model.User{Name: u.Name}
 				hasUser, err := user_model.GetUser(ctx, user)
···
 				// TODO: probably we should respect 'remember' user's choice...
 				linkAccount(ctx, user, *gothUser, true)
 				return false // user is already created here, all redirects are handled
-			} else if setting.OAuth2Client.AccountLinking == setting.OAuth2AccountLinkingLogin {
+			case setting.OAuth2AccountLinkingLogin:
 				showLinkingLogin(ctx, *gothUser)
 				return false // user will be created only after linking login
 			}

routers/web/auth/oauth_test.go

···
 	assert.Equal(t, "user5", oidcToken.PreferredUsername)
 	assert.Equal(t, "https://try.gitea.io/user5", oidcToken.Profile)
 	assert.Equal(t, "https://try.gitea.io/assets/img/avatar_default.png", oidcToken.Picture)
-	assert.Equal(t, "", oidcToken.Website)
+	assert.Empty(t, oidcToken.Website)
 	assert.Equal(t, timeutil.TimeStamp(0), oidcToken.UpdatedAt)
 	assert.Equal(t, "[e-mail]", oidcToken.Email)
 	assert.True(t, oidcToken.EmailVerified)

routers/web/org/members.go

···
 	}
 
 	pager := context.NewPagination(int(total), setting.UI.MembersPagingNum, page, 5)
-	opts.ListOptions.Page = page
-	opts.ListOptions.PageSize = setting.UI.MembersPagingNum
+	opts.Page = page
+	opts.PageSize = setting.UI.MembersPagingNum
 	members, membersIsPublic, err := organization.FindOrgMembers(ctx, opts)
 	if err != nil {
 		ctx.ServerError("GetMembers", err)

routers/web/repo/action_aggregator_test.go

···
 			cmt := issue.Comments[c]
 			t.Logf("%v %v %v\n", cmt.Type, cmt.CreatedUnix, cmt.Content)
 		}
-		assert.EqualValues(t, len(after), len(issue.Comments))
+		assert.Len(t, issue.Comments, len(after))
 		t.Fail()
 		return
 	}
···
 			l.AssigneeTeamID = 0
 		}
 
-		assert.EqualValues(t, (after)[c], issue.Comments[c],
+		assert.Equal(t, (after)[c], issue.Comments[c],
 			"Comment %v is not equal", c,
 		)
 	}

routers/web/repo/attachment.go

···
 	}
 
 	if repository == nil { // If not linked
-		if !(ctx.IsSigned && attach.UploaderID == ctx.Doer.ID) { // We block if not the uploader
+		if !ctx.IsSigned || attach.UploaderID != ctx.Doer.ID { // We block if not the uploader
 			ctx.Error(http.StatusNotFound)
 			return
 		}

routers/web/repo/compare.go

···
 			config := unit.PullRequestsConfig()
 
 			if !config.AutodetectManualMerge {
-				allowEmptyPr := !(ci.BaseBranch == ci.HeadBranch && ctx.Repo.Repository.Name == ci.HeadRepo.Name)
+				allowEmptyPr := ci.BaseBranch != ci.HeadBranch || ctx.Repo.Repository.Name != ci.HeadRepo.Name
 				ctx.Data["AllowEmptyPr"] = allowEmptyPr
 
 				return !allowEmptyPr
···
 
 	if len(commits) == 1 {
 		c := commits[0]
-		title = strings.TrimSpace(c.UserCommit.Summary())
+		title = strings.TrimSpace(c.Summary())
 
-		body := strings.Split(strings.TrimSpace(c.UserCommit.Message()), "\n")
+		body := strings.Split(strings.TrimSpace(c.Message()), "\n")
 		if len(body) > 1 {
 			ctx.Data["content"] = strings.Join(body[1:], "\n")
 		}
···
 				RightHunkSize: rightHunkSize,
 			},
 		}
-		if direction == "up" {
+		switch direction {
+		case "up":
 			section.Lines = append([]*gitdiff.DiffLine{lineSection}, section.Lines...)
-		} else if direction == "down" {
+		case "down":
 			section.Lines = append(section.Lines, lineSection)
 		}
 	}
···
 }
 
 func getExcerptLines(commit *git.Commit, filePath string, idxLeft, idxRight, chunkSize int) ([]*gitdiff.DiffLine, error) {
-	blob, err := commit.Tree.GetBlobByPath(filePath)
+	blob, err := commit.GetBlobByPath(filePath)
 	if err != nil {
 		return nil, err
 	}

routers/web/repo/editor_test.go

···
 		"..a.dotty../.folder../.name...": "..a.dotty../.folder../.name...",
 	}
 	for k, v := range kases {
-		assert.EqualValues(t, cleanUploadFileName(k), v)
+		assert.Equal(t, cleanUploadFileName(k), v)
 	}
 }
 

routers/web/repo/githttp_test.go

···
 	}
 
 	for i := range tests {
-		assert.EqualValues(t, tests[i].b, containsParentDirectorySeparator(tests[i].v))
+		assert.Equal(t, tests[i].b, containsParentDirectorySeparator(tests[i].v))
 	}
 }

routers/web/repo/issue.go

···
 	// 0 means issues with no label
 	// blank means labels will not be filtered for issues
 	selectLabels := ctx.FormString("labels")
-	if selectLabels == "" {
+	switch selectLabels {
+	case "":
 		ctx.Data["AllLabels"] = true
-	} else if selectLabels == "0" {
+	case "0":
 		ctx.Data["NoLabel"] = true
 	}
 	if len(selectLabels) > 0 {
···
 			return 0
 		}
 		reviewTyp := issues_model.ReviewTypeApprove
-		if typ == "reject" {
+		switch typ {
+		case "reject":
 			reviewTyp = issues_model.ReviewTypeReject
-		} else if typ == "waiting" {
+		case "waiting":
 			reviewTyp = issues_model.ReviewTypeRequest
 		}
 		for _, count := range counts {
···
 			}
 			repoPerms[blocker.RepoID] = perm
 		}
-		if perm.CanReadIssuesOrPulls(blocker.Issue.IsPull) {
+		if perm.CanReadIssuesOrPulls(blocker.IsPull) {
 			canRead = append(canRead, blocker)
 		} else {
 			notPermitted = append(notPermitted, blocker)
···
 		// Check if issue admin/poster changes the status of issue.
 		if (ctx.Repo.CanWriteIssuesOrPulls(issue.IsPull) || (ctx.IsSigned && issue.IsPoster(ctx.Doer.ID))) &&
 			(form.Status == "reopen" || form.Status == "close") &&
-			!(issue.IsPull && issue.PullRequest.HasMerged) {
+			(!issue.IsPull || !issue.PullRequest.HasMerged) {
 			// Duplication and conflict check should apply to reopen pull request.
 			var pr *issues_model.PullRequest
 
···
 		return
 	}
 
-	if !ctx.Repo.Permission.CanReadIssuesOrPulls(comment.Issue.IsPull) {
+	if !ctx.Repo.CanReadIssuesOrPulls(comment.Issue.IsPull) {
 		ctx.NotFound("CanReadIssuesOrPulls", issues_model.ErrCommentNotExist{})
 		return
 	}

routers/web/repo/issue_content_history.go

···
 	diffHTMLBuf := bytes.Buffer{}
 	diffHTMLBuf.WriteString("<pre class='chroma'>")
 	for _, it := range diff {
-		if it.Type == diffmatchpatch.DiffInsert {
+		switch it.Type {
+		case diffmatchpatch.DiffInsert:
 			diffHTMLBuf.WriteString("<span class='gi'>")
 			diffHTMLBuf.WriteString(html.EscapeString(it.Text))
 			diffHTMLBuf.WriteString("</span>")
-		} else if it.Type == diffmatchpatch.DiffDelete {
+		case diffmatchpatch.DiffDelete:
 			diffHTMLBuf.WriteString("<span class='gd'>")
 			diffHTMLBuf.WriteString(html.EscapeString(it.Text))
 			diffHTMLBuf.WriteString("</span>")
-		} else {
+		default:
 			diffHTMLBuf.WriteString(html.EscapeString(it.Text))
 		}
 	}

routers/web/repo/issue_label_test.go

···
 	contexttest.LoadRepo(t, ctx, 2)
 	web.SetForm(ctx, &forms.InitializeLabelsForm{TemplateName: "Default"})
 	InitializeLabels(ctx)
-	assert.EqualValues(t, http.StatusSeeOther, ctx.Resp.Status())
+	assert.Equal(t, http.StatusSeeOther, ctx.Resp.Status())
 	unittest.AssertExistsAndLoadBean(t, &issues_model.Label{
 		RepoID: 2,
 		Name:   "enhancement",
···
 		assert.True(t, ok)
 		if assert.Len(t, labels, len(testCase.ExpectedLabelIDs)) {
 			for i, label := range labels {
-				assert.EqualValues(t, testCase.ExpectedLabelIDs[i], label.ID)
+				assert.Equal(t, testCase.ExpectedLabelIDs[i], label.ID)
 			}
 		}
 	}
···
 		Color: "#abcdef",
 	})
 	NewLabel(ctx)
-	assert.EqualValues(t, http.StatusSeeOther, ctx.Resp.Status())
+	assert.Equal(t, http.StatusSeeOther, ctx.Resp.Status())
 	unittest.AssertExistsAndLoadBean(t, &issues_model.Label{
 		Name:  "newlabel",
 		Color: "#abcdef",
···
 		IsArchived: true,
 	})
 	UpdateLabel(ctx)
-	assert.EqualValues(t, http.StatusSeeOther, ctx.Resp.Status())
+	assert.Equal(t, http.StatusSeeOther, ctx.Resp.Status())
 	unittest.AssertExistsAndLoadBean(t, &issues_model.Label{
 		ID:    2,
 		Name:  "newnameforlabel",
···
 	contexttest.LoadRepo(t, ctx, 1)
 	ctx.Req.Form.Set("id", "2")
 	DeleteLabel(ctx)
-	assert.EqualValues(t, http.StatusOK, ctx.Resp.Status())
+	assert.Equal(t, http.StatusOK, ctx.Resp.Status())
 	unittest.AssertNotExistsBean(t, &issues_model.Label{ID: 2})
 	unittest.AssertNotExistsBean(t, &issues_model.IssueLabel{LabelID: 2})
 	assert.EqualValues(t, ctx.Tr("repo.issues.label_deletion_success"), ctx.Flash.SuccessMsg)
···
 	ctx.Req.Form.Set("issue_ids", "1,3")
 	ctx.Req.Form.Set("action", "clear")
 	UpdateIssueLabel(ctx)
-	assert.EqualValues(t, http.StatusOK, ctx.Resp.Status())
+	assert.Equal(t, http.StatusOK, ctx.Resp.Status())
 	unittest.AssertNotExistsBean(t, &issues_model.IssueLabel{IssueID: 1})
 	unittest.AssertNotExistsBean(t, &issues_model.IssueLabel{IssueID: 3})
 	unittest.CheckConsistencyFor(t, &issues_model.Label{})
···
 		ctx.Req.Form.Set("action", testCase.Action)
 		ctx.Req.Form.Set("id", strconv.Itoa(int(testCase.LabelID)))
 		UpdateIssueLabel(ctx)
-		assert.EqualValues(t, http.StatusOK, ctx.Resp.Status())
+		assert.Equal(t, http.StatusOK, ctx.Resp.Status())
 		for _, issueID := range testCase.IssueIDs {
 			unittest.AssertExistsIf(t, testCase.ExpectedAdd, &issues_model.IssueLabel{
 				IssueID: issueID,

routers/web/repo/projects.go

···
 	pager.AddParam(ctx, "state", "State")
 	ctx.Data["Page"] = pager
 
-	ctx.Data["CanWriteProjects"] = ctx.Repo.Permission.CanWrite(unit.TypeProjects)
+	ctx.Data["CanWriteProjects"] = ctx.Repo.CanWrite(unit.TypeProjects)
 	ctx.Data["IsShowClosed"] = isShowClosed
 	ctx.Data["IsProjectsPage"] = true
 	ctx.Data["SortType"] = sortType
···
 	ctx.Data["Title"] = ctx.Tr("repo.projects.new")
 	ctx.Data["TemplateConfigs"] = project_model.GetTemplateConfigs()
 	ctx.Data["CardTypes"] = project_model.GetCardConfig()
-	ctx.Data["CanWriteProjects"] = ctx.Repo.Permission.CanWrite(unit.TypeProjects)
+	ctx.Data["CanWriteProjects"] = ctx.Repo.CanWrite(unit.TypeProjects)
 	ctx.Data["CancelLink"] = ctx.Repo.Repository.Link() + "/projects"
 	ctx.HTML(http.StatusOK, tplProjectsNew)
 }
···
 func RenderEditProject(ctx *context.Context) {
 	ctx.Data["Title"] = ctx.Tr("repo.projects.edit")
 	ctx.Data["PageIsEditProjects"] = true
-	ctx.Data["CanWriteProjects"] = ctx.Repo.Permission.CanWrite(unit.TypeProjects)
+	ctx.Data["CanWriteProjects"] = ctx.Repo.CanWrite(unit.TypeProjects)
 	ctx.Data["CardTypes"] = project_model.GetCardConfig()
 
 	p, err := project_model.GetProjectByID(ctx, ctx.ParamsInt64(":id"))
···
 
 	ctx.Data["Title"] = ctx.Tr("repo.projects.edit")
 	ctx.Data["PageIsEditProjects"] = true
-	ctx.Data["CanWriteProjects"] = ctx.Repo.Permission.CanWrite(unit.TypeProjects)
+	ctx.Data["CanWriteProjects"] = ctx.Repo.CanWrite(unit.TypeProjects)
 	ctx.Data["CardTypes"] = project_model.GetCardConfig()
 	ctx.Data["CancelLink"] = project_model.ProjectLinkForRepo(ctx.Repo.Repository, projectID)
 
···
 
 	ctx.Data["Title"] = project.Title
 	ctx.Data["IsProjectsPage"] = true
-	ctx.Data["CanWriteProjects"] = ctx.Repo.Permission.CanWrite(unit.TypeProjects)
+	ctx.Data["CanWriteProjects"] = ctx.Repo.CanWrite(unit.TypeProjects)
 	ctx.Data["Project"] = project
 	ctx.Data["IssuesMap"] = issuesMap
 	ctx.Data["Columns"] = columns

routers/web/repo/pull.go

···
 		foundStartCommit := len(specifiedStartCommit) == 0
 		foundEndCommit := len(specifiedEndCommit) == 0
 
-		if !(foundStartCommit && foundEndCommit) {
+		if !foundStartCommit || !foundEndCommit {
 			for _, commit := range prInfo.Commits {
 				if commit.ID.String() == specifiedStartCommit {
 					foundStartCommit = true
···
 			}
 		}
 
-		if !(foundStartCommit && foundEndCommit) {
+		if !foundStartCommit || !foundEndCommit {
 			ctx.NotFound("Given SHA1 not found for this PR", nil)
 			return
 		}

routers/web/repo/pull_review.go

···
 		return
 	}
 	ctx.Data["AfterCommitID"] = pullHeadCommitID
-	if origin == "diff" {
+	switch origin {
+	case "diff":
 		ctx.HTML(http.StatusOK, tplDiffConversation)
-	} else if origin == "timeline" {
+	case "timeline":
 		ctx.HTML(http.StatusOK, tplTimelineConversation)
 	}
 }

routers/web/repo/setting/avatar.go

···
 		return fmt.Errorf("io.ReadAll: %w", err)
 	}
 	st := typesniffer.DetectContentType(data)
-	if !(st.IsImage() && !st.IsSvgImage()) {
+	if !st.IsImage() || st.IsSvgImage() {
 		return errors.New(ctx.Locale.TrString("settings.uploaded_avatar_not_a_image"))
 	}
 	if err = repo_service.UploadAvatar(ctx, ctxRepo, data); err != nil {

routers/web/repo/setting/settings_test.go

···
 	}
 	web.SetForm(ctx, &addKeyForm)
 	DeployKeysPost(ctx)
-	assert.EqualValues(t, http.StatusSeeOther, ctx.Resp.Status())
+	assert.Equal(t, http.StatusSeeOther, ctx.Resp.Status())
 
 	unittest.AssertExistsAndLoadBean(t, &asymkey_model.DeployKey{
 		Name:    addKeyForm.Title,
···
 	}
 	web.SetForm(ctx, &addKeyForm)
 	DeployKeysPost(ctx)
-	assert.EqualValues(t, http.StatusSeeOther, ctx.Resp.Status())
+	assert.Equal(t, http.StatusSeeOther, ctx.Resp.Status())
 
 	unittest.AssertExistsAndLoadBean(t, &asymkey_model.DeployKey{
 		Name:    addKeyForm.Title,
···
 
 	CollaborationPost(ctx)
 
-	assert.EqualValues(t, http.StatusSeeOther, ctx.Resp.Status())
+	assert.Equal(t, http.StatusSeeOther, ctx.Resp.Status())
 
 	exists, err := repo_model.IsCollaborator(ctx, re.ID, 4)
 	require.NoError(t, err)
···
 
 	CollaborationPost(ctx)
 
-	assert.EqualValues(t, http.StatusSeeOther, ctx.Resp.Status())
+	assert.Equal(t, http.StatusSeeOther, ctx.Resp.Status())
 	assert.NotEmpty(t, ctx.Flash.ErrorMsg)
 }
 
···
 
 	CollaborationPost(ctx)
 
-	assert.EqualValues(t, http.StatusSeeOther, ctx.Resp.Status())
+	assert.Equal(t, http.StatusSeeOther, ctx.Resp.Status())
 
 	exists, err := repo_model.IsCollaborator(ctx, re.ID, 4)
 	require.NoError(t, err)
···
 	// Try adding the same collaborator again
 	CollaborationPost(ctx)
 
-	assert.EqualValues(t, http.StatusSeeOther, ctx.Resp.Status())
+	assert.Equal(t, http.StatusSeeOther, ctx.Resp.Status())
 	assert.NotEmpty(t, ctx.Flash.ErrorMsg)
 }
 
···
 
 	CollaborationPost(ctx)
 
-	assert.EqualValues(t, http.StatusSeeOther, ctx.Resp.Status())
+	assert.Equal(t, http.StatusSeeOther, ctx.Resp.Status())
 	assert.NotEmpty(t, ctx.Flash.ErrorMsg)
 }
 
···
 	AddTeamPost(ctx)
 
 	assert.True(t, repo_service.HasRepository(db.DefaultContext, team, re.ID))
-	assert.EqualValues(t, http.StatusSeeOther, ctx.Resp.Status())
+	assert.Equal(t, http.StatusSeeOther, ctx.Resp.Status())
 	assert.Empty(t, ctx.Flash.ErrorMsg)
 }
 
···
 	AddTeamPost(ctx)
 
 	assert.False(t, repo_service.HasRepository(db.DefaultContext, team, re.ID))
-	assert.EqualValues(t, http.StatusSeeOther, ctx.Resp.Status())
+	assert.Equal(t, http.StatusSeeOther, ctx.Resp.Status())
 	assert.NotEmpty(t, ctx.Flash.ErrorMsg)
 }
 
···
 
 	AddTeamPost(ctx)
 	assert.True(t, repo_service.HasRepository(db.DefaultContext, team, re.ID))
-	assert.EqualValues(t, http.StatusSeeOther, ctx.Resp.Status())
+	assert.Equal(t, http.StatusSeeOther, ctx.Resp.Status())
 	assert.NotEmpty(t, ctx.Flash.ErrorMsg)
 }
 
···
 	ctx.Repo = repo
 
 	AddTeamPost(ctx)
-	assert.EqualValues(t, http.StatusSeeOther, ctx.Resp.Status())
+	assert.Equal(t, http.StatusSeeOther, ctx.Resp.Status())
 	assert.NotEmpty(t, ctx.Flash.ErrorMsg)
 }
 

routers/web/repo/wiki_test.go

···
 		return
 	}
 	for i, pageMeta := range pageMetas {
-		assert.EqualValues(t, expectedNames[i], pageMeta.Name)
+		assert.Equal(t, expectedNames[i], pageMeta.Name)
 	}
 }
 
···
 	ctx.SetParams("*", "Home")
 	contexttest.LoadRepo(t, ctx, 1)
 	Wiki(ctx)
-	assert.EqualValues(t, http.StatusOK, ctx.Resp.Status())
+	assert.Equal(t, http.StatusOK, ctx.Resp.Status())
 	assert.EqualValues(t, "Home", ctx.Data["Title"])
 	assertPagesMetas(t, []string{"Home", "Long Page", "Page With Image", "Page With Spaced Name", "Unescaped File", "XSS"}, ctx.Data["Pages"])
 }
···
 	ctx, _ := contexttest.MockContext(t, "user2/repo1/wiki/?action=_pages")
 	contexttest.LoadRepo(t, ctx, 1)
 	WikiPages(ctx)
-	assert.EqualValues(t, http.StatusOK, ctx.Resp.Status())
+	assert.Equal(t, http.StatusOK, ctx.Resp.Status())
 	assertPagesMetas(t, []string{"Home", "Long Page", "Page With Image", "Page With Spaced Name", "Unescaped File", "XSS"}, ctx.Data["Pages"])
 }
 
···
 	contexttest.LoadUser(t, ctx, 2)
 	contexttest.LoadRepo(t, ctx, 1)
 	NewWiki(ctx)
-	assert.EqualValues(t, http.StatusOK, ctx.Resp.Status())
+	assert.Equal(t, http.StatusOK, ctx.Resp.Status())
 	assert.EqualValues(t, ctx.Tr("repo.wiki.new_page"), ctx.Data["Title"])
 }
 
···
 			Message: message,
 		})
 		NewWikiPost(ctx)
-		assert.EqualValues(t, http.StatusSeeOther, ctx.Resp.Status())
+		assert.Equal(t, http.StatusSeeOther, ctx.Resp.Status())
 		assertWikiExists(t, ctx.Repo.Repository, wiki_service.UserTitleToWebPath("", title))
 		assert.Equal(t, content, wikiContent(t, ctx.Repo.Repository, wiki_service.UserTitleToWebPath("", title)))
 	}
···
 		Message: message,
 	})
 	NewWikiPost(ctx)
-	assert.EqualValues(t, http.StatusOK, ctx.Resp.Status())
+	assert.Equal(t, http.StatusOK, ctx.Resp.Status())
 	assert.EqualValues(t, ctx.Tr("repo.wiki.reserved_page"), ctx.Flash.ErrorMsg)
 	assertWikiNotExists(t, ctx.Repo.Repository, "_edit")
 }
···
 	contexttest.LoadUser(t, ctx, 2)
 	contexttest.LoadRepo(t, ctx, 1)
 	EditWiki(ctx)
-	assert.EqualValues(t, http.StatusOK, ctx.Resp.Status())
+	assert.Equal(t, http.StatusOK, ctx.Resp.Status())
 	assert.EqualValues(t, "Home", ctx.Data["Title"])
 	assert.Equal(t, wikiContent(t, ctx.Repo.Repository, "Home"), ctx.Data["content"])
 }
···
 			Message: message,
 		})
 		EditWikiPost(ctx)
-		assert.EqualValues(t, http.StatusSeeOther, ctx.Resp.Status())
+		assert.Equal(t, http.StatusSeeOther, ctx.Resp.Status())
 		assertWikiExists(t, ctx.Repo.Repository, wiki_service.UserTitleToWebPath("", title))
 		assert.Equal(t, content, wikiContent(t, ctx.Repo.Repository, wiki_service.UserTitleToWebPath("", title)))
 		if title != "Home" {
···
 	contexttest.LoadUser(t, ctx, 2)
 	contexttest.LoadRepo(t, ctx, 1)
 	DeleteWikiPagePost(ctx)
-	assert.EqualValues(t, http.StatusOK, ctx.Resp.Status())
+	assert.Equal(t, http.StatusOK, ctx.Resp.Status())
 	assertWikiNotExists(t, ctx.Repo.Repository, "Home")
 }
 
···
 		contexttest.LoadRepo(t, ctx, 1)
 		WikiRaw(ctx)
 		if filetype == "" {
-			assert.EqualValues(t, http.StatusNotFound, ctx.Resp.Status(), "filepath: %s", filepath)
+			assert.Equal(t, http.StatusNotFound, ctx.Resp.Status(), "filepath: %s", filepath)
 		} else {
-			assert.EqualValues(t, http.StatusOK, ctx.Resp.Status(), "filepath: %s", filepath)
-			assert.EqualValues(t, filetype, ctx.Resp.Header().Get("Content-Type"), "filepath: %s", filepath)
+			assert.Equal(t, http.StatusOK, ctx.Resp.Status(), "filepath: %s", filepath)
+			assert.Equal(t, filetype, ctx.Resp.Header().Get("Content-Type"), "filepath: %s", filepath)
 		}
 	}
 }

routers/web/user/home.go

···
 			return 0
 		}
 		reviewTyp := issues_model.ReviewTypeApprove
-		if typ == "reject" {
+		switch typ {
+		case "reject":
 			reviewTyp = issues_model.ReviewTypeReject
-		} else if typ == "waiting" {
+		case "waiting":
 			reviewTyp = issues_model.ReviewTypeRequest
 		}
 		for _, count := range counts {

routers/web/user/home_test.go

···
 		NumIssues[repo.ID] = repo.NumIssues
 	}
 	assert.False(t, IsArchived[50])
-	assert.EqualValues(t, 1, NumIssues[50])
+	assert.Equal(t, 1, NumIssues[50])
 	assert.True(t, IsArchived[51])
-	assert.EqualValues(t, 1, NumIssues[51])
+	assert.Equal(t, 1, NumIssues[51])
 
 	// Act
 	Issues(ctx)
 
 	// Assert: One Issue (ID 30) from one Repo (ID 50) is retrieved, while nothing from archived Repo 51 is retrieved
-	assert.EqualValues(t, http.StatusOK, ctx.Resp.Status())
+	assert.Equal(t, http.StatusOK, ctx.Resp.Status())
 
 	assert.Len(t, ctx.Data["Issues"], 1)
 }
···
 	contexttest.LoadUser(t, ctx, 2)
 	ctx.Req.Form.Set("state", "closed")
 	Issues(ctx)
-	assert.EqualValues(t, http.StatusOK, ctx.Resp.Status())
+	assert.Equal(t, http.StatusOK, ctx.Resp.Status())
 
 	assert.EqualValues(t, true, ctx.Data["IsShowClosed"])
 	assert.Len(t, ctx.Data["Issues"], 1)
···
 	ctx.Req.Form.Set("state", "open")
 	ctx.Req.Form.Set("type", "your_repositories")
 	Pulls(ctx)
-	assert.EqualValues(t, http.StatusOK, ctx.Resp.Status())
+	assert.Equal(t, http.StatusOK, ctx.Resp.Status())
 
 	assert.Len(t, ctx.Data["Issues"], 5)
 }
···
 	ctx.Req.Form.Set("state", "closed")
 	ctx.Req.Form.Set("sort", "furthestduedate")
 	Milestones(ctx)
-	assert.EqualValues(t, http.StatusOK, ctx.Resp.Status())
+	assert.Equal(t, http.StatusOK, ctx.Resp.Status())
 	assert.EqualValues(t, map[int64]int64{1: 1}, ctx.Data["Counts"])
 	assert.EqualValues(t, true, ctx.Data["IsShowClosed"])
 	assert.EqualValues(t, "furthestduedate", ctx.Data["SortType"])
 	assert.EqualValues(t, 1, ctx.Data["Total"])
 	assert.Len(t, ctx.Data["Milestones"], 1)
 	assert.Len(t, ctx.Data["Repos"], 2) // both repo 42 and 1 have milestones and both are owned by user 2
-	assert.EqualValues(t, "user2/glob", ctx.Data["Repos"].(repo_model.RepositoryList)[0].FullName())
-	assert.EqualValues(t, "user2/repo1", ctx.Data["Repos"].(repo_model.RepositoryList)[1].FullName())
+	assert.Equal(t, "user2/glob", ctx.Data["Repos"].(repo_model.RepositoryList)[0].FullName())
+	assert.Equal(t, "user2/repo1", ctx.Data["Repos"].(repo_model.RepositoryList)[1].FullName())
 }
 
 func TestMilestonesForSpecificRepo(t *testing.T) {
···
 	ctx.Req.Form.Set("state", "closed")
 	ctx.Req.Form.Set("sort", "furthestduedate")
 	Milestones(ctx)
-	assert.EqualValues(t, http.StatusOK, ctx.Resp.Status())
+	assert.Equal(t, http.StatusOK, ctx.Resp.Status())
 	assert.EqualValues(t, map[int64]int64{1: 1}, ctx.Data["Counts"])
 	assert.EqualValues(t, true, ctx.Data["IsShowClosed"])
 	assert.EqualValues(t, "furthestduedate", ctx.Data["SortType"])
···
 	contexttest.LoadUser(t, ctx, 2)
 	contexttest.LoadOrganization(t, ctx, 3)
 	Issues(ctx)
-	assert.EqualValues(t, http.StatusOK, ctx.Resp.Status())
+	assert.Equal(t, http.StatusOK, ctx.Resp.Status())
 
 	assert.True(t, ctx.Data["PageIsOrgIssues"].(bool))
 
···
 
 	if assert.Len(t, labels, len(orgLabels)) {
 		for i, label := range labels {
-			assert.EqualValues(t, orgLabels[i].OrgID, label.OrgID)
-			assert.EqualValues(t, orgLabels[i].ID, label.ID)
-			assert.EqualValues(t, orgLabels[i].Name, label.Name)
+			assert.Equal(t, orgLabels[i].OrgID, label.OrgID)
+			assert.Equal(t, orgLabels[i].ID, label.ID)
+			assert.Equal(t, orgLabels[i].Name, label.Name)
 		}
 	}
 }

routers/web/user/notification.go

···
 			return 0
 		}
 		reviewTyp := issues_model.ReviewTypeApprove
-		if typ == "reject" {
+		switch typ {
+		case "reject":
 			reviewTyp = issues_model.ReviewTypeReject
-		} else if typ == "waiting" {
+		case "waiting":
 			reviewTyp = issues_model.ReviewTypeRequest
 		}
 		for _, count := range counts {

routers/web/user/setting/account.go

···
 	// Set Email Notification Preference
 	if ctx.FormString("_method") == "NOTIFICATION" {
 		preference := ctx.FormString("preference")
-		if !(preference == user_model.EmailNotificationsEnabled ||
-			preference == user_model.EmailNotificationsOnMention ||
-			preference == user_model.EmailNotificationsDisabled ||
-			preference == user_model.EmailNotificationsAndYourOwn) {
+		if preference != user_model.EmailNotificationsEnabled &&
+			preference != user_model.EmailNotificationsOnMention &&
+			preference != user_model.EmailNotificationsDisabled &&
+			preference != user_model.EmailNotificationsAndYourOwn {
 			log.Error("Email notifications preference change returned unrecognized option %s: %s", preference, ctx.Doer.Name)
 			ctx.ServerError("SetEmailPreference", errors.New("option unrecognized"))
 			return

routers/web/user/setting/account_test.go

···
 			AccountPost(ctx)
 
 			assert.Contains(t, ctx.Flash.ErrorMsg, req.Message)
-			assert.EqualValues(t, http.StatusSeeOther, ctx.Resp.Status())
+			assert.Equal(t, http.StatusSeeOther, ctx.Resp.Status())
 		})
 	}
 }

routers/web/user/setting/profile.go

···
 		}
 
 		st := typesniffer.DetectContentType(data)
-		if !(st.IsImage() && !st.IsSvgImage()) {
+		if !st.IsImage() || st.IsSvgImage() {
 			return errors.New(ctx.Locale.TrString("settings.uploaded_avatar_not_a_image"))
 		}
 		if err = user_service.UploadAvatar(ctx, ctxUser, data); err != nil {

routers/web/web.go

···
 	individualPermsChecker := func(ctx *context.Context) {
 		// org permissions have been checked in context.OrgAssignment(), but individual permissions haven't been checked.
 		if ctx.ContextUser.IsIndividual() {
-			switch {
-			case ctx.ContextUser.Visibility == structs.VisibleTypePrivate:
+			switch ctx.ContextUser.Visibility {
+			case structs.VisibleTypePrivate:
 				if ctx.Doer == nil || (ctx.ContextUser.ID != ctx.Doer.ID && !ctx.Doer.IsAdmin) {
 					ctx.NotFound("Visit Project", nil)
 					return
 				}
-			case ctx.ContextUser.Visibility == structs.VisibleTypeLimited:
+			case structs.VisibleTypeLimited:
 				if ctx.Doer == nil {
 					ctx.NotFound("Visit Project", nil)
 					return

services/actions/auth_test.go

···
 	var taskID int64 = 23
 	token, err := CreateAuthorizationToken(taskID, 1, 2)
 	require.NoError(t, err)
-	assert.NotEqual(t, "", token)
+	assert.NotEmpty(t, token)
 	claims := jwt.MapClaims{}
 	_, err = jwt.ParseWithClaims(token, claims, func(t *jwt.Token) (any, error) {
 		return setting.GetGeneralTokenSigningSecret(), nil
···
 	var taskID int64 = 23
 	token, err := CreateAuthorizationToken(taskID, 1, 2)
 	require.NoError(t, err)
-	assert.NotEqual(t, "", token)
+	assert.NotEmpty(t, token)
 	headers := http.Header{}
 	headers.Set("Authorization", "Bearer "+token)
 	rTaskID, err := ParseAuthorizationToken(&http.Request{

services/actions/cleanup_test.go

···
 		require.NoError(t, CleanupLogs(db.DefaultContext))
 
 		task := unittest.AssertExistsAndLoadBean(t, &actions_model.ActionTask{ID: 1001})
-		assert.EqualValues(t, "does-not-exist", task.LogFilename)
+		assert.Equal(t, "does-not-exist", task.LogFilename)
 		assert.True(t, task.LogExpired)
 		assert.Nil(t, task.LogIndexes)
 	})

services/attachment/attachment_test.go

···
 
 	attachment, err := repo_model.GetAttachmentByUUID(db.DefaultContext, attach.UUID)
 	require.NoError(t, err)
-	assert.EqualValues(t, user.ID, attachment.UploaderID)
+	assert.Equal(t, user.ID, attachment.UploaderID)
 	assert.Equal(t, int64(0), attachment.DownloadCount)
 }

services/auth/reverseproxy_test.go

···
 
 		require.EqualValues(t, 1, user_model.CountUsers(db.DefaultContext, nil))
 		unittest.AssertExistsAndLoadBean(t, &user_model.User{Email: "[e-mail]", Name: "Edgar", LowerName: "edgar", FullName: "Edgar Allan Poe", IsAdmin: true})
-		require.EqualValues(t, "[e-mail]", user.Email)
-		require.EqualValues(t, "Edgar", user.Name)
-		require.EqualValues(t, "edgar", user.LowerName)
-		require.EqualValues(t, "Edgar Allan Poe", user.FullName)
+		require.Equal(t, "[e-mail]", user.Email)
+		require.Equal(t, "Edgar", user.Name)
+		require.Equal(t, "edgar", user.LowerName)
+		require.Equal(t, "Edgar Allan Poe", user.FullName)
 		require.True(t, user.IsAdmin)
 	})
 
···
 
 		require.EqualValues(t, 2, user_model.CountUsers(db.DefaultContext, nil))
 		unittest.AssertExistsAndLoadBean(t, &user_model.User{Email: "[e-mail]", Name: "Gusted", LowerName: "gusted", FullName: "❤‿❤"}, "is_admin = false")
-		require.EqualValues(t, "[e-mail]", user.Email)
-		require.EqualValues(t, "Gusted", user.Name)
-		require.EqualValues(t, "gusted", user.LowerName)
-		require.EqualValues(t, "❤‿❤", user.FullName)
+		require.Equal(t, "[e-mail]", user.Email)
+		require.Equal(t, "Gusted", user.Name)
+		require.Equal(t, "gusted", user.LowerName)
+		require.Equal(t, "❤‿❤", user.FullName)
 		require.False(t, user.IsAdmin)
 	})
 }

services/auth/source/oauth2/jwtsigningkey_test.go

···
 
 		block, _ := pem.Decode(fileContent)
 		assert.NotNil(t, block)
-		assert.EqualValues(t, "PRIVATE KEY", block.Type)
+		assert.Equal(t, "PRIVATE KEY", block.Type)
 
 		parsedKey, err := x509.ParsePKCS8PrivateKey(block.Bytes)
 		require.NoError(t, err)
···
 		parsedKey := loadKey(t)
 
 		rsaPrivateKey := parsedKey.(*rsa.PrivateKey)
-		assert.EqualValues(t, 2048, rsaPrivateKey.N.BitLen())
+		assert.Equal(t, 2048, rsaPrivateKey.N.BitLen())
 
 		t.Run("Load key with differ specified algorithm", func(t *testing.T) {
 			defer test.MockVariableValue(&setting.OAuth2.JWTSigningAlgorithm, "EdDSA")()
 
 			parsedKey := loadKey(t)
 			rsaPrivateKey := parsedKey.(*rsa.PrivateKey)
-			assert.EqualValues(t, 2048, rsaPrivateKey.N.BitLen())
+			assert.Equal(t, 2048, rsaPrivateKey.N.BitLen())
 		})
 	})
 
···
 		parsedKey := loadKey(t)
 
 		rsaPrivateKey := parsedKey.(*rsa.PrivateKey)
-		assert.EqualValues(t, 3072, rsaPrivateKey.N.BitLen())
+		assert.Equal(t, 3072, rsaPrivateKey.N.BitLen())
 	})
 
 	t.Run("RSA-4096", func(t *testing.T) {
···
 		parsedKey := loadKey(t)
 
 		rsaPrivateKey := parsedKey.(*rsa.PrivateKey)
-		assert.EqualValues(t, 4096, rsaPrivateKey.N.BitLen())
+		assert.Equal(t, 4096, rsaPrivateKey.N.BitLen())
 	})
 
 	t.Run("ECDSA-256", func(t *testing.T) {
···
 		parsedKey := loadKey(t)
 
 		ecdsaPrivateKey := parsedKey.(*ecdsa.PrivateKey)
-		assert.EqualValues(t, 256, ecdsaPrivateKey.Params().BitSize)
+		assert.Equal(t, 256, ecdsaPrivateKey.Params().BitSize)
 	})
 
 	t.Run("ECDSA-384", func(t *testing.T) {
···
 		parsedKey := loadKey(t)
 
 		ecdsaPrivateKey := parsedKey.(*ecdsa.PrivateKey)
-		assert.EqualValues(t, 384, ecdsaPrivateKey.Params().BitSize)
+		assert.Equal(t, 384, ecdsaPrivateKey.Params().BitSize)
 	})
 
 	t.Run("ECDSA-512", func(t *testing.T) {
···
 		parsedKey := loadKey(t)
 
 		ecdsaPrivateKey := parsedKey.(*ecdsa.PrivateKey)
-		assert.EqualValues(t, 521, ecdsaPrivateKey.Params().BitSize)
+		assert.Equal(t, 521, ecdsaPrivateKey.Params().BitSize)
 	})
 
 	t.Run("EdDSA", func(t *testing.T) {

services/context/api.go

···
 	if status == http.StatusInternalServerError {
 		log.ErrorWithSkip(1, "%s: %s", title, message)
 
-		if setting.IsProd && !(ctx.Doer != nil && ctx.Doer.IsAdmin) {
+		if setting.IsProd && (ctx.Doer == nil || !ctx.Doer.IsAdmin) {
 			message = ""
 		}
 	}
···
 			}
 			defer baseCleanUp()
 
-			ctx.Base.AppendContextValue(apiContextKey, ctx)
-			ctx.Base.AppendContextValueFunc(gitrepo.RepositoryContextKey, func() any { return ctx.Repo.GitRepo })
+			ctx.AppendContextValue(apiContextKey, ctx)
+			ctx.AppendContextValueFunc(gitrepo.RepositoryContextKey, func() any { return ctx.Repo.GitRepo })
 
 			// If request sends files, parse them here otherwise the Query() can't be parsed and the CsrfToken will be invalid.
 			if ctx.Req.Method == "POST" && strings.Contains(ctx.Req.Header.Get("Content-Type"), "multipart/form-data") {
···
 func ReferencesGitRepo(allowEmpty ...bool) func(ctx *APIContext) (cancel context.CancelFunc) {
 	return func(ctx *APIContext) (cancel context.CancelFunc) {
 		// Empty repository does not have reference information.
-		if ctx.Repo.Repository.IsEmpty && !(len(allowEmpty) != 0 && allowEmpty[0]) {
+		if ctx.Repo.Repository.IsEmpty && (len(allowEmpty) == 0 || !allowEmpty[0]) {
 			return nil
 		}
 

services/context/api_test.go

···
 
 		links := genAPILinks(u, 100, 20, curPage)
 
-		assert.EqualValues(t, links, response)
+		assert.Equal(t, links, response)
 	}
 }

services/context/context.go

···
 
 func NewTemplateContextForWeb(ctx *Context) TemplateContext {
 	tmplCtx := NewTemplateContext(ctx)
-	tmplCtx["Locale"] = ctx.Base.Locale
+	tmplCtx["Locale"] = ctx.Locale
 	tmplCtx["AvatarUtils"] = templates.NewAvatarUtils(ctx)
 	return tmplCtx
 }
···
 			ctx.PageData = map[string]any{}
 			ctx.Data["PageData"] = ctx.PageData
 
-			ctx.Base.AppendContextValue(WebContextKey, ctx)
-			ctx.Base.AppendContextValueFunc(gitrepo.RepositoryContextKey, func() any { return ctx.Repo.GitRepo })
+			ctx.AppendContextValue(WebContextKey, ctx)
+			ctx.AppendContextValueFunc(gitrepo.RepositoryContextKey, func() any { return ctx.Repo.GitRepo })
 
 			ctx.Csrf = NewCSRFProtector(csrfOpts)
 

services/context/package.go

···
 
 			// it is still needed when rendering 500 page in a package handler
 			ctx := NewWebContext(base, renderer, nil)
-			ctx.Base.AppendContextValue(WebContextKey, ctx)
+			ctx.AppendContextValue(WebContextKey, ctx)
 			next.ServeHTTP(ctx.Resp, ctx.Req)
 		})
 	}

services/context/private.go

···
 			base, baseCleanUp := NewBaseContext(w, req)
 			ctx := &PrivateContext{Base: base}
 			defer baseCleanUp()
-			ctx.Base.AppendContextValue(privateContextKey, ctx)
+			ctx.AppendContextValue(privateContextKey, ctx)
 
 			next.ServeHTTP(ctx.Resp, ctx.Req)
 		})

services/context/quota.go

···
 
 // ctx.CheckQuota checks whether the user in question is within quota limits (web context)
 func (ctx *Context) CheckQuota(subject quota_model.LimitSubject, userID int64, username string) bool {
-	ok, err := checkQuota(ctx.Base.originCtx, subject, userID, username, func(userID int64, username string) {
+	ok, err := checkQuota(ctx.originCtx, subject, userID, username, func(userID int64, username string) {
 		showHTML := false
 		for _, part := range ctx.Req.Header["Accept"] {
 			if strings.Contains(part, "text/html") {
···
 
 // ctx.CheckQuota checks whether the user in question is within quota limits (API context)
 func (ctx *APIContext) CheckQuota(subject quota_model.LimitSubject, userID int64, username string) bool {
-	ok, err := checkQuota(ctx.Base.originCtx, subject, userID, username, func(userID int64, username string) {
+	ok, err := checkQuota(ctx.originCtx, subject, userID, username, func(userID int64, username string) {
 		ctx.JSON(http.StatusRequestEntityTooLarge, APIQuotaExceeded{
 			Message:  "quota exceeded",
 			UserID:   userID,

services/context/repo.go

···
 
 // CanCreateBranch returns true if repository is editable and user has proper access level.
 func (r *Repository) CanCreateBranch() bool {
-	return r.Permission.CanWrite(unit_model.TypeCode) && r.Repository.CanCreateBranch()
+	return r.CanWrite(unit_model.TypeCode) && r.Repository.CanCreateBranch()
 }
 
 func (r *Repository) GetObjectFormat() git.ObjectFormat {
···
 	// 2. Is the user a contributor, admin, poster or assignee and do the repository policies require this?
 	isAssigned, _ := issues_model.IsUserAssignedToIssue(ctx, issue, user)
 	return r.Repository.IsTimetrackerEnabled(ctx) && (!r.Repository.AllowOnlyContributorsToTrackTime(ctx) ||
-		r.Permission.CanWriteIssuesOrPulls(issue.IsPull) || issue.IsPoster(user.ID) || isAssigned)
+		r.CanWriteIssuesOrPulls(issue.IsPull) || issue.IsPoster(user.ID) || isAssigned)
 }
 
 // CanCreateIssueDependencies returns whether or not a user can create dependencies.
 func (r *Repository) CanCreateIssueDependencies(ctx context.Context, user *user_model.User, isPull bool) bool {
-	return r.Repository.IsDependenciesEnabled(ctx) && r.Permission.CanWriteIssuesOrPulls(isPull)
+	return r.Repository.IsDependenciesEnabled(ctx) && r.CanWriteIssuesOrPulls(isPull)
 }
 
 // GetCommitsCount returns cached commit count for current view
···
 	}
 
 	// Check access.
-	if !ctx.Repo.Permission.HasAccess() {
+	if !ctx.Repo.HasAccess() {
 		if ctx.FormString("go-get") == "1" {
 			EarlyResponseForGoGetMeta(ctx)
 			return

services/context/upload/upload.go

···
 
 // AddUploadContext renders template values for dropzone
 func AddUploadContext(ctx *context.Context, uploadType string) {
-	if uploadType == "release" {
+	switch uploadType {
+	case "release":
 		ctx.Data["UploadUrl"] = ctx.Repo.RepoLink + "/releases/attachments"
 		ctx.Data["UploadRemoveUrl"] = ctx.Repo.RepoLink + "/releases/attachments/remove"
 		ctx.Data["UploadLinkUrl"] = ctx.Repo.RepoLink + "/releases/attachments"
 		ctx.Data["UploadAccepts"] = strings.ReplaceAll(setting.Repository.Release.AllowedTypes, "|", ",")
 		ctx.Data["UploadMaxFiles"] = setting.Attachment.MaxFiles
 		ctx.Data["UploadMaxSize"] = setting.Attachment.MaxSize
-	} else if uploadType == "comment" {
+	case "comment":
 		ctx.Data["UploadUrl"] = ctx.Repo.RepoLink + "/issues/attachments"
 		ctx.Data["UploadRemoveUrl"] = ctx.Repo.RepoLink + "/issues/attachments/remove"
 		if len(ctx.Params(":index")) > 0 {
···
 		ctx.Data["UploadAccepts"] = strings.ReplaceAll(setting.Attachment.AllowedTypes, "|", ",")
 		ctx.Data["UploadMaxFiles"] = setting.Attachment.MaxFiles
 		ctx.Data["UploadMaxSize"] = setting.Attachment.MaxSize
-	} else if uploadType == "repo" {
+	case "repo":
 		ctx.Data["UploadUrl"] = ctx.Repo.RepoLink + "/upload-file"
 		ctx.Data["UploadRemoveUrl"] = ctx.Repo.RepoLink + "/upload-remove"
 		ctx.Data["UploadLinkUrl"] = ctx.Repo.RepoLink + "/upload-file"

services/contexttest/context_tests.go

···
 	ctx.PageData = map[string]any{}
 	ctx.Data["PageStartTime"] = time.Now()
 	chiCtx := chi.NewRouteContext()
-	ctx.Base.AppendContextValue(chi.RouteCtxKey, chiCtx)
+	ctx.AppendContextValue(chi.RouteCtxKey, chiCtx)
 	return ctx, resp
 }
 
···
 	_ = baseCleanUp // during test, it doesn't need to do clean up. TODO: this can be improved later
 
 	chiCtx := chi.NewRouteContext()
-	ctx.Base.AppendContextValue(chi.RouteCtxKey, chiCtx)
+	ctx.AppendContextValue(chi.RouteCtxKey, chiCtx)
 	return ctx, resp
 }
 
···
 	ctx := &context.PrivateContext{Base: base}
 	_ = baseCleanUp // during test, it doesn't need to do clean up. TODO: this can be improved later
 	chiCtx := chi.NewRouteContext()
-	ctx.Base.AppendContextValue(chi.RouteCtxKey, chiCtx)
+	ctx.AppendContextValue(chi.RouteCtxKey, chiCtx)
 	return ctx, resp
 }
 

services/convert/git_commit_test.go

···
 	commitMeta := ToCommitMeta(headRepo, tag)
 
 	assert.NotNil(t, commitMeta)
-	assert.EqualValues(t, &api.CommitMeta{
+	assert.Equal(t, &api.CommitMeta{
 		SHA:     sha1.EmptyObjectID().String(),
 		URL:     util.URLJoin(headRepo.APIURL(), "git/commits", sha1.EmptyObjectID().String()),
 		Created: time.Unix(0, 0),

services/convert/notification.go

···
 func ToNotificationThread(ctx context.Context, n *activities_model.Notification) *api.NotificationThread {
 	result := &api.NotificationThread{
 		ID:        n.ID,
-		Unread:    !(n.Status == activities_model.NotificationStatusRead || n.Status == activities_model.NotificationStatusPinned),
+		Unread:    n.Status != activities_model.NotificationStatusRead && n.Status != activities_model.NotificationStatusPinned,
 		Pinned:    n.Status == activities_model.NotificationStatusPinned,
 		UpdatedAt: n.UpdatedUnix.AsTime(),
 		URL:       n.APIURL(),

services/convert/pull_review.go

···
 	result := make([]*api.PullReview, 0, len(rl))
 	for i := range rl {
 		// show pending reviews only for the user who created them
-		if rl[i].Type == issues_model.ReviewTypePending && (doer == nil || !(doer.IsAdmin || doer.ID == rl[i].ReviewerID)) {
+		if rl[i].Type == issues_model.ReviewTypePending && (doer == nil || (!doer.IsAdmin && doer.ID != rl[i].ReviewerID)) {
 			continue
 		}
 		r, err := ToPullReview(ctx, rl[i], doer)

services/convert/pull_test.go

···
 	require.NoError(t, pr.LoadIssue(db.DefaultContext))
 	apiPullRequest := ToAPIPullRequest(git.DefaultContext, pr, nil)
 	assert.NotNil(t, apiPullRequest)
-	assert.EqualValues(t, &structs.PRBranchInfo{
+	assert.Equal(t, &structs.PRBranchInfo{
 		Name:       "branch1",
 		Ref:        "refs/pull/2/head",
 		Sha:        "4a357436d925b5c974181ff12a994538ddc5a269",

services/convert/release_test.go

···
 	apiRelease := ToAPIRelease(db.DefaultContext, repo1, release1)
 	assert.NotNil(t, apiRelease)
 	assert.EqualValues(t, 1, apiRelease.ID)
-	assert.EqualValues(t, "https://try.gitea.io/api/v1/repos/user2/repo1/releases/1", apiRelease.URL)
-	assert.EqualValues(t, "https://try.gitea.io/api/v1/repos/user2/repo1/releases/1/assets", apiRelease.UploadURL)
+	assert.Equal(t, "https://try.gitea.io/api/v1/repos/user2/repo1/releases/1", apiRelease.URL)
+	assert.Equal(t, "https://try.gitea.io/api/v1/repos/user2/repo1/releases/1/assets", apiRelease.UploadURL)
 }

services/convert/user_test.go

···
 
 	apiUser = toUser(db.DefaultContext, user1, false, false)
 	assert.False(t, apiUser.IsAdmin)
-	assert.EqualValues(t, api.VisibleTypePublic.String(), apiUser.Visibility)
+	assert.Equal(t, api.VisibleTypePublic.String(), apiUser.Visibility)
 
 	user31 := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: 31, IsAdmin: false, Visibility: api.VisibleTypePrivate})
 
 	apiUser = toUser(db.DefaultContext, user31, true, true)
 	assert.False(t, apiUser.IsAdmin)
-	assert.EqualValues(t, api.VisibleTypePrivate.String(), apiUser.Visibility)
+	assert.Equal(t, api.VisibleTypePrivate.String(), apiUser.Visibility)
 }

services/convert/utils_test.go

···
 )
 
 func TestToCorrectPageSize(t *testing.T) {
-	assert.EqualValues(t, 30, ToCorrectPageSize(0))
-	assert.EqualValues(t, 30, ToCorrectPageSize(-10))
-	assert.EqualValues(t, 20, ToCorrectPageSize(20))
-	assert.EqualValues(t, 50, ToCorrectPageSize(100))
+	assert.Equal(t, 30, ToCorrectPageSize(0))
+	assert.Equal(t, 30, ToCorrectPageSize(-10))
+	assert.Equal(t, 20, ToCorrectPageSize(20))
+	assert.Equal(t, 50, ToCorrectPageSize(100))
 }
 
 func TestToGitServiceType(t *testing.T) {

services/doctor/fix16961_test.go

···
 			if gotFixed != tt.wantFixed {
 				t.Errorf("fixPullRequestsConfig_16961() = %v, want %v", gotFixed, tt.wantFixed)
 			}
-			assert.EqualValues(t, &tt.expected, cfg)
+			assert.Equal(t, &tt.expected, cfg)
 		})
 	}
 }
···
 			if gotFixed != tt.wantFixed {
 				t.Errorf("fixIssuesConfig_16961() = %v, want %v", gotFixed, tt.wantFixed)
 			}
-			assert.EqualValues(t, &tt.expected, cfg)
+			assert.Equal(t, &tt.expected, cfg)
 		})
 	}
 }

services/f3/util/logger_test.go

···
 		actual = fmt.Sprintf(message, args...)
 	}, nil)
 	logger.Message("EXPECTED %s", "MESSAGE")
-	assert.EqualValues(t, expected, actual)
+	assert.Equal(t, expected, actual)
 }
 
 func TestF3UtilLogger(t *testing.T) {

services/gitdiff/gitdiff.go

···
 		_, _ = fmt.Fscanf(rd, "%s ", &name)
 		char, _ := rd.ReadByte()
 		_ = rd.UnreadByte()
-		for !(char == 0 || char == '"' || char == 'b') {
+		for char != 0 && char != '"' && char != 'b' {
 			var suffix string
 			_, _ = fmt.Fscanf(rd, "%s ", &suffix)
 			name += " " + suffix

services/gitdiff/highlightdiff.go

···
 // token is a html tag or entity, eg: "<span ...>", "</span>", "&lt;"
 func extractHTMLToken(s string) (before, token, after string, valid bool) {
 	for pos1 := 0; pos1 < len(s); pos1++ {
-		if s[pos1] == '<' {
+		switch s[pos1] {
+		case '<':
 			pos2 := strings.IndexByte(s[pos1:], '>')
 			if pos2 == -1 {
 				return "", "", s, false
 			}
 			return s[:pos1], s[pos1 : pos1+pos2+1], s[pos1+pos2+1:], true
-		} else if s[pos1] == '&' {
+		case '&':
 			pos2 := strings.IndexByte(s[pos1:], ';')
 			if pos2 == -1 {
 				return "", "", s, false

services/gitdiff/highlightdiff_test.go

···
 
 	diff.Text = "C"
 	hcd.recoverOneDiff(&diff)
-	assert.Equal(t, "", diff.Text)
+	assert.Empty(t, diff.Text)
 }
 
 func TestDiffWithHighlightPlaceholder(t *testing.T) {
···
 		"a='\U00100000'",
 		"a='\U0010FFFD''",
 	)
-	assert.Equal(t, "", hcd.PlaceholderTokenMap[0x00100000])
-	assert.Equal(t, "", hcd.PlaceholderTokenMap[0x0010FFFD])
+	assert.Empty(t, hcd.PlaceholderTokenMap[0x00100000])
+	assert.Empty(t, hcd.PlaceholderTokenMap[0x0010FFFD])
 
 	expected := fmt.Sprintf(`<span class="nx">a</span><span class="o">=</span><span class="s1">&#39;</span><span class="removed-code">%s</span>&#39;`, "\U00100000")
 	output := diffToHTML(hcd.lineWrapperTags, diffs, DiffLineDel)

services/issue/comments_test.go

···
 		// Reactions don't exist anymore for this comment.
 		unittest.AssertNotExistsBean(t, &issues_model.Reaction{CommentID: comment.ID})
 		// Number of comments was decreased.
-		assert.EqualValues(t, issue.NumComments-1, unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: comment.IssueID}).NumComments)
+		assert.Equal(t, issue.NumComments-1, unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: comment.IssueID}).NumComments)
 		// A notification was fired for the deletion of this comment.
-		assert.EqualValues(t, hookTaskCount+1, unittest.GetCount(t, &webhook_model.HookTask{}))
+		assert.Equal(t, hookTaskCount+1, unittest.GetCount(t, &webhook_model.HookTask{}))
 	})
 
 	t.Run("Comment of pending review", func(t *testing.T) {
···
 		// We have to ensure that this comment's linked review is pending.
 		comment := unittest.AssertExistsAndLoadBean(t, &issues_model.Comment{ID: 4}, "review_id != 0")
 		review := unittest.AssertExistsAndLoadBean(t, &issues_model.Review{ID: comment.ReviewID})
-		assert.EqualValues(t, issues_model.ReviewTypePending, review.Type)
+		assert.Equal(t, issues_model.ReviewTypePending, review.Type)
 		issue := unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: comment.IssueID})
 
 		require.NoError(t, webhook_model.CreateWebhook(db.DefaultContext, &webhook_model.Webhook{
···
 		// The comment doesn't exist anymore.
 		unittest.AssertNotExistsBean(t, &issues_model.Comment{ID: comment.ID})
 		// Ensure that the number of comments wasn't decreased.
-		assert.EqualValues(t, issue.NumComments, unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: comment.IssueID}).NumComments)
+		assert.Equal(t, issue.NumComments, unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: comment.IssueID}).NumComments)
 		// No notification was fired for the deletion of this comment.
-		assert.EqualValues(t, hookTaskCount, unittest.GetCount(t, &webhook_model.HookTask{}))
+		assert.Equal(t, hookTaskCount, unittest.GetCount(t, &webhook_model.HookTask{}))
 	})
 }
 
···
 
 		newComment := unittest.AssertExistsAndLoadBean(t, &issues_model.Comment{ID: 2})
 		// Content was updated.
-		assert.EqualValues(t, comment.Content, newComment.Content)
+		assert.Equal(t, comment.Content, newComment.Content)
 		// Content version was updated.
-		assert.EqualValues(t, 2, newComment.ContentVersion)
+		assert.Equal(t, 2, newComment.ContentVersion)
 		// A notification was fired for the update of this comment.
-		assert.EqualValues(t, hookTaskCount+1, unittest.GetCount(t, &webhook_model.HookTask{}))
+		assert.Equal(t, hookTaskCount+1, unittest.GetCount(t, &webhook_model.HookTask{}))
 		// Issue history was saved for this comment.
 		unittest.AssertExistsAndLoadBean(t, &issues_model.ContentHistory{CommentID: comment.ID, IsFirstCreated: true, ContentText: oldContent})
 		unittest.AssertExistsAndLoadBean(t, &issues_model.ContentHistory{CommentID: comment.ID, ContentText: comment.Content}, "is_first_created = false")
···
 
 		comment := unittest.AssertExistsAndLoadBean(t, &issues_model.Comment{ID: 4}, "review_id != 0")
 		review := unittest.AssertExistsAndLoadBean(t, &issues_model.Review{ID: comment.ReviewID})
-		assert.EqualValues(t, issues_model.ReviewTypePending, review.Type)
+		assert.Equal(t, issues_model.ReviewTypePending, review.Type)
 		issue := unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: comment.IssueID})
 		unittest.AssertNotExistsBean(t, &issues_model.ContentHistory{CommentID: comment.ID})
 		require.NoError(t, webhook_model.CreateWebhook(db.DefaultContext, &webhook_model.Webhook{
···
 
 		newComment := unittest.AssertExistsAndLoadBean(t, &issues_model.Comment{ID: 2})
 		// Content was updated.
-		assert.EqualValues(t, comment.Content, newComment.Content)
+		assert.Equal(t, comment.Content, newComment.Content)
 		// Content version was updated.
-		assert.EqualValues(t, 2, newComment.ContentVersion)
+		assert.Equal(t, 2, newComment.ContentVersion)
 		// No notification was fired for the update of this comment.
-		assert.EqualValues(t, hookTaskCount, unittest.GetCount(t, &webhook_model.HookTask{}))
+		assert.Equal(t, hookTaskCount, unittest.GetCount(t, &webhook_model.HookTask{}))
 		// Issue history was not saved for this comment.
 		unittest.AssertNotExistsBean(t, &issues_model.ContentHistory{CommentID: comment.ID})
 	})

services/issue/issue_test.go

···
 	repoLink := "/foo/bar"
 
 	endNames, urls := GetRefEndNamesAndURLs(issues, repoLink)
-	assert.EqualValues(t, map[int64]string{1: "branch1", 2: "tag1", 3: "c0ffee"}, endNames)
-	assert.EqualValues(t, map[int64]string{
+	assert.Equal(t, map[int64]string{1: "branch1", 2: "tag1", 3: "c0ffee"}, endNames)
+	assert.Equal(t, map[int64]string{
 		1: repoLink + "/src/branch/branch1",
 		2: repoLink + "/src/tag/tag1",
 		3: repoLink + "/src/commit/c0ffee",

services/lfs/server.go

···
 	}
 
 	var isUpload bool
-	if br.Operation == "upload" {
+	switch br.Operation {
+	case "upload":
 		isUpload = true
-	} else if br.Operation == "download" {
+	case "download":
 		isUpload = false
-	} else {
+	default:
 		log.Trace("Attempt to BATCH with invalid operation: %s", br.Operation)
 		writeStatus(ctx, http.StatusBadRequest)
 		return

services/mailer/mail_issue.go

···
 
 	// =========== Repo watchers ===========
 	// Make repo watchers last, since it's likely the list with the most users
-	if !(ctx.Issue.IsPull && ctx.Issue.PullRequest.IsWorkInProgress(ctx) && ctx.ActionType != activities_model.ActionCreatePullRequest) {
+	if !ctx.Issue.IsPull || !ctx.Issue.PullRequest.IsWorkInProgress(ctx) || ctx.ActionType == activities_model.ActionCreatePullRequest {
 		ids, err = repo_model.GetRepoWatchersIDs(ctx, ctx.Issue.RepoID)
 		if err != nil {
 			return fmt.Errorf("GetRepoWatchersIDs(%d): %w", ctx.Issue.RepoID, err)
···
 		}
 		// At this point we exclude:
 		// user that don't have all mails enabled or users only get mail on mention and this is one ...
-		if !(user.EmailNotificationsPreference == user_model.EmailNotificationsEnabled ||
-			user.EmailNotificationsPreference == user_model.EmailNotificationsAndYourOwn ||
-			fromMention && user.EmailNotificationsPreference == user_model.EmailNotificationsOnMention) {
+		if user.EmailNotificationsPreference != user_model.EmailNotificationsEnabled &&
+			user.EmailNotificationsPreference != user_model.EmailNotificationsAndYourOwn && (!fromMention || user.EmailNotificationsPreference != user_model.EmailNotificationsOnMention) {
 			continue
 		}
 

services/mailer/mail_test.go

···
 		t.Run(tc.userDisplayName, func(t *testing.T) {
 			user := &user_model.User{FullName: tc.userDisplayName, Name: "tmp"}
 			got := fromDisplayName(user)
-			assert.EqualValues(t, tc.fromDisplayName, got)
+			assert.Equal(t, tc.fromDisplayName, got)
 		})
 	}
 
···
 			setting.Domain = oldDomain
 		}()
 
-		assert.EqualValues(t, "Mister X (by Code IT on [code.it])", fromDisplayName(&user_model.User{FullName: "Mister X", Name: "tmp"}))
+		assert.Equal(t, "Mister X (by Code IT on [code.it])", fromDisplayName(&user_model.User{FullName: "Mister X", Name: "tmp"}))
 	})
 }
 

services/mailer/mailer_test.go

···
 	_, err := m1.ToMessage().WriteTo(buf)
 	require.NoError(t, err)
 	header, _ := extractMailHeaderAndContent(t, buf.String())
-	assert.EqualValues(t, map[string]string{
+	assert.Equal(t, map[string]string{
 		"Content-Type":             "multipart/alternative;",
 		"Date":                     "Mon, 01 Jan 0001 00:00:00 +0000",
 		"From":                     "\"Test Gitea\" <[e-mail]>",
···
 	_, err = m1.ToMessage().WriteTo(buf)
 	require.NoError(t, err)
 	header, _ = extractMailHeaderAndContent(t, buf.String())
-	assert.EqualValues(t, map[string]string{
+	assert.Equal(t, map[string]string{
 		"Content-Type":             "multipart/alternative;",
 		"Date":                     "Mon, 01 Jan 0001 00:00:00 +0000",
 		"From":                     "\"Test Gitea\" <[e-mail]>",

services/mailer/notify.go

···
 	issue *issues_model.Issue, comment *issues_model.Comment, mentions []*user_model.User,
 ) {
 	var act activities_model.ActionType
-	if comment.Type == issues_model.CommentTypeClose {
+	switch comment.Type {
+	case issues_model.CommentTypeClose:
 		act = activities_model.ActionCloseIssue
-	} else if comment.Type == issues_model.CommentTypeReopen {
+	case issues_model.CommentTypeReopen:
 		act = activities_model.ActionReopenIssue
-	} else if comment.Type == issues_model.CommentTypeComment {
+	case issues_model.CommentTypeComment:
 		act = activities_model.ActionCommentIssue
-	} else if comment.Type == issues_model.CommentTypeCode {
+	case issues_model.CommentTypeCode:
 		act = activities_model.ActionCommentIssue
-	} else if comment.Type == issues_model.CommentTypePullRequestPush {
+	case issues_model.CommentTypePullRequestPush:
 		act = 0
 	}
 
···
 
 func (m *mailNotifier) PullRequestReview(ctx context.Context, pr *issues_model.PullRequest, r *issues_model.Review, comment *issues_model.Comment, mentions []*user_model.User) {
 	var act activities_model.ActionType
-	if comment.Type == issues_model.CommentTypeClose {
+	switch comment.Type {
+	case issues_model.CommentTypeClose:
 		act = activities_model.ActionCloseIssue
-	} else if comment.Type == issues_model.CommentTypeReopen {
+	case issues_model.CommentTypeReopen:
 		act = activities_model.ActionReopenIssue
-	} else if comment.Type == issues_model.CommentTypeComment {
+	case issues_model.CommentTypeComment:
 		act = activities_model.ActionCommentPull
 	}
 	if err := MailParticipantsComment(ctx, comment, act, pr.Issue, mentions); err != nil {

services/migrations/gitea_downloader_test.go

···
 	topics, err := downloader.GetTopics()
 	require.NoError(t, err)
 	sort.Strings(topics)
-	assert.EqualValues(t, []string{"ci", "gitea", "migration", "test"}, topics)
+	assert.Equal(t, []string{"ci", "gitea", "migration", "test"}, topics)
 
 	labels, err := downloader.GetLabels()
 	require.NoError(t, err)
···
 	require.NoError(t, err)
 	assert.True(t, isEnd)
 	assert.Len(t, issues, 7)
-	assert.EqualValues(t, "open", issues[0].State)
+	assert.Equal(t, "open", issues[0].State)
 
 	issues, isEnd, err = downloader.GetIssues(3, 2)
 	require.NoError(t, err)

services/migrations/gitea_uploader_test.go

···
 
 	repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{OwnerID: user.ID, Name: repoName})
 	assert.True(t, repo.HasWiki())
-	assert.EqualValues(t, repo_model.RepositoryReady, repo.Status)
+	assert.Equal(t, repo_model.RepositoryReady, repo.Status)
 
 	milestones, err := db.Find[issues_model.Milestone](db.DefaultContext, issues_model.FindMilestoneOptions{
 		RepoID:   repo.ID,
···
 	uploader.userMap = make(map[int64]int64)
 	err = uploader.remapUser(&source, &target)
 	require.NoError(t, err)
-	assert.EqualValues(t, user.ID, target.GetUserID())
+	assert.Equal(t, user.ID, target.GetUserID())
 }
 
 func TestGiteaUploadRemapExternalUser(t *testing.T) {
···
 	target = repo_model.Release{}
 	err = uploader.remapUser(&source, &target)
 	require.NoError(t, err)
-	assert.EqualValues(t, linkedUser.ID, target.GetUserID())
+	assert.Equal(t, linkedUser.ID, target.GetUserID())
 }
 
 func TestGiteaUploadUpdateGitForPullRequest(t *testing.T) {
···
 
 			head, err := uploader.updateGitForPullRequest(&testCase.pr)
 			require.NoError(t, err)
-			assert.EqualValues(t, testCase.head, head)
+			assert.Equal(t, testCase.head, head)
 
 			log.Info(stopMark)
 
 			logFiltered, logStopped := logChecker.Check(5 * time.Second)
 			assert.True(t, logStopped)
 			if len(testCase.logFilter) > 0 {
-				assert.EqualValues(t, testCase.logFiltered, logFiltered, "for log message filters: %v", testCase.logFilter)
+				assert.Equal(t, testCase.logFiltered, logFiltered, "for log message filters: %v", testCase.logFilter)
 			}
 		})
 	}

services/migrations/gitlab_test.go

···
 	topics, err := downloader.GetTopics()
 	require.NoError(t, err)
 	assert.Len(t, topics, 2)
-	assert.EqualValues(t, []string{"migration", "test"}, topics)
+	assert.Equal(t, []string{"migration", "test"}, topics)
 
 	milestones, err := downloader.GetMilestones()
 	require.NoError(t, err)
···
 	// the only issue in this repository has number 2
 	assert.Len(t, issues, 1)
 	assert.EqualValues(t, 2, issues[0].Number)
-	assert.EqualValues(t, "vpn unlimited errors", issues[0].Title)
+	assert.Equal(t, "vpn unlimited errors", issues[0].Title)
 
 	prs, _, err := downloader.GetPullRequests(1, 10)
 	require.NoError(t, err)
···
 	// pull request 3 in Forgejo
 	assert.Len(t, prs, 1)
 	assert.EqualValues(t, 3, prs[0].Number)
-	assert.EqualValues(t, "Review", prs[0].Title)
+	assert.Equal(t, "Review", prs[0].Title)
 }
 
 func gitlabClientMockSetup(t *testing.T) (*http.ServeMux, *httptest.Server, *gitlab.Client) {
···
 	require.NoError(t, json.Unmarshal([]byte(testResponse), &awards))
 
 	reactions := downloader.awardsToReactions(awards)
-	assert.EqualValues(t, []*base.Reaction{
+	assert.Equal(t, []*base.Reaction{
 		{
 			UserName: "lafriks",
 			UserID:   1241334,
···
 
 	for i, note := range notes {
 		actualComment := *downloader.convertNoteToComment(17, &note)
-		assert.EqualValues(t, actualComment, comments[i])
+		assert.Equal(t, actualComment, comments[i])
 	}
 }
 

services/migrations/gogs_test.go

···
 			}
 
 			assert.IsType(t, &GogsDownloader{}, got)
-			assert.EqualValues(t, tt.baseURL, got.(*GogsDownloader).baseURL)
-			assert.EqualValues(t, tt.repoOwner, got.(*GogsDownloader).repoOwner)
-			assert.EqualValues(t, tt.repoName, got.(*GogsDownloader).repoName)
+			assert.Equal(t, tt.baseURL, got.(*GogsDownloader).baseURL)
+			assert.Equal(t, tt.repoOwner, got.(*GogsDownloader).repoOwner)
+			assert.Equal(t, tt.repoName, got.(*GogsDownloader).repoName)
 		})
 	}
 }

services/mirror/mirror_test.go

···
 `
 	results := parseRemoteUpdateOutput(output, "origin")
 	assert.Len(t, results, 10)
-	assert.EqualValues(t, "refs/tags/v0.1.8", results[0].refName.String())
-	assert.EqualValues(t, gitShortEmptySha, results[0].oldCommitID)
-	assert.EqualValues(t, "", results[0].newCommitID)
+	assert.Equal(t, "refs/tags/v0.1.8", results[0].refName.String())
+	assert.Equal(t, gitShortEmptySha, results[0].oldCommitID)
+	assert.Empty(t, results[0].newCommitID)
 
-	assert.EqualValues(t, "refs/heads/master", results[1].refName.String())
-	assert.EqualValues(t, gitShortEmptySha, results[1].oldCommitID)
-	assert.EqualValues(t, "", results[1].newCommitID)
+	assert.Equal(t, "refs/heads/master", results[1].refName.String())
+	assert.Equal(t, gitShortEmptySha, results[1].oldCommitID)
+	assert.Empty(t, results[1].newCommitID)
 
-	assert.EqualValues(t, "refs/heads/test1", results[2].refName.String())
-	assert.EqualValues(t, "", results[2].oldCommitID)
-	assert.EqualValues(t, gitShortEmptySha, results[2].newCommitID)
+	assert.Equal(t, "refs/heads/test1", results[2].refName.String())
+	assert.Empty(t, results[2].oldCommitID)
+	assert.Equal(t, gitShortEmptySha, results[2].newCommitID)
 
-	assert.EqualValues(t, "refs/tags/tag1", results[3].refName.String())
-	assert.EqualValues(t, "", results[3].oldCommitID)
-	assert.EqualValues(t, gitShortEmptySha, results[3].newCommitID)
+	assert.Equal(t, "refs/tags/tag1", results[3].refName.String())
+	assert.Empty(t, results[3].oldCommitID)
+	assert.Equal(t, gitShortEmptySha, results[3].newCommitID)
 
-	assert.EqualValues(t, "refs/heads/test2", results[4].refName.String())
-	assert.EqualValues(t, "f895a1e", results[4].oldCommitID)
-	assert.EqualValues(t, "957a993", results[4].newCommitID)
+	assert.Equal(t, "refs/heads/test2", results[4].refName.String())
+	assert.Equal(t, "f895a1e", results[4].oldCommitID)
+	assert.Equal(t, "957a993", results[4].newCommitID)
 
-	assert.EqualValues(t, "refs/heads/test3", results[5].refName.String())
-	assert.EqualValues(t, "957a993", results[5].oldCommitID)
-	assert.EqualValues(t, "a87ba5f", results[5].newCommitID)
+	assert.Equal(t, "refs/heads/test3", results[5].refName.String())
+	assert.Equal(t, "957a993", results[5].oldCommitID)
+	assert.Equal(t, "a87ba5f", results[5].newCommitID)
 
-	assert.EqualValues(t, "refs/pull/26595/head", results[6].refName.String())
-	assert.EqualValues(t, gitShortEmptySha, results[6].oldCommitID)
-	assert.EqualValues(t, "", results[6].newCommitID)
+	assert.Equal(t, "refs/pull/26595/head", results[6].refName.String())
+	assert.Equal(t, gitShortEmptySha, results[6].oldCommitID)
+	assert.Empty(t, results[6].newCommitID)
 
-	assert.EqualValues(t, "refs/pull/26595/merge", results[7].refName.String())
-	assert.EqualValues(t, gitShortEmptySha, results[7].oldCommitID)
-	assert.EqualValues(t, "", results[7].newCommitID)
+	assert.Equal(t, "refs/pull/26595/merge", results[7].refName.String())
+	assert.Equal(t, gitShortEmptySha, results[7].oldCommitID)
+	assert.Empty(t, results[7].newCommitID)
 
-	assert.EqualValues(t, "refs/pull/25873/head", results[8].refName.String())
-	assert.EqualValues(t, "e0639e38fb", results[8].oldCommitID)
-	assert.EqualValues(t, "6db2410489", results[8].newCommitID)
+	assert.Equal(t, "refs/pull/25873/head", results[8].refName.String())
+	assert.Equal(t, "e0639e38fb", results[8].oldCommitID)
+	assert.Equal(t, "6db2410489", results[8].newCommitID)
 
-	assert.EqualValues(t, "refs/pull/25873/merge", results[9].refName.String())
-	assert.EqualValues(t, "1c97ebc746", results[9].oldCommitID)
-	assert.EqualValues(t, "976d27d52f", results[9].newCommitID)
+	assert.Equal(t, "refs/pull/25873/merge", results[9].refName.String())
+	assert.Equal(t, "1c97ebc746", results[9].oldCommitID)
+	assert.Equal(t, "976d27d52f", results[9].newCommitID)
 }

services/packages/cleanup/cleanup.go

···
 		}
 
 		if anyVersionDeleted {
-			if pcr.Type == packages_model.TypeDebian {
+			switch pcr.Type {
+			case packages_model.TypeDebian:
 				if err := debian_service.BuildAllRepositoryFiles(ctx, pcr.OwnerID); err != nil {
 					return fmt.Errorf("CleanupRule [%d]: debian.BuildAllRepositoryFiles failed: %w", pcr.ID, err)
 				}
-			} else if pcr.Type == packages_model.TypeAlpine {
+			case packages_model.TypeAlpine:
 				if err := alpine_service.BuildAllRepositoryFiles(ctx, pcr.OwnerID); err != nil {
 					return fmt.Errorf("CleanupRule [%d]: alpine.BuildAllRepositoryFiles failed: %w", pcr.ID, err)
 				}
-			} else if pcr.Type == packages_model.TypeRpm {
+			case packages_model.TypeRpm:
 				if err := rpm_service.BuildAllRepositoryFiles(ctx, pcr.OwnerID); err != nil {
 					return fmt.Errorf("CleanupRule [%d]: rpm.BuildAllRepositoryFiles failed: %w", pcr.ID, err)
 				}
-			} else if pcr.Type == packages_model.TypeArch {
+			case packages_model.TypeArch:
 				if err := arch_service.BuildAllRepositoryFiles(ctx, pcr.OwnerID); err != nil {
 					return fmt.Errorf("CleanupRule [%d]: arch.BuildAllRepositoryFiles failed: %w", pcr.ID, err)
 				}
-			} else if pcr.Type == packages_model.TypeAlt {
+			case packages_model.TypeAlt:
 				if err := alt_service.BuildAllRepositoryFiles(ctx, pcr.OwnerID); err != nil {
 					return fmt.Errorf("CleanupRule [%d]: alt.BuildAllRepositoryFiles failed: %w", pcr.ID, err)
 				}

services/packages/cleanup/cleanup_sha256_test.go

···
 		for range expected {
 			filtered = append(filtered, true)
 		}
-		assert.EqualValues(t, filtered, logFiltered, expected)
+		assert.Equal(t, filtered, logFiltered, expected)
 	}
 
 	ancient := 1 * time.Hour

services/packages/container/blob_uploader.go

···
 
 	u.BytesReceived += n
 
-	u.HashStateBytes, err = u.MultiHasher.MarshalBinary()
+	u.HashStateBytes, err = u.MarshalBinary()
 	if err != nil {
 		return err
 	}

services/pull/check_test.go

···
 
 	select {
 	case id := <-idChan:
-		assert.EqualValues(t, pr.ID, id)
+		assert.Equal(t, pr.ID, id)
 	case <-time.After(time.Second):
 		assert.FailNow(t, "Timeout: nothing was added to pullRequestQueue")
 	}

services/pull/review.go

···
 			commit, err := gitRepo.LineBlame(head, gitRepo.Path, treePath, uint(line))
 			if err == nil {
 				commitID = commit.ID.String()
-			} else if !(strings.Contains(err.Error(), "exit status 128 - fatal: no such path") || notEnoughLines.MatchString(err.Error())) {
+			} else if !strings.Contains(err.Error(), "exit status 128 - fatal: no such path") && !notEnoughLines.MatchString(err.Error()) {
 				return nil, fmt.Errorf("LineBlame[%s, %s, %s, %d]: %w", pr.GetGitRefName(), gitRepo.Path, treePath, line, err)
 			}
 		}

services/release/release_test.go

···
 	}))
 	assert.NoError(t, repo_model.GetReleaseAttachments(db.DefaultContext, &release))
 	assert.Len(t, release.Attachments, 1)
-	assert.EqualValues(t, attach.UUID, release.Attachments[0].UUID)
-	assert.EqualValues(t, attach.Name, release.Attachments[0].Name)
-	assert.EqualValues(t, attach.ExternalURL, release.Attachments[0].ExternalURL)
+	assert.Equal(t, attach.UUID, release.Attachments[0].UUID)
+	assert.Equal(t, attach.Name, release.Attachments[0].Name)
+	assert.Equal(t, attach.ExternalURL, release.Attachments[0].ExternalURL)
 
 	release = repo_model.Release{
 		RepoID:       repo.ID,
···
 	}))
 	assert.NoError(t, repo_model.GetReleaseAttachments(db.DefaultContext, &release))
 	assert.Len(t, release.Attachments, 1)
-	assert.EqualValues(t, "test", release.Attachments[0].Name)
-	assert.EqualValues(t, "https://forgejo.org/", release.Attachments[0].ExternalURL)
+	assert.Equal(t, "test", release.Attachments[0].Name)
+	assert.Equal(t, "https://forgejo.org/", release.Attachments[0].ExternalURL)
 
 	release = repo_model.Release{
 		RepoID:       repo.ID,
···
 	}))
 	require.NoError(t, repo_model.GetReleaseAttachments(db.DefaultContext, release))
 	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)
-	assert.EqualValues(t, attach.ExternalURL, release.Attachments[0].ExternalURL)
+	assert.Equal(t, attach.UUID, release.Attachments[0].UUID)
+	assert.Equal(t, release.ID, release.Attachments[0].ReleaseID)
+	assert.Equal(t, attach.Name, release.Attachments[0].Name)
+	assert.Equal(t, attach.ExternalURL, release.Attachments[0].ExternalURL)
 
 	// update the attachment name
 	require.NoError(t, UpdateRelease(db.DefaultContext, user, gitRepo, release, false, []*AttachmentChange{
···
 	release.Attachments = nil
 	require.NoError(t, repo_model.GetReleaseAttachments(db.DefaultContext, release))
 	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)
-	assert.EqualValues(t, attach.ExternalURL, release.Attachments[0].ExternalURL)
+	assert.Equal(t, attach.UUID, release.Attachments[0].UUID)
+	assert.Equal(t, release.ID, release.Attachments[0].ReleaseID)
+	assert.Equal(t, "test2.txt", release.Attachments[0].Name)
+	assert.Equal(t, attach.ExternalURL, release.Attachments[0].ExternalURL)
 
 	// delete the attachment
 	require.NoError(t, UpdateRelease(db.DefaultContext, user, gitRepo, release, false, []*AttachmentChange{
···
 	}))
 	assert.NoError(t, repo_model.GetReleaseAttachments(db.DefaultContext, release))
 	assert.Len(t, release.Attachments, 1)
-	assert.EqualValues(t, release.ID, release.Attachments[0].ReleaseID)
-	assert.EqualValues(t, "test", release.Attachments[0].Name)
-	assert.EqualValues(t, "https://forgejo.org/", release.Attachments[0].ExternalURL)
+	assert.Equal(t, release.ID, release.Attachments[0].ReleaseID)
+	assert.Equal(t, "test", release.Attachments[0].Name)
+	assert.Equal(t, "https://forgejo.org/", release.Attachments[0].ExternalURL)
 	externalAttachmentUUID := release.Attachments[0].UUID
 
 	// update the attachment name
···
 	release.Attachments = nil
 	assert.NoError(t, repo_model.GetReleaseAttachments(db.DefaultContext, release))
 	assert.Len(t, release.Attachments, 1)
-	assert.EqualValues(t, externalAttachmentUUID, release.Attachments[0].UUID)
-	assert.EqualValues(t, release.ID, release.Attachments[0].ReleaseID)
-	assert.EqualValues(t, "test2", release.Attachments[0].Name)
-	assert.EqualValues(t, "https://about.gitea.com/", release.Attachments[0].ExternalURL)
+	assert.Equal(t, externalAttachmentUUID, release.Attachments[0].UUID)
+	assert.Equal(t, release.ID, release.Attachments[0].ReleaseID)
+	assert.Equal(t, "test2", release.Attachments[0].Name)
+	assert.Equal(t, "https://about.gitea.com/", release.Attachments[0].ExternalURL)
 }
 
 func TestRelease_createTag(t *testing.T) {

services/repository/archiver/archiver_test.go

···
 	bogusReq, err := NewRequest(ctx, ctx.Repo.Repository.ID, ctx.Repo.GitRepo, firstCommit, git.ZIP)
 	require.NoError(t, err)
 	assert.NotNil(t, bogusReq)
-	assert.EqualValues(t, firstCommit+".zip", bogusReq.GetArchiveName())
+	assert.Equal(t, firstCommit+".zip", bogusReq.GetArchiveName())
 
 	// Check a series of bogus requests.
 	// Step 1, valid commit with a bad extension.
···
 	bogusReq, err = NewRequest(ctx, ctx.Repo.Repository.ID, ctx.Repo.GitRepo, "master", git.ZIP)
 	require.NoError(t, err)
 	assert.NotNil(t, bogusReq)
-	assert.EqualValues(t, "master.zip", bogusReq.GetArchiveName())
+	assert.Equal(t, "master.zip", bogusReq.GetArchiveName())
 
 	bogusReq, err = NewRequest(ctx, ctx.Repo.Repository.ID, ctx.Repo.GitRepo, "test/archive", git.ZIP)
 	require.NoError(t, err)
 	assert.NotNil(t, bogusReq)
-	assert.EqualValues(t, "test-archive.zip", bogusReq.GetArchiveName())
+	assert.Equal(t, "test-archive.zip", bogusReq.GetArchiveName())
 
 	// Now two valid requests, firstCommit with valid extensions.
 	zipReq, err := NewRequest(ctx, ctx.Repo.Repository.ID, ctx.Repo.GitRepo, firstCommit, git.ZIP)

services/repository/avatar_test.go

···
 	err = DeleteAvatar(db.DefaultContext, repo)
 	require.NoError(t, err)
 
-	assert.Equal(t, "", repo.Avatar)
+	assert.Empty(t, repo.Avatar)
 }
 
 func TestTemplateGenerateAvatar(t *testing.T) {

services/repository/contributors_graph_test.go

···
 		keys = append(keys, k)
 	}
 	slices.Sort(keys)
-	assert.EqualValues(t, []string{
+	assert.Equal(t, []string{
 		"[e-mail]",
 		"[e-mail]",
 		"[e-mail]",
 		"total", // generated summary
 	}, keys)
 
-	assert.EqualValues(t, &ContributorData{
+	assert.Equal(t, &ContributorData{
 		Name:         "Ethan Koenig",
 		AvatarLink:   "/assets/img/avatar_default.png",
 		TotalCommits: 1,
···
 			},
 		},
 	}, data["[e-mail]"])
-	assert.EqualValues(t, &ContributorData{
+	assert.Equal(t, &ContributorData{
 		Name:         "Total",
 		AvatarLink:   "",
 		TotalCommits: 3,

services/repository/files/content_test.go

···
 
 	t.Run("Get README.md contents with GetContents(ctx, )", func(t *testing.T) {
 		fileContentResponse, err := GetContents(db.DefaultContext, repo, treePath, ref, false)
-		assert.EqualValues(t, expectedContentsResponse, fileContentResponse)
+		assert.Equal(t, expectedContentsResponse, fileContentResponse)
 		require.NoError(t, err)
 	})
 
 	t.Run("Get README.md contents with ref as empty string (should then use the repo's default branch) with GetContents(ctx, )", func(t *testing.T) {
 		fileContentResponse, err := GetContents(db.DefaultContext, repo, treePath, "", false)
-		assert.EqualValues(t, expectedContentsResponse, fileContentResponse)
+		assert.Equal(t, expectedContentsResponse, fileContentResponse)
 		require.NoError(t, err)
 	})
 }

services/repository/files/diff_test.go

···
 		require.NoError(t, err)
 		bs, err := json.Marshal(diff)
 		require.NoError(t, err)
-		assert.EqualValues(t, string(expectedBs), string(bs))
+		assert.Equal(t, string(expectedBs), string(bs))
 	})
 
 	t.Run("empty branch, same results", func(t *testing.T) {
···
 		require.NoError(t, err)
 		bs, err := json.Marshal(diff)
 		require.NoError(t, err)
-		assert.EqualValues(t, expectedBs, bs)
+		assert.Equal(t, expectedBs, bs)
 	})
 }
 

services/repository/files/file_test.go

···
 		name := "this/is/test"
 		cleanName := CleanUploadFileName(name)
 		expectedCleanName := name
-		assert.EqualValues(t, expectedCleanName, cleanName)
+		assert.Equal(t, expectedCleanName, cleanName)
 	})
 
 	t.Run("Clean a .git path", func(t *testing.T) {
 		name := "this/is/test/.git"
 		cleanName := CleanUploadFileName(name)
 		expectedCleanName := ""
-		assert.EqualValues(t, expectedCleanName, cleanName)
+		assert.Equal(t, expectedCleanName, cleanName)
 	})
 }

services/repository/files/tree_test.go

···
 		TotalCount: 1,
 	}
 
-	assert.EqualValues(t, expectedTree, tree)
+	assert.Equal(t, expectedTree, tree)
 }

services/repository/lfs.go

···
 
 	err = git_model.IterateLFSMetaObjectsForRepo(ctx, repo.ID, func(ctx context.Context, metaObject *git_model.LFSMetaObject) error {
 		total++
-		pointerSha := git.ComputeBlobHash(objectFormat, []byte(metaObject.Pointer.StringContent()))
+		pointerSha := git.ComputeBlobHash(objectFormat, []byte(metaObject.StringContent()))
 
 		if gitRepo.IsObjectExist(pointerSha.String()) {
 			return git_model.MarkLFSMetaObject(ctx, metaObject.ID)

services/user/avatar_test.go

···
 		err := UploadAvatar(db.DefaultContext, user, buff.Bytes())
 		require.NoError(t, err)
 		verification := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: 1})
-		assert.NotEqual(t, "", verification.Avatar)
+		assert.NotEmpty(t, verification.Avatar)
 
 		// fail to delete ...
 		storage.Avatars = storage.UninitializedStorage
···
 
 		// ... the avatar is removed from the database
 		verification = unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: 1})
-		assert.Equal(t, "", verification.Avatar)
+		assert.Empty(t, verification.Avatar)
 	})
 
 	t.Run("Success", func(t *testing.T) {
···
 		err := UploadAvatar(db.DefaultContext, user, buff.Bytes())
 		require.NoError(t, err)
 		verification := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: 1})
-		assert.NotEqual(t, "", verification.Avatar)
+		assert.NotEmpty(t, verification.Avatar)
 
 		err = DeleteAvatar(db.DefaultContext, user)
 		require.NoError(t, err)
 
 		verification = unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: 1})
-		assert.Equal(t, "", verification.Avatar)
+		assert.Empty(t, verification.Avatar)
 	})
 }

services/user/user_test.go

···
 
 		redirectUID, err := user_model.LookupUserRedirect(db.DefaultContext, oldUsername)
 		require.NoError(t, err)
-		assert.EqualValues(t, user.ID, redirectUID)
+		assert.Equal(t, user.ID, redirectUID)
 
 		unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{OwnerID: user.ID, OwnerName: user.Name})
 	})

services/webhook/default_test.go

···
 		assert.Equal(t, 12, j.Get("number").MustBeValid().ToInt())
 		assert.Equal(t, "http://localhost:3000/test/repo/pulls/12", j.Get("html_url").MustBeValid().ToString())
 		assert.Equal(t, jsoniter.NilValue, j.Get("updated_at").ValueType())
-		assert.Equal(t, "", j.Get("state").MustBeValid().ToString())
+		assert.Empty(t, j.Get("state").MustBeValid().ToString())
 		assert.Equal(t, "Fix bug", j.Get("title").MustBeValid().ToString())
 		assert.Equal(t, "fixes bug #2", j.Get("body").MustBeValid().ToString())
 

services/webhook/deliver_test.go

···
 		case "/webhook/66d222a5d6349e1311f551e50722d837e30fce98":
 			// Version 1
 			assert.Equal(t, "push", r.Header.Get("X-GitHub-Event"))
-			assert.Equal(t, "", r.Header.Get("Content-Type"))
+			assert.Empty(t, r.Header.Get("Content-Type"))
 			body, err := io.ReadAll(r.Body)
 			require.NoError(t, err)
 			assert.Equal(t, `{"data": 42}`, string(body))

services/webhook/general.go

···
 	for i, user := range assignList {
 		assignStringList[i] = user.UserName
 	}
-	if p.Action == api.HookIssueAssigned {
+	switch p.Action {
+	case api.HookIssueAssigned:
 		operateResult = fmt.Sprintf("%s assign this to %s", p.Sender.UserName, assignList[len(assignList)-1].UserName)
-	} else if p.Action == api.HookIssueUnassigned {
+	case api.HookIssueUnassigned:
 		operateResult = fmt.Sprintf("%s unassigned this for someone", p.Sender.UserName)
-	} else if p.Action == api.HookIssueMilestoned {
+	case api.HookIssueMilestoned:
 		operateResult = fmt.Sprintf("%s/milestone/%d", p.Repository.HTMLURL, p.PullRequest.Milestone.ID)
 	}
 	link = p.PullRequest.HTMLURL
···
 	for i, user := range assignList {
 		assignStringList[i] = user.UserName
 	}
-	if p.Action == api.HookIssueAssigned {
+	switch p.Action {
+	case api.HookIssueAssigned:
 		operateResult = fmt.Sprintf("%s assign this to %s", p.Sender.UserName, assignList[len(assignList)-1].UserName)
-	} else if p.Action == api.HookIssueUnassigned {
+	case api.HookIssueUnassigned:
 		operateResult = fmt.Sprintf("%s unassigned this for someone", p.Sender.UserName)
-	} else if p.Action == api.HookIssueMilestoned {
+	case api.HookIssueMilestoned:
 		operateResult = fmt.Sprintf("%s/milestone/%d", p.Repository.HTMLURL, p.Issue.Milestone.ID)
 	}
 	link = p.Issue.HTMLURL

services/webhook/msteams_test.go

···
 		assert.Equal(t, "[test/repo] New wiki page 'index' (Wiki change comment)", pl.Summary)
 		assert.Len(t, pl.Sections, 1)
 		assert.Equal(t, "user1", pl.Sections[0].ActivitySubtitle)
-		assert.Equal(t, "", pl.Sections[0].Text)
+		assert.Empty(t, pl.Sections[0].Text)
 		assert.Len(t, pl.Sections[0].Facts, 2)
 		for _, fact := range pl.Sections[0].Facts {
 			if fact.Name == "Repository:" {
···
 		assert.Equal(t, "[test/repo] Wiki page 'index' edited (Wiki change comment)", pl.Summary)
 		assert.Len(t, pl.Sections, 1)
 		assert.Equal(t, "user1", pl.Sections[0].ActivitySubtitle)
-		assert.Equal(t, "", pl.Sections[0].Text)
+		assert.Empty(t, pl.Sections[0].Text)
 		assert.Len(t, pl.Sections[0].Facts, 2)
 		for _, fact := range pl.Sections[0].Facts {
 			if fact.Name == "Repository:" {

services/webhook/notifier_test.go

···
 		var payloadContent structs.PushPayload
 		require.NoError(t, json.Unmarshal([]byte(hookTask.PayloadContent), &payloadContent))
 		assert.Len(t, payloadContent.Commits, 1)
-		assert.EqualValues(t, "2c54faec6c45d31c1abfaecdab471eac6633738a", payloadContent.Commits[0].ID)
+		assert.Equal(t, "2c54faec6c45d31c1abfaecdab471eac6633738a", payloadContent.Commits[0].ID)
 	})
 }
 
···
 		var payloadContent structs.PushPayload
 		require.NoError(t, json.Unmarshal([]byte(hookTask.PayloadContent), &payloadContent))
 		assert.Len(t, payloadContent.Commits, 1)
-		assert.EqualValues(t, "2c54faec6c45d31c1abfaecdab471eac6633738a", payloadContent.Commits[0].ID)
+		assert.Equal(t, "2c54faec6c45d31c1abfaecdab471eac6633738a", payloadContent.Commits[0].ID)
 	})
 }

services/wiki/wiki_test.go

···
 
 func TestWebPathSegments(t *testing.T) {
 	a := WebPathSegments("a%2Fa/b+c/d-e/f-g.-")
-	assert.EqualValues(t, []string{"a/a", "b c", "d e", "f-g"}, a)
+	assert.Equal(t, []string{"a/a", "b c", "d e", "f-g"}, a)
 }
 
 func TestUserTitleToWebPath(t *testing.T) {
···
 		{"a b", "a%20b.md"},
 	} {
 		_, displayName := WebPathToUserTitle(test.WebPath)
-		assert.EqualValues(t, test.Expected, displayName)
+		assert.Equal(t, test.Expected, displayName)
 	}
 }
 
···
 		{"2000-01-02-meeting.md", "2000-01-02+meeting"},
 		{"2000-01-02 meeting.-.md", "2000-01-02%20meeting.-"},
 	} {
-		assert.EqualValues(t, test.Expected, WebPathToGitPath(test.WikiName))
+		assert.Equal(t, test.Expected, WebPathToGitPath(test.WikiName))
 	}
 }
 
···
 		_, userTitle1 := WebPathToUserTitle(webPath1)
 		gitPath1 := WebPathToGitPath(webPath1)
 
-		assert.EqualValues(t, userTitle, userTitle1, "UserTitle for userTitle: %q", userTitle)
-		assert.EqualValues(t, webPath, webPath1, "WebPath for userTitle: %q", userTitle)
-		assert.EqualValues(t, gitPath, gitPath1, "GitPath for userTitle: %q", userTitle)
+		assert.Equal(t, userTitle, userTitle1, "UserTitle for userTitle: %q", userTitle)
+		assert.Equal(t, webPath, webPath1, "WebPath for userTitle: %q", userTitle)
+		assert.Equal(t, gitPath, gitPath1, "GitPath for userTitle: %q", userTitle)
 	}
 }
 
···
 			gitPath := WebPathToGitPath(webPath)
 			entry, err := masterTree.GetTreeEntryByPath(gitPath)
 			require.NoError(t, err)
-			assert.EqualValues(t, gitPath, entry.Name(), "%s not added correctly", userTitle)
+			assert.Equal(t, gitPath, entry.Name(), "%s not added correctly", userTitle)
 		})
 	}
 
···
 		gitPath := WebPathToGitPath(webPath)
 		entry, err := masterTree.GetTreeEntryByPath(gitPath)
 		require.NoError(t, err)
-		assert.EqualValues(t, gitPath, entry.Name(), "%s not edited correctly", newWikiName)
+		assert.Equal(t, gitPath, entry.Name(), "%s not edited correctly", newWikiName)
 
 		if newWikiName != "Home" {
 			_, err := masterTree.GetTreeEntryByPath("Home.md")
···
 					t.Errorf("expect to find an escaped file but we could not detect one")
 				}
 			}
-			assert.EqualValues(t, tt.wikiPath, newWikiPath)
+			assert.Equal(t, tt.wikiPath, newWikiPath)
 		})
 	}
 }
···
 	existence, newWikiPath, err := prepareGitPath(gitRepo, "master", "Home")
 	assert.False(t, existence)
 	require.NoError(t, err)
-	assert.EqualValues(t, "Home.md", newWikiPath)
+	assert.Equal(t, "Home.md", newWikiPath)
 }
 
 func TestWebPathConversion(t *testing.T) {
 	assert.Equal(t, "path/wiki", WebPathToURLPath(WebPath("path/wiki")))
 	assert.Equal(t, "wiki", WebPathToURLPath(WebPath("wiki")))
-	assert.Equal(t, "", WebPathToURLPath(WebPath("")))
+	assert.Empty(t, WebPathToURLPath(WebPath("")))
 }
 
 func TestWebPathFromRequest(t *testing.T) {

tests/integration/actions_variables_test.go

···
 			resp := sess.MakeRequest(t, req, http.StatusBadRequest)
 			var error errorJSON
 			DecodeJSON(t, resp, &error)
-			assert.EqualValues(t, "Failed to find the variable.", error.Error)
+			assert.Equal(t, "Failed to find the variable.", error.Error)
 		} else {
 			sess.MakeRequest(t, req, http.StatusOK)
 			flashCookie := sess.GetCookie(forgejo_context.CookieNameFlash)
 			assert.NotNil(t, flashCookie)
-			assert.EqualValues(t, "success%3DThe%2Bvariable%2Bhas%2Bbeen%2Bedited.", flashCookie.Value)
+			assert.Equal(t, "success%3DThe%2Bvariable%2Bhas%2Bbeen%2Bedited.", flashCookie.Value)
 		}
 
 		req = NewRequestWithValues(t, "POST", baseURL+fmt.Sprintf("/%d/delete", id), map[string]string{
···
 			resp := sess.MakeRequest(t, req, http.StatusBadRequest)
 			var error errorJSON
 			DecodeJSON(t, resp, &error)
-			assert.EqualValues(t, "Failed to find the variable.", error.Error)
+			assert.Equal(t, "Failed to find the variable.", error.Error)
 		} else {
 			sess.MakeRequest(t, req, http.StatusOK)
 			flashCookie := sess.GetCookie(forgejo_context.CookieNameFlash)
 			assert.NotNil(t, flashCookie)
-			assert.EqualValues(t, "success%3DThe%2Bvariable%2Bhas%2Bbeen%2Bremoved.", flashCookie.Value)
+			assert.Equal(t, "success%3DThe%2Bvariable%2Bhas%2Bbeen%2Bremoved.", flashCookie.Value)
 		}
 	}
 

tests/integration/admin_user_test.go

···
 
 		// 6th column is the 2FA column.
 		// One user that has TOTP and another user that has WebAuthn.
-		assert.EqualValues(t, 2, htmlDoc.Find(".admin-setting-content table tbody tr td:nth-child(6) .octicon-check").Length())
+		assert.Equal(t, 2, htmlDoc.Find(".admin-setting-content table tbody tr td:nth-child(6) .octicon-check").Length())
 	})
 
 	t.Run("Normal user", func(t *testing.T) {

tests/integration/api_admin_actions_test.go

···
 	DecodeJSON(t, res, &jobs)
 
 	assert.Len(t, jobs, 1)
-	assert.EqualValues(t, job.ID, jobs[0].ID)
+	assert.Equal(t, job.ID, jobs[0].ID)
 }

tests/integration/api_admin_test.go

···
 
 	errMap := make(map[string]any)
 	json.Unmarshal(resp.Body.Bytes(), &errMap)
-	assert.EqualValues(t, "e-mail invalid [email: ]", errMap["message"].(string))
+	assert.Equal(t, "e-mail invalid [email: ]", errMap["message"].(string))
 
 	user2 = unittest.AssertExistsAndLoadBean(t, &user_model.User{LoginName: "user2"})
 	assert.False(t, user2.IsRestricted)

tests/integration/api_branch_test.go

···
 		AddTokenAuth(token)
 	resp := MakeRequest(t, req, NoExpectedStatus)
 	if !exists {
-		assert.EqualValues(t, http.StatusNotFound, resp.Code)
+		assert.Equal(t, http.StatusNotFound, resp.Code)
 		return
 	}
-	assert.EqualValues(t, http.StatusOK, resp.Code)
+	assert.Equal(t, http.StatusOK, resp.Code)
 	var branch api.Branch
 	DecodeJSON(t, resp, &branch)
-	assert.EqualValues(t, branchName, branch.Name)
+	assert.Equal(t, branchName, branch.Name)
 	assert.True(t, branch.UserCanPush)
 	assert.True(t, branch.UserCanMerge)
 }
···
 	if resp.Code == http.StatusOK {
 		var branchProtection api.BranchProtection
 		DecodeJSON(t, resp, &branchProtection)
-		assert.EqualValues(t, branchName, branchProtection.RuleName)
+		assert.Equal(t, branchName, branchProtection.RuleName)
 		return &branchProtection
 	}
 	return nil
···
 	if resp.Code == http.StatusCreated {
 		var branchProtection api.BranchProtection
 		DecodeJSON(t, resp, &branchProtection)
-		assert.EqualValues(t, branchName, branchProtection.RuleName)
+		assert.Equal(t, branchName, branchProtection.RuleName)
 	}
 }
 
···
 	if resp.Code == http.StatusOK {
 		var branchProtection api.BranchProtection
 		DecodeJSON(t, resp, &branchProtection)
-		assert.EqualValues(t, branchName, branchProtection.RuleName)
+		assert.Equal(t, branchName, branchProtection.RuleName)
 	}
 }
 
···
 	DecodeJSON(t, resp, &branch)
 
 	if resp.Result().StatusCode == http.StatusCreated {
-		assert.EqualValues(t, newBranch, branch.Name)
+		assert.Equal(t, newBranch, branch.Name)
 	}
 
 	return resp.Result().StatusCode == status

tests/integration/api_comment_test.go

···
 
 	var updatedComment api.Comment
 	DecodeJSON(t, resp, &updatedComment)
-	assert.EqualValues(t, commentBody, updatedComment.Body)
+	assert.Equal(t, commentBody, updatedComment.Body)
 	unittest.AssertExistsAndLoadBean(t, &issues_model.Comment{ID: updatedComment.ID, IssueID: issue.ID, Content: commentBody})
 
 	urlStr = fmt.Sprintf("/api/v1/repos/%s/%s/issues/%d/comments",
···
 
 	var updatedComment api.Comment
 	DecodeJSON(t, resp, &updatedComment)
-	assert.EqualValues(t, comment.ID, updatedComment.ID)
-	assert.EqualValues(t, newCommentBody, updatedComment.Body)
+	assert.Equal(t, comment.ID, updatedComment.ID)
+	assert.Equal(t, newCommentBody, updatedComment.Body)
 	unittest.AssertExistsAndLoadBean(t, &issues_model.Comment{ID: comment.ID, IssueID: issue.ID, Content: newCommentBody})
 }
 

tests/integration/api_fork_test.go

···
 		DecodeJSON(t, resp, &forks)
 
 		assert.Empty(t, forks)
-		assert.EqualValues(t, "0", resp.Header().Get("X-Total-Count"))
+		assert.Equal(t, "0", resp.Header().Get("X-Total-Count"))
 	})
 
 	t.Run("Logged in", func(t *testing.T) {
···
 		DecodeJSON(t, resp, &forks)
 
 		assert.Len(t, forks, 1)
-		assert.EqualValues(t, "1", resp.Header().Get("X-Total-Count"))
+		assert.Equal(t, "1", resp.Header().Get("X-Total-Count"))
 	})
 }

tests/integration/api_gpg_keys_test.go

···
 		assert.Len(t, keys, 1)
 
 		primaryKey1 := keys[0] // Primary key 1
-		assert.EqualValues(t, "38EA3BCED732982C", primaryKey1.KeyID)
+		assert.Equal(t, "38EA3BCED732982C", primaryKey1.KeyID)
 		assert.Len(t, primaryKey1.Emails, 1)
-		assert.EqualValues(t, "[e-mail]", primaryKey1.Emails[0].Email)
+		assert.Equal(t, "[e-mail]", primaryKey1.Emails[0].Email)
 		assert.True(t, primaryKey1.Emails[0].Verified)
 
 		subKey := primaryKey1.SubsKey[0] // Subkey of 38EA3BCED732982C
-		assert.EqualValues(t, "70D7C694D17D03AD", subKey.KeyID)
+		assert.Equal(t, "70D7C694D17D03AD", subKey.KeyID)
 		assert.Empty(t, subKey.Emails)
 
 		var key api.GPGKey
···
 														AddTokenAuth(tokenWithGPGKeyScope)
 		resp = MakeRequest(t, req, http.StatusOK)
 		DecodeJSON(t, resp, &key)
-		assert.EqualValues(t, "38EA3BCED732982C", key.KeyID)
+		assert.Equal(t, "38EA3BCED732982C", key.KeyID)
 		assert.Len(t, key.Emails, 1)
-		assert.EqualValues(t, "[e-mail]", key.Emails[0].Email)
+		assert.Equal(t, "[e-mail]", key.Emails[0].Email)
 		assert.True(t, key.Emails[0].Verified)
 
 		req = NewRequest(t, "GET", "/api/v1/user/gpg_keys/"+strconv.FormatInt(subKey.ID, 10)). // Subkey of 38EA3BCED732982C
 													AddTokenAuth(tokenWithGPGKeyScope)
 		resp = MakeRequest(t, req, http.StatusOK)
 		DecodeJSON(t, resp, &key)
-		assert.EqualValues(t, "70D7C694D17D03AD", key.KeyID)
+		assert.Equal(t, "70D7C694D17D03AD", key.KeyID)
 		assert.Empty(t, key.Emails)
 	})
 

tests/integration/api_helper_for_declarative_test.go

···
 		expected = http.StatusOK
 	}
 
-	if !assert.EqualValues(t, expected, resp.Code,
+	if !assert.Equal(t, expected, resp.Code,
 		"Request: %s %s", req.Method, req.URL.String()) {
 		logUnexpectedResponse(t, resp)
 	}

tests/integration/api_issue_label_test.go

···
 	apiLabel := new(api.Label)
 	DecodeJSON(t, resp, &apiLabel)
 	dbLabel := unittest.AssertExistsAndLoadBean(t, &issues_model.Label{ID: apiLabel.ID, RepoID: repo.ID})
-	assert.EqualValues(t, dbLabel.Name, apiLabel.Name)
-	assert.EqualValues(t, strings.TrimLeft(dbLabel.Color, "#"), apiLabel.Color)
+	assert.Equal(t, dbLabel.Name, apiLabel.Name)
+	assert.Equal(t, strings.TrimLeft(dbLabel.Color, "#"), apiLabel.Color)
 
 	req = NewRequestWithJSON(t, "POST", urlStr, &api.CreateLabelOption{
 		Name:        "TestL 2",
···
 		AddTokenAuth(token)
 	resp = MakeRequest(t, req, http.StatusOK)
 	DecodeJSON(t, resp, &apiLabel)
-	assert.EqualValues(t, strings.TrimLeft(dbLabel.Color, "#"), apiLabel.Color)
+	assert.Equal(t, strings.TrimLeft(dbLabel.Color, "#"), apiLabel.Color)
 
 	// EditLabel
 	newName := "LabelNewName"
···
 	}).AddTokenAuth(token)
 	resp = MakeRequest(t, req, http.StatusOK)
 	DecodeJSON(t, resp, &apiLabel)
-	assert.EqualValues(t, newColor, apiLabel.Color)
+	assert.Equal(t, newColor, apiLabel.Color)
 	req = NewRequestWithJSON(t, "PATCH", singleURLStr, &api.EditLabelOption{
 		Color: &newColorWrong,
 	}).AddTokenAuth(token)
···
 	var apiLabels []*api.Label
 	DecodeJSON(t, resp, &apiLabels)
 	if assert.Len(t, apiLabels, 1) {
-		assert.EqualValues(t, label.ID, apiLabels[0].ID)
+		assert.Equal(t, label.ID, apiLabels[0].ID)
 	}
 
 	unittest.AssertCount(t, &issues_model.IssueLabel{IssueID: issue.ID}, 1)
···
 	var apiLabels []*api.Label
 	DecodeJSON(t, resp, &apiLabels)
 	if assert.Len(t, apiLabels, 1) {
-		assert.EqualValues(t, label.Name, apiLabels[0].Name)
+		assert.Equal(t, label.Name, apiLabels[0].Name)
 	}
 }
 
···
 	apiLabel := new(api.Label)
 	DecodeJSON(t, resp, &apiLabel)
 	dbLabel := unittest.AssertExistsAndLoadBean(t, &issues_model.Label{ID: apiLabel.ID, OrgID: owner.ID})
-	assert.EqualValues(t, dbLabel.Name, apiLabel.Name)
-	assert.EqualValues(t, strings.TrimLeft(dbLabel.Color, "#"), apiLabel.Color)
+	assert.Equal(t, dbLabel.Name, apiLabel.Name)
+	assert.Equal(t, strings.TrimLeft(dbLabel.Color, "#"), apiLabel.Color)
 
 	req = NewRequestWithJSON(t, "POST", urlStr, &api.CreateLabelOption{
 		Name:        "TestL 2",
···
 		AddTokenAuth(token)
 	resp = MakeRequest(t, req, http.StatusOK)
 	DecodeJSON(t, resp, &apiLabel)
-	assert.EqualValues(t, strings.TrimLeft(dbLabel.Color, "#"), apiLabel.Color)
+	assert.Equal(t, strings.TrimLeft(dbLabel.Color, "#"), apiLabel.Color)
 
 	// EditLabel
 	newName := "LabelNewName"
···
 	}).AddTokenAuth(token)
 	resp = MakeRequest(t, req, http.StatusOK)
 	DecodeJSON(t, resp, &apiLabel)
-	assert.EqualValues(t, newColor, apiLabel.Color)
+	assert.Equal(t, newColor, apiLabel.Color)
 	req = NewRequestWithJSON(t, "PATCH", singleURLStr, &api.EditLabelOption{
 		Color: &newColorWrong,
 	}).AddTokenAuth(token)

tests/integration/api_issue_milestone_test.go

···
 		AddTokenAuth(token)
 	resp = MakeRequest(t, req, http.StatusOK)
 	DecodeJSON(t, resp, &apiMilestone)
-	assert.EqualValues(t, apiMilestones[2], apiMilestone)
+	assert.Equal(t, apiMilestones[2], apiMilestone)
 
 	req = NewRequest(t, "GET", fmt.Sprintf("/api/v1/repos/%s/%s/milestones?state=%s&name=%s", owner.Name, repo.Name, "all", "milestone2")).
 		AddTokenAuth(token)

tests/integration/api_issue_stopwatch_test.go

···
 	stopwatch := unittest.AssertExistsAndLoadBean(t, &issues_model.Stopwatch{UserID: owner.ID})
 	issue := unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: stopwatch.IssueID})
 	if assert.Len(t, apiWatches, 1) {
-		assert.EqualValues(t, stopwatch.CreatedUnix.AsTime().Unix(), apiWatches[0].Created.Unix())
-		assert.EqualValues(t, issue.Index, apiWatches[0].IssueIndex)
-		assert.EqualValues(t, issue.Title, apiWatches[0].IssueTitle)
-		assert.EqualValues(t, repo.Name, apiWatches[0].RepoName)
-		assert.EqualValues(t, repo.OwnerName, apiWatches[0].RepoOwnerName)
+		assert.Equal(t, stopwatch.CreatedUnix.AsTime().Unix(), apiWatches[0].Created.Unix())
+		assert.Equal(t, issue.Index, apiWatches[0].IssueIndex)
+		assert.Equal(t, issue.Title, apiWatches[0].IssueTitle)
+		assert.Equal(t, repo.Name, apiWatches[0].RepoName)
+		assert.Equal(t, repo.OwnerName, apiWatches[0].RepoOwnerName)
 		assert.Positive(t, apiWatches[0].Seconds)
 	}
 }

tests/integration/api_issue_subscription_test.go

···
 		wi := new(api.WatchInfo)
 		DecodeJSON(t, resp, wi)
 
-		assert.EqualValues(t, isWatching, wi.Subscribed)
-		assert.EqualValues(t, !isWatching, wi.Ignored)
-		assert.EqualValues(t, issue.APIURL(db.DefaultContext)+"/subscriptions", wi.URL)
+		assert.Equal(t, isWatching, wi.Subscribed)
+		assert.Equal(t, !isWatching, wi.Ignored)
+		assert.Equal(t, issue.APIURL(db.DefaultContext)+"/subscriptions", wi.URL)
 		assert.EqualValues(t, issue.CreatedUnix, wi.CreatedAt.Unix())
-		assert.EqualValues(t, issueRepo.APIURL(), wi.RepositoryURL)
+		assert.Equal(t, issueRepo.APIURL(), wi.RepositoryURL)
 	}
 
 	testSubscription(issue1, true)

tests/integration/api_issue_test.go

···
 	req = NewRequest(t, "GET", link.String()).AddTokenAuth(token)
 	resp = MakeRequest(t, req, http.StatusOK)
 	DecodeJSON(t, resp, &apiIssues)
-	assert.EqualValues(t, "22", resp.Header().Get("X-Total-Count"))
+	assert.Equal(t, "22", resp.Header().Get("X-Total-Count"))
 	assert.Len(t, apiIssues, 20)
 
 	query.Add("limit", "10")
···
 	req = NewRequest(t, "GET", link.String()).AddTokenAuth(token)
 	resp = MakeRequest(t, req, http.StatusOK)
 	DecodeJSON(t, resp, &apiIssues)
-	assert.EqualValues(t, "22", resp.Header().Get("X-Total-Count"))
+	assert.Equal(t, "22", resp.Header().Get("X-Total-Count"))
 	assert.Len(t, apiIssues, 10)
 
 	query = url.Values{"assigned": {"true"}, "state": {"all"}}

tests/integration/api_issue_tracked_time_test.go

···
 
 	for i, time := range expect {
 		assert.Equal(t, time.ID, apiTimes[i].ID)
-		assert.EqualValues(t, issue2.Title, apiTimes[i].Issue.Title)
-		assert.EqualValues(t, issue2.ID, apiTimes[i].IssueID)
+		assert.Equal(t, issue2.Title, apiTimes[i].Issue.Title)
+		assert.Equal(t, issue2.ID, apiTimes[i].IssueID)
 		assert.Equal(t, time.Created.Unix(), apiTimes[i].Created.Unix())
 		assert.Equal(t, time.Time, apiTimes[i].Time)
 		user, err := user_model.GetUserByID(db.DefaultContext, time.UserID)
···
 	DecodeJSON(t, resp, &apiNewTime)
 
 	assert.EqualValues(t, 33, apiNewTime.Time)
-	assert.EqualValues(t, user2.ID, apiNewTime.UserID)
+	assert.Equal(t, user2.ID, apiNewTime.UserID)
 	assert.EqualValues(t, 947688818, apiNewTime.Created.Unix())
 }

tests/integration/api_notification_test.go

···
 	assert.EqualValues(t, 5, apiN.ID)
 	assert.False(t, apiN.Pinned)
 	assert.True(t, apiN.Unread)
-	assert.EqualValues(t, "issue4", apiN.Subject.Title)
+	assert.Equal(t, "issue4", apiN.Subject.Title)
 	assert.EqualValues(t, "Issue", apiN.Subject.Type)
-	assert.EqualValues(t, thread5.Issue.APIURL(db.DefaultContext), apiN.Subject.URL)
-	assert.EqualValues(t, thread5.Repository.HTMLURL(), apiN.Repository.HTMLURL)
+	assert.Equal(t, thread5.Issue.APIURL(db.DefaultContext), apiN.Subject.URL)
+	assert.Equal(t, thread5.Repository.HTMLURL(), apiN.Repository.HTMLURL)
 
 	MakeRequest(t, NewRequest(t, "GET", "/api/v1/notifications/new"), http.StatusUnauthorized)
 

tests/integration/api_oauth2_apps_test.go

···
 	var createdApp *api.OAuth2Application
 	DecodeJSON(t, resp, &createdApp)
 
-	assert.EqualValues(t, appBody.Name, createdApp.Name)
+	assert.Equal(t, appBody.Name, createdApp.Name)
 	assert.Len(t, createdApp.ClientSecret, 56)
 	assert.Len(t, createdApp.ClientID, 36)
 	assert.True(t, createdApp.ConfidentialClient)
 	assert.NotEmpty(t, createdApp.Created)
-	assert.EqualValues(t, appBody.RedirectURIs[0], createdApp.RedirectURIs[0])
+	assert.Equal(t, appBody.RedirectURIs[0], createdApp.RedirectURIs[0])
 	unittest.AssertExistsAndLoadBean(t, &auth_model.OAuth2Application{UID: user.ID, Name: createdApp.Name})
 }
 
···
 	DecodeJSON(t, resp, &appList)
 	expectedApp := appList[0]
 
-	assert.EqualValues(t, expectedApp.Name, existApp.Name)
-	assert.EqualValues(t, expectedApp.ClientID, existApp.ClientID)
+	assert.Equal(t, expectedApp.Name, existApp.Name)
+	assert.Equal(t, expectedApp.ClientID, existApp.ClientID)
 	assert.Equal(t, expectedApp.ConfidentialClient, existApp.ConfidentialClient)
 	assert.Len(t, expectedApp.ClientID, 36)
 	assert.Empty(t, expectedApp.ClientSecret)
-	assert.EqualValues(t, expectedApp.RedirectURIs[0], existApp.RedirectURIs[0])
+	assert.Equal(t, expectedApp.RedirectURIs[0], existApp.RedirectURIs[0])
 	unittest.AssertExistsAndLoadBean(t, &auth_model.OAuth2Application{ID: expectedApp.ID, Name: expectedApp.Name})
 }
 
···
 	DecodeJSON(t, resp, &app)
 	expectedApp := app
 
-	assert.EqualValues(t, expectedApp.Name, existApp.Name)
-	assert.EqualValues(t, expectedApp.ClientID, existApp.ClientID)
+	assert.Equal(t, expectedApp.Name, existApp.Name)
+	assert.Equal(t, expectedApp.ClientID, existApp.ClientID)
 	assert.Equal(t, expectedApp.ConfidentialClient, existApp.ConfidentialClient)
 	assert.Len(t, expectedApp.ClientID, 36)
 	assert.Empty(t, expectedApp.ClientSecret)
 	assert.Len(t, expectedApp.RedirectURIs, 1)
-	assert.EqualValues(t, expectedApp.RedirectURIs[0], existApp.RedirectURIs[0])
+	assert.Equal(t, expectedApp.RedirectURIs[0], existApp.RedirectURIs[0])
 	unittest.AssertExistsAndLoadBean(t, &auth_model.OAuth2Application{ID: expectedApp.ID, Name: expectedApp.Name})
 }
 
···
 	expectedApp := app
 
 	assert.Len(t, expectedApp.RedirectURIs, 2)
-	assert.EqualValues(t, expectedApp.RedirectURIs[0], appBody.RedirectURIs[0])
-	assert.EqualValues(t, expectedApp.RedirectURIs[1], appBody.RedirectURIs[1])
+	assert.Equal(t, expectedApp.RedirectURIs[0], appBody.RedirectURIs[0])
+	assert.Equal(t, expectedApp.RedirectURIs[1], appBody.RedirectURIs[1])
 	assert.Equal(t, expectedApp.ConfidentialClient, appBody.ConfidentialClient)
 	unittest.AssertExistsAndLoadBean(t, &auth_model.OAuth2Application{ID: expectedApp.ID, Name: expectedApp.Name})
 }

tests/integration/api_org_actions_test.go

···
 	DecodeJSON(t, res, &jobs)
 
 	assert.Len(t, jobs, 1)
-	assert.EqualValues(t, job.ID, jobs[0].ID)
+	assert.Equal(t, job.ID, jobs[0].ID)
 }

tests/integration/api_org_test.go

···
 		AddTokenAuth(token)
 	resp = MakeRequest(t, req, http.StatusOK)
 	DecodeJSON(t, resp, &apiOrg)
-	assert.EqualValues(t, org.UserName, apiOrg.Name)
+	assert.Equal(t, org.UserName, apiOrg.Name)
 
 	req = NewRequestf(t, "GET", "/api/v1/orgs/%s/repos", org.UserName).
 		AddTokenAuth(token)
···
 	var users []*api.User
 	DecodeJSON(t, resp, &users)
 	assert.Len(t, users, 1)
-	assert.EqualValues(t, "user1", users[0].UserName)
+	assert.Equal(t, "user1", users[0].UserName)
 }
 
 func TestAPIOrgRename(t *testing.T) {
···
 	DecodeJSON(t, resp, &data)
 	assert.True(t, data.Ok)
 	if assert.Len(t, data.Data, 1) {
-		assert.EqualValues(t, "Empty", data.Data[0].Name)
+		assert.Equal(t, "Empty", data.Data[0].Name)
 	}
 }
 

tests/integration/api_packages_alt_test.go

···
 					assert.Equal(t, []int(nil), result.DirIndexes)
 					assert.Equal(t, []string{"hello"}, result.BaseNames)
 					assert.Equal(t, []string{"/usr/local/bin/"}, result.DirNames)
-					assert.Equal(t, "", result.DistTag)
+					assert.Empty(t, result.DistTag)
 					assert.Equal(t, "gitea-test-1.0.2-1.x86_64.rpm", result.AptIndexLegacyFileName)
 					assert.Equal(t, 7116, result.AptIndexLegacyFileSize)
 					assert.Equal(t, "9ea82dd62968719aea19c08cd2ced79a", result.MD5Sum)

tests/integration/api_packages_cargo_test.go

···
 
 			flashCookie := session.GetCookie(gitea_context.CookieNameFlash)
 			assert.NotNil(t, flashCookie)
-			assert.EqualValues(t, "error%3DCannot%2Brebuild%252C%2Bno%2Bindex%2Bis%2Binitialized.", flashCookie.Value)
+			assert.Equal(t, "error%3DCannot%2Brebuild%252C%2Bno%2Bindex%2Bis%2Binitialized.", flashCookie.Value)
 			unittest.AssertExistsIf(t, false, &repo_model.Repository{OwnerID: user.ID, Name: cargo_service.IndexRepositoryName})
 		})
 
···
 
 			flashCookie := session.GetCookie(gitea_context.CookieNameFlash)
 			assert.NotNil(t, flashCookie)
-			assert.EqualValues(t, "success%3DThe%2BCargo%2Bindex%2Bwas%2Bsuccessfully%2Brebuild.", flashCookie.Value)
+			assert.Equal(t, "success%3DThe%2BCargo%2Bindex%2Bwas%2Bsuccessfully%2Brebuild.", flashCookie.Value)
 		})
 	})
 }

tests/integration/api_packages_conan_test.go

···
 
 						assert.Equal(t, int64(len(contentConaninfo)), pb.Size)
 					} else {
-						assert.FailNow(t, "unknown file: %s", pf.Name)
+						assert.FailNow(t, "unknown file", "name: %s", pf.Name)
 					}
 				}
 			})

tests/integration/api_packages_container_cleanup_sha256_test.go

···
 		for range expected {
 			filtered = append(filtered, true)
 		}
-		assert.EqualValues(t, filtered, logFiltered, expected)
+		assert.Equal(t, filtered, logFiltered, expected)
 	}
 
 	userToken := ""

tests/integration/api_packages_container_test.go

···
 								assert.Equal(t, "application/vnd.docker.image.rootfs.diff.tar.gzip", pfd.Properties.GetByName(container_module.PropertyMediaType))
 								assert.Equal(t, blobDigest, pfd.Properties.GetByName(container_module.PropertyDigest))
 							default:
-								assert.FailNow(t, "unknown file: %s", pfd.File.Name)
+								assert.FailNow(t, "unknown file", "name: %s", pfd.File.Name)
 							}
 						}
 

tests/integration/api_packages_nuget_test.go

···
 					assert.Equal(t, nuget_module.PropertySymbolID, pps[0].Name)
 					assert.Equal(t, symbolID, pps[0].Value)
 				default:
-					assert.FailNow(t, "unexpected file: %v", pf.Name)
+					assert.FailNow(t, "unexpected file", "name: %s", pf.Name)
 				}
 			}
 

tests/integration/api_packages_rpm_test.go

···
 					var result Metadata
 					decodeGzipXML(t, resp, &result)
 
-					assert.EqualValues(t, 1, result.PackageCount)
+					assert.Equal(t, 1, result.PackageCount)
 					assert.Len(t, result.Packages, 1)
 					p := result.Packages[0]
 					assert.Equal(t, "rpm", p.Type)
···
 					var result Filelists
 					decodeGzipXML(t, resp, &result)
 
-					assert.EqualValues(t, 1, result.PackageCount)
+					assert.Equal(t, 1, result.PackageCount)
 					assert.Len(t, result.Packages, 1)
 					p := result.Packages[0]
 					assert.NotEmpty(t, p.Pkgid)
···
 					var result Other
 					decodeGzipXML(t, resp, &result)
 
-					assert.EqualValues(t, 1, result.PackageCount)
+					assert.Equal(t, 1, result.PackageCount)
 					assert.Len(t, result.Packages, 1)
 					p := result.Packages[0]
 					assert.NotEmpty(t, p.Pkgid)

tests/integration/api_packages_test.go

···
 			var ap2 *api.Package
 			DecodeJSON(t, resp, &ap2)
 			assert.NotNil(t, ap2.Repository)
-			assert.EqualValues(t, repo.ID, ap2.Repository.ID)
+			assert.Equal(t, repo.ID, ap2.Repository.ID)
 
 			// link to repository without write access, should fail
 			req = NewRequest(t, "POST", fmt.Sprintf("/api/v1/packages/%s/generic/%s/-/link/%s", user.Name, packageName, "repo3")).AddTokenAuth(tokenWritePackage)

tests/integration/api_pull_review_test.go

···
 				resp := MakeRequest(t, req, http.StatusOK)
 				DecodeJSON(t, resp, &review)
 				require.EqualValues(t, string(event), review.State)
-				require.EqualValues(t, 0, review.CodeCommentsCount)
+				require.Equal(t, 0, review.CodeCommentsCount)
 			}
 
 			{
···
 				resp := MakeRequest(t, req, http.StatusOK)
 				var getReview api.PullReview
 				DecodeJSON(t, resp, &getReview)
-				require.EqualValues(t, getReview, review)
+				require.Equal(t, getReview, review)
 			}
 			requireReviewCount(2)
 
···
 				}).AddTokenAuth(token)
 				resp := MakeRequest(t, req, http.StatusOK)
 				DecodeJSON(t, resp, &reviewComment)
-				assert.EqualValues(t, review.ID, reviewComment.ReviewID)
-				assert.EqualValues(t, newCommentBody, reviewComment.Body)
+				assert.Equal(t, review.ID, reviewComment.ReviewID)
+				assert.Equal(t, newCommentBody, reviewComment.Body)
 				assert.EqualValues(t, reviewLine, reviewComment.OldLineNum)
 				assert.EqualValues(t, 0, reviewComment.LineNum)
-				assert.EqualValues(t, path, reviewComment.Path)
+				assert.Equal(t, path, reviewComment.Path)
 			}
 
 			{
···
 
 				var comment api.PullReviewComment
 				DecodeJSON(t, resp, &comment)
-				assert.EqualValues(t, reviewComment, comment)
+				assert.Equal(t, reviewComment, comment)
 			}
 
 			{
···
 		return
 	}
 	for _, r := range reviews {
-		assert.EqualValues(t, pullIssue.HTMLURL(), r.HTMLPullURL)
+		assert.Equal(t, pullIssue.HTMLURL(), r.HTMLPullURL)
 	}
 	assert.EqualValues(t, 8, reviews[3].ID)
 	assert.EqualValues(t, "APPROVED", reviews[3].State)
-	assert.EqualValues(t, 0, reviews[3].CodeCommentsCount)
+	assert.Equal(t, 0, reviews[3].CodeCommentsCount)
 	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.Equal(t, 1, reviews[5].CodeCommentsCount)
 	assert.EqualValues(t, -1, reviews[5].Reviewer.ID) // ghost user
 	assert.False(t, reviews[5].Stale)
 	assert.True(t, reviews[5].Official)
···
 	resp = MakeRequest(t, req, http.StatusOK)
 	var review api.PullReview
 	DecodeJSON(t, resp, &review)
-	assert.EqualValues(t, *reviews[3], review)
+	assert.Equal(t, *reviews[3], review)
 
 	req = NewRequestf(t, "GET", "/api/v1/repos/%s/%s/pulls/%d/reviews/%d", repo.OwnerName, repo.Name, pullIssue.Index, reviews[5].ID).
 		AddTokenAuth(token)
 	resp = MakeRequest(t, req, http.StatusOK)
 	DecodeJSON(t, resp, &review)
-	assert.EqualValues(t, *reviews[5], review)
+	assert.Equal(t, *reviews[5], review)
 
 	// test GetPullReviewComments
 	comment := unittest.AssertExistsAndLoadBean(t, &issues_model.Comment{ID: 7})
···
 	var reviewComments []*api.PullReviewComment
 	DecodeJSON(t, resp, &reviewComments)
 	assert.Len(t, reviewComments, 1)
-	assert.EqualValues(t, "Ghost", reviewComments[0].Poster.UserName)
-	assert.EqualValues(t, "a review from a deleted user", reviewComments[0].Body)
-	assert.EqualValues(t, comment.ID, reviewComments[0].ID)
+	assert.Equal(t, "Ghost", reviewComments[0].Poster.UserName)
+	assert.Equal(t, "a review from a deleted user", reviewComments[0].Body)
+	assert.Equal(t, comment.ID, reviewComments[0].ID)
 	assert.EqualValues(t, comment.UpdatedUnix, reviewComments[0].Updated.Unix())
-	assert.EqualValues(t, comment.HTMLURL(db.DefaultContext), reviewComments[0].HTMLURL)
+	assert.Equal(t, comment.HTMLURL(db.DefaultContext), reviewComments[0].HTMLURL)
 
 	// test CreatePullReview
 	req = NewRequestWithJSON(t, http.MethodPost, fmt.Sprintf("/api/v1/repos/%s/%s/pulls/%d/reviews", repo.OwnerName, repo.Name, pullIssue.Index), &api.CreatePullReviewOptions{
···
 	DecodeJSON(t, resp, &review)
 	assert.EqualValues(t, 6, review.ID)
 	assert.EqualValues(t, "PENDING", review.State)
-	assert.EqualValues(t, 3, review.CodeCommentsCount)
+	assert.Equal(t, 3, review.CodeCommentsCount)
 
 	// test SubmitPullReview
 	req = NewRequestWithJSON(t, http.MethodPost, fmt.Sprintf("/api/v1/repos/%s/%s/pulls/%d/reviews/%d", repo.OwnerName, repo.Name, pullIssue.Index, review.ID), &api.SubmitPullReviewOptions{
···
 	DecodeJSON(t, resp, &review)
 	assert.EqualValues(t, 6, review.ID)
 	assert.EqualValues(t, "APPROVED", review.State)
-	assert.EqualValues(t, 3, review.CodeCommentsCount)
+	assert.Equal(t, 3, review.CodeCommentsCount)
 
 	// test dismiss review
 	req = NewRequestWithJSON(t, http.MethodPost, fmt.Sprintf("/api/v1/repos/%s/%s/pulls/%d/reviews/%d/dismissals", repo.OwnerName, repo.Name, pullIssue.Index, review.ID), &api.DismissPullReviewOptions{
···
 	resp = MakeRequest(t, req, http.StatusOK)
 	DecodeJSON(t, resp, &review)
 	assert.EqualValues(t, "COMMENT", review.State)
-	assert.EqualValues(t, 0, review.CodeCommentsCount)
+	assert.Equal(t, 0, review.CodeCommentsCount)
 	req = NewRequestf(t, http.MethodDelete, "/api/v1/repos/%s/%s/pulls/%d/reviews/%d", repo.OwnerName, repo.Name, pullIssue.Index, review.ID).
 		AddTokenAuth(token)
 	MakeRequest(t, req, http.StatusNoContent)
···
 	resp = MakeRequest(t, req, http.StatusOK)
 	DecodeJSON(t, resp, &commentReview)
 	assert.EqualValues(t, "COMMENT", commentReview.State)
-	assert.EqualValues(t, 2, commentReview.CodeCommentsCount)
+	assert.Equal(t, 2, commentReview.CodeCommentsCount)
 	assert.Empty(t, commentReview.Body)
 	assert.False(t, commentReview.Dismissed)
 
···
 	resp = MakeRequest(t, req, http.StatusOK)
 	DecodeJSON(t, resp, &commentReview)
 	assert.EqualValues(t, "COMMENT", commentReview.State)
-	assert.EqualValues(t, 0, commentReview.CodeCommentsCount)
-	assert.EqualValues(t, commentBody, commentReview.Body)
+	assert.Equal(t, 0, commentReview.CodeCommentsCount)
+	assert.Equal(t, commentBody, commentReview.Body)
 	assert.False(t, commentReview.Dismissed)
 
 	// test CreatePullReview Comment without body and no comments
···
 	resp = MakeRequest(t, req, http.StatusUnprocessableEntity)
 	errMap := make(map[string]any)
 	json.Unmarshal(resp.Body.Bytes(), &errMap)
-	assert.EqualValues(t, "review event COMMENT requires a body or a comment", errMap["message"].(string))
+	assert.Equal(t, "review event COMMENT requires a body or a comment", errMap["message"].(string))
 
 	// test get review requests
 	// to make it simple, use same api with get review
···
 	DecodeJSON(t, resp, &reviews)
 	assert.EqualValues(t, 11, reviews[0].ID)
 	assert.EqualValues(t, "REQUEST_REVIEW", reviews[0].State)
-	assert.EqualValues(t, 0, reviews[0].CodeCommentsCount)
+	assert.Equal(t, 0, reviews[0].CodeCommentsCount)
 	assert.False(t, reviews[0].Stale)
 	assert.True(t, reviews[0].Official)
-	assert.EqualValues(t, "test_team", reviews[0].ReviewerTeam.Name)
+	assert.Equal(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.Equal(t, 0, reviews[0].CodeCommentsCount)
 	assert.False(t, reviews[1].Stale)
 	assert.True(t, reviews[1].Official)
 	assert.EqualValues(t, 1, reviews[1].Reviewer.ID)

tests/integration/api_pull_test.go

···
 				if assert.Len(t, files, 1) {
 					assert.Equal(t, "File-WoW", files[0].Filename)
 					assert.Empty(t, files[0].PreviousFilename)
-					assert.EqualValues(t, 1, files[0].Additions)
-					assert.EqualValues(t, 1, files[0].Changes)
-					assert.EqualValues(t, 0, files[0].Deletions)
+					assert.Equal(t, 1, files[0].Additions)
+					assert.Equal(t, 1, files[0].Changes)
+					assert.Equal(t, 0, files[0].Deletions)
 					assert.Equal(t, "added", files[0].Status)
 				}
 			}))
···
 	DecodeJSON(t, res, pull)
 
 	assert.NotNil(t, pull.Milestone)
-	assert.EqualValues(t, opts.Milestone, pull.Milestone.ID)
+	assert.Equal(t, opts.Milestone, pull.Milestone.ID)
 	if assert.Len(t, pull.Assignees, 1) {
-		assert.EqualValues(t, opts.Assignees[0], owner10.Name)
+		assert.Equal(t, opts.Assignees[0], owner10.Name)
 	}
 	assert.NotNil(t, pull.Labels)
-	assert.EqualValues(t, opts.Labels[0], pull.Labels[0].ID)
+	assert.Equal(t, opts.Labels[0], pull.Labels[0].ID)
 }
 
 func TestAPICreatePullWithFieldsFailure(t *testing.T) {
···
 	apiPull := new(api.PullRequest)
 	resp := MakeRequest(t, req, http.StatusCreated)
 	DecodeJSON(t, resp, apiPull)
-	assert.EqualValues(t, "master", apiPull.Base.Name)
+	assert.Equal(t, "master", apiPull.Base.Name)
 
 	newTitle := "edit a this pr"
 	newBody := "edited body"
···
 	}).AddTokenAuth(token)
 	resp = MakeRequest(t, req, http.StatusCreated)
 	DecodeJSON(t, resp, apiPull)
-	assert.EqualValues(t, "feature/1", apiPull.Base.Name)
+	assert.Equal(t, "feature/1", apiPull.Base.Name)
 	// check comment history
 	pull := unittest.AssertExistsAndLoadBean(t, &issues_model.PullRequest{ID: apiPull.ID})
 	err := pull.LoadIssue(db.DefaultContext)
···
 	apiPullIdempotent := new(api.PullRequest)
 	resp = MakeRequest(t, req, http.StatusCreated)
 	DecodeJSON(t, resp, apiPullIdempotent)
-	assert.EqualValues(t, apiPull.State, apiPullIdempotent.State)
+	assert.Equal(t, apiPull.State, apiPullIdempotent.State)
 
 	req = NewRequestWithJSON(t, http.MethodPatch, urlStr, &api.EditPullRequestOption{
 		Base: "not-exist",
···
 		var bodyResp userResponse
 		DecodeJSON(t, resp, &bodyResp)
 
-		assert.EqualValues(t, "insufficient permission to delete head branch", bodyResp.Message)
+		assert.Equal(t, "insufficient permission to delete head branch", bodyResp.Message)
 
 		// Check that the branch still exist.
 		req = NewRequest(t, "GET", "/api/v1/repos/user2/repo1/branches/base-pr").AddTokenAuth(token)

tests/integration/api_push_mirror_test.go

···
 			if testCase.message != "" {
 				err := api.APIError{}
 				DecodeJSON(t, resp, &err)
-				assert.EqualValues(t, testCase.message, err.Message)
+				assert.Equal(t, testCase.message, err.Message)
 			}
 
 			req = NewRequest(t, "GET", urlStr).AddTokenAuth(token)
···
 			DecodeJSON(t, resp, &pushMirrors)
 			if assert.Len(t, pushMirrors, testCase.mirrorCount) && testCase.mirrorCount > 0 {
 				pushMirror := pushMirrors[0]
-				assert.EqualValues(t, remoteAddress, pushMirror.RemoteAddress)
+				assert.Equal(t, remoteAddress, pushMirror.RemoteAddress)
 
 				repo_model.DeletePushMirrors = deletePushMirrors
 				req = NewRequest(t, "DELETE", fmt.Sprintf("%s/%s", urlStr, pushMirror.RemoteName)).AddTokenAuth(token)
···
 
 			var apiError api.APIError
 			DecodeJSON(t, resp, &apiError)
-			assert.EqualValues(t, "'use_ssh' is mutually exclusive with 'remote_username' and 'remote_passoword'", apiError.Message)
+			assert.Equal(t, "'use_ssh' is mutually exclusive with 'remote_username' and 'remote_passoword'", apiError.Message)
 		})
 
 		t.Run("SSH not available", func(t *testing.T) {
···
 
 			var apiError api.APIError
 			DecodeJSON(t, resp, &apiError)
-			assert.EqualValues(t, "SSH authentication not available.", apiError.Message)
+			assert.Equal(t, "SSH authentication not available.", apiError.Message)
 		})
 
 		t.Run("Normal", func(t *testing.T) {
···
 				var pushMirrors []*api.PushMirror
 				DecodeJSON(t, resp, &pushMirrors)
 				assert.Len(t, pushMirrors, 1)
-				assert.EqualValues(t, publickey, pushMirrors[0].PublicKey)
+				assert.Equal(t, publickey, pushMirrors[0].PublicKey)
 			})
 
 			t.Run("Add deploy key", func(t *testing.T) {
···
 				DecodeJSON(t, resp, &commitList)
 
 				assert.Len(t, commitList, 1)
-				assert.EqualValues(t, sha, commitList[0].SHA)
+				assert.Equal(t, sha, commitList[0].SHA)
 
 				assert.Eventually(t, func() bool {
 					req := NewRequest(t, "GET", fmt.Sprintf("/api/v1/repos/%s/commits?limit=1", srcRepo.FullName())).AddTokenAuth(token)

tests/integration/api_quota_management_test.go

···
 	require.NoError(t, err)
 	assert.NotNil(t, rule)
 	assert.EqualValues(t, -1, rule.Limit)
-	assert.EqualValues(t, quota_model.LimitSubjects{quota_model.LimitSubjectSizeAll}, rule.Subjects)
+	assert.Equal(t, quota_model.LimitSubjects{quota_model.LimitSubjectSizeAll}, rule.Subjects)
 
 	rule, err = quota_model.GetRuleByName(db.DefaultContext, "deny-git-lfs")
 	require.NoError(t, err)
 	assert.NotNil(t, rule)
 	assert.EqualValues(t, 0, rule.Limit)
-	assert.EqualValues(t, quota_model.LimitSubjects{quota_model.LimitSubjectSizeGitLFS}, rule.Subjects)
+	assert.Equal(t, quota_model.LimitSubjects{quota_model.LimitSubjectSizeGitLFS}, rule.Subjects)
 
 	// Verify that the new rule was also created
 	rule, err = quota_model.GetRuleByName(db.DefaultContext, "new-rule")
 	require.NoError(t, err)
 	assert.NotNil(t, rule)
 	assert.EqualValues(t, 0, rule.Limit)
-	assert.EqualValues(t, quota_model.LimitSubjects{quota_model.LimitSubjectSizeAssetsAll}, rule.Subjects)
+	assert.Equal(t, quota_model.LimitSubjects{quota_model.LimitSubjectSizeAssetsAll}, rule.Subjects)
 
 	t.Run("invalid rule spec", func(t *testing.T) {
 		defer tests.PrintCurrentTest(t)()
···
 		var q api.QuotaInfo
 		DecodeJSON(t, resp, &q)
 
-		assert.EqualValues(t, api.QuotaUsed{}, q.Used)
+		assert.Equal(t, api.QuotaUsed{}, q.Used)
 		assert.Empty(t, q.Groups)
 	})
 
···
 		var q api.QuotaInfo
 		DecodeJSON(t, resp, &q)
 
-		assert.EqualValues(t, api.QuotaUsed{}, q.Used)
+		assert.Equal(t, api.QuotaUsed{}, q.Used)
 		assert.Empty(t, q.Groups)
 
 		t.Run("#/user/quota/artifacts", func(t *testing.T) {
···
 
 		assert.Equal(t, "deny-all", q.Name)
 		assert.EqualValues(t, 0, q.Limit)
-		assert.EqualValues(t, []string{"size:all"}, q.Subjects)
+		assert.Equal(t, []string{"size:all"}, q.Subjects)
 
 		rule, err := quota_model.GetRuleByName(db.DefaultContext, "deny-all")
 		require.NoError(t, err)

tests/integration/api_quota_use_test.go

···
 		var msg context.APIQuotaExceeded
 		DecodeJSON(t, resp, &msg)
 
-		assert.EqualValues(t, env.Orgs.Limited.ID, msg.UserID)
+		assert.Equal(t, env.Orgs.Limited.ID, msg.UserID)
 		assert.Equal(t, env.Orgs.Limited.UserName, msg.UserName)
 	})
 }

tests/integration/api_releases_test.go

···
 		Title:   newRelease.Title,
 	}
 	unittest.AssertExistsAndLoadBean(t, rel)
-	assert.EqualValues(t, newRelease.Note, rel.Note)
+	assert.Equal(t, newRelease.Note, rel.Note)
 
 	return &newRelease
 }
···
 		Title:   newRelease.Title,
 	}
 	unittest.AssertExistsAndLoadBean(t, rel)
-	assert.EqualValues(t, rel.Note, newRelease.Note)
+	assert.Equal(t, rel.Note, newRelease.Note)
 	assert.True(t, newRelease.HideArchiveLinks)
 }
 
···
 		var attachment *api.Attachment
 		DecodeJSON(t, resp, &attachment)
 
-		assert.EqualValues(t, filename, attachment.Name)
+		assert.Equal(t, filename, attachment.Name)
 		assert.EqualValues(t, 104, attachment.Size)
 
 		req = NewRequestWithBody(t, http.MethodPost, assetURL+"?name=test-asset", bytes.NewReader(body.Bytes())).
···
 		var attachment2 *api.Attachment
 		DecodeJSON(t, resp, &attachment2)
 
-		assert.EqualValues(t, "test-asset", attachment2.Name)
+		assert.Equal(t, "test-asset", attachment2.Name)
 		assert.EqualValues(t, 104, attachment2.Size)
 	})
 
···
 		var attachment *api.Attachment
 		DecodeJSON(t, resp, &attachment)
 
-		assert.EqualValues(t, "stream.bin", attachment.Name)
+		assert.Equal(t, "stream.bin", attachment.Name)
 		assert.EqualValues(t, 104, attachment.Size)
-		assert.EqualValues(t, "attachment", attachment.Type)
+		assert.Equal(t, "attachment", attachment.Type)
 	})
 }
 
···
 	var attachment *api.Attachment
 	DecodeJSON(t, resp, &attachment)
 
-	assert.EqualValues(t, "test-asset", attachment.Name)
+	assert.Equal(t, "test-asset", attachment.Name)
 	assert.EqualValues(t, 0, attachment.Size)
-	assert.EqualValues(t, "https://forgejo.org/", attachment.DownloadURL)
-	assert.EqualValues(t, "external", attachment.Type)
+	assert.Equal(t, "https://forgejo.org/", attachment.DownloadURL)
+	assert.Equal(t, "external", attachment.Type)
 }
 
 func TestAPIDuplicateAssetRelease(t *testing.T) {

tests/integration/api_repo_actions_test.go

···
 	DecodeJSON(t, res, &jobs)
 
 	assert.Len(t, jobs, 1)
-	assert.EqualValues(t, job.ID, jobs[0].ID)
+	assert.Equal(t, job.ID, jobs[0].ID)
 }
 
 func TestAPIWorkflowDispatchReturnInfo(t *testing.T) {

tests/integration/api_repo_archive_test.go

···
 	bs, err := io.ReadAll(resp.Body)
 	require.NoError(t, err)
 	assert.Len(t, bs, 320)
-	assert.EqualValues(t, "application/zip", resp.Header().Get("Content-Type"))
+	assert.Equal(t, "application/zip", resp.Header().Get("Content-Type"))
 
 	link, _ = url.Parse(fmt.Sprintf("/api/v1/repos/%s/%s/archive/master.tar.gz", user2.Name, repo.Name))
 	resp = MakeRequest(t, NewRequest(t, "GET", link.String()).AddTokenAuth(token), http.StatusOK)
 	bs, err = io.ReadAll(resp.Body)
 	require.NoError(t, err)
 	assert.Len(t, bs, 266)
-	assert.EqualValues(t, "application/gzip", resp.Header().Get("Content-Type"))
+	assert.Equal(t, "application/gzip", resp.Header().Get("Content-Type"))
 
 	// Must return a link to a commit ID as the "immutable" archive link
 	linkHeaderRe := regexp.MustCompile(`<(?P<url>https?://.*/api/v1/repos/user2/repo1/archive/[a-f0-9]+\.tar\.gz.*)>; rel="immutable"`)
···
 	bs2, err := io.ReadAll(resp.Body)
 	require.NoError(t, err)
 	// The locked URL should give the same bytes as the non-locked one
-	assert.EqualValues(t, bs, bs2)
+	assert.Equal(t, bs, bs2)
 
 	link, _ = url.Parse(fmt.Sprintf("/api/v1/repos/%s/%s/archive/master.bundle", user2.Name, repo.Name))
 	resp = MakeRequest(t, NewRequest(t, "GET", link.String()).AddTokenAuth(token), http.StatusOK)
 	bs, err = io.ReadAll(resp.Body)
 	require.NoError(t, err)
 	assert.Len(t, bs, 382)
-	assert.EqualValues(t, "application/octet-stream", resp.Header().Get("Content-Type"))
+	assert.Equal(t, "application/octet-stream", resp.Header().Get("Content-Type"))
 
 	link, _ = url.Parse(fmt.Sprintf("/api/v1/repos/%s/%s/archive/master", user2.Name, repo.Name))
 	MakeRequest(t, NewRequest(t, "GET", link.String()).AddTokenAuth(token), http.StatusBadRequest)
···
 	bs2, err := io.ReadAll(resp.Body)
 	require.NoError(t, err)
 	// The locked URL should give the same bytes as the non-locked one
-	assert.EqualValues(t, bs, bs2)
+	assert.Equal(t, bs, bs2)
 
 	link, _ = url.Parse(fmt.Sprintf("/api/v1/repos/%s/%s/bundle/master", user2.Name, repo.Name))
 	resp = MakeRequest(t, NewRequest(t, "GET", link.String()).AddTokenAuth(token), http.StatusOK)

tests/integration/api_repo_branch_test.go

···
 		var branches []*api.Branch
 		require.NoError(t, json.Unmarshal(bs, &branches))
 		assert.Len(t, branches, 2)
-		assert.EqualValues(t, "test_branch", branches[0].Name)
-		assert.EqualValues(t, "master", branches[1].Name)
+		assert.Equal(t, "test_branch", branches[0].Name)
+		assert.Equal(t, "master", branches[1].Name)
 
 		link2, _ := url.Parse(fmt.Sprintf("/api/v1/repos/org3/%s/branches/test_branch", repo3.Name))
 		MakeRequest(t, NewRequest(t, "GET", link2.String()).AddTokenAuth(publicOnlyToken), http.StatusForbidden)
···
 		require.NoError(t, err)
 		var branch api.Branch
 		require.NoError(t, json.Unmarshal(bs, &branch))
-		assert.EqualValues(t, "test_branch", branch.Name)
+		assert.Equal(t, "test_branch", branch.Name)
 
 		MakeRequest(t, NewRequest(t, "POST", link.String()).AddTokenAuth(publicOnlyToken), http.StatusForbidden)
 
···
 		require.NoError(t, err)
 		var branch2 api.Branch
 		require.NoError(t, json.Unmarshal(bs, &branch2))
-		assert.EqualValues(t, "test_branch2", branch2.Name)
-		assert.EqualValues(t, branch.Commit.ID, branch2.Commit.ID)
+		assert.Equal(t, "test_branch2", branch2.Name)
+		assert.Equal(t, branch.Commit.ID, branch2.Commit.ID)
 
 		resp = MakeRequest(t, NewRequest(t, "GET", link.String()).AddTokenAuth(token), http.StatusOK)
 		bs, err = io.ReadAll(resp.Body)
···
 		branches = []*api.Branch{}
 		require.NoError(t, json.Unmarshal(bs, &branches))
 		assert.Len(t, branches, 3)
-		assert.EqualValues(t, "test_branch", branches[0].Name)
-		assert.EqualValues(t, "test_branch2", branches[1].Name)
-		assert.EqualValues(t, "master", branches[2].Name)
+		assert.Equal(t, "test_branch", branches[0].Name)
+		assert.Equal(t, "test_branch2", branches[1].Name)
+		assert.Equal(t, "master", branches[2].Name)
 
 		link3, _ := url.Parse(fmt.Sprintf("/api/v1/repos/org3/%s/branches/test_branch2", repo3.Name))
 		MakeRequest(t, NewRequest(t, "DELETE", link3.String()), http.StatusNotFound)
···
 	var branches []*api.Branch
 	require.NoError(t, json.Unmarshal(bs, &branches))
 	assert.Len(t, branches, 2)
-	assert.EqualValues(t, "test_branch", branches[0].Name)
-	assert.EqualValues(t, "master", branches[1].Name)
+	assert.Equal(t, "test_branch", branches[0].Name)
+	assert.Equal(t, "master", branches[1].Name)
 
 	link2, _ := url.Parse(fmt.Sprintf("/api/v1/repos/org3/%s/branches/test_branch", repo5.Name))
 	resp = MakeRequest(t, NewRequest(t, "GET", link2.String()).AddTokenAuth(token), http.StatusOK)
···
 	require.NoError(t, err)
 	var branch api.Branch
 	require.NoError(t, json.Unmarshal(bs, &branch))
-	assert.EqualValues(t, "test_branch", branch.Name)
+	assert.Equal(t, "test_branch", branch.Name)
 
 	req := NewRequest(t, "POST", link.String()).AddTokenAuth(token)
 	req.Header.Add("Content-Type", "application/json")
···
 	resp = MakeRequest(t, req, http.StatusForbidden)
 	bs, err = io.ReadAll(resp.Body)
 	require.NoError(t, err)
-	assert.EqualValues(t, "{\"message\":\"Git Repository is a mirror.\",\"url\":\""+setting.AppURL+"api/swagger\"}\n", string(bs))
+	assert.Equal(t, "{\"message\":\"Git Repository is a mirror.\",\"url\":\""+setting.AppURL+"api/swagger\"}\n", string(bs))
 
 	resp = MakeRequest(t, NewRequest(t, "DELETE", link2.String()).AddTokenAuth(token), http.StatusForbidden)
 	bs, err = io.ReadAll(resp.Body)
 	require.NoError(t, err)
-	assert.EqualValues(t, "{\"message\":\"Git Repository is a mirror.\",\"url\":\""+setting.AppURL+"api/swagger\"}\n", string(bs))
+	assert.Equal(t, "{\"message\":\"Git Repository is a mirror.\",\"url\":\""+setting.AppURL+"api/swagger\"}\n", string(bs))
 }

tests/integration/api_repo_file_create_test.go

···
 			expectedFileResponse := getExpectedFileResponseForCreate("user2/repo1", commitID, treePath, latestCommit.ID.String())
 			var fileResponse api.FileResponse
 			DecodeJSON(t, resp, &fileResponse)
-			assert.EqualValues(t, expectedFileResponse.Content, fileResponse.Content)
-			assert.EqualValues(t, expectedFileResponse.Commit.SHA, fileResponse.Commit.SHA)
-			assert.EqualValues(t, expectedFileResponse.Commit.HTMLURL, fileResponse.Commit.HTMLURL)
-			assert.EqualValues(t, expectedFileResponse.Commit.Author.Email, fileResponse.Commit.Author.Email)
-			assert.EqualValues(t, expectedFileResponse.Commit.Author.Name, fileResponse.Commit.Author.Name)
-			assert.EqualValues(t, expectedFileResponse.Commit.Author.Date, fileResponse.Commit.Author.Date)
-			assert.EqualValues(t, expectedFileResponse.Commit.Committer.Email, fileResponse.Commit.Committer.Email)
-			assert.EqualValues(t, expectedFileResponse.Commit.Committer.Name, fileResponse.Commit.Committer.Name)
-			assert.EqualValues(t, expectedFileResponse.Commit.Committer.Date, fileResponse.Commit.Committer.Date)
+			assert.Equal(t, expectedFileResponse.Content, fileResponse.Content)
+			assert.Equal(t, expectedFileResponse.Commit.SHA, fileResponse.Commit.SHA)
+			assert.Equal(t, expectedFileResponse.Commit.HTMLURL, fileResponse.Commit.HTMLURL)
+			assert.Equal(t, expectedFileResponse.Commit.Author.Email, fileResponse.Commit.Author.Email)
+			assert.Equal(t, expectedFileResponse.Commit.Author.Name, fileResponse.Commit.Author.Name)
+			assert.Equal(t, expectedFileResponse.Commit.Author.Date, fileResponse.Commit.Author.Date)
+			assert.Equal(t, expectedFileResponse.Commit.Committer.Email, fileResponse.Commit.Committer.Email)
+			assert.Equal(t, expectedFileResponse.Commit.Committer.Name, fileResponse.Commit.Committer.Name)
+			assert.Equal(t, expectedFileResponse.Commit.Committer.Date, fileResponse.Commit.Committer.Date)
 			gitRepo.Close()
 		}
 
···
 		expectedSHA := "a635aa942442ddfdba07468cf9661c08fbdf0ebf"
 		expectedHTMLURL := fmt.Sprintf(setting.AppURL+"user2/repo1/src/branch/new_branch/new/file%d.txt", fileID)
 		expectedDownloadURL := fmt.Sprintf(setting.AppURL+"user2/repo1/raw/branch/new_branch/new/file%d.txt", fileID)
-		assert.EqualValues(t, expectedSHA, fileResponse.Content.SHA)
-		assert.EqualValues(t, expectedHTMLURL, *fileResponse.Content.HTMLURL)
-		assert.EqualValues(t, expectedDownloadURL, *fileResponse.Content.DownloadURL)
-		assert.EqualValues(t, createFileOptions.Message+"\n", fileResponse.Commit.Message)
+		assert.Equal(t, expectedSHA, fileResponse.Content.SHA)
+		assert.Equal(t, expectedHTMLURL, *fileResponse.Content.HTMLURL)
+		assert.Equal(t, expectedDownloadURL, *fileResponse.Content.DownloadURL)
+		assert.Equal(t, createFileOptions.Message+"\n", fileResponse.Commit.Message)
 
 		// Test creating a file without a message
 		createFileOptions = getCreateFileOptions()
···
 		resp = MakeRequest(t, req, http.StatusCreated)
 		DecodeJSON(t, resp, &fileResponse)
 		expectedMessage := "Add " + treePath + "\n"
-		assert.EqualValues(t, expectedMessage, fileResponse.Commit.Message)
+		assert.Equal(t, expectedMessage, fileResponse.Commit.Message)
 
 		// Test trying to create a file that already exists, should fail
 		createFileOptions = getCreateFileOptions()
···
 			latestCommit, _ := gitRepo.GetCommitByPath(treePath)
 			expectedFileResponse := getExpectedFileResponseForCreate("user2/"+reponame, commitID, treePath, latestCommit.ID.String())
 			DecodeJSON(t, resp, &fileResponse)
-			assert.EqualValues(t, expectedFileResponse.Content, fileResponse.Content)
-			assert.EqualValues(t, expectedFileResponse.Commit.SHA, fileResponse.Commit.SHA)
-			assert.EqualValues(t, expectedFileResponse.Commit.HTMLURL, fileResponse.Commit.HTMLURL)
-			assert.EqualValues(t, expectedFileResponse.Commit.Author.Email, fileResponse.Commit.Author.Email)
-			assert.EqualValues(t, expectedFileResponse.Commit.Author.Name, fileResponse.Commit.Author.Name)
-			assert.EqualValues(t, expectedFileResponse.Commit.Author.Date, fileResponse.Commit.Author.Date)
-			assert.EqualValues(t, expectedFileResponse.Commit.Committer.Email, fileResponse.Commit.Committer.Email)
-			assert.EqualValues(t, expectedFileResponse.Commit.Committer.Name, fileResponse.Commit.Committer.Name)
-			assert.EqualValues(t, expectedFileResponse.Commit.Committer.Date, fileResponse.Commit.Committer.Date)
+			assert.Equal(t, expectedFileResponse.Content, fileResponse.Content)
+			assert.Equal(t, expectedFileResponse.Commit.SHA, fileResponse.Commit.SHA)
+			assert.Equal(t, expectedFileResponse.Commit.HTMLURL, fileResponse.Commit.HTMLURL)
+			assert.Equal(t, expectedFileResponse.Commit.Author.Email, fileResponse.Commit.Author.Email)
+			assert.Equal(t, expectedFileResponse.Commit.Author.Name, fileResponse.Commit.Author.Name)
+			assert.Equal(t, expectedFileResponse.Commit.Author.Date, fileResponse.Commit.Author.Date)
+			assert.Equal(t, expectedFileResponse.Commit.Committer.Email, fileResponse.Commit.Committer.Email)
+			assert.Equal(t, expectedFileResponse.Commit.Committer.Name, fileResponse.Commit.Committer.Name)
+			assert.Equal(t, expectedFileResponse.Commit.Committer.Date, fileResponse.Commit.Committer.Date)
 			gitRepo.Close()
 		})
 	})

tests/integration/api_repo_file_delete_test.go

···
 		DecodeJSON(t, resp, &fileResponse)
 		assert.NotNil(t, fileResponse)
 		assert.Nil(t, fileResponse.Content)
-		assert.EqualValues(t, deleteFileOptions.Message+"\n", fileResponse.Commit.Message)
+		assert.Equal(t, deleteFileOptions.Message+"\n", fileResponse.Commit.Message)
 
 		// Test deleting file without a message
 		fileID++
···
 		resp = MakeRequest(t, req, http.StatusOK)
 		DecodeJSON(t, resp, &fileResponse)
 		expectedMessage := "Delete " + treePath + "\n"
-		assert.EqualValues(t, expectedMessage, fileResponse.Commit.Message)
+		assert.Equal(t, expectedMessage, fileResponse.Commit.Message)
 
 		// Test deleting a file with the wrong SHA
 		fileID++

tests/integration/api_repo_file_update_test.go

···
 			expectedFileResponse := getExpectedFileResponseForUpdate(commitID, treePath, lasCommit.ID.String())
 			var fileResponse api.FileResponse
 			DecodeJSON(t, resp, &fileResponse)
-			assert.EqualValues(t, expectedFileResponse.Content, fileResponse.Content)
-			assert.EqualValues(t, expectedFileResponse.Commit.SHA, fileResponse.Commit.SHA)
-			assert.EqualValues(t, expectedFileResponse.Commit.HTMLURL, fileResponse.Commit.HTMLURL)
-			assert.EqualValues(t, expectedFileResponse.Commit.Author.Email, fileResponse.Commit.Author.Email)
-			assert.EqualValues(t, expectedFileResponse.Commit.Author.Name, fileResponse.Commit.Author.Name)
+			assert.Equal(t, expectedFileResponse.Content, fileResponse.Content)
+			assert.Equal(t, expectedFileResponse.Commit.SHA, fileResponse.Commit.SHA)
+			assert.Equal(t, expectedFileResponse.Commit.HTMLURL, fileResponse.Commit.HTMLURL)
+			assert.Equal(t, expectedFileResponse.Commit.Author.Email, fileResponse.Commit.Author.Email)
+			assert.Equal(t, expectedFileResponse.Commit.Author.Name, fileResponse.Commit.Author.Name)
 			gitRepo.Close()
 		}
 
···
 		expectedSHA := "08bd14b2e2852529157324de9c226b3364e76136"
 		expectedHTMLURL := fmt.Sprintf(setting.AppURL+"user2/repo1/src/branch/new_branch/update/file%d.txt", fileID)
 		expectedDownloadURL := fmt.Sprintf(setting.AppURL+"user2/repo1/raw/branch/new_branch/update/file%d.txt", fileID)
-		assert.EqualValues(t, expectedSHA, fileResponse.Content.SHA)
-		assert.EqualValues(t, expectedHTMLURL, *fileResponse.Content.HTMLURL)
-		assert.EqualValues(t, expectedDownloadURL, *fileResponse.Content.DownloadURL)
-		assert.EqualValues(t, updateFileOptions.Message+"\n", fileResponse.Commit.Message)
+		assert.Equal(t, expectedSHA, fileResponse.Content.SHA)
+		assert.Equal(t, expectedHTMLURL, *fileResponse.Content.HTMLURL)
+		assert.Equal(t, expectedDownloadURL, *fileResponse.Content.DownloadURL)
+		assert.Equal(t, updateFileOptions.Message+"\n", fileResponse.Commit.Message)
 
 		// Test updating a file and renaming it
 		updateFileOptions = getUpdateFileOptions()
···
 		expectedSHA = "08bd14b2e2852529157324de9c226b3364e76136"
 		expectedHTMLURL = fmt.Sprintf(setting.AppURL+"user2/repo1/src/branch/master/rename/update/file%d.txt", fileID)
 		expectedDownloadURL = fmt.Sprintf(setting.AppURL+"user2/repo1/raw/branch/master/rename/update/file%d.txt", fileID)
-		assert.EqualValues(t, expectedSHA, fileResponse.Content.SHA)
-		assert.EqualValues(t, expectedHTMLURL, *fileResponse.Content.HTMLURL)
-		assert.EqualValues(t, expectedDownloadURL, *fileResponse.Content.DownloadURL)
+		assert.Equal(t, expectedSHA, fileResponse.Content.SHA)
+		assert.Equal(t, expectedHTMLURL, *fileResponse.Content.HTMLURL)
+		assert.Equal(t, expectedDownloadURL, *fileResponse.Content.DownloadURL)
 
 		// Test updating a file without a message
 		updateFileOptions = getUpdateFileOptions()
···
 		resp = MakeRequest(t, req, http.StatusOK)
 		DecodeJSON(t, resp, &fileResponse)
 		expectedMessage := "Update " + treePath + "\n"
-		assert.EqualValues(t, expectedMessage, fileResponse.Commit.Message)
+		assert.Equal(t, expectedMessage, fileResponse.Commit.Message)
 
 		// Test updating a file with the wrong SHA
 		fileID++

tests/integration/api_repo_files_change_test.go

···
 			DecodeJSON(t, resp, &filesResponse)
 
 			// check create file
-			assert.EqualValues(t, expectedCreateFileResponse.Content, filesResponse.Files[0])
+			assert.Equal(t, expectedCreateFileResponse.Content, filesResponse.Files[0])
 
 			// check update file
-			assert.EqualValues(t, expectedUpdateFileResponse.Content, filesResponse.Files[1])
+			assert.Equal(t, expectedUpdateFileResponse.Content, filesResponse.Files[1])
 
 			// test commit info
-			assert.EqualValues(t, expectedCreateFileResponse.Commit.SHA, filesResponse.Commit.SHA)
-			assert.EqualValues(t, expectedCreateFileResponse.Commit.HTMLURL, filesResponse.Commit.HTMLURL)
-			assert.EqualValues(t, expectedCreateFileResponse.Commit.Author.Email, filesResponse.Commit.Author.Email)
-			assert.EqualValues(t, expectedCreateFileResponse.Commit.Author.Name, filesResponse.Commit.Author.Name)
-			assert.EqualValues(t, expectedCreateFileResponse.Commit.Committer.Email, filesResponse.Commit.Committer.Email)
-			assert.EqualValues(t, expectedCreateFileResponse.Commit.Committer.Name, filesResponse.Commit.Committer.Name)
+			assert.Equal(t, expectedCreateFileResponse.Commit.SHA, filesResponse.Commit.SHA)
+			assert.Equal(t, expectedCreateFileResponse.Commit.HTMLURL, filesResponse.Commit.HTMLURL)
+			assert.Equal(t, expectedCreateFileResponse.Commit.Author.Email, filesResponse.Commit.Author.Email)
+			assert.Equal(t, expectedCreateFileResponse.Commit.Author.Name, filesResponse.Commit.Author.Name)
+			assert.Equal(t, expectedCreateFileResponse.Commit.Committer.Email, filesResponse.Commit.Committer.Email)
+			assert.Equal(t, expectedCreateFileResponse.Commit.Committer.Name, filesResponse.Commit.Committer.Name)
 
 			// test delete file
 			assert.Nil(t, filesResponse.Files[2])
···
 		expectedUpdateSHA := "08bd14b2e2852529157324de9c226b3364e76136"
 		expectedUpdateHTMLURL := fmt.Sprintf(setting.AppURL+"user2/repo1/src/branch/new_branch/update/file%d.txt", fileID)
 		expectedUpdateDownloadURL := fmt.Sprintf(setting.AppURL+"user2/repo1/raw/branch/new_branch/update/file%d.txt", fileID)
-		assert.EqualValues(t, expectedCreateSHA, filesResponse.Files[0].SHA)
-		assert.EqualValues(t, expectedCreateHTMLURL, *filesResponse.Files[0].HTMLURL)
-		assert.EqualValues(t, expectedCreateDownloadURL, *filesResponse.Files[0].DownloadURL)
-		assert.EqualValues(t, expectedUpdateSHA, filesResponse.Files[1].SHA)
-		assert.EqualValues(t, expectedUpdateHTMLURL, *filesResponse.Files[1].HTMLURL)
-		assert.EqualValues(t, expectedUpdateDownloadURL, *filesResponse.Files[1].DownloadURL)
+		assert.Equal(t, expectedCreateSHA, filesResponse.Files[0].SHA)
+		assert.Equal(t, expectedCreateHTMLURL, *filesResponse.Files[0].HTMLURL)
+		assert.Equal(t, expectedCreateDownloadURL, *filesResponse.Files[0].DownloadURL)
+		assert.Equal(t, expectedUpdateSHA, filesResponse.Files[1].SHA)
+		assert.Equal(t, expectedUpdateHTMLURL, *filesResponse.Files[1].HTMLURL)
+		assert.Equal(t, expectedUpdateDownloadURL, *filesResponse.Files[1].DownloadURL)
 		assert.Nil(t, filesResponse.Files[2])
 
-		assert.EqualValues(t, changeFilesOptions.Message+"\n", filesResponse.Commit.Message)
+		assert.Equal(t, changeFilesOptions.Message+"\n", filesResponse.Commit.Message)
 
 		// Test updating a file and renaming it
 		changeFilesOptions = getChangeFilesOptions()
···
 		expectedUpdateSHA = "08bd14b2e2852529157324de9c226b3364e76136"
 		expectedUpdateHTMLURL = fmt.Sprintf(setting.AppURL+"user2/repo1/src/branch/master/rename/update/file%d.txt", fileID)
 		expectedUpdateDownloadURL = fmt.Sprintf(setting.AppURL+"user2/repo1/raw/branch/master/rename/update/file%d.txt", fileID)
-		assert.EqualValues(t, expectedUpdateSHA, filesResponse.Files[0].SHA)
-		assert.EqualValues(t, expectedUpdateHTMLURL, *filesResponse.Files[0].HTMLURL)
-		assert.EqualValues(t, expectedUpdateDownloadURL, *filesResponse.Files[0].DownloadURL)
+		assert.Equal(t, expectedUpdateSHA, filesResponse.Files[0].SHA)
+		assert.Equal(t, expectedUpdateHTMLURL, *filesResponse.Files[0].HTMLURL)
+		assert.Equal(t, expectedUpdateDownloadURL, *filesResponse.Files[0].DownloadURL)
 
 		// Test updating a file without a message
 		changeFilesOptions = getChangeFilesOptions()
···
 		resp = MakeRequest(t, req, http.StatusCreated)
 		DecodeJSON(t, resp, &filesResponse)
 		expectedMessage := fmt.Sprintf("Add %v\nUpdate %v\nDelete %v\n", createTreePath, updateTreePath, deleteTreePath)
-		assert.EqualValues(t, expectedMessage, filesResponse.Commit.Message)
+		assert.Equal(t, expectedMessage, filesResponse.Commit.Message)
 
 		// Test updating a file with the wrong SHA
 		fileID++

tests/integration/api_repo_get_contents_list_test.go

···
 	lastCommit, err := gitRepo.GetCommitByPath("README.md")
 	require.NoError(t, err)
 	expectedContentsListResponse := getExpectedContentsListResponseForContents(ref, refType, lastCommit.ID.String())
-	assert.EqualValues(t, expectedContentsListResponse, contentsListResponse)
+	assert.Equal(t, expectedContentsListResponse, contentsListResponse)
 
 	// No ref
 	refType = "branch"
···
 	assert.NotNil(t, contentsListResponse)
 
 	expectedContentsListResponse = getExpectedContentsListResponseForContents(repo1.DefaultBranch, refType, lastCommit.ID.String())
-	assert.EqualValues(t, expectedContentsListResponse, contentsListResponse)
+	assert.Equal(t, expectedContentsListResponse, contentsListResponse)
 
 	// ref is the branch we created above in setup
 	ref = newBranch
···
 	lastCommit, err = branchCommit.GetCommitByPath("README.md")
 	require.NoError(t, err)
 	expectedContentsListResponse = getExpectedContentsListResponseForContents(ref, refType, lastCommit.ID.String())
-	assert.EqualValues(t, expectedContentsListResponse, contentsListResponse)
+	assert.Equal(t, expectedContentsListResponse, contentsListResponse)
 
 	// ref is the new tag we created above in setup
 	ref = newTag
···
 	lastCommit, err = tagCommit.GetCommitByPath("README.md")
 	require.NoError(t, err)
 	expectedContentsListResponse = getExpectedContentsListResponseForContents(ref, refType, lastCommit.ID.String())
-	assert.EqualValues(t, expectedContentsListResponse, contentsListResponse)
+	assert.Equal(t, expectedContentsListResponse, contentsListResponse)
 
 	// ref is a commit
 	ref = commitID
···
 	DecodeJSON(t, resp, &contentsListResponse)
 	assert.NotNil(t, contentsListResponse)
 	expectedContentsListResponse = getExpectedContentsListResponseForContents(ref, refType, commitID)
-	assert.EqualValues(t, expectedContentsListResponse, contentsListResponse)
+	assert.Equal(t, expectedContentsListResponse, contentsListResponse)
 
 	// Test file contents a file with a bad ref
 	ref = "badref"

tests/integration/api_repo_get_contents_test.go

···
 	assert.NotNil(t, contentsResponse)
 	lastCommit, _ := gitRepo.GetCommitByPath("README.md")
 	expectedContentsResponse := getExpectedContentsResponseForContents(ref, refType, lastCommit.ID.String())
-	assert.EqualValues(t, *expectedContentsResponse, contentsResponse)
+	assert.Equal(t, *expectedContentsResponse, contentsResponse)
 
 	// No ref
 	refType = "branch"
···
 	DecodeJSON(t, resp, &contentsResponse)
 	assert.NotNil(t, contentsResponse)
 	expectedContentsResponse = getExpectedContentsResponseForContents(repo1.DefaultBranch, refType, lastCommit.ID.String())
-	assert.EqualValues(t, *expectedContentsResponse, contentsResponse)
+	assert.Equal(t, *expectedContentsResponse, contentsResponse)
 
 	// ref is the branch we created above  in setup
 	ref = newBranch
···
 	branchCommit, _ := gitRepo.GetBranchCommit(ref)
 	lastCommit, _ = branchCommit.GetCommitByPath("README.md")
 	expectedContentsResponse = getExpectedContentsResponseForContents(ref, refType, lastCommit.ID.String())
-	assert.EqualValues(t, *expectedContentsResponse, contentsResponse)
+	assert.Equal(t, *expectedContentsResponse, contentsResponse)
 
 	// ref is the new tag we created above in setup
 	ref = newTag
···
 	tagCommit, _ := gitRepo.GetTagCommit(ref)
 	lastCommit, _ = tagCommit.GetCommitByPath("README.md")
 	expectedContentsResponse = getExpectedContentsResponseForContents(ref, refType, lastCommit.ID.String())
-	assert.EqualValues(t, *expectedContentsResponse, contentsResponse)
+	assert.Equal(t, *expectedContentsResponse, contentsResponse)
 
 	// ref is a commit
 	ref = commitID
···
 	DecodeJSON(t, resp, &contentsResponse)
 	assert.NotNil(t, contentsResponse)
 	expectedContentsResponse = getExpectedContentsResponseForContents(ref, refType, commitID)
-	assert.EqualValues(t, *expectedContentsResponse, contentsResponse)
+	assert.Equal(t, *expectedContentsResponse, contentsResponse)
 
 	// Test file contents a file with a bad ref
 	ref = "badref"
···
 		resp := MakeRequest(t, NewRequest(t, http.MethodGet, noRef), http.StatusOK)
 		raw, err := io.ReadAll(resp.Body)
 		require.NoError(t, err)
-		assert.EqualValues(t, content, string(raw))
+		assert.Equal(t, content, string(raw))
 
 		resp = MakeRequest(t, NewRequest(t, http.MethodGet, refInPath), http.StatusOK)
 		raw, err = io.ReadAll(resp.Body)
 		require.NoError(t, err)
-		assert.EqualValues(t, content, string(raw))
+		assert.Equal(t, content, string(raw))
 
 		resp = MakeRequest(t, NewRequest(t, http.MethodGet, refInQuery), http.StatusOK)
 		raw, err = io.ReadAll(resp.Body)
 		require.NoError(t, err)
-		assert.EqualValues(t, content, string(raw))
+		assert.Equal(t, content, string(raw))
 	})
 }

tests/integration/api_repo_git_commits_test.go

···
 	DecodeJSON(t, resp, &apiData)
 
 	assert.Len(t, apiData, 2)
-	assert.EqualValues(t, "cfe3b3c1fd36fba04f9183287b106497e1afe986", apiData[0].CommitMeta.SHA)
+	assert.Equal(t, "cfe3b3c1fd36fba04f9183287b106497e1afe986", apiData[0].CommitMeta.SHA)
 	compareCommitFiles(t, []string{"link_hi", "test.csv"}, apiData[0].Files)
-	assert.EqualValues(t, "c8e31bc7688741a5287fcde4fbb8fc129ca07027", apiData[1].CommitMeta.SHA)
+	assert.Equal(t, "c8e31bc7688741a5287fcde4fbb8fc129ca07027", apiData[1].CommitMeta.SHA)
 	compareCommitFiles(t, []string{"test.csv"}, apiData[1].Files)
 
-	assert.EqualValues(t, "2", resp.Header().Get("X-Total"))
+	assert.Equal(t, "2", resp.Header().Get("X-Total"))
 }
 
 func TestAPIReposGitCommitListNotMaster(t *testing.T) {
···
 	DecodeJSON(t, resp, &apiData)
 
 	assert.Len(t, apiData, 3)
-	assert.EqualValues(t, "69554a64c1e6030f051e5c3f94bfbd773cd6a324", apiData[0].CommitMeta.SHA)
+	assert.Equal(t, "69554a64c1e6030f051e5c3f94bfbd773cd6a324", apiData[0].CommitMeta.SHA)
 	compareCommitFiles(t, []string{"readme.md"}, apiData[0].Files)
-	assert.EqualValues(t, "27566bd5738fc8b4e3fef3c5e72cce608537bd95", apiData[1].CommitMeta.SHA)
+	assert.Equal(t, "27566bd5738fc8b4e3fef3c5e72cce608537bd95", apiData[1].CommitMeta.SHA)
 	compareCommitFiles(t, []string{"readme.md"}, apiData[1].Files)
-	assert.EqualValues(t, "5099b81332712fe655e34e8dd63574f503f61811", apiData[2].CommitMeta.SHA)
+	assert.Equal(t, "5099b81332712fe655e34e8dd63574f503f61811", apiData[2].CommitMeta.SHA)
 	compareCommitFiles(t, []string{"readme.md"}, apiData[2].Files)
 
-	assert.EqualValues(t, "3", resp.Header().Get("X-Total"))
+	assert.Equal(t, "3", resp.Header().Get("X-Total"))
 }
 
 func TestAPIReposGitCommitListPage2Empty(t *testing.T) {
···
 	reqDiff := NewRequestf(t, "GET", "/api/v1/repos/%s/repo16/git/commits/f27c2b2b03dcab38beaf89b0ab4ff61f6de63441.diff", user.Name).
 		AddTokenAuth(token)
 	resp := MakeRequest(t, reqDiff, http.StatusOK)
-	assert.EqualValues(t,
+	assert.Equal(t,
 		"commit f27c2b2b03dcab38beaf89b0ab4ff61f6de63441\nAuthor: User2 <[e-mail]>\nDate:   Sun Aug 6 19:55:01 2017 +0200\n\n    good signed commit\n\ndiff --git a/readme.md b/readme.md\nnew file mode 100644\nindex 0000000..458121c\n--- /dev/null\n+++ b/readme.md\n@@ -0,0 +1 @@\n+good sign\n",
 		resp.Body.String())
 
···
 	reqPatch := NewRequestf(t, "GET", "/api/v1/repos/%s/repo16/git/commits/f27c2b2b03dcab38beaf89b0ab4ff61f6de63441.patch", user.Name).
 		AddTokenAuth(token)
 	resp = MakeRequest(t, reqPatch, http.StatusOK)
-	assert.EqualValues(t,
+	assert.Equal(t,
 		"From f27c2b2b03dcab38beaf89b0ab4ff61f6de63441 Mon Sep 17 00:00:00 2001\nFrom: User2 <[e-mail]>\nDate: Sun, 6 Aug 2017 19:55:01 +0200\nSubject: [PATCH] good signed commit\n\n---\n readme.md | 1 +\n 1 file changed, 1 insertion(+)\n create mode 100644 readme.md\n\ndiff --git a/readme.md b/readme.md\nnew file mode 100644\nindex 0000000..458121c\n--- /dev/null\n+++ b/readme.md\n@@ -0,0 +1 @@\n+good sign\n",
 		resp.Body.String())
 }
···
 	assert.Equal(t, "f27c2b2b03dcab38beaf89b0ab4ff61f6de63441", apiData[0].CommitMeta.SHA)
 	compareCommitFiles(t, []string{"readme.md"}, apiData[0].Files)
 
-	assert.EqualValues(t, "1", resp.Header().Get("X-Total"))
+	assert.Equal(t, "1", resp.Header().Get("X-Total"))
 }
 
 func TestGetFileHistoryNotOnMaster(t *testing.T) {
···
 	assert.Equal(t, "c8e31bc7688741a5287fcde4fbb8fc129ca07027", apiData[0].CommitMeta.SHA)
 	compareCommitFiles(t, []string{"test.csv"}, apiData[0].Files)
 
-	assert.EqualValues(t, "1", resp.Header().Get("X-Total"))
+	assert.Equal(t, "1", resp.Header().Get("X-Total"))
 }

tests/integration/api_repo_lfs_locks_test.go

···
 			var lfsLock api.LFSLockResponse
 			DecodeJSON(t, resp, &lfsLock)
 			assert.Equal(t, test.user.Name, lfsLock.Lock.Owner.Name)
-			assert.EqualValues(t, lfsLock.Lock.LockedAt.Format(time.RFC3339), lfsLock.Lock.LockedAt.Format(time.RFC3339Nano)) // locked at should be rounded to second
+			assert.Equal(t, lfsLock.Lock.LockedAt.Format(time.RFC3339), lfsLock.Lock.LockedAt.Format(time.RFC3339Nano)) // locked at should be rounded to second
 			for _, id := range test.addTime {
 				resultsTests[id].locksTimes = append(resultsTests[id].locksTimes, time.Now())
 			}
···
 		DecodeJSON(t, resp, &lfsLocks)
 		assert.Len(t, lfsLocks.Locks, test.totalCount)
 		for i, lock := range lfsLocks.Locks {
-			assert.EqualValues(t, test.locksOwners[i].Name, lock.Owner.Name)
+			assert.Equal(t, test.locksOwners[i].Name, lock.Owner.Name)
 			assert.WithinDuration(t, test.locksTimes[i], lock.LockedAt, 10*time.Second)
-			assert.EqualValues(t, lock.LockedAt.Format(time.RFC3339), lock.LockedAt.Format(time.RFC3339Nano)) // locked at should be rounded to second
+			assert.Equal(t, lock.LockedAt.Format(time.RFC3339), lock.LockedAt.Format(time.RFC3339Nano)) // locked at should be rounded to second
 		}
 
 		req = NewRequestWithJSON(t, "POST", fmt.Sprintf("/%s.git/info/lfs/locks/verify", test.repo.FullName()), map[string]string{})
···
 		assert.Len(t, lfsLocksVerify.Ours, test.oursCount)
 		assert.Len(t, lfsLocksVerify.Theirs, test.theirsCount)
 		for _, lock := range lfsLocksVerify.Ours {
-			assert.EqualValues(t, test.user.Name, lock.Owner.Name)
+			assert.Equal(t, test.user.Name, lock.Owner.Name)
 			deleteTests = append(deleteTests, struct {
 				user   *user_model.User
 				repo   *repo_model.Repository

tests/integration/api_repo_lfs_migrate_test.go

···
 		LFS:         true,
 	}).AddTokenAuth(token)
 	resp := MakeRequest(t, req, NoExpectedStatus)
-	assert.EqualValues(t, http.StatusCreated, resp.Code)
+	assert.Equal(t, http.StatusCreated, resp.Code)
 
 	store := lfs.NewContentStore()
 	ok, _ := store.Verify(lfs.Pointer{Oid: "fb8f7d8435968c4f82a726a92395be4d16f2f63116caf36c8ad35c60831ab041", Size: 6})

tests/integration/api_repo_raw_test.go

···
 		req := NewRequestf(t, "GET", "/api/v1/repos/%s/repo1/raw/%s/README.md", user.Name, ref).
 			AddTokenAuth(token)
 		resp := MakeRequest(t, req, http.StatusOK)
-		assert.EqualValues(t, "file", resp.Header().Get("x-gitea-object-type"))
+		assert.Equal(t, "file", resp.Header().Get("x-gitea-object-type"))
 	}
 	// Test default branch
 	req := NewRequestf(t, "GET", "/api/v1/repos/%s/repo1/raw/README.md", user.Name).
 		AddTokenAuth(token)
 	resp := MakeRequest(t, req, http.StatusOK)
-	assert.EqualValues(t, "file", resp.Header().Get("x-gitea-object-type"))
+	assert.Equal(t, "file", resp.Header().Get("x-gitea-object-type"))
 }

tests/integration/api_repo_tags_test.go

···
 	assert.Len(t, tags, 2)
 	for _, tag := range tags {
 		if tag.Name != "v1.1" {
-			assert.EqualValues(t, newTag.Name, tag.Name)
-			assert.EqualValues(t, newTag.Message, tag.Message)
-			assert.EqualValues(t, "nice!\nand some text", tag.Message)
-			assert.EqualValues(t, newTag.Commit.SHA, tag.Commit.SHA)
+			assert.Equal(t, newTag.Name, tag.Name)
+			assert.Equal(t, newTag.Message, tag.Message)
+			assert.Equal(t, "nice!\nand some text", tag.Message)
+			assert.Equal(t, newTag.Commit.SHA, tag.Commit.SHA)
 		}
 	}
 
···
 	resp = MakeRequest(t, req, http.StatusOK)
 	var tag *api.Tag
 	DecodeJSON(t, resp, &tag)
-	assert.EqualValues(t, newTag, tag)
+	assert.Equal(t, newTag, tag)
 
 	// delete tag
 	delReq := NewRequestf(t, "DELETE", "/api/v1/repos/%s/%s/tags/%s", user.Name, repoName, newTag.Name).

tests/integration/api_repo_teams_test.go

···
 	var teams []*api.Team
 	DecodeJSON(t, res, &teams)
 	if assert.Len(t, teams, 2) {
-		assert.EqualValues(t, "Owners", teams[0].Name)
+		assert.Equal(t, "Owners", teams[0].Name)
 		assert.True(t, teams[0].CanCreateOrgRepo)
 		assert.True(t, util.SliceSortedEqual(unit.AllUnitKeyNames(), teams[0].Units))
-		assert.EqualValues(t, "owner", teams[0].Permission)
+		assert.Equal(t, "owner", teams[0].Permission)
 
-		assert.EqualValues(t, "test_team", teams[1].Name)
+		assert.Equal(t, "test_team", teams[1].Name)
 		assert.False(t, teams[1].CanCreateOrgRepo)
-		assert.EqualValues(t, []string{"repo.issues"}, teams[1].Units)
-		assert.EqualValues(t, "write", teams[1].Permission)
+		assert.Equal(t, []string{"repo.issues"}, teams[1].Units)
+		assert.Equal(t, "write", teams[1].Permission)
 	}
 
 	// IsTeam
···
 	res = MakeRequest(t, req, http.StatusOK)
 	var team *api.Team
 	DecodeJSON(t, res, &team)
-	assert.EqualValues(t, teams[1], team)
+	assert.Equal(t, teams[1], team)
 
 	req = NewRequest(t, "GET", fmt.Sprintf("/api/v1/repos/%s/teams/%s", publicOrgRepo.FullName(), "NonExistingTeam")).
 		AddTokenAuth(token)

tests/integration/api_repo_test.go

···
 		unittest.Cond("is_private = ?", false))
 	assert.Len(t, apiRepos, expectedLen)
 	for _, repo := range apiRepos {
-		assert.EqualValues(t, user.ID, repo.Owner.ID)
+		assert.Equal(t, user.ID, repo.Owner.ID)
 		assert.False(t, repo.Private)
 	}
 }
···
 	resp := MakeRequest(t, req, http.StatusOK)
 	DecodeJSON(t, resp, &repo)
 	assert.EqualValues(t, 1, repo.ID)
-	assert.EqualValues(t, "repo1", repo.Name)
-	assert.EqualValues(t, 2, repo.Releases)
-	assert.EqualValues(t, 1, repo.OpenIssues)
-	assert.EqualValues(t, 3, repo.OpenPulls)
+	assert.Equal(t, "repo1", repo.Name)
+	assert.Equal(t, 2, repo.Releases)
+	assert.Equal(t, 1, repo.OpenIssues)
+	assert.Equal(t, 3, repo.OpenPulls)
 
 	req = NewRequest(t, "GET", "/api/v1/repos/user12/repo10")
 	resp = MakeRequest(t, req, http.StatusOK)
 	DecodeJSON(t, resp, &repo)
 	assert.EqualValues(t, 10, repo.ID)
-	assert.EqualValues(t, "repo10", repo.Name)
-	assert.EqualValues(t, 1, repo.OpenPulls)
-	assert.EqualValues(t, 1, repo.Forks)
+	assert.Equal(t, "repo10", repo.Name)
+	assert.Equal(t, 1, repo.OpenPulls)
+	assert.Equal(t, 1, repo.Forks)
 
 	req = NewRequest(t, "GET", "/api/v1/repos/user5/repo4")
 	resp = MakeRequest(t, req, http.StatusOK)
 	DecodeJSON(t, resp, &repo)
 	assert.EqualValues(t, 4, repo.ID)
-	assert.EqualValues(t, "repo4", repo.Name)
-	assert.EqualValues(t, 1, repo.Stars)
+	assert.Equal(t, "repo4", repo.Name)
+	assert.Equal(t, 1, repo.Stars)
 }
 
 func TestAPIOrgRepos(t *testing.T) {
···
 	var units []unit_model.Type
 	units = append(units, unit_model.TypeCode)
 
-	if err := repo_service.UpdateRepositoryUnits(db.DefaultContext, repo21, nil, units); err != nil {
-		assert.Fail(t, "should have been able to delete code repository unit; failed to %v", err)
-	}
+	require.NoError(t, repo_service.UpdateRepositoryUnits(db.DefaultContext, repo21, nil, units))
 	assert.False(t, repo21.UnitEnabled(db.DefaultContext, unit_model.TypeCode))
 
 	session := loginUser(t, "user2")
···
 			case "Remote visit addressed rate limitation.":
 				t.Log("test hit github rate limitation")
 			case "You can not import from disallowed hosts.":
-				assert.EqualValues(t, "private-ip", testCase.repoName)
+				assert.Equal(t, "private-ip", testCase.repoName)
 			default:
-				assert.FailNow(t, "unexpected error '%v' on url '%s'", respJSON["message"], testCase.cloneURL)
+				assert.FailNow(t, "unexpected error", "'%v' on url '%s'", respJSON["message"], testCase.cloneURL)
 			}
 		} else {
-			assert.EqualValues(t, testCase.expectedStatus, resp.Code)
+			assert.Equal(t, testCase.expectedStatus, resp.Code)
 		}
 	}
 }
···
 	req := NewRequest(t, "GET", "/api/v1/repos/user2/repo1")
 	resp := MakeRequest(t, req, http.StatusOK)
 	DecodeJSON(t, resp, &repo)
-	assert.EqualValues(t, "sha1", repo.ObjectFormatName)
+	assert.Equal(t, "sha1", repo.ObjectFormatName)
 }
 
 func TestAPIRepoCommitPull(t *testing.T) {
···
 		DecodeJSON(t, resp, &repos)
 
 		assert.Len(t, repos, 2)
-		assert.EqualValues(t, "big_test_private_4", repos[0].Name)
+		assert.Equal(t, "big_test_private_4", repos[0].Name)
 		// Postgres doesn't do ascii sorting.
 		if setting.Database.Type.IsPostgreSQL() {
-			assert.EqualValues(t, "commitsonpr", repos[1].Name)
+			assert.Equal(t, "commitsonpr", repos[1].Name)
 		} else {
-			assert.EqualValues(t, "commits_search_test", repos[1].Name)
+			assert.Equal(t, "commits_search_test", repos[1].Name)
 		}
 	})
 
···
 		DecodeJSON(t, resp, &repos)
 
 		assert.Len(t, repos, 2)
-		assert.EqualValues(t, "utf8", repos[0].Name)
-		assert.EqualValues(t, "test_workflows", repos[1].Name)
+		assert.Equal(t, "utf8", repos[0].Name)
+		assert.Equal(t, "test_workflows", repos[1].Name)
 	})
 }

tests/integration/api_repo_topic_test.go

···
 	res := MakeRequest(t, NewRequest(t, "GET", searchURL.String()), http.StatusOK)
 	DecodeJSON(t, res, &topics)
 	assert.Len(t, topics.TopicNames, 4)
-	assert.EqualValues(t, "6", res.Header().Get("x-total-count"))
+	assert.Equal(t, "6", res.Header().Get("x-total-count"))
 
 	query.Add("q", "topic")
 	searchURL.RawQuery = query.Encode()
···
 	DecodeJSON(t, res, &topics)
 	if assert.Len(t, topics.TopicNames, 1) {
 		assert.EqualValues(t, 2, topics.TopicNames[0].ID)
-		assert.EqualValues(t, "database", topics.TopicNames[0].Name)
-		assert.EqualValues(t, 1, topics.TopicNames[0].RepoCount)
+		assert.Equal(t, "database", topics.TopicNames[0].Name)
+		assert.Equal(t, 1, topics.TopicNames[0].RepoCount)
 	}
 }
 

tests/integration/api_settings_test.go

···
 	resp = MakeRequest(t, req, http.StatusOK)
 
 	DecodeJSON(t, resp, &apiSettings)
-	assert.EqualValues(t, &api.GeneralAPISettings{
+	assert.Equal(t, &api.GeneralAPISettings{
 		MaxResponseItems:       setting.API.MaxResponseItems,
 		DefaultPagingNum:       setting.API.DefaultPagingNum,
 		DefaultGitTreesPerPage: setting.API.DefaultGitTreesPerPage,
···
 	resp = MakeRequest(t, req, http.StatusOK)
 
 	DecodeJSON(t, resp, &repo)
-	assert.EqualValues(t, &api.GeneralRepoSettings{
+	assert.Equal(t, &api.GeneralRepoSettings{
 		MirrorsDisabled:      !setting.Mirror.Enabled,
 		HTTPGitDisabled:      setting.Repository.DisableHTTPGit,
 		MigrationsDisabled:   setting.Repository.DisableMigrations,
···
 	resp = MakeRequest(t, req, http.StatusOK)
 
 	DecodeJSON(t, resp, &attachment)
-	assert.EqualValues(t, &api.GeneralAttachmentSettings{
+	assert.Equal(t, &api.GeneralAttachmentSettings{
 		Enabled:      setting.Attachment.Enabled,
 		AllowedTypes: setting.Attachment.AllowedTypes,
 		MaxFiles:     setting.Attachment.MaxFiles,

tests/integration/api_team_test.go

···
 
 	var apiTeam api.Team
 	DecodeJSON(t, resp, &apiTeam)
-	assert.EqualValues(t, team.ID, apiTeam.ID)
+	assert.Equal(t, team.ID, apiTeam.ID)
 	assert.Equal(t, team.Name, apiTeam.Name)
-	assert.EqualValues(t, convert.ToOrganization(db.DefaultContext, org), apiTeam.Organization)
+	assert.Equal(t, convert.ToOrganization(db.DefaultContext, org), apiTeam.Organization)
 
 	// non team member user will not access the teams details
 	teamUser2 := unittest.AssertExistsAndLoadBean(t, &organization.TeamUser{ID: 3})
···
 		if units != nil {
 			sort.StringSlice(units).Sort()
 			sort.StringSlice(apiTeam.Units).Sort()
-			assert.EqualValues(t, units, apiTeam.Units, "units")
+			assert.Equal(t, units, apiTeam.Units, "units")
 		}
 		if unitsMap != nil {
-			assert.EqualValues(t, unitsMap, apiTeam.UnitsMap, "unitsMap")
+			assert.Equal(t, unitsMap, apiTeam.UnitsMap, "unitsMap")
 		}
 	})
 }

tests/integration/api_team_user_test.go

···
 	expectedUser := convert.ToUser(db.DefaultContext, user, user)
 
 	// test time via unix timestamp
-	assert.EqualValues(t, expectedUser.LastLogin.Unix(), user2.LastLogin.Unix())
-	assert.EqualValues(t, expectedUser.Created.Unix(), user2.Created.Unix())
+	assert.Equal(t, expectedUser.LastLogin.Unix(), user2.LastLogin.Unix())
+	assert.Equal(t, expectedUser.Created.Unix(), user2.Created.Unix())
 	expectedUser.LastLogin = user2.LastLogin
 	expectedUser.Created = user2.Created
 

tests/integration/api_token_test.go

···
 				} else if minRequiredLevel == auth_model.Write {
 					unauthorizedLevel = auth_model.Read
 				} else {
-					assert.FailNow(t, "Invalid test case: Unknown access token scope level: %v", minRequiredLevel)
+					assert.FailNow(t, "Invalid test case", "Unknown access token scope level: %v", minRequiredLevel)
 				}
 			}
 

tests/integration/api_twofa_test.go

···
 
 	DecodeJSON(t, resp, &userParsed)
 
-	assert.EqualValues(t, "Basic authorization is not allowed while having security keys enrolled", userParsed.Message)
+	assert.Equal(t, "Basic authorization is not allowed while having security keys enrolled", userParsed.Message)
 }

tests/integration/api_user_actions_test.go

···
 	DecodeJSON(t, res, &jobs)
 
 	assert.Len(t, jobs, 1)
-	assert.EqualValues(t, job.ID, jobs[0].ID)
+	assert.Equal(t, job.ID, jobs[0].ID)
 }

tests/integration/api_user_email_test.go

···
 	var emails []*api.Email
 	DecodeJSON(t, resp, &emails)
 
-	assert.EqualValues(t, []*api.Email{
+	assert.Equal(t, []*api.Email{
 		{
 			Email:    "[e-mail]",
 			Verified: true,
···
 
 	var emails []*api.Email
 	DecodeJSON(t, resp, &emails)
-	assert.EqualValues(t, []*api.Email{
+	assert.Equal(t, []*api.Email{
 		{
 			Email:    "[e-mail]",
 			Verified: true,
···
 
 	var emails []*api.Email
 	DecodeJSON(t, resp, &emails)
-	assert.EqualValues(t, []*api.Email{
+	assert.Equal(t, []*api.Email{
 		{
 			Email:    "[e-mail]",
 			Verified: true,

tests/integration/api_user_search_test.go

···
 	for _, user := range results.Data {
 		assert.Contains(t, user.UserName, query)
 		modelUser = unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: user.ID})
-		assert.EqualValues(t, modelUser.GetPlaceholderEmail(), user.Email)
+		assert.Equal(t, modelUser.GetPlaceholderEmail(), user.Email)
 	}
 }
 
···
 			assert.NotEmpty(t, results.Data)
 			if assert.Len(t, results.Data, 1) {
 				user := results.Data[0]
-				assert.EqualValues(t, user.UserName, systemUser.Name)
-				assert.EqualValues(t, user.ID, systemUser.ID)
+				assert.Equal(t, user.UserName, systemUser.Name)
+				assert.Equal(t, user.ID, systemUser.ID)
 			}
 		})
 	}
···
 	for _, user := range results.Data {
 		assert.Contains(t, user.UserName, query)
 		assert.NotEmpty(t, user.Email)
-		assert.EqualValues(t, "private", user.Visibility)
+		assert.Equal(t, "private", user.Visibility)
 	}
 }
 

tests/integration/appearance_settings_test.go

···
 
 	dataTheme, dataThemeExists := page.Find("html").Attr("data-theme")
 	assert.True(t, dataThemeExists)
-	assert.EqualValues(t, expectedTheme, dataTheme)
+	assert.Equal(t, expectedTheme, dataTheme)
 
 	selectedTheme := page.Find("form[action='/user/settings/appearance/theme'] .menu .item.selected")
 	selectorTheme, selectorThemeExists := selectedTheme.Attr("data-value")
 	assert.True(t, selectorThemeExists)
-	assert.EqualValues(t, expectedTheme, selectorTheme)
-	assert.EqualValues(t, expectedName, strings.TrimSpace(selectedTheme.Text()))
+	assert.Equal(t, expectedTheme, selectorTheme)
+	assert.Equal(t, expectedName, strings.TrimSpace(selectedTheme.Text()))
 }
 
 // testSelectedTheme changes user's theme

tests/integration/auth_ldap_test.go

···
 	binddn, _ = doc.Find(`input[name="bind_dn"]`).Attr("value")
 	assert.Equal(t, "uid=gitea,ou=service,dc=planetexpress,dc=com", binddn)
 	domainname, _ := doc.Find(`input[name="default_domain_name"]`).Attr("value")
-	assert.Equal(t, "", domainname)
+	assert.Empty(t, domainname)
 
 	req = NewRequestWithValues(t, "POST", href, buildAuthSourceLDAPPayload(csrf, "", "", "test.org", "", "", "off"))
 	session.MakeRequest(t, req, http.StatusSeeOther)

tests/integration/auth_token_test.go

···
 	assert.NotNil(t, rememberCookie)
 
 	// Check if the password really changed.
-	assert.NotEqualValues(t, unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: 1}).Passwd, user.Passwd)
+	assert.NotEqual(t, unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: 1}).Passwd, user.Passwd)
 
 	// /user/settings/account should provide with a new LTA cookie, so check for that.
 	// If LTA cookie provides authentication /user/login shouldn't return status 200.

tests/integration/block_test.go

···
 		assert.False(t, unittest.BeanExists(t, &user_model.BlockedUser{BlockID: doer.ID, UserID: org.ID}))
 		flashCookie := session.GetCookie(forgejo_context.CookieNameFlash)
 		assert.NotNil(t, flashCookie)
-		assert.EqualValues(t, "error%3DYou%2Bcannot%2Bblock%2Byourself.", flashCookie.Value)
+		assert.Equal(t, "error%3DYou%2Bcannot%2Bblock%2Byourself.", flashCookie.Value)
 	})
 }
 
···
 
 			flashCookie := session.GetCookie(forgejo_context.CookieNameFlash)
 			assert.NotNil(t, flashCookie)
-			assert.EqualValues(t, "error%3DCannot%2Badd%2Bthe%2Bcollaborator%252C%2Bbecause%2Bthe%2Brepository%2Bowner%2Bhas%2Bblocked%2Bthem.", flashCookie.Value)
+			assert.Equal(t, "error%3DCannot%2Badd%2Bthe%2Bcollaborator%252C%2Bbecause%2Bthe%2Brepository%2Bowner%2Bhas%2Bblocked%2Bthem.", flashCookie.Value)
 		})
 
 		t.Run("BlockedUser Add doer", func(t *testing.T) {
···
 
 			flashCookie := session.GetCookie(forgejo_context.CookieNameFlash)
 			assert.NotNil(t, flashCookie)
-			assert.EqualValues(t, "error%3DCannot%2Badd%2Bthe%2Bcollaborator%252C%2Bbecause%2Bthey%2Bhave%2Bblocked%2Bthe%2Brepository%2Bowner.", flashCookie.Value)
+			assert.Equal(t, "error%3DCannot%2Badd%2Bthe%2Bcollaborator%252C%2Bbecause%2Bthey%2Bhave%2Bblocked%2Bthe%2Brepository%2Bowner.", flashCookie.Value)
 		})
 	})
 

tests/integration/cmd_forgejo_actions_test.go

···
 			t.Run(testCase.testName, func(t *testing.T) {
 				defer tests.PrintCurrentTest(t)()
 				output, err := runMainApp("forgejo-cli", "actions", "register", "--secret", testCase.secret, "--scope", testCase.scope)
-				assert.EqualValues(t, "", output)
+				assert.Empty(t, output)
 
 				var exitErr *exec.ExitError
 				require.ErrorAs(t, err, &exitErr)
···
 			t.Run(testCase.testName, func(t *testing.T) {
 				uuid, err := runMainAppWithStdin(testCase.stdin, "forgejo-cli", "actions", "register", testCase.secretOption(), "--scope=org26")
 				require.NoError(t, err)
-				assert.EqualValues(t, expecteduuid, uuid)
+				assert.Equal(t, expecteduuid, uuid)
 			})
 		}
 
···
 				for i := 0; i < 2; i++ {
 					uuid, err := runMainApp("forgejo-cli", cmd...)
 					require.NoError(t, err)
-					if assert.EqualValues(t, testCase.uuid, uuid) {
+					if assert.Equal(t, testCase.uuid, uuid) {
 						ownerName, repoName, found := strings.Cut(testCase.scope, "/")
 						action, err := actions_model.GetRunnerByUUID(t.Context(), uuid)
 						require.NoError(t, err)
···
 							assert.Equal(t, repoName, repo.Name, action.RepoID)
 						}
 						if testCase.name != "" {
-							assert.EqualValues(t, testCase.name, action.Name)
+							assert.Equal(t, testCase.name, action.Name)
 						}
 						if testCase.labels != "" {
 							labels := strings.Split(testCase.labels, ",")
-							assert.EqualValues(t, labels, action.AgentLabels)
+							assert.Equal(t, labels, action.AgentLabels)
 						}
 						if testCase.version != "" {
-							assert.EqualValues(t, testCase.version, action.Version)
+							assert.Equal(t, testCase.version, action.Version)
 						}
 					}
 				}

tests/integration/cmd_forgejo_f3_test.go

···
 		user := users.CreateChild(ctx)
 		user.FromFormat(userFormat)
 		user.Upsert(ctx)
-		require.EqualValues(t, user.GetID(), users.GetIDFromName(ctx, userFormat.UserName))
+		require.Equal(t, user.GetID(), users.GetIDFromName(ctx, userFormat.UserName))
 
 		projectFormat := creator.GenerateProject()
 		projectFormat.SetID(fixtureProjectID)
···
 		project := projects.CreateChild(ctx)
 		project.FromFormat(projectFormat)
 		project.Upsert(ctx)
-		require.EqualValues(t, project.GetID(), projects.GetIDFromName(ctx, projectFormat.Name))
+		require.Equal(t, project.GetID(), projects.GetIDFromName(ctx, projectFormat.Name))
 
 		fromPath = fmt.Sprintf("/forge/users/%s/projects/%s", userFormat.UserName, projectFormat.Name)
 	}
···
 		user := users.CreateChild(ctx)
 		user.FromFormat(userFormat)
 		user.Upsert(ctx)
-		require.EqualValues(t, user.GetID(), users.GetIDFromName(ctx, userFormat.UserName))
+		require.Equal(t, user.GetID(), users.GetIDFromName(ctx, userFormat.UserName))
 
 		projectFormat := creator.GenerateProject()
 		projects = user.MustFind(f3_generic.NewPathFromString("projects"))
 		project := projects.CreateChild(ctx)
 		project.FromFormat(projectFormat)
 		project.Upsert(ctx)
-		require.EqualValues(t, project.GetID(), projects.GetIDFromName(ctx, projectFormat.Name))
+		require.Equal(t, project.GetID(), projects.GetIDFromName(ctx, projectFormat.Name))
 
 		toPath = fmt.Sprintf("/forge/users/%s/projects/%s", userFormat.UserName, projectFormat.Name)
 	}

tests/integration/comment_roles_system_test.go

···
 			resp := MakeRequest(t, req, http.StatusOK)
 			htmlDoc := NewHTMLParser(t, resp.Body)
 
-			assert.EqualValues(t, tc.username, htmlDoc.Find("a.author").Text())
+			assert.Equal(t, tc.username, htmlDoc.Find("a.author").Text())
 			assert.EqualValues(t, tc.roleCount, htmlDoc.Find(".role-label").Length())
 		})
 	}

tests/integration/comment_roles_test.go

···
 		response = sessionUser2.MakeRequest(t, NewRequest(t, "GET", path.Join(user, repo, "pulls", testID)), http.StatusOK)
 		page = NewHTMLParser(t, response.Body)
 		commentHeads := page.Find(".timeline .comment .comment-header .comment-header-right")
-		assert.EqualValues(t, 6, commentHeads.Length())
+		assert.Equal(t, 6, commentHeads.Length())
 
 		// Test the first comment and it's label "Owner"
 		labels := commentHeads.Eq(0).Find(".role-label")
-		assert.EqualValues(t, 1, labels.Length())
+		assert.Equal(t, 1, labels.Length())
 		testIssueCommentUserLabel(t, labels.Eq(0), "Owner", ownerTooltip)
 
 		// Test the second (review) comment and it's labels "Author" and "Owner"
 		labels = commentHeads.Eq(1).Find(".role-label")
-		assert.EqualValues(t, 2, labels.Length())
+		assert.Equal(t, 2, labels.Length())
 		testIssueCommentUserLabel(t, labels.Eq(0), "Author", authorTooltipPR)
 		testIssueCommentUserLabel(t, labels.Eq(1), "Owner", ownerTooltip)
 
 		// Test the third (review) comment and it's labels "Author" and "Owner"
 		labels = commentHeads.Eq(2).Find(".role-label")
-		assert.EqualValues(t, 2, labels.Length())
+		assert.Equal(t, 2, labels.Length())
 		testIssueCommentUserLabel(t, labels.Eq(0), "Author", authorTooltipPR)
 		testIssueCommentUserLabel(t, labels.Eq(1), "Owner", ownerTooltip)
 
 		// Test the fourth comment and it's labels "Author" and "Owner"
 		labels = commentHeads.Eq(3).Find(".role-label")
-		assert.EqualValues(t, 2, labels.Length())
+		assert.Equal(t, 2, labels.Length())
 		testIssueCommentUserLabel(t, labels.Eq(0), "Author", authorTooltipPR)
 		testIssueCommentUserLabel(t, labels.Eq(1), "Owner", ownerTooltip)
 
 		// Test the fivth comment and it's label "Contributor"
 		labels = commentHeads.Eq(4).Find(".role-label")
-		assert.EqualValues(t, 1, labels.Length())
+		assert.Equal(t, 1, labels.Length())
 		testIssueCommentUserLabel(t, labels.Eq(0), "Contributor", contributorTooltip)
 
 		// Test the sixth comment and it's label "First-time contributor"
 		labels = commentHeads.Eq(5).Find(".role-label")
-		assert.EqualValues(t, 1, labels.Length())
+		assert.Equal(t, 1, labels.Length())
 		testIssueCommentUserLabel(t, labels.Eq(0), "First-time contributor", newContributorTooltip)
 	})
 
···
 		response := sessionUser2.MakeRequest(t, NewRequest(t, "GET", path.Join(user, repo, "issues", testID)), http.StatusOK)
 		page := NewHTMLParser(t, response.Body)
 		commentHeads := page.Find(".timeline .comment .comment-header .comment-header-right")
-		assert.EqualValues(t, 4, commentHeads.Length())
+		assert.Equal(t, 4, commentHeads.Length())
 
 		// Test the first comment and it's label "Owner"
 		labels := commentHeads.Eq(0).Find(".role-label")
-		assert.EqualValues(t, 1, labels.Length())
+		assert.Equal(t, 1, labels.Length())
 		testIssueCommentUserLabel(t, labels.Eq(0), "Owner", ownerTooltip)
 
 		// Test the second comment and it's labels "Author" and "Owner"
 		labels = commentHeads.Eq(1).Find(".role-label")
-		assert.EqualValues(t, 2, labels.Length())
+		assert.Equal(t, 2, labels.Length())
 		testIssueCommentUserLabel(t, labels.Eq(0), "Author", authorTooltipIssue)
 		testIssueCommentUserLabel(t, labels.Eq(1), "Owner", ownerTooltip)
 
 		// Test the third comment and it's label "Contributor"
 		labels = commentHeads.Eq(2).Find(".role-label")
-		assert.EqualValues(t, 1, labels.Length())
+		assert.Equal(t, 1, labels.Length())
 		testIssueCommentUserLabel(t, labels.Eq(0), "Contributor", contributorTooltip)
 
 		// Test the fifth comment and it's lack of labels
 		labels = commentHeads.Eq(3).Find(".role-label")
-		assert.EqualValues(t, 0, labels.Length())
+		assert.Equal(t, 0, labels.Length())
 	})
 }
 
···
 	title := label.Text()
 	tooltip, exists := label.Attr("data-tooltip-content")
 	assert.True(t, exists)
-	assert.EqualValues(t, expectedTitle, strings.TrimSpace(title))
-	assert.EqualValues(t, expectedTooltip, strings.TrimSpace(tooltip))
+	assert.Equal(t, expectedTitle, strings.TrimSpace(title))
+	assert.Equal(t, expectedTooltip, strings.TrimSpace(tooltip))
 }
 
 // testEasyLeaveIssueComment is used to create a comment on an issue with minimum code and parameters

tests/integration/commit_status_test.go

···
 		defer tests.PrintCurrentTest(t)()
 		pairs, err := git_model.GetLatestCommitStatusForPairs(db.DefaultContext, nil)
 		require.NoError(t, err)
-		assert.EqualValues(t, map[int64][]*git_model.CommitStatus{}, pairs)
+		assert.Equal(t, map[int64][]*git_model.CommitStatus{}, pairs)
 	})
 
 	t.Run("Repo 1", func(t *testing.T) {
···
 		pairs, err := git_model.GetLatestCommitStatusForPairs(db.DefaultContext, []git_model.RepoSHA{{RepoID: 1, SHA: "1234123412341234123412341234123412341234"}})
 		require.NoError(t, err)
 
-		assert.EqualValues(t, map[int64][]*git_model.CommitStatus{
+		assert.Equal(t, map[int64][]*git_model.CommitStatus{
 			1: {
 				{
 					ID:          7,
···
 		pairs, err := git_model.GetLatestCommitStatusForPairs(db.DefaultContext, []git_model.RepoSHA{{RepoID: 62, SHA: "774f93df12d14931ea93259ae93418da4482fcc1"}})
 		require.NoError(t, err)
 
-		assert.EqualValues(t, map[int64][]*git_model.CommitStatus{
+		assert.Equal(t, map[int64][]*git_model.CommitStatus{
 			62: {
 				{
 					ID:          8,
···
 		pairs, err := git_model.GetLatestCommitStatusForPairs(db.DefaultContext, []git_model.RepoSHA{{RepoID: 62, SHA: "774f93df12d14931ea93259ae93418da4482fcc"}})
 		require.NoError(t, err)
 
-		assert.EqualValues(t, map[int64][]*git_model.CommitStatus{}, pairs)
+		assert.Equal(t, map[int64][]*git_model.CommitStatus{}, pairs)
 	})
 
 	t.Run("SHA with non-existent repo id", func(t *testing.T) {
···
 		pairs, err := git_model.GetLatestCommitStatusForPairs(db.DefaultContext, []git_model.RepoSHA{{RepoID: 1, SHA: "774f93df12d14931ea93259ae93418da4482fcc1"}})
 		require.NoError(t, err)
 
-		assert.EqualValues(t, map[int64][]*git_model.CommitStatus{}, pairs)
+		assert.Equal(t, map[int64][]*git_model.CommitStatus{}, pairs)
 	})
 }
 
···
 		defer tests.PrintCurrentTest(t)()
 		repoStatuses, err := git_model.GetLatestCommitStatusForRepoCommitIDs(db.DefaultContext, 62, nil)
 		require.NoError(t, err)
-		assert.EqualValues(t, map[string][]*git_model.CommitStatus{}, repoStatuses)
+		assert.Equal(t, map[string][]*git_model.CommitStatus{}, repoStatuses)
 	})
 
 	t.Run("Repo 1", func(t *testing.T) {
 		defer tests.PrintCurrentTest(t)()
 		repoStatuses, err := git_model.GetLatestCommitStatusForRepoCommitIDs(db.DefaultContext, 1, []string{"1234123412341234123412341234123412341234"})
 		require.NoError(t, err)
-		assert.EqualValues(t, map[string][]*git_model.CommitStatus{
+		assert.Equal(t, map[string][]*git_model.CommitStatus{
 			"1234123412341234123412341234123412341234": {
 				{
 					ID:          3,
···
 		defer tests.PrintCurrentTest(t)()
 		repoStatuses, err := git_model.GetLatestCommitStatusForRepoCommitIDs(db.DefaultContext, 62, []string{"774f93df12d14931ea93259ae93418da4482fcc1"})
 		require.NoError(t, err)
-		assert.EqualValues(t, map[string][]*git_model.CommitStatus{
+		assert.Equal(t, map[string][]*git_model.CommitStatus{
 			"774f93df12d14931ea93259ae93418da4482fcc1": {
 				{
 					ID:          8,
···
 		defer tests.PrintCurrentTest(t)()
 		repoStatuses, err := git_model.GetLatestCommitStatusForRepoCommitIDs(db.DefaultContext, 62, []string{"774f93df12d14931ea93259ae93418da4482fcc"})
 		require.NoError(t, err)
-		assert.EqualValues(t, map[string][]*git_model.CommitStatus{}, repoStatuses)
+		assert.Equal(t, map[string][]*git_model.CommitStatus{}, repoStatuses)
 	})
 
 	t.Run("non-existent repo ID", func(t *testing.T) {
 		defer tests.PrintCurrentTest(t)()
 		repoStatuses, err := git_model.GetLatestCommitStatusForRepoCommitIDs(db.DefaultContext, 1, []string{"774f93df12d14931ea93259ae93418da4482fcc"})
 		require.NoError(t, err)
-		assert.EqualValues(t, map[string][]*git_model.CommitStatus{}, repoStatuses)
+		assert.Equal(t, map[string][]*git_model.CommitStatus{}, repoStatuses)
 	})
 }

tests/integration/dump_restore_test.go

···
 		}).([]*base.Comment)
 		assert.True(c.t, ok)
 		for _, comment := range comments {
-			assert.EqualValues(c.t, issue.Number, comment.IssueIndex)
+			assert.Equal(c.t, issue.Number, comment.IssueIndex)
 		}
 	}
 
···
 		comments, ok := c.assertEqual(filename, []base.Comment{}, compareFields{}).([]*base.Comment)
 		assert.True(c.t, ok)
 		for _, comment := range comments {
-			assert.EqualValues(c.t, pr.Number, comment.IssueIndex)
+			assert.Equal(c.t, pr.Number, comment.IssueIndex)
 		}
 	}
 }
···
 func (c *compareDump) assertLoadYAMLFiles(beforeFilename, afterFilename string, before, after any) {
 	_, beforeErr := os.Stat(beforeFilename)
 	_, afterErr := os.Stat(afterFilename)
-	assert.EqualValues(c.t, errors.Is(beforeErr, os.ErrNotExist), errors.Is(afterErr, os.ErrNotExist))
+	assert.Equal(c.t, errors.Is(beforeErr, os.ErrNotExist), errors.Is(afterErr, os.ErrNotExist))
 	if errors.Is(beforeErr, os.ErrNotExist) {
 		return
 	}
···
 }
 
 func (c *compareDump) assertEqualSlices(before, after reflect.Value, fields compareFields) any {
-	assert.EqualValues(c.t, before.Len(), after.Len())
+	assert.Equal(c.t, before.Len(), after.Len())
 	if before.Len() == after.Len() {
 		for i := 0; i < before.Len(); i++ {
 			_ = c.assertEqualValues(
···
 				assert.True(c.t, ok)
 				as, ok := ai.(string)
 				assert.True(c.t, ok)
-				assert.EqualValues(c.t, compare.transform(bs), compare.transform(as))
+				assert.Equal(c.t, compare.transform(bs), compare.transform(as))
 				continue
 			}
 			if compare.before != nil && compare.after != nil {
 				//
 				// The fields are expected to have different values
 				//
-				assert.EqualValues(c.t, compare.before, bi)
-				assert.EqualValues(c.t, compare.after, ai)
+				assert.Equal(c.t, compare.before, bi)
+				assert.Equal(c.t, compare.after, ai)
 				continue
 			}
 			if compare.nested != nil {
···
 				continue
 			}
 		}
-		assert.EqualValues(c.t, bi, ai)
+		assert.Equal(c.t, bi, ai)
 	}
 	return after.Interface()
 }

tests/integration/editor_test.go

···
 		// Check if master branch has been locked successfully
 		flashCookie := session.GetCookie(gitea_context.CookieNameFlash)
 		assert.NotNil(t, flashCookie)
-		assert.EqualValues(t, "success%3DBranch%2Bprotection%2Bfor%2Brule%2B%2522master%2522%2Bhas%2Bbeen%2Bupdated.", flashCookie.Value)
+		assert.Equal(t, "success%3DBranch%2Bprotection%2Bfor%2Brule%2B%2522master%2522%2Bhas%2Bbeen%2Bupdated.", flashCookie.Value)
 
 		// Request editor page
 		req = NewRequest(t, "GET", "/user2/repo1/_new/master/")
···
 
 		res := make(map[string]string)
 		require.NoError(t, json.NewDecoder(resp.Body).Decode(&res))
-		assert.EqualValues(t, "/user2/repo1/settings/branches", res["redirect"])
+		assert.Equal(t, "/user2/repo1/settings/branches", res["redirect"])
 
 		// Check if master branch has been locked successfully
 		flashCookie = session.GetCookie(gitea_context.CookieNameFlash)
 		assert.NotNil(t, flashCookie)
-		assert.EqualValues(t, "error%3DRemoving%2Bbranch%2Bprotection%2Brule%2B%25221%2522%2Bfailed.", flashCookie.Value)
+		assert.Equal(t, "error%3DRemoving%2Bbranch%2Bprotection%2Brule%2B%25221%2522%2Bfailed.", flashCookie.Value)
 	})
 }
 
···
 	// Verify the change
 	req = NewRequest(t, "GET", path.Join(user, repo, "raw/branch", branch, filePath))
 	resp = session.MakeRequest(t, req, http.StatusOK)
-	assert.EqualValues(t, newContent, resp.Body.String())
+	assert.Equal(t, newContent, resp.Body.String())
 
 	return resp
 }
···
 	// Verify the change
 	req = NewRequest(t, "GET", path.Join(user, repo, "raw/branch", targetBranch, filePath))
 	resp = session.MakeRequest(t, req, http.StatusOK)
-	assert.EqualValues(t, newContent, resp.Body.String())
+	assert.Equal(t, newContent, resp.Body.String())
 
 	return resp
 }
···
 
 	placeholder, ok := htmlDoc.Find("input[name='commit_summary']").Attr("placeholder")
 	assert.True(t, ok)
-	assert.EqualValues(t, `Add "<filename>"`, placeholder)
+	assert.Equal(t, `Add "<filename>"`, placeholder)
 }
 
 func TestCommitMail(t *testing.T) {
···
 		assert.False(t, inactivatedMail.IsActivated)
 
 		otherEmail := unittest.AssertExistsAndLoadBean(t, &user_model.EmailAddress{ID: 1, IsActivated: true})
-		assert.NotEqualValues(t, otherEmail.UID, user.ID)
+		assert.NotEqual(t, otherEmail.UID, user.ID)
 
 		primaryEmail := unittest.AssertExistsAndLoadBean(t, &user_model.EmailAddress{ID: 3, UID: user.ID, IsActivated: true})
 
···
 				session.MakeRequest(t, req, http.StatusSeeOther)
 				if !case2.skipLastCommit {
 					newlastCommit, _ := lastCommitAndCSRF(t, case1.link, false)
-					assert.NotEqualValues(t, newlastCommit, lastCommit)
+					assert.NotEqual(t, newlastCommit, lastCommit)
 				}
 
 				commit, err := gitRepo.GetCommitByPath(case1.fileName)
 				require.NoError(t, err)
 
-				assert.EqualValues(t, "user2", commit.Author.Name)
-				assert.EqualValues(t, "[e-mail]", commit.Author.Email)
-				assert.EqualValues(t, "user2", commit.Committer.Name)
-				assert.EqualValues(t, "[e-mail]", commit.Committer.Email)
+				assert.Equal(t, "user2", commit.Author.Name)
+				assert.Equal(t, "[e-mail]", commit.Author.Email)
+				assert.Equal(t, "user2", commit.Committer.Name)
+				assert.Equal(t, "[e-mail]", commit.Committer.Email)
 			})
 
 			t.Run("Normal", func(t *testing.T) {
···
 				session.MakeRequest(t, req, http.StatusSeeOther)
 				if !case2.skipLastCommit {
 					newlastCommit, _ := lastCommitAndCSRF(t, case2.link, false)
-					assert.NotEqualValues(t, newlastCommit, lastCommit)
+					assert.NotEqual(t, newlastCommit, lastCommit)
 				}
 
 				commit, err := gitRepo.GetCommitByPath(case2.fileName)
 				require.NoError(t, err)
 
-				assert.EqualValues(t, "user2", commit.Author.Name)
-				assert.EqualValues(t, primaryEmail.Email, commit.Author.Email)
-				assert.EqualValues(t, "user2", commit.Committer.Name)
-				assert.EqualValues(t, primaryEmail.Email, commit.Committer.Email)
+				assert.Equal(t, "user2", commit.Author.Name)
+				assert.Equal(t, primaryEmail.Email, commit.Author.Email)
+				assert.Equal(t, "user2", commit.Committer.Name)
+				assert.Equal(t, primaryEmail.Email, commit.Committer.Email)
 			})
 		}
 

tests/integration/empty_repo_test.go

···
 	var fileResponse api.FileResponse
 	DecodeJSON(t, resp, &fileResponse)
 	expectedHTMLURL := setting.AppURL + "user30/empty/src/branch/new_branch/new-file.txt"
-	assert.EqualValues(t, expectedHTMLURL, *fileResponse.Content.HTMLURL)
+	assert.Equal(t, expectedHTMLURL, *fileResponse.Content.HTMLURL)
 
 	req = NewRequest(t, "GET", "/user30/empty/src/branch/new_branch/new-file.txt")
 	resp = session.MakeRequest(t, req, http.StatusOK)

tests/integration/explore_repos_test.go

···
 		resp := MakeRequest(t, req, http.StatusOK)
 		htmlDoc := NewHTMLParser(t, resp.Body).Find("#repo-search-form")
 
-		assert.EqualValues(t, "Go", htmlDoc.Find("input[name='language']").AttrOr("value", "not found"))
-		assert.EqualValues(t, "true", htmlDoc.Find("input[name='topic']").AttrOr("value", "not found"))
+		assert.Equal(t, "Go", htmlDoc.Find("input[name='language']").AttrOr("value", "not found"))
+		assert.Equal(t, "true", htmlDoc.Find("input[name='topic']").AttrOr("value", "not found"))
 	})
 }

tests/integration/feed_repo_test.go

···
 		assert.Contains(t, rss.Channel.Link, "/user2/repo1")
 		assert.NotEmpty(t, rss.Channel.PubDate)
 		assert.Len(t, rss.Channel.Items, 1)
-		assert.EqualValues(t, "issue5", rss.Channel.Items[0].Description)
+		assert.Equal(t, "issue5", rss.Channel.Items[0].Description)
 		assert.NotEmpty(t, rss.Channel.Items[0].PubDate)
 	})
 }

tests/integration/forgejo_confirmation_repo_test.go

···
 
 			flashCookie := session.GetCookie(gitea_context.CookieNameFlash)
 			assert.NotNil(t, flashCookie)
-			assert.EqualValues(t, "success%3DThis%2Brepository%2Bhas%2Bbeen%2Bmarked%2Bfor%2Btransfer%2Band%2Bawaits%2Bconfirmation%2Bfrom%2B%2522User%2BOne%2522", flashCookie.Value)
+			assert.Equal(t, "success%3DThis%2Brepository%2Bhas%2Bbeen%2Bmarked%2Bfor%2Btransfer%2Band%2Bawaits%2Bconfirmation%2Bfrom%2B%2522User%2BOne%2522", flashCookie.Value)
 		})
 	})
 
···
 
 			flashCookie := session.GetCookie(gitea_context.CookieNameFlash)
 			assert.NotNil(t, flashCookie)
-			assert.EqualValues(t, "success%3DThe%2Bfork%2Bhas%2Bbeen%2Bconverted%2Binto%2Ba%2Bregular%2Brepository.", flashCookie.Value)
+			assert.Equal(t, "success%3DThe%2Bfork%2Bhas%2Bbeen%2Bconverted%2Binto%2Ba%2Bregular%2Brepository.", flashCookie.Value)
 		})
 	})
 
···
 
 			flashCookie := session.GetCookie(gitea_context.CookieNameFlash)
 			assert.NotNil(t, flashCookie)
-			assert.EqualValues(t, "success%3DThe%2Brepository%2Bwiki%2527s%2Bbranch%2Bname%2Bhas%2Bbeen%2Bsuccessfully%2Bnormalized.", flashCookie.Value)
+			assert.Equal(t, "success%3DThe%2Brepository%2Bwiki%2527s%2Bbranch%2Bname%2Bhas%2Bbeen%2Bsuccessfully%2Bnormalized.", flashCookie.Value)
 		})
 	})
 
···
 
 			flashCookie := session.GetCookie(gitea_context.CookieNameFlash)
 			assert.NotNil(t, flashCookie)
-			assert.EqualValues(t, "success%3DThe%2Brepository%2Bwiki%2Bdata%2Bhas%2Bbeen%2Bdeleted.", flashCookie.Value)
+			assert.Equal(t, "success%3DThe%2Brepository%2Bwiki%2Bdata%2Bhas%2Bbeen%2Bdeleted.", flashCookie.Value)
 		})
 	})
 
···
 
 			flashCookie := session.GetCookie(gitea_context.CookieNameFlash)
 			assert.NotNil(t, flashCookie)
-			assert.EqualValues(t, "success%3DThe%2Brepository%2Bhas%2Bbeen%2Bdeleted.", flashCookie.Value)
+			assert.Equal(t, "success%3DThe%2Brepository%2Bhas%2Bbeen%2Bdeleted.", flashCookie.Value)
 		})
 	})
 }

tests/integration/git_push_test.go

···
 
 	dbBranches := make([]*git_model.Branch, 0)
 	require.NoError(t, db.GetEngine(db.DefaultContext).Where("repo_id=?", repo.ID).Find(&dbBranches))
-	assert.Equalf(t, len(pushedBranches), len(dbBranches), "mismatched number of branches in db")
+	assert.Lenf(t, dbBranches, len(pushedBranches), "mismatched number of branches in db")
 	dbBranchesMap := make(map[string]*git_model.Branch, len(dbBranches))
 	for _, branch := range dbBranches {
 		dbBranchesMap[branch.Name] = branch

tests/integration/git_smart_http_test.go

···
 			resp, err := http.DefaultClient.Do(req)
 			require.NoError(t, err)
 			defer resp.Body.Close()
-			assert.EqualValues(t, kase.code, resp.StatusCode)
+			assert.Equal(t, kase.code, resp.StatusCode)
 			_, err = io.ReadAll(resp.Body)
 			require.NoError(t, err)
 		})

tests/integration/git_test.go

···
 		// Check if master branch has been locked successfully
 		flashCookie := ctx.Session.GetCookie(gitea_context.CookieNameFlash)
 		assert.NotNil(t, flashCookie)
-		assert.EqualValues(t, "success%3DBranch%2Bprotection%2Bfor%2Brule%2B%2522"+url.QueryEscape(branch)+"%2522%2Bhas%2Bbeen%2Bupdated.", flashCookie.Value)
+		assert.Equal(t, "success%3DBranch%2Bprotection%2Bfor%2Brule%2B%2522"+url.QueryEscape(branch)+"%2522%2Bhas%2Bbeen%2Bupdated.", flashCookie.Value)
 	}
 }
 
···
 		doc := NewHTMLParser(t, resp.Body)
 		editButtonCount := doc.doc.Find("div.diff-file-header-actions a[href*='/_edit/']").Length()
 		if editable {
-			assert.Positive(t, editButtonCount, 0, "Expected to find a button to edit a file in the PR diff view but there were none")
+			assert.Positive(t, editButtonCount, "Expected to find a button to edit a file in the PR diff view but there were none")
 		} else {
 			assert.Equal(t, 0, editButtonCount, "Expected not to find any buttons to edit files in PR diff view but there were some")
 		}
···
 
 				currentHeadCommitID, err := upstreamGitRepo.GetRefCommitID(pr.GetGitRefName())
 				require.NoError(t, err)
-				assert.EqualValues(t, headCommitID, currentHeadCommitID)
+				assert.Equal(t, headCommitID, currentHeadCommitID)
 			})
 			t.Run("Succeeds", func(t *testing.T) {
 				defer tests.PrintCurrentTest(t)()
···
 
 				currentHeadCommitID, err := upstreamGitRepo.GetRefCommitID(pr.GetGitRefName())
 				require.NoError(t, err)
-				assert.NotEqualValues(t, headCommitID, currentHeadCommitID)
+				assert.NotEqual(t, headCommitID, currentHeadCommitID)
 			})
 		})
 

tests/integration/gpg_git_test.go

···
 				t, testCtx, user, "master", "always", "signed-always.txt", func(t *testing.T, response api.FileResponse) {
 					assert.NotNil(t, response.Verification)
 					if response.Verification == nil {
-						assert.FailNow(t, "no verification provided with response! %v", response)
+						assert.FailNow(t, "no verification provided with response", "response: %v", response)
 					}
 					assert.True(t, response.Verification.Verified)
 					if !response.Verification.Verified {
···
 				t, testCtx, user, "parentsigned", "parentsigned-always", "signed-parent2.txt", func(t *testing.T, response api.FileResponse) {
 					assert.NotNil(t, response.Verification)
 					if response.Verification == nil {
-						assert.FailNow(t, "no verification provided with response! %v", response)
+						assert.FailNow(t, "no verification provided with response", "response: %v", response)
 					}
 					assert.True(t, response.Verification.Verified)
 					if !response.Verification.Verified {
···
 				t, testCtx, user, "always", "always-parentsigned", "signed-always-parentsigned.txt", func(t *testing.T, response api.FileResponse) {
 					assert.NotNil(t, response.Verification)
 					if response.Verification == nil {
-						assert.FailNow(t, "no verification provided with response! %v", response)
+						assert.FailNow(t, "no verification provided with response", "response: %v", response)
 					}
 					assert.True(t, response.Verification.Verified)
 					if !response.Verification.Verified {
···
 			t.Run("CheckMasterBranchSigned", doAPIGetBranch(testCtx, "master", func(t *testing.T, branch api.Branch) {
 				assert.NotNil(t, branch.Commit)
 				if branch.Commit == nil {
-					assert.FailNow(t, "no commit provided with branch! %v", branch)
+					assert.FailNow(t, "no commit provided with branch", "branch: %v", branch)
 				}
 				assert.NotNil(t, branch.Commit.Verification)
 				if branch.Commit.Verification == nil {
-					assert.FailNow(t, "no verification provided with branch commit! %v", branch.Commit)
+					assert.FailNow(t, "no verification provided with branch commit", "commit: %v", branch.Commit)
 				}
 				assert.True(t, branch.Commit.Verification.Verified)
 				if !branch.Commit.Verification.Verified {

tests/integration/html_helper.go

···
 	t.Helper()
 
 	options := doc.AssertDropdown(t, dropdownName).Find(".menu [data-value]:not([data-value=''])")
-	assert.Positive(t, options.Length(), 0, fmt.Sprintf("%s dropdown has no options", dropdownName))
+	assert.Positive(t, options.Length(), "%s dropdown has no options", dropdownName)
 }
 
 func (doc *HTMLDoc) AssertDropdownHasSelectedOption(t testing.TB, dropdownName, expectedValue string) {

tests/integration/incoming_email_test.go

···
 		ref, err := incoming_payload.GetReferenceFromPayload(db.DefaultContext, issuePayload)
 		require.NoError(t, err)
 		assert.IsType(t, ref, new(issues_model.Issue))
-		assert.EqualValues(t, issue.ID, ref.(*issues_model.Issue).ID)
+		assert.Equal(t, issue.ID, ref.(*issues_model.Issue).ID)
 
 		ref, err = incoming_payload.GetReferenceFromPayload(db.DefaultContext, commentPayload)
 		require.NoError(t, err)
 		assert.IsType(t, ref, new(issues_model.Comment))
-		assert.EqualValues(t, comment.ID, ref.(*issues_model.Comment).ID)
+		assert.Equal(t, comment.ID, ref.(*issues_model.Comment).ID)
 	})
 
 	t.Run("Token", func(t *testing.T) {

tests/integration/integration_test.go

···
 	}
 	testWebRoutes.ServeHTTP(recorder, req)
 	if expectedStatus != NoExpectedStatus {
-		if !assert.EqualValues(t, expectedStatus, recorder.Code, "Request: %s %s", req.Method, req.URL.String()) {
+		if !assert.Equal(t, expectedStatus, recorder.Code, "Request: %s %s", req.Method, req.URL.String()) {
 			logUnexpectedResponse(t, recorder)
 		}
 	}
···
 	recorder := NewNilResponseRecorder()
 	testWebRoutes.ServeHTTP(recorder, req)
 	if expectedStatus != NoExpectedStatus {
-		if !assert.EqualValues(t, expectedStatus, recorder.Code,
+		if !assert.Equal(t, expectedStatus, recorder.Code,
 			"Request: %s %s", req.Method, req.URL.String()) {
 			logUnexpectedResponse(t, &recorder.ResponseRecorder)
 		}
···
 	recorder := NewNilResponseHashSumRecorder()
 	testWebRoutes.ServeHTTP(recorder, req)
 	if expectedStatus != NoExpectedStatus {
-		if !assert.EqualValues(t, expectedStatus, recorder.Code,
+		if !assert.Equal(t, expectedStatus, recorder.Code,
 			"Request: %s %s", req.Method, req.URL.String()) {
 			logUnexpectedResponse(t, &recorder.ResponseRecorder)
 		}

tests/integration/issue_subscribe_test.go

···
 	resp := session.MakeRequest(t, NewRequest(t, "GET", path.Join(testIssue)), http.StatusOK)
 	area := NewHTMLParser(t, resp.Body).Find(selector)
 	tooltip, exists := area.Attr("data-tooltip-content")
-	assert.EqualValues(t, unavailable, exists)
+	assert.Equal(t, unavailable, exists)
 	if unavailable {
-		assert.EqualValues(t, "Sign in to subscribe to this issue.", tooltip)
+		assert.Equal(t, "Sign in to subscribe to this issue.", tooltip)
 	}
 
 	resp = session.MakeRequest(t, NewRequest(t, "GET", path.Join(testPull)), http.StatusOK)
 	area = NewHTMLParser(t, resp.Body).Find(selector)
 	tooltip, exists = area.Attr("data-tooltip-content")
-	assert.EqualValues(t, unavailable, exists)
+	assert.Equal(t, unavailable, exists)
 	if unavailable {
-		assert.EqualValues(t, "Sign in to subscribe to this pull request.", tooltip)
+		assert.Equal(t, "Sign in to subscribe to this pull request.", tooltip)
 	}
 }

tests/integration/issue_test.go

···
 
 func getIssuesSelection(t testing.TB, htmlDoc *HTMLDoc) *goquery.Selection {
 	issueList := htmlDoc.doc.Find("#issue-list")
-	assert.EqualValues(t, 1, issueList.Length())
+	assert.Equal(t, 1, issueList.Length())
 	return issueList.Find(".flex-item").Find(".issue-title")
 }
 
···
 	if expectedNumIssues > setting.UI.IssuePagingNum {
 		expectedNumIssues = setting.UI.IssuePagingNum
 	}
-	assert.EqualValues(t, expectedNumIssues, issuesSelection.Length())
+	assert.Equal(t, expectedNumIssues, issuesSelection.Length())
 
 	issuesSelection.Each(func(_ int, selection *goquery.Selection) {
 		issue := getIssue(t, repo.ID, selection)
-		assert.EqualValues(t, user.ID, issue.PosterID)
+		assert.Equal(t, user.ID, issue.PosterID)
 	})
 }
 
···
 
 	htmlDoc := NewHTMLParser(t, resp.Body)
 	issuesSelection := getIssuesSelection(t, htmlDoc)
-	assert.EqualValues(t, 1, issuesSelection.Length())
+	assert.Equal(t, 1, issuesSelection.Length())
 	issuesSelection.Each(func(_ int, selection *goquery.Selection) {
 		issue := getIssue(t, repo.ID, selection)
 		assert.False(t, issue.IsClosed)
···
 	resp = MakeRequest(t, req, http.StatusOK)
 	htmlDoc = NewHTMLParser(t, resp.Body)
 	issuesSelection = getIssuesSelection(t, htmlDoc)
-	assert.EqualValues(t, 0, issuesSelection.Length())
+	assert.Equal(t, 0, issuesSelection.Length())
 
 	// should match as 'first' when using a standard query
 	req = NewRequestf(t, "GET", "%s/issues?q=%st", repo.Link(), keyword)
 	resp = MakeRequest(t, req, http.StatusOK)
 	htmlDoc = NewHTMLParser(t, resp.Body)
 	issuesSelection = getIssuesSelection(t, htmlDoc)
-	assert.EqualValues(t, 1, issuesSelection.Length())
+	assert.Equal(t, 1, issuesSelection.Length())
 	issuesSelection.Each(func(_ int, selection *goquery.Selection) {
 		issue := getIssue(t, repo.ID, selection)
 		assert.False(t, issue.IsClosed)
···
 		resp := MakeRequest(t, req, http.StatusOK)
 		htmlDoc := NewHTMLParser(t, resp.Body)
 		issuesSelection := getIssuesSelection(t, htmlDoc)
-		assert.EqualValues(t, 3, issuesSelection.Length())
+		assert.Equal(t, 3, issuesSelection.Length())
 	})
 
 	t.Run("Issues with no project", func(t *testing.T) {
···
 		resp := MakeRequest(t, req, http.StatusOK)
 		htmlDoc := NewHTMLParser(t, resp.Body)
 		issuesSelection := getIssuesSelection(t, htmlDoc)
-		assert.EqualValues(t, 1, issuesSelection.Length())
+		assert.Equal(t, 1, issuesSelection.Length())
 		issuesSelection.Each(func(_ int, selection *goquery.Selection) {
 			issue := getIssue(t, repo.ID, selection)
 			assert.Equal(t, issueNoProject.ID, issue.ID)
···
 		resp := MakeRequest(t, req, http.StatusOK)
 		htmlDoc := NewHTMLParser(t, resp.Body)
 		issuesSelection := getIssuesSelection(t, htmlDoc)
-		assert.EqualValues(t, 2, issuesSelection.Length())
+		assert.Equal(t, 2, issuesSelection.Length())
 		found := map[int64]bool{
 			1: false,
 			5: false,
···
 
 		if hasDependency {
 			assert.NotEmpty(t, issues)
-			assert.EqualValues(t, issues[0].Index, dependencyID)
+			assert.Equal(t, issues[0].Index, dependencyID)
 		} else {
 			assert.Empty(t, issues)
 		}
···
 	session.MakeRequest(t, req, http.StatusOK)
 
 	comment = unittest.AssertExistsAndLoadBean(t, &issues_model.Comment{ID: commentID})
-	assert.Equal(t, "", comment.Content)
+	assert.Empty(t, comment.Content)
 }
 
 func TestIssueCommentUpdateSimultaneously(t *testing.T) {
···
 	req = NewRequest(t, "GET", link.String())
 	resp = session.MakeRequest(t, req, http.StatusOK)
 	DecodeJSON(t, resp, &apiIssues)
-	assert.EqualValues(t, "22", resp.Header().Get("X-Total-Count"))
+	assert.Equal(t, "22", resp.Header().Get("X-Total-Count"))
 	assert.Len(t, apiIssues, 20)
 
 	query.Add("limit", "5")
···
 	req = NewRequest(t, "GET", link.String())
 	resp = session.MakeRequest(t, req, http.StatusOK)
 	DecodeJSON(t, resp, &apiIssues)
-	assert.EqualValues(t, "22", resp.Header().Get("X-Total-Count"))
+	assert.Equal(t, "22", resp.Header().Get("X-Total-Count"))
 	assert.Len(t, apiIssues, 5)
 
 	query = url.Values{"assigned": {"true"}, "state": {"all"}}
···
 	var apiIssue api.Issue
 	DecodeJSON(t, resp, &apiIssue)
 
-	assert.EqualValues(t, issue.ID, apiIssue.ID)
+	assert.Equal(t, issue.ID, apiIssue.ID)
 }
 
 func TestIssuePinMove(t *testing.T) {
 	defer tests.PrepareTestEnv(t)()
 	session := loginUser(t, "user2")
 	issueURL, issue := testIssueWithBean(t, "user2", 1, "Title", "Content")
-	assert.EqualValues(t, 0, issue.PinOrder)
+	assert.Equal(t, 0, issue.PinOrder)
 
 	req := NewRequestWithValues(t, "POST", fmt.Sprintf("%s/pin", issueURL), map[string]string{
 		"_csrf": GetCSRF(t, session, issueURL),
···
 	issue = unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: issue.ID})
 
 	position := 1
-	assert.EqualValues(t, position, issue.PinOrder)
+	assert.Equal(t, position, issue.PinOrder)
 
 	newPosition := 2
 
···
 		session5.MakeRequest(t, req, http.StatusNotFound)
 
 		issue = unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: issue.ID})
-		assert.EqualValues(t, position, issue.PinOrder)
+		assert.Equal(t, position, issue.PinOrder)
 	}
 
 	movePinURL := issueURL[:strings.LastIndexByte(issueURL, '/')] + "/move_pin?_csrf=" + GetCSRF(t, session, issueURL)
···
 	session.MakeRequest(t, req, http.StatusNoContent)
 
 	issue = unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: issue.ID})
-	assert.EqualValues(t, newPosition, issue.PinOrder)
+	assert.Equal(t, newPosition, issue.PinOrder)
 }
 
 func TestUpdateIssueDeadline(t *testing.T) {
···
 	var apiIssue api.IssueDeadline
 	DecodeJSON(t, resp, &apiIssue)
 
-	assert.EqualValues(t, "2022-04-06", apiIssue.Deadline.Format("2006-01-02"))
+	assert.Equal(t, "2022-04-06", apiIssue.Deadline.Format("2006-01-02"))
 }
 
 func TestUpdateIssueTitle(t *testing.T) {
···
 			}{}
 
 			DecodeJSON(t, resp, &issueAfter)
-			assert.EqualValues(t, issueTitleUpdateTest.title, issueAfter.Title)
+			assert.Equal(t, issueTitleUpdateTest.title, issueAfter.Title)
 		}
 	}
 }
···
 
 	// the "reference" uses relative URLs, then JS code will convert them to absolute URLs for current origin, in case users are using multiple domains
 	ref, _ := htmlDoc.Find(`.timeline-item.comment.first .reference-issue`).Attr("data-reference")
-	assert.EqualValues(t, "/user2/repo1/issues/1#issue-1", ref)
+	assert.Equal(t, "/user2/repo1/issues/1#issue-1", ref)
 
 	ref, _ = htmlDoc.Find(`.timeline-item.comment:not(.first) .reference-issue`).Attr("data-reference")
-	assert.EqualValues(t, "/user2/repo1/issues/1#issuecomment-2", ref)
+	assert.Equal(t, "/user2/repo1/issues/1#issuecomment-2", ref)
 }
 
 func TestGetContentHistory(t *testing.T) {
···
 		var respJSON contentHistoryResp
 		DecodeJSON(t, resp, &respJSON)
 
-		assert.EqualValues(t, canDelete, respJSON.CanSoftDelete)
+		assert.Equal(t, canDelete, respJSON.CanSoftDelete)
 		assert.EqualValues(t, contentHistory.ID, respJSON.HistoryID)
 		assert.EqualValues(t, contentHistory.ID-1, respJSON.PrevHistoryID)
 	}
···
 		DecodeJSON(t, resp, &data)
 
 		assert.Len(t, data.Results, 1)
-		assert.EqualValues(t, "user2", data.Results[0].UserName)
+		assert.Equal(t, "user2", data.Results[0].UserName)
 		assert.EqualValues(t, 2, data.Results[0].UserID)
 	})
 
···
 		DecodeJSON(t, resp, &data)
 
 		assert.Len(t, data.Results, 1)
-		assert.EqualValues(t, "user1", data.Results[0].UserName)
+		assert.Equal(t, "user1", data.Results[0].UserName)
 		assert.EqualValues(t, 1, data.Results[0].UserID)
 	})
 }

tests/integration/links_test.go

···
 	for link, redirectLink := range redirects {
 		req := NewRequest(t, "GET", link)
 		resp := MakeRequest(t, req, http.StatusSeeOther)
-		assert.EqualValues(t, path.Join(setting.AppSubURL, redirectLink), test.RedirectURL(resp))
+		assert.Equal(t, path.Join(setting.AppSubURL, redirectLink), test.RedirectURL(resp))
 	}
 }
 
···
 		for _, info := range redirects {
 			req := NewRequest(t, info.verb, info.from)
 			resp := MakeRequest(t, req, http.StatusSeeOther)
-			assert.EqualValues(t, path.Join(setting.AppSubURL, info.to), test.RedirectURL(resp), info.from)
+			assert.Equal(t, path.Join(setting.AppSubURL, info.to), test.RedirectURL(resp), info.from)
 		}
 	}
 

tests/integration/markup_external_test.go

···
 	const repoURL = "user30/renderer"
 	req := NewRequest(t, "GET", repoURL+"/src/branch/master/README.html")
 	resp := MakeRequest(t, req, http.StatusOK)
-	assert.EqualValues(t, "text/html; charset=utf-8", resp.Header()["Content-Type"][0])
+	assert.Equal(t, "text/html; charset=utf-8", resp.Header()["Content-Type"][0])
 
 	bs, err := io.ReadAll(resp.Body)
 	require.NoError(t, err)
···
 	div := doc.Find("div.file-view")
 	data, err := div.Html()
 	require.NoError(t, err)
-	assert.EqualValues(t, "<div>\n\ttest external renderer\n</div>", strings.TrimSpace(data))
+	assert.Equal(t, "<div>\n\ttest external renderer\n</div>", strings.TrimSpace(data))
 }

tests/integration/migrate_test.go

···
 				})
 				resp = session.MakeRequest(t, req, http.StatusSeeOther)
 				// Step 5: a redirection displays the migrated repository
-				assert.EqualValues(t, fmt.Sprintf("/%s/%s", ownerName, migratedRepoName), test.RedirectURL(resp))
+				assert.Equal(t, fmt.Sprintf("/%s/%s", ownerName, migratedRepoName), test.RedirectURL(resp))
 				// Step 6: check the repo was created
 				unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{Name: migratedRepoName})
 			})
···
 				})
 				resp = session.MakeRequest(t, req, http.StatusSeeOther)
 				// Step 5: a redirection displays the migrated repository
-				assert.EqualValues(t, fmt.Sprintf("/%s/%s", user.Name, migratedRepoName), test.RedirectURL(resp))
+				assert.Equal(t, fmt.Sprintf("/%s/%s", user.Name, migratedRepoName), test.RedirectURL(resp))
 				// Step 6: check the repo was created and load the repo
 				migratedRepo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{Name: migratedRepoName, WikiBranch: "obscure-name"})
 				// Step 7: check if the wiki is enabled
···
 				})
 				resp = session.MakeRequest(t, req, http.StatusSeeOther)
 				// Step 5: a redirection displays the migrated repository
-				assert.EqualValues(t, fmt.Sprintf("/%s/%s", ownerName, migratedRepoName), test.RedirectURL(resp))
+				assert.Equal(t, fmt.Sprintf("/%s/%s", ownerName, migratedRepoName), test.RedirectURL(resp))
 				// Step 6: check the repo was created and load the repo
 				migratedRepo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{Name: migratedRepoName})
 				// Step 7: check if releases are enabled

tests/integration/mirror_pull_test.go

···
 
 	count, err := db.Count[repo_model.Release](db.DefaultContext, findOptions)
 	require.NoError(t, err)
-	assert.EqualValues(t, initCount+1, count)
+	assert.Equal(t, initCount+1, count)
 
 	release, err := repo_model.GetRelease(db.DefaultContext, repo.ID, "v0.2")
 	require.NoError(t, err)
···
 
 	count, err = db.Count[repo_model.Release](db.DefaultContext, findOptions)
 	require.NoError(t, err)
-	assert.EqualValues(t, initCount, count)
+	assert.Equal(t, initCount, count)
 }

tests/integration/mirror_push_test.go

···
 				htmlDoc := NewHTMLParser(t, resp.Body)
 
 				publickey = htmlDoc.Find(".ui.table td a[data-clipboard-text]").AttrOr("data-clipboard-text", "")
-				assert.EqualValues(t, publickey, pushMirror.GetPublicKey())
+				assert.Equal(t, publickey, pushMirror.GetPublicKey())
 			})
 
 			t.Run("Add deploy key", func(t *testing.T) {

tests/integration/new_org_test.go

···
 
 		// Verify page header
 		header := strings.TrimSpace(page.Find(".form[action='/org/create'] .header").Text())
-		assert.EqualValues(t, locale.TrString("new_org.title"), header)
+		assert.Equal(t, locale.TrString("new_org.title"), header)
 	})
 }

tests/integration/oauth_test.go

···
 			return c.Value
 		}
 	}
-	require.True(t, false, "_csrf not found in cookies")
+	require.Fail(t, "_csrf not found in cookies")
 	return ""
 }
 

tests/integration/opengraph_test.go

···
 				foundProps[prop] = content
 			})
 
-			assert.EqualValues(t, tc.expected, foundProps, "mismatching opengraph properties")
+			assert.Equal(t, tc.expected, foundProps, "mismatching opengraph properties")
 		})
 	}
 }

tests/integration/org_nav_test.go

···
 
 	// Verify the "New repository" and "New migration" buttons
 	links := doc.Find(".organization.profile .grid .column .center")
-	assert.EqualValues(t, locale.TrString("new_repo.link"), strings.TrimSpace(links.Find("a[href^='/repo/create?org=']").Text()))
-	assert.EqualValues(t, locale.TrString("new_migrate.link"), strings.TrimSpace(links.Find("a[href^='/repo/migrate?org=']").Text()))
+	assert.Equal(t, locale.TrString("new_repo.link"), strings.TrimSpace(links.Find("a[href^='/repo/create?org=']").Text()))
+	assert.Equal(t, locale.TrString("new_migrate.link"), strings.TrimSpace(links.Find("a[href^='/repo/migrate?org=']").Text()))
 
 	// Check if the "View <orgname>" button is available on dashboard for the org admin (member)
 	resp = session1.MakeRequest(t, NewRequest(t, "GET", "/org/org_navigation_test/dashboard"), http.StatusOK)

tests/integration/org_test.go

···
 				sel := htmlDoc.doc.Find("a.name")
 				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()))
+					assert.Equal(t, repos[i], strings.TrimSpace(sel.Eq(i).Text()))
 				}
 			}
 		})

tests/integration/private_project_test.go

···
 		htmlDoc = NewHTMLParser(t, resp.Body)
 		issueCardsLen := htmlDoc.Find(".project-column .issue-card").Length()
 		if hasAccess {
-			assert.EqualValues(t, 2, issueCardsLen)
+			assert.Equal(t, 2, issueCardsLen)
 		} else {
-			assert.EqualValues(t, 1, issueCardsLen)
+			assert.Equal(t, 1, issueCardsLen)
 			// Ensure that the public issue is shown.
-			assert.EqualValues(t, publicIssueHref[0], htmlDoc.Find(".project-column .issue-card .issue-card-title").AttrOr("href", ""))
+			assert.Equal(t, publicIssueHref[0], htmlDoc.Find(".project-column .issue-card .issue-card-title").AttrOr("href", ""))
 		}
 
 		// And that the issue count is correct.
 		issueCount := strings.TrimSpace(htmlDoc.Find(".project-column-issue-count").Text())
 		if hasAccess {
-			assert.EqualValues(t, "2", issueCount)
+			assert.Equal(t, "2", issueCount)
 		} else {
-			assert.EqualValues(t, "1", issueCount)
+			assert.Equal(t, "1", issueCount)
 		}
 	}
 

tests/integration/project_test.go

···
 	columnsAfter, err := project1.GetColumns(db.DefaultContext)
 	require.NoError(t, err)
 	assert.Len(t, columns, 3)
-	assert.EqualValues(t, columns[1].ID, columnsAfter[0].ID)
-	assert.EqualValues(t, columns[2].ID, columnsAfter[1].ID)
-	assert.EqualValues(t, columns[0].ID, columnsAfter[2].ID)
+	assert.Equal(t, columns[1].ID, columnsAfter[0].ID)
+	assert.Equal(t, columns[2].ID, columnsAfter[1].ID)
+	assert.Equal(t, columns[0].ID, columnsAfter[2].ID)
 
 	require.NoError(t, project_model.DeleteProjectByID(db.DefaultContext, project1.ID))
 }

tests/integration/pull_compare_test.go

···
 
 	req = NewRequest(t, "GET", link)
 	resp = session.MakeRequest(t, req, http.StatusOK)
-	assert.EqualValues(t, http.StatusOK, resp.Code)
+	assert.Equal(t, http.StatusOK, resp.Code)
 }

tests/integration/pull_create_test.go

···
 
 			respChildPR := testPullCreateDirectly(t, session, "user2", "repo1", "master", "user1", "repo1", "recent-push", "Child Pull Request")
 			elemChildPR := strings.Split(test.RedirectURL(respChildPR), "/")
-			assert.EqualValues(t, "user2", elemChildPR[1])
-			assert.EqualValues(t, "repo1", elemChildPR[2])
-			assert.EqualValues(t, "pulls", elemChildPR[3])
+			assert.Equal(t, "user2", elemChildPR[1])
+			assert.Equal(t, "repo1", elemChildPR[2])
+			assert.Equal(t, "pulls", elemChildPR[3])
 			session2 := loginUser(t, "user2")
 			// Merge the PR from the fork
 			testPullMerge(t, session2, elemChildPR[1], elemChildPR[2], elemChildPR[4], repo_model.MergeStyleSquash, false)
 
 			respBasePR := testPullCreate(t, session, "user2", "repo1", true, "master", "recent-push-base", "Base Pull Request")
 			elemBasePR := strings.Split(test.RedirectURL(respBasePR), "/")
-			assert.EqualValues(t, "pulls", elemBasePR[3])
+			assert.Equal(t, "pulls", elemBasePR[3])
 			// Leave the PR from the base repo open (it conflicts with the PR from the fork anyway)
 
 			// Count recently pushed branches on the base repo

tests/integration/pull_merge_test.go

···
 		}{}
 		DecodeJSON(t, resp, &respJSON)
 
-		assert.EqualValues(t, fmt.Sprintf("/%s/%s/pulls/%s", user, repo, pullnum), respJSON.Redirect)
+		assert.Equal(t, fmt.Sprintf("/%s/%s/pulls/%s", user, repo, pullnum), respJSON.Redirect)
 	}
 
 	return resp
···
 		resp := testPullCreate(t, session, "user1", "repo1", false, "master", "master", "This is a pull title")
 
 		elem := strings.Split(test.RedirectURL(resp), "/")
-		assert.EqualValues(t, "pulls", elem[3])
+		assert.Equal(t, "pulls", elem[3])
 		testPullMerge(t, session, elem[1], elem[2], elem[4], repo_model.MergeStyleMerge, false)
 
 		hookTasks = retrieveHookTasks(t, 1, false)
···
 		resp := testPullCreate(t, session, "user1", "repo1", false, "master", "master", "This is a pull title")
 
 		elem := strings.Split(test.RedirectURL(resp), "/")
-		assert.EqualValues(t, "pulls", elem[3])
+		assert.Equal(t, "pulls", elem[3])
 		testPullMerge(t, session, elem[1], elem[2], elem[4], repo_model.MergeStyleRebase, false)
 
 		hookTasks = retrieveHookTasks(t, 1, false)
···
 		resp := testPullCreate(t, session, "user1", "repo1", false, "master", "master", "This is a pull title")
 
 		elem := strings.Split(test.RedirectURL(resp), "/")
-		assert.EqualValues(t, "pulls", elem[3])
+		assert.Equal(t, "pulls", elem[3])
 		testPullMerge(t, session, elem[1], elem[2], elem[4], repo_model.MergeStyleRebaseMerge, false)
 
 		hookTasks = retrieveHookTasks(t, 1, false)
···
 		resp := testPullCreate(t, session, "user1", "repo1", false, "master", "master", "This is a pull title")
 
 		elem := strings.Split(test.RedirectURL(resp), "/")
-		assert.EqualValues(t, "pulls", elem[3])
+		assert.Equal(t, "pulls", elem[3])
 		testPullMerge(t, session, elem[1], elem[2], elem[4], repo_model.MergeStyleSquash, false)
 
 		hookTasks = retrieveHookTasks(t, 1, false)
···
 		resp := testPullCreate(t, session, "user1", "repo1", false, "master", "feature/test", "This is a pull title")
 
 		elem := strings.Split(test.RedirectURL(resp), "/")
-		assert.EqualValues(t, "pulls", elem[3])
+		assert.Equal(t, "pulls", elem[3])
 		testPullMerge(t, session, elem[1], elem[2], elem[4], repo_model.MergeStyleMerge, false)
 
 		// Check PR branch deletion
···
 		assert.NotEmpty(t, respJSON.Redirect, "Redirected URL is not found")
 
 		elem = strings.Split(respJSON.Redirect, "/")
-		assert.EqualValues(t, "pulls", elem[3])
+		assert.Equal(t, "pulls", elem[3])
 
 		// Check branch deletion result
 		req := NewRequest(t, "GET", respJSON.Redirect)
···
 		htmlDoc := NewHTMLParser(t, resp.Body)
 		resultMsg := htmlDoc.doc.Find(".ui.message>p").Text()
 
-		assert.EqualValues(t, "Branch \"user1/repo1:feature/test\" has been deleted.", resultMsg)
+		assert.Equal(t, "Branch \"user1/repo1:feature/test\" has been deleted.", resultMsg)
 	})
 }
 
···
 
 		respBasePR := testPullCreate(t, session, "user2", "repo1", true, "master", "base-pr", "Base Pull Request")
 		elemBasePR := strings.Split(test.RedirectURL(respBasePR), "/")
-		assert.EqualValues(t, "pulls", elemBasePR[3])
+		assert.Equal(t, "pulls", elemBasePR[3])
 
 		respChildPR := testPullCreate(t, session, "user1", "repo1", false, "base-pr", "child-pr", "Child Pull Request")
 		elemChildPR := strings.Split(test.RedirectURL(respChildPR), "/")
-		assert.EqualValues(t, "pulls", elemChildPR[3])
+		assert.Equal(t, "pulls", elemChildPR[3])
 
 		testPullMerge(t, session, elemBasePR[1], elemBasePR[2], elemBasePR[4], repo_model.MergeStyleMerge, true)
 
···
 		targetBranch := htmlDoc.doc.Find("#branch_target>a").Text()
 		prStatus := strings.TrimSpace(htmlDoc.doc.Find(".issue-title-meta>.issue-state-label").Text())
 
-		assert.EqualValues(t, "master", targetBranch)
-		assert.EqualValues(t, "Open", prStatus)
+		assert.Equal(t, "master", targetBranch)
+		assert.Equal(t, "Open", prStatus)
 	})
 }
 
···
 
 		respBasePR := testPullCreate(t, session, "user1", "repo1", false, "master", "base-pr", "Base Pull Request")
 		elemBasePR := strings.Split(test.RedirectURL(respBasePR), "/")
-		assert.EqualValues(t, "pulls", elemBasePR[3])
+		assert.Equal(t, "pulls", elemBasePR[3])
 
 		respChildPR := testPullCreate(t, session, "user1", "repo1", true, "base-pr", "child-pr", "Child Pull Request")
 		elemChildPR := strings.Split(test.RedirectURL(respChildPR), "/")
-		assert.EqualValues(t, "pulls", elemChildPR[3])
+		assert.Equal(t, "pulls", elemChildPR[3])
 
 		testPullMerge(t, session, elemBasePR[1], elemBasePR[2], elemBasePR[4], repo_model.MergeStyleMerge, true)
 
···
 		targetBranch := htmlDoc.doc.Find("#branch_target>a").Text()
 		prStatus := strings.TrimSpace(htmlDoc.doc.Find(".issue-title-meta>.issue-state-label").Text())
 
-		assert.EqualValues(t, "base-pr", targetBranch)
-		assert.EqualValues(t, "Closed", prStatus)
+		assert.Equal(t, "base-pr", targetBranch)
+		assert.Equal(t, "Closed", prStatus)
 	})
 }
 
···
 
 		// merge the pull request
 		elem := strings.Split(test.RedirectURL(createPullResp), "/")
-		assert.EqualValues(t, "pulls", elem[3])
+		assert.Equal(t, "pulls", elem[3])
 		testPullMerge(t, session, elem[1], elem[2], elem[4], repo_model.MergeStyleMerge, false)
 
 		// check if the issue is closed
···
 	defer repo.Close()
 	id, err := repo.GetBranchCommitID(branch)
 	require.NoError(t, err)
-	assert.EqualValues(t, commitID, id)
+	assert.Equal(t, commitID, id)
 }
 
 func TestPullMergeBranchProtect(t *testing.T) {
···
 
 		flashCookie := user4Session.GetCookie(forgejo_context.CookieNameFlash)
 		assert.NotNil(t, flashCookie)
-		assert.EqualValues(t, "error%3DYou%2Bdon%2527t%2Bhave%2Bpermission%2Bto%2Bdelete%2Bthe%2Bhead%2Bbranch.", flashCookie.Value)
+		assert.Equal(t, "error%3DYou%2Bdon%2527t%2Bhave%2Bpermission%2Bto%2Bdelete%2Bthe%2Bhead%2Bbranch.", flashCookie.Value)
 
 		// Check that the branch still exist.
 		req = NewRequest(t, "GET", "/user2/repo1/src/branch/base-pr")

tests/integration/pull_review_test.go

···
 		resp := testPullCreate(t, user2Session, "user2", "test_reviewer", false, repo.DefaultBranch, "codeowner-basebranch", "Test Pull Request")
 		prURL := test.RedirectURL(resp)
 		elem := strings.Split(prURL, "/")
-		assert.EqualValues(t, "pulls", elem[3])
+		assert.Equal(t, "pulls", elem[3])
 
 		req := NewRequest(t, http.MethodGet, prURL)
 		resp = MakeRequest(t, req, http.StatusOK)
···
 			require.NoError(t, err)
 			prUpdated1 := unittest.AssertExistsAndLoadBean(t, &issues_model.PullRequest{ID: pr.ID})
 			require.NoError(t, prUpdated1.LoadIssue(db.DefaultContext))
-			assert.EqualValues(t, "[WIP] Test Pull Request", prUpdated1.Issue.Title)
+			assert.Equal(t, "[WIP] Test Pull Request", prUpdated1.Issue.Title)
 
 			err = issue_service.ChangeTitle(db.DefaultContext, prUpdated1.Issue, user2, "Test Pull Request2")
 			require.NoError(t, err)
 			prUpdated2 := unittest.AssertExistsAndLoadBean(t, &issues_model.PullRequest{ID: pr.ID})
 			require.NoError(t, prUpdated2.LoadIssue(db.DefaultContext))
-			assert.EqualValues(t, "Test Pull Request2", prUpdated2.Issue.Title)
+			assert.Equal(t, "Test Pull Request2", prUpdated2.Issue.Title)
 		})
 
 		// change the default branch CODEOWNERS file to change README.md's codeowner
···
 			testEditFile(t, user1Session, "user1", "repo1", "master", "README.md", "Hello, World (Edited)\n")
 			resp := testPullCreate(t, user1Session, "user1", "repo1", false, "master", "master", "This is a pull title")
 			elem := strings.Split(test.RedirectURL(resp), "/")
-			assert.EqualValues(t, "pulls", elem[3])
+			assert.Equal(t, "pulls", elem[3])
 			testPullMerge(t, user1Session, elem[1], elem[2], elem[4], repo_model.MergeStyleMerge, false)
 
 			// Get the commit SHA
···
 			testEditFileToNewBranch(t, user1Session, "user1", "repo1", "master", "a-test-branch", "README.md", "Hello, World (Edited...again)\n")
 			resp := testPullCreate(t, user1Session, "user1", "repo1", false, "master", "a-test-branch", "This is a pull title")
 			elem := strings.Split(test.RedirectURL(resp), "/")
-			assert.EqualValues(t, "pulls", elem[3])
+			assert.Equal(t, "pulls", elem[3])
 			testIssueClose(t, user1Session, elem[1], elem[2], elem[4], true)
 
 			// Get the commit SHA
···
 			defer test.MockVariableValue(&mailer.SendAsync, func(msgs ...*mailer.Message) {
 				assert.Len(t, msgs, 2)
 				assert.Equal(t, "[e-mail]", msgs[0].To)
-				assert.EqualValues(t, "Re: [user2/repo1] issue2 (PR #2)", msgs[0].Subject)
+				assert.Equal(t, "Re: [user2/repo1] issue2 (PR #2)", msgs[0].Subject)
 				assert.Contains(t, msgs[0].Body, "Notification time!")
 				called = true
 			})()
···
 			defer test.MockVariableValue(&mailer.SendAsync, func(msgs ...*mailer.Message) {
 				assert.Len(t, msgs, 2)
 				assert.Equal(t, "[e-mail]", msgs[0].To)
-				assert.EqualValues(t, "Re: [user2/repo1] issue2 (PR #2)", msgs[0].Subject)
+				assert.Equal(t, "Re: [user2/repo1] issue2 (PR #2)", msgs[0].Subject)
 				assert.Contains(t, msgs[0].Body, "Notification time 2!")
 				called = true
 			})()

tests/integration/pull_status_test.go

···
 			commitURL, exists = doc.doc.Find("#commits-table tbody tr td.sha a").Last().Attr("href")
 			assert.True(t, exists)
 			assert.NotEmpty(t, commitURL)
-			assert.EqualValues(t, commitID, path.Base(commitURL))
+			assert.Equal(t, commitID, path.Base(commitURL))
 
 			cls, ok := doc.doc.Find("#commits-table tbody tr td.message .commit-status").Last().Attr("class")
 			assert.True(t, ok)
···
 
 		repo1 := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{OwnerName: "user1", Name: "repo1"})
 		css := unittest.AssertExistsAndLoadBean(t, &git_model.CommitStatusSummary{RepoID: repo1.ID, SHA: commitID})
-		assert.EqualValues(t, api.CommitStatusWarning, css.State)
+		assert.Equal(t, api.CommitStatusWarning, css.State)
 	})
 }
 

tests/integration/pull_update_test.go

···
 		// Test GetDiverging
 		diffCount, err := pull_service.GetDiverging(git.DefaultContext, pr)
 		require.NoError(t, err)
-		assert.EqualValues(t, 1, diffCount.Behind)
-		assert.EqualValues(t, 1, diffCount.Ahead)
+		assert.Equal(t, 1, diffCount.Behind)
+		assert.Equal(t, 1, diffCount.Ahead)
 		require.NoError(t, pr.LoadBaseRepo(db.DefaultContext))
 		require.NoError(t, pr.LoadIssue(db.DefaultContext))
 
···
 		// Test GetDiverging after update
 		diffCount, err = pull_service.GetDiverging(git.DefaultContext, pr)
 		require.NoError(t, err)
-		assert.EqualValues(t, 0, diffCount.Behind)
-		assert.EqualValues(t, 2, diffCount.Ahead)
+		assert.Equal(t, 0, diffCount.Behind)
+		assert.Equal(t, 2, diffCount.Ahead)
 	})
 }
 
···
 		// Test GetDiverging
 		diffCount, err := pull_service.GetDiverging(git.DefaultContext, pr)
 		require.NoError(t, err)
-		assert.EqualValues(t, 1, diffCount.Behind)
-		assert.EqualValues(t, 1, diffCount.Ahead)
+		assert.Equal(t, 1, diffCount.Behind)
+		assert.Equal(t, 1, diffCount.Ahead)
 		require.NoError(t, pr.LoadBaseRepo(db.DefaultContext))
 		require.NoError(t, pr.LoadIssue(db.DefaultContext))
 
···
 		// Test GetDiverging after update
 		diffCount, err = pull_service.GetDiverging(git.DefaultContext, pr)
 		require.NoError(t, err)
-		assert.EqualValues(t, 0, diffCount.Behind)
-		assert.EqualValues(t, 1, diffCount.Ahead)
+		assert.Equal(t, 0, diffCount.Behind)
+		assert.Equal(t, 1, diffCount.Ahead)
 	})
 }
 
···
 		// Test GetDiverging
 		diffCount, err := pull_service.GetDiverging(git.DefaultContext, pr)
 		require.NoError(t, err)
-		assert.EqualValues(t, 1, diffCount.Behind)
-		assert.EqualValues(t, 1, diffCount.Ahead)
+		assert.Equal(t, 1, diffCount.Behind)
+		assert.Equal(t, 1, diffCount.Ahead)
 		require.NoError(t, pr.LoadBaseRepo(db.DefaultContext))
 		require.NoError(t, pr.LoadIssue(db.DefaultContext))
 
···
 	// Test GetDiverging
 	diffCount, err := pull_service.GetDiverging(git.DefaultContext, pr)
 	require.NoError(t, err)
-	assert.EqualValues(t, 1, diffCount.Behind)
-	assert.EqualValues(t, 1, diffCount.Ahead)
+	assert.Equal(t, 1, diffCount.Behind)
+	assert.Equal(t, 1, diffCount.Ahead)
 	require.NoError(t, pr.LoadBaseRepo(db.DefaultContext))
 	require.NoError(t, pr.LoadIssue(db.DefaultContext))
 

tests/integration/quota_use_test.go

···
 	htmlDoc := NewHTMLParser(ctx.t, ctx.response.Body)
 	flashMessage := strings.TrimSpace(htmlDoc.Find(`.flash-message`).Text())
 
-	assert.EqualValues(ctx.t, value, flashMessage)
+	assert.Equal(ctx.t, value, flashMessage)
 }
 
 func (ctx *quotaWebEnvAsContext) ExpectFlashMessageContains(parts ...string) {

tests/integration/release_feed_test.go

···
 		defer tests.PrintCurrentTest(t)()
 
 		resp := MakeRequest(t, NewRequest(t, "GET", "/user2/repo1/releases.rss"), http.StatusOK)
-		assert.EqualValues(t, `<?xml version="1.0" encoding="UTF-8"?><rss version="2.0" xmlns:content="http://purl.org/rss/1.0/modules/content/">
+		assert.Equal(t, `<?xml version="1.0" encoding="UTF-8"?><rss version="2.0" xmlns:content="http://purl.org/rss/1.0/modules/content/">
   <channel>
     <title>Releases for user2/repo1</title>
     <link>http://localhost/user2/repo1/release</link>
···
 		defer tests.PrintCurrentTest(t)()
 
 		resp := MakeRequest(t, NewRequest(t, "GET", "/user2/repo1/releases.atom"), http.StatusOK)
-		assert.EqualValues(t, `<?xml version="1.0" encoding="UTF-8"?><feed xmlns="http://www.w3.org/2005/Atom">
+		assert.Equal(t, `<?xml version="1.0" encoding="UTF-8"?><feed xmlns="http://www.w3.org/2005/Atom">
   <title>Releases for user2/repo1</title>
   <id>http://localhost/user2/repo1/release</id>
   <updated></updated>

tests/integration/release_test.go

···
 
 	htmlDoc := NewHTMLParser(t, resp.Body)
 	labelText := htmlDoc.doc.Find("#release-list > li .detail .label").First().Text()
-	assert.EqualValues(t, label, labelText)
+	assert.Equal(t, label, labelText)
 	titleText := htmlDoc.doc.Find("#release-list > li .detail h4 a").First().Text()
-	assert.EqualValues(t, version, titleText)
+	assert.Equal(t, version, titleText)
 
 	// Check release count in the counter on the Release/Tag switch, as well as that the tab is highlighted
 	if count < 10 { // Only check values less than 10, should be enough attempts before this test cracks
···
 	}
 
 	releaseList := htmlDoc.doc.Find("#release-list > li")
-	assert.EqualValues(t, count, releaseList.Length())
+	assert.Equal(t, count, releaseList.Length())
 }
 
 func TestViewReleases(t *testing.T) {
···
 		commitsToMain = append(commitsToMain, s.Find(".ahead > a").Text())
 	})
 
-	assert.EqualValues(t, []string{
+	assert.Equal(t, []string{
 		"/user2/repo-release/releases/tag/empty-target-branch",
 		"/user2/repo-release/releases/tag/non-existing-target-branch",
 		"/user2/repo-release/releases/tag/v2.0",
 		"/user2/repo-release/releases/tag/v1.1",
 		"/user2/repo-release/releases/tag/v1.0",
 	}, links)
-	assert.EqualValues(t, []string{
+	assert.Equal(t, []string{
 		"1 commits", // like v1.1
 		"1 commits", // like v1.1
 		"0 commits",
···
 	htmlDoc := NewHTMLParser(t, resp.Body)
 	// check the "number of commits to main since this release"
 	releaseList := htmlDoc.doc.Find("#release-list .ahead > a")
-	assert.EqualValues(t, 1, releaseList.Length())
-	assert.EqualValues(t, "3 commits", releaseList.First().Text())
+	assert.Equal(t, 1, releaseList.Length())
+	assert.Equal(t, "3 commits", releaseList.First().Text())
 }
 
 func TestViewReleaseListLogin(t *testing.T) {
···
 		links = append(links, link)
 	})
 
-	assert.EqualValues(t, []string{
+	assert.Equal(t, []string{
 		"/user2/repo1/releases/tag/draft-release",
 		"/user2/repo1/releases/tag/v1.0",
 		"/user2/repo1/releases/tag/v1.1",
···
 		links = append(links, link)
 	})
 
-	assert.EqualValues(t, []string{
+	assert.Equal(t, []string{
 		"/user2/repo1/releases/tag/v1.1",
 	}, links)
 }
···
 		tagNames = append(tagNames, s.Find(".tag a.tw-flex.tw-items-center").Text())
 	})
 
-	assert.EqualValues(t, []string{"v1.0", "delete-tag", "v1.1"}, tagNames)
+	assert.Equal(t, []string{"v1.0", "delete-tag", "v1.1"}, tagNames)
 }
 
 func TestDownloadReleaseAttachment(t *testing.T) {

tests/integration/remote_test.go

···
 	assert.Equal(t, auth_model.Remote, userBeforeSignIn.LoginType)
 	assert.Equal(t, auth_model.OAuth2, userAfterSignIn.LoginType)
 	// the OAuth2 email was used to set the missing user email
-	assert.Equal(t, "", userBeforeSignIn.Email)
+	assert.Empty(t, userBeforeSignIn.Email)
 	assert.Equal(t, gitlabEmail, userAfterSignIn.Email)
 }
 

tests/integration/rename_branch_test.go

···
 
 		flashCookie := session.GetCookie(gitea_context.CookieNameFlash)
 		assert.NotNil(t, flashCookie)
-		assert.EqualValues(t, "error%3DCannot%2Brename%2Bbranch%2Bmain2%2Bbecause%2Bit%2Bis%2Ba%2Bprotected%2Bbranch.", flashCookie.Value)
+		assert.Equal(t, "error%3DCannot%2Brename%2Bbranch%2Bmain2%2Bbecause%2Bit%2Bis%2Ba%2Bprotected%2Bbranch.", flashCookie.Value)
 
 		// Verify it didn't change.
 		repo1 := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 1})

tests/integration/repo_activity_test.go

···
 		testEditFile(t, session, "user1", "repo1", "master", "README.md", "Hello, World (Edited)\n")
 		resp := testPullCreate(t, session, "user1", "repo1", false, "master", "master", "This is a pull title")
 		elem := strings.Split(test.RedirectURL(resp), "/")
-		assert.EqualValues(t, "pulls", elem[3])
+		assert.Equal(t, "pulls", elem[3])
 		testPullMerge(t, session, elem[1], elem[2], elem[4], repo_model.MergeStyleMerge, false)
 
 		testEditFileToNewBranch(t, session, "user1", "repo1", "master", "feat/better_readme", "README.md", "Hello, World (Edited Again)\n")

tests/integration/repo_collaborator_test.go

···
 	page := NewHTMLParser(t, response.Body).Find(".repo-setting-content")
 
 	// Veirfy header
-	assert.EqualValues(t, "Collaborators", strings.TrimSpace(page.Find("h4").Text()))
+	assert.Equal(t, "Collaborators", strings.TrimSpace(page.Find("h4").Text()))
 
 	// Veirfy button text
 	page = page.Find("#repo-collab-form")
-	assert.EqualValues(t, "Add collaborator", strings.TrimSpace(page.Find("button.primary").Text()))
+	assert.Equal(t, "Add collaborator", strings.TrimSpace(page.Find("button.primary").Text()))
 
 	// Veirfy placeholder
 	placeholder, exists := page.Find("#search-user-box input").Attr("placeholder")
 	assert.True(t, exists)
-	assert.EqualValues(t, "Search users…", placeholder)
+	assert.Equal(t, "Search users…", placeholder)
 }

tests/integration/repo_commits_search_test.go

···
 
 	doc := NewHTMLParser(t, resp.Body)
 	sel := doc.doc.Find("#commits-table tbody tr td.sha a")
-	assert.EqualValues(t, commit, strings.TrimSpace(sel.Text()))
+	assert.Equal(t, commit, strings.TrimSpace(sel.Text()))
 }
 
 func TestRepoCommitsSearch(t *testing.T) {

tests/integration/repo_commits_test.go

···
 		assert.Equal(t, api.CommitStatusState(state), statuses[0].State)
 		assert.Equal(t, setting.AppURL+"api/v1/repos/user2/repo1/statuses/65f1bf27bc3bf70f64657658635e66094edbcb4d", statuses[0].URL)
 		assert.Equal(t, "http://test.ci/", statuses[0].TargetURL)
-		assert.Equal(t, "", statuses[0].Description)
+		assert.Empty(t, statuses[0].Description)
 		assert.Equal(t, "testci", statuses[0].Context)
 
 		assert.Len(t, status.Statuses, 1)

tests/integration/repo_fork_test.go

···
 			htmlDoc := NewHTMLParser(t, resp.Body)
 
 			forkButton := htmlDoc.Find("a[href*='/forks']")
-			assert.EqualValues(t, 1, forkButton.Length())
+			assert.Equal(t, 1, forkButton.Length())
 
 			href, _ := forkButton.Attr("href")
 			assert.Equal(t, "/user2/repo1/forks", href)

tests/integration/repo_generate_test.go

···
 
 	// Verify form header
 	header := strings.TrimSpace(htmlDoc.doc.Find(".form[action='/repo/create'] .header").Text())
-	assert.EqualValues(t, locale.TrString("new_repo.title"), header)
+	assert.Equal(t, locale.TrString("new_repo.title"), header)
 
 	htmlDoc.AssertDropdownHasSelectedOption(t, "uid", strconv.FormatInt(owner.ID, 10))
 
···
 	})
 	resp := session.MakeRequest(t, req, http.StatusSeeOther)
 
-	assert.EqualValues(t, "/user2/spaced-name", test.RedirectURL(resp))
+	assert.Equal(t, "/user2/spaced-name", test.RedirectURL(resp))
 	unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{OwnerID: 2, Name: "spaced-name"})
 }
 

tests/integration/repo_mergecommit_revert_test.go

···
 	resp = session.MakeRequest(t, req, http.StatusSeeOther)
 
 	// A successful revert redirects to the main branch
-	assert.EqualValues(t, "/user2/test_commit_revert/src/branch/main", resp.Header().Get("Location"))
+	assert.Equal(t, "/user2/test_commit_revert/src/branch/main", resp.Header().Get("Location"))
 }

tests/integration/repo_migration_ui_test.go

···
 	t.Helper()
 
 	// Compare lengths of item lists
-	assert.EqualValues(t, len(expectedItems), items.Length())
+	assert.Equal(t, len(expectedItems), items.Length())
 
 	// Compare contents of item lists
 	for index, expectedName := range expectedItems {
 		name, exists := items.Eq(index).Attr("name")
 		assert.True(t, exists)
-		assert.EqualValues(t, expectedName, name)
+		assert.Equal(t, expectedName, name)
 	}
 }

tests/integration/repo_search_test.go

···
 	container := doc.Find(".repository").Find(".ui.container")
 
 	branchDropdown := container.Find(".js-branch-tag-selector")
-	assert.EqualValues(t, indexer, len(branchDropdown.Nodes) == 0)
+	assert.Equal(t, indexer, len(branchDropdown.Nodes) == 0)
 
 	dropdownOptions := container.
 		Find(".menu[data-test-tag=fuzzy-dropdown]").
···
 		})
 
 	if indexer {
-		assert.EqualValues(t, []string{"exact", "union"}, dropdownOptions)
+		assert.Equal(t, []string{"exact", "union"}, dropdownOptions)
 	} else {
-		assert.EqualValues(t, []string{"exact", "union", "regexp"}, dropdownOptions)
+		assert.Equal(t, []string{"exact", "union", "regexp"}, dropdownOptions)
 	}
 
 	filenames := resultFilenames(t, doc)

tests/integration/repo_settings_test.go

···
 		session.MakeRequest(t, req, http.StatusSeeOther)
 		flashCookie := session.GetCookie(gitea_context.CookieNameFlash)
 		assert.NotNil(t, flashCookie)
-		assert.EqualValues(t, "error%3DThere%2Bis%2Balready%2Ba%2Brule%2Bfor%2Bthis%2Bset%2Bof%2Bbranches", flashCookie.Value)
+		assert.Equal(t, "error%3DThere%2Bis%2Balready%2Ba%2Brule%2Bfor%2Bthis%2Bset%2Bof%2Bbranches", flashCookie.Value)
 
 		// Verify it wasn't added.
 		unittest.AssertCount(t, &git_model.ProtectedBranch{RuleName: "master", RepoID: repo.ID}, 1)

tests/integration/repo_test.go

···
 	})
 
 	commitT := time.Date(2017, time.June, 14, 13, 54, 21, 0, time.UTC).In(time.Local).Format(time.RFC1123)
-	assert.EqualValues(t, []file{
+	assert.Equal(t, []file{
 		{
 			fileName:   "doc",
 			commitID:   "2a47ca4b614a9f5a43abbd5ad851a54a616ffee6",
···
 			defer tests.PrintCurrentTest(t)()
 
 			htmlTitle := GetHTMLTitle(t, nil, "/user2/repo1")
-			assert.EqualValues(t, "user2/repo1 - Forgejo: Beyond coding. We Forge.", htmlTitle)
+			assert.Equal(t, "user2/repo1 - Forgejo: Beyond coding. We Forge.", htmlTitle)
 		})
 		t.Run("With description", func(t *testing.T) {
 			defer tests.PrintCurrentTest(t)()
 
 			htmlTitle := GetHTMLTitle(t, nil, "/user27/repo49")
-			assert.EqualValues(t, "user27/repo49: A wonderful repository with more than just a README.md - Forgejo: Beyond coding. We Forge.", htmlTitle)
+			assert.Equal(t, "user27/repo49: A wonderful repository with more than just a README.md - Forgejo: Beyond coding. We Forge.", htmlTitle)
 		})
 	})
 
···
 				defer tests.PrintCurrentTest(t)()
 
 				htmlTitle := GetHTMLTitle(t, nil, "/user2/repo59/src/branch/master/deep/nesting")
-				assert.EqualValues(t, "repo59/deep/nesting at master - user2/repo59 - Forgejo: Beyond coding. We Forge.", htmlTitle)
+				assert.Equal(t, "repo59/deep/nesting at master - user2/repo59 - Forgejo: Beyond coding. We Forge.", htmlTitle)
 			})
 			t.Run("Non-default branch", func(t *testing.T) {
 				defer tests.PrintCurrentTest(t)()
 
 				htmlTitle := GetHTMLTitle(t, nil, "/user2/repo59/src/branch/cake-recipe/deep/nesting")
-				assert.EqualValues(t, "repo59/deep/nesting at cake-recipe - user2/repo59 - Forgejo: Beyond coding. We Forge.", htmlTitle)
+				assert.Equal(t, "repo59/deep/nesting at cake-recipe - user2/repo59 - Forgejo: Beyond coding. We Forge.", htmlTitle)
 			})
 			t.Run("Commit", func(t *testing.T) {
 				defer tests.PrintCurrentTest(t)()
 
 				htmlTitle := GetHTMLTitle(t, nil, "/user2/repo59/src/commit/d8f53dfb33f6ccf4169c34970b5e747511c18beb/deep/nesting/")
-				assert.EqualValues(t, "repo59/deep/nesting at d8f53dfb33f6ccf4169c34970b5e747511c18beb - user2/repo59 - Forgejo: Beyond coding. We Forge.", htmlTitle)
+				assert.Equal(t, "repo59/deep/nesting at d8f53dfb33f6ccf4169c34970b5e747511c18beb - user2/repo59 - Forgejo: Beyond coding. We Forge.", htmlTitle)
 			})
 			t.Run("Tag", func(t *testing.T) {
 				defer tests.PrintCurrentTest(t)()
 
 				htmlTitle := GetHTMLTitle(t, nil, "/user2/repo59/src/tag/v1.0/deep/nesting/")
-				assert.EqualValues(t, "repo59/deep/nesting at v1.0 - user2/repo59 - Forgejo: Beyond coding. We Forge.", htmlTitle)
+				assert.Equal(t, "repo59/deep/nesting at v1.0 - user2/repo59 - Forgejo: Beyond coding. We Forge.", htmlTitle)
 			})
 		})
 		t.Run("File", func(t *testing.T) {
···
 				defer tests.PrintCurrentTest(t)()
 
 				htmlTitle := GetHTMLTitle(t, nil, "/user2/repo59/src/branch/master/deep/nesting/folder/secret_sauce_recipe.txt")
-				assert.EqualValues(t, "repo59/deep/nesting/folder/secret_sauce_recipe.txt at master - user2/repo59 - Forgejo: Beyond coding. We Forge.", htmlTitle)
+				assert.Equal(t, "repo59/deep/nesting/folder/secret_sauce_recipe.txt at master - user2/repo59 - Forgejo: Beyond coding. We Forge.", htmlTitle)
 			})
 			t.Run("Non-default branch", func(t *testing.T) {
 				defer tests.PrintCurrentTest(t)()
 
 				htmlTitle := GetHTMLTitle(t, nil, "/user2/repo59/src/branch/cake-recipe/deep/nesting/folder/secret_sauce_recipe.txt")
-				assert.EqualValues(t, "repo59/deep/nesting/folder/secret_sauce_recipe.txt at cake-recipe - user2/repo59 - Forgejo: Beyond coding. We Forge.", htmlTitle)
+				assert.Equal(t, "repo59/deep/nesting/folder/secret_sauce_recipe.txt at cake-recipe - user2/repo59 - Forgejo: Beyond coding. We Forge.", htmlTitle)
 			})
 			t.Run("Commit", func(t *testing.T) {
 				defer tests.PrintCurrentTest(t)()
 
 				htmlTitle := GetHTMLTitle(t, nil, "/user2/repo59/src/commit/d8f53dfb33f6ccf4169c34970b5e747511c18beb/deep/nesting/folder/secret_sauce_recipe.txt")
-				assert.EqualValues(t, "repo59/deep/nesting/folder/secret_sauce_recipe.txt at d8f53dfb33f6ccf4169c34970b5e747511c18beb - user2/repo59 - Forgejo: Beyond coding. We Forge.", htmlTitle)
+				assert.Equal(t, "repo59/deep/nesting/folder/secret_sauce_recipe.txt at d8f53dfb33f6ccf4169c34970b5e747511c18beb - user2/repo59 - Forgejo: Beyond coding. We Forge.", htmlTitle)
 			})
 			t.Run("Tag", func(t *testing.T) {
 				defer tests.PrintCurrentTest(t)()
 
 				htmlTitle := GetHTMLTitle(t, nil, "/user2/repo59/src/tag/v1.0/deep/nesting/folder/secret_sauce_recipe.txt")
-				assert.EqualValues(t, "repo59/deep/nesting/folder/secret_sauce_recipe.txt at v1.0 - user2/repo59 - Forgejo: Beyond coding. We Forge.", htmlTitle)
+				assert.Equal(t, "repo59/deep/nesting/folder/secret_sauce_recipe.txt at v1.0 - user2/repo59 - Forgejo: Beyond coding. We Forge.", htmlTitle)
 			})
 		})
 	})
···
 			defer tests.PrintCurrentTest(t)()
 
 			htmlTitle := GetHTMLTitle(t, nil, "/user2/repo1/issues")
-			assert.EqualValues(t, "Issues - user2/repo1 - Forgejo: Beyond coding. We Forge.", htmlTitle)
+			assert.Equal(t, "Issues - user2/repo1 - Forgejo: Beyond coding. We Forge.", htmlTitle)
 		})
 		t.Run("View issue page", func(t *testing.T) {
 			defer tests.PrintCurrentTest(t)()
 
 			htmlTitle := GetHTMLTitle(t, nil, "/user2/repo1/issues/1")
-			assert.EqualValues(t, "#1 - issue1 - user2/repo1 - Forgejo: Beyond coding. We Forge.", htmlTitle)
+			assert.Equal(t, "#1 - issue1 - user2/repo1 - Forgejo: Beyond coding. We Forge.", htmlTitle)
 		})
 	})
 
···
 			defer tests.PrintCurrentTest(t)()
 
 			htmlTitle := GetHTMLTitle(t, nil, "/user2/repo1/pulls")
-			assert.EqualValues(t, "Pull requests - user2/repo1 - Forgejo: Beyond coding. We Forge.", htmlTitle)
+			assert.Equal(t, "Pull requests - user2/repo1 - Forgejo: Beyond coding. We Forge.", htmlTitle)
 		})
 		t.Run("View pull request", func(t *testing.T) {
 			defer tests.PrintCurrentTest(t)()
 
 			htmlTitle := GetHTMLTitle(t, nil, "/user2/repo1/pulls/2")
-			assert.EqualValues(t, "#2 - issue2 - user2/repo1 - Forgejo: Beyond coding. We Forge.", htmlTitle)
+			assert.Equal(t, "#2 - issue2 - user2/repo1 - Forgejo: Beyond coding. We Forge.", htmlTitle)
 		})
 	})
 }
···
 	repoTopics := htmlDoc.doc.Find("#repo-topics")
 	repoSummary := htmlDoc.doc.Find(".repository-summary")
 
-	assert.EqualValues(t, 0, description.Length())
-	assert.EqualValues(t, 0, repoTopics.Length())
-	assert.EqualValues(t, 0, repoSummary.Length())
+	assert.Equal(t, 0, description.Length())
+	assert.Equal(t, 0, repoTopics.Length())
+	assert.Equal(t, 0, repoSummary.Length())
 }
 
 func TestViewFileInRepoRSSFeed(t *testing.T) {
···
 		repoTopics := htmlDoc.doc.Find("#repo-topics")
 		repoSummary := htmlDoc.doc.Find(".repository-summary")
 
-		assert.EqualValues(t, 0, description.Length())
-		assert.EqualValues(t, 0, repoTopics.Length())
-		assert.EqualValues(t, 0, repoSummary.Length())
+		assert.Equal(t, 0, description.Length())
+		assert.Equal(t, 0, repoTopics.Length())
+		assert.Equal(t, 0, repoSummary.Length())
 	})
 
 	t.Run("File size", func(t *testing.T) {
···
 			return s.AttrOr("data-entryname", "")
 		})
 
-		assert.EqualValues(t, []string{"Charlie", "alpha", "Beta", "delta", "licensa", "LICENSE", "licensz", "README.md", "zEta"}, filesList)
+		assert.Equal(t, []string{"Charlie", "alpha", "Beta", "delta", "licensa", "LICENSE", "licensz", "README.md", "zEta"}, filesList)
 	})
 }
 

tests/integration/repo_topic_test.go

···
 	res := MakeRequest(t, NewRequest(t, "GET", searchURL.String()), http.StatusOK)
 	DecodeJSON(t, res, &topics)
 	assert.Len(t, topics.TopicNames, 4)
-	assert.EqualValues(t, "6", res.Header().Get("x-total-count"))
+	assert.Equal(t, "6", res.Header().Get("x-total-count"))
 
 	query.Add("q", "topic")
 	searchURL.RawQuery = query.Encode()
···
 	DecodeJSON(t, res, &topics)
 	if assert.Len(t, topics.TopicNames, 1) {
 		assert.EqualValues(t, 2, topics.TopicNames[0].ID)
-		assert.EqualValues(t, "database", topics.TopicNames[0].Name)
-		assert.EqualValues(t, 1, topics.TopicNames[0].RepoCount)
+		assert.Equal(t, "database", topics.TopicNames[0].Name)
+		assert.Equal(t, 1, topics.TopicNames[0].RepoCount)
 	}
 }
 

tests/integration/repo_wiki_test.go

···
 		resp := MakeRequest(t, req, http.StatusOK)
 		htmlDoc := NewHTMLParser(t, resp.Body)
 
-		assert.EqualValues(t, "Helpdesk", htmlDoc.Find(".wiki-content-toc a").Text())
+		assert.Equal(t, "Helpdesk", htmlDoc.Find(".wiki-content-toc a").Text())
 	})
 }

tests/integration/repofiles_change_test.go

···
 			lastCommit, err := gitRepo.GetCommitByPath("new/file.txt")
 			require.NoError(t, err)
 			expectedFileResponse := getExpectedFileResponseForRepofilesCreate(commitID, lastCommit.ID.String())
-			assert.EqualValues(t, expectedFileResponse.Content, filesResponse.Files[0])
-			assert.EqualValues(t, expectedFileResponse.Commit.SHA, filesResponse.Commit.SHA)
-			assert.EqualValues(t, expectedFileResponse.Commit.HTMLURL, filesResponse.Commit.HTMLURL)
-			assert.EqualValues(t, expectedFileResponse.Commit.Author.Email, filesResponse.Commit.Author.Email)
-			assert.EqualValues(t, expectedFileResponse.Commit.Author.Name, filesResponse.Commit.Author.Name)
+			assert.Equal(t, expectedFileResponse.Content, filesResponse.Files[0])
+			assert.Equal(t, expectedFileResponse.Commit.SHA, filesResponse.Commit.SHA)
+			assert.Equal(t, expectedFileResponse.Commit.HTMLURL, filesResponse.Commit.HTMLURL)
+			assert.Equal(t, expectedFileResponse.Commit.Author.Email, filesResponse.Commit.Author.Email)
+			assert.Equal(t, expectedFileResponse.Commit.Author.Name, filesResponse.Commit.Author.Name)
 		})
 
 		t.Run("Update", func(t *testing.T) {
···
 			lastCommit, err := commit.GetCommitByPath(opts.Files[0].TreePath)
 			require.NoError(t, err)
 			expectedFileResponse := getExpectedFileResponseForRepofilesUpdate(commit.ID.String(), opts.Files[0].TreePath, lastCommit.ID.String())
-			assert.EqualValues(t, expectedFileResponse.Content, filesResponse.Files[0])
-			assert.EqualValues(t, expectedFileResponse.Commit.SHA, filesResponse.Commit.SHA)
-			assert.EqualValues(t, expectedFileResponse.Commit.HTMLURL, filesResponse.Commit.HTMLURL)
-			assert.EqualValues(t, expectedFileResponse.Commit.Author.Email, filesResponse.Commit.Author.Email)
-			assert.EqualValues(t, expectedFileResponse.Commit.Author.Name, filesResponse.Commit.Author.Name)
+			assert.Equal(t, expectedFileResponse.Content, filesResponse.Files[0])
+			assert.Equal(t, expectedFileResponse.Commit.SHA, filesResponse.Commit.SHA)
+			assert.Equal(t, expectedFileResponse.Commit.HTMLURL, filesResponse.Commit.HTMLURL)
+			assert.Equal(t, expectedFileResponse.Commit.Author.Email, filesResponse.Commit.Author.Email)
+			assert.Equal(t, expectedFileResponse.Commit.Author.Name, filesResponse.Commit.Author.Name)
 		})
 
 		t.Run("Update and move", func(t *testing.T) {
···
 			assert.Nil(t, fromEntry)  // Should no longer exist here
 			assert.NotNil(t, toEntry) // Should exist here
 			// assert SHA has remained the same but paths use the new file name
-			assert.EqualValues(t, expectedFileResponse.Content.SHA, filesResponse.Files[0].SHA)
-			assert.EqualValues(t, expectedFileResponse.Content.Name, filesResponse.Files[0].Name)
-			assert.EqualValues(t, expectedFileResponse.Content.Path, filesResponse.Files[0].Path)
-			assert.EqualValues(t, expectedFileResponse.Content.URL, filesResponse.Files[0].URL)
-			assert.EqualValues(t, expectedFileResponse.Commit.SHA, filesResponse.Commit.SHA)
-			assert.EqualValues(t, expectedFileResponse.Commit.HTMLURL, filesResponse.Commit.HTMLURL)
+			assert.Equal(t, expectedFileResponse.Content.SHA, filesResponse.Files[0].SHA)
+			assert.Equal(t, expectedFileResponse.Content.Name, filesResponse.Files[0].Name)
+			assert.Equal(t, expectedFileResponse.Content.Path, filesResponse.Files[0].Path)
+			assert.Equal(t, expectedFileResponse.Content.URL, filesResponse.Files[0].URL)
+			assert.Equal(t, expectedFileResponse.Commit.SHA, filesResponse.Commit.SHA)
+			assert.Equal(t, expectedFileResponse.Commit.HTMLURL, filesResponse.Commit.HTMLURL)
 		})
 
 		t.Run("Change without branch names", func(t *testing.T) {
···
 			commit, _ := gitRepo.GetBranchCommit(repo.DefaultBranch)
 			lastCommit, _ := commit.GetCommitByPath(opts.Files[0].TreePath)
 			expectedFileResponse := getExpectedFileResponseForRepofilesUpdate(commit.ID.String(), opts.Files[0].TreePath, lastCommit.ID.String())
-			assert.EqualValues(t, expectedFileResponse.Content, filesResponse.Files[0])
+			assert.Equal(t, expectedFileResponse.Content, filesResponse.Files[0])
 		})
 
 		t.Run("Delete files", func(t *testing.T) {
···
 			expectedFileResponse := getExpectedFileResponseForRepofilesDelete()
 			assert.NotNil(t, filesResponse)
 			assert.Nil(t, filesResponse.Files[0])
-			assert.EqualValues(t, expectedFileResponse.Commit.Message, filesResponse.Commit.Message)
-			assert.EqualValues(t, expectedFileResponse.Commit.Author.Identity, filesResponse.Commit.Author.Identity)
-			assert.EqualValues(t, expectedFileResponse.Commit.Committer.Identity, filesResponse.Commit.Committer.Identity)
-			assert.EqualValues(t, expectedFileResponse.Verification, filesResponse.Verification)
+			assert.Equal(t, expectedFileResponse.Commit.Message, filesResponse.Commit.Message)
+			assert.Equal(t, expectedFileResponse.Commit.Author.Identity, filesResponse.Commit.Author.Identity)
+			assert.Equal(t, expectedFileResponse.Commit.Committer.Identity, filesResponse.Commit.Committer.Identity)
+			assert.Equal(t, expectedFileResponse.Verification, filesResponse.Verification)
 
 			filesResponse, err = files_service.ChangeRepoFiles(git.DefaultContext, repo, doer, opts)
 			assert.Nil(t, filesResponse)
···
 			expectedFileResponse := getExpectedFileResponseForRepofilesDelete()
 			assert.NotNil(t, filesResponse)
 			assert.Nil(t, filesResponse.Files[0])
-			assert.EqualValues(t, expectedFileResponse.Commit.Message, filesResponse.Commit.Message)
-			assert.EqualValues(t, expectedFileResponse.Commit.Author.Identity, filesResponse.Commit.Author.Identity)
-			assert.EqualValues(t, expectedFileResponse.Commit.Committer.Identity, filesResponse.Commit.Committer.Identity)
-			assert.EqualValues(t, expectedFileResponse.Verification, filesResponse.Verification)
+			assert.Equal(t, expectedFileResponse.Commit.Message, filesResponse.Commit.Message)
+			assert.Equal(t, expectedFileResponse.Commit.Author.Identity, filesResponse.Commit.Author.Identity)
+			assert.Equal(t, expectedFileResponse.Commit.Committer.Identity, filesResponse.Commit.Committer.Identity)
+			assert.Equal(t, expectedFileResponse.Verification, filesResponse.Verification)
 		})
 	})
 }

tests/integration/runner_test.go

···
 			sess.MakeRequest(t, req, http.StatusSeeOther)
 			flashCookie := sess.GetCookie(forgejo_context.CookieNameFlash)
 			assert.NotNil(t, flashCookie)
-			assert.EqualValues(t, "success%3DRunner%2Bupdated%2Bsuccessfully", flashCookie.Value)
+			assert.Equal(t, "success%3DRunner%2Bupdated%2Bsuccessfully", flashCookie.Value)
 		}
 
 		req = NewRequestWithValues(t, "POST", baseURL+fmt.Sprintf("/%d/delete", id), map[string]string{
···
 			sess.MakeRequest(t, req, http.StatusOK)
 			flashCookie := sess.GetCookie(forgejo_context.CookieNameFlash)
 			assert.NotNil(t, flashCookie)
-			assert.EqualValues(t, "success%3DRunner%2Bdeleted%2Bsuccessfully", flashCookie.Value)
+			assert.Equal(t, "success%3DRunner%2Bdeleted%2Bsuccessfully", flashCookie.Value)
 		}
 	}
 

tests/integration/session_test.go

···
 
 	sess, err := auth.RegenerateSession(db.DefaultContext, "", key)
 	require.NoError(t, err)
-	assert.EqualValues(t, key, sess.Key)
+	assert.Equal(t, key, sess.Key)
 	assert.Empty(t, sess.Data, 0)
 
 	sess, err = auth.ReadSession(db.DefaultContext, key2)
 	require.NoError(t, err)
-	assert.EqualValues(t, key2, sess.Key)
+	assert.Equal(t, key2, sess.Key)
 	assert.Empty(t, sess.Data, 0)
 }

tests/integration/signin_test.go

···
 	htmlDoc := NewHTMLParser(t, resp.Body)
 	resultMsg := htmlDoc.doc.Find(".ui.message>p").Text()
 
-	assert.EqualValues(t, message, resultMsg)
+	assert.Equal(t, message, resultMsg)
 }
 
 func TestSignin(t *testing.T) {

tests/integration/user_avatar_test.go

···
 
 	req = NewRequestf(t, "GET", "/%s.png", user2.Name)
 	resp := MakeRequest(t, req, http.StatusSeeOther)
-	assert.EqualValues(t, fmt.Sprintf("/avatars/%s", user2.Avatar), resp.Header().Get("location"))
+	assert.Equal(t, fmt.Sprintf("/avatars/%s", user2.Avatar), resp.Header().Get("location"))
 
 	// Can't test if the response matches because the image is re-generated on upload but checking that this at least doesn't give a 404 should be enough.
 }

tests/integration/user_dashboard_test.go

···
 	response := session.MakeRequest(t, NewRequest(t, "GET", "/"), http.StatusOK)
 	page := NewHTMLParser(t, response.Body)
 	links := page.Find("#navbar .dropdown[data-tooltip-content='Create…'] .menu")
-	assert.EqualValues(t, locale.TrString("new_repo.link"), strings.TrimSpace(links.Find("a[href='/repo/create']").Text()))
-	assert.EqualValues(t, locale.TrString("new_migrate.link"), strings.TrimSpace(links.Find("a[href='/repo/migrate']").Text()))
-	assert.EqualValues(t, locale.TrString("new_org.link"), strings.TrimSpace(links.Find("a[href='/org/create']").Text()))
+	assert.Equal(t, locale.TrString("new_repo.link"), strings.TrimSpace(links.Find("a[href='/repo/create']").Text()))
+	assert.Equal(t, locale.TrString("new_migrate.link"), strings.TrimSpace(links.Find("a[href='/repo/migrate']").Text()))
+	assert.Equal(t, locale.TrString("new_org.link"), strings.TrimSpace(links.Find("a[href='/org/create']").Text()))
 }
 
 func TestUserDashboardFeedWelcome(t *testing.T) {
···
 		htmlDoc.doc.Find("#activity-feed .flex-item-main .title").Each(func(i int, s *goquery.Selection) {
 			count++
 			if s.IsMatcher(goquery.Single("a")) {
-				assert.EqualValues(t, "❗ not rendered", s.Text())
+				assert.Equal(t, "❗ not rendered", s.Text())
 			} else {
-				assert.EqualValues(t, ":exclamation: not rendered", s.Text())
+				assert.Equal(t, ":exclamation: not rendered", s.Text())
 			}
 		})
 
-		assert.EqualValues(t, 6, count)
+		assert.Equal(t, 6, count)
 	})
 }

tests/integration/user_profile_activity_test.go

···
 
 	// When profile activity is configured as public, but the profile is private, tell the user about this and link to visibility settings.
 	hintLink := testUser2ActivityVisibility(t, userRegular, "Your activity is only visible to you and the instance administrators because your profile is private. Configure.", true)
-	assert.EqualValues(t, "/user/settings#visibility-setting", hintLink)
+	assert.Equal(t, "/user/settings#visibility-setting", hintLink)
 
 	// When the profile is private, tell the admin about this.
 	testUser2ActivityVisibility(t, userAdmin, "This activity is visible to you because you're an administrator, but the user wants it to remain private.", true)
···
 	testUser2ActivityVisibility(t, userGuest, "This user has disabled the public visibility of the activity.", false)
 
 	// Verify that Configure link is correct
-	assert.EqualValues(t, "/user/settings#keep-activity-private", hintLink)
+	assert.Equal(t, "/user/settings#keep-activity-private", hintLink)
 }
 
 // testChangeUserActivityVisibility allows to easily change visibility of public activity for a user
···
 	hintLink, hintLinkExists := page.Find("#visibility-hint a").Attr("href")
 
 	// Check that the hint aligns with the actual feed availability
-	assert.EqualValues(t, availability, page.Find("#activity-feed").Length() > 0)
+	assert.Equal(t, availability, page.Find("#activity-feed").Length() > 0)
 
 	// Check availability of RSS feed button too
-	assert.EqualValues(t, availability, page.Find("#profile-avatar-card a[href='/user2.rss']").Length() > 0)
+	assert.Equal(t, availability, page.Find("#profile-avatar-card a[href='/user2.rss']").Length() > 0)
 
 	// Check that the current tab is displayed and is active regardless of it's actual availability
 	// For example, on /<user> it wouldn't be available to guest, but it should be still present on /<user>?tab=activity
···
 	t.Helper()
 	response := session.MakeRequest(t, NewRequest(t, "GET", "/user2"), http.StatusOK)
 	page := NewHTMLParser(t, response.Body)
-	assert.EqualValues(t, buttons, page.Find("overflow-menu .item[href='/user2?tab=activity']").Length() > 0)
+	assert.Equal(t, buttons, page.Find("overflow-menu .item[href='/user2?tab=activity']").Length() > 0)
 }

tests/integration/user_redirect_test.go

···
 
 		flashCookie := session.GetCookie(forgejo_context.CookieNameFlash)
 		assert.NotNil(t, flashCookie)
-		assert.EqualValues(t, "success%3DYour%2Bprofile%2Bhas%2Bbeen%2Bupdated.", flashCookie.Value)
+		assert.Equal(t, "success%3DYour%2Bprofile%2Bhas%2Bbeen%2Bupdated.", flashCookie.Value)
 
 		unittest.AssertExistsIf(t, true, &user_model.Redirect{LowerName: "user2", RedirectUserID: 2})
 	})
···
 		session.MakeRequest(t, req, http.StatusSeeOther)
 		flashCookie := session.GetCookie(forgejo_context.CookieNameFlash)
 		assert.NotNil(t, flashCookie)
-		assert.EqualValues(t, "success%3DThe%2Buser%2Baccount%2Bhas%2Bbeen%2Bupdated.", flashCookie.Value)
+		assert.Equal(t, "success%3DThe%2Buser%2Baccount%2Bhas%2Bbeen%2Bupdated.", flashCookie.Value)
 
 		unittest.AssertExistsIf(t, true, &user_model.User{LowerName: "user2"})
 		unittest.AssertExistsIf(t, false, &user_model.Redirect{LowerName: "user2", RedirectUserID: 2})
···
 
 		flashCookie := session.GetCookie(forgejo_context.CookieNameFlash)
 		assert.NotNil(t, flashCookie)
-		assert.EqualValues(t, "success%3DYour%2Bprofile%2Bhas%2Bbeen%2Bupdated.", flashCookie.Value)
+		assert.Equal(t, "success%3DYour%2Bprofile%2Bhas%2Bbeen%2Bupdated.", flashCookie.Value)
 
 		unittest.AssertExistsIf(t, true, &user_model.Redirect{LowerName: "user2-new", RedirectUserID: 2})
 
···
 
 		flashCookie = session.GetCookie(forgejo_context.CookieNameFlash)
 		assert.NotNil(t, flashCookie)
-		assert.EqualValues(t, "success%3DYour%2Bprofile%2Bhas%2Bbeen%2Bupdated.", flashCookie.Value)
+		assert.Equal(t, "success%3DYour%2Bprofile%2Bhas%2Bbeen%2Bupdated.", flashCookie.Value)
 
 		unittest.AssertExistsIf(t, false, &user_model.Redirect{LowerName: "user2-new", RedirectUserID: 2})
 		unittest.AssertExistsIf(t, true, &user_model.Redirect{LowerName: "user2-new-2", RedirectUserID: 2})

tests/integration/user_test.go

···
 		user34 := "the_34-user.with.all.allowedChars"
 		req := NewRequestf(t, "GET", "/%s.rss", user34)
 		resp := MakeRequest(t, req, http.StatusOK)
-		if assert.EqualValues(t, "application/rss+xml;charset=utf-8", resp.Header().Get("Content-Type")) {
+		if assert.Equal(t, "application/rss+xml;charset=utf-8", resp.Header().Get("Content-Type")) {
 			rssDoc := NewHTMLParser(t, resp.Body).Find("channel")
 			title, _ := rssDoc.ChildrenFiltered("title").Html()
-			assert.EqualValues(t, "Feed of "the_1-user.with.all.allowedChars"", title)
+			assert.Equal(t, "Feed of "the_1-user.with.all.allowedChars"", title)
 			description, _ := rssDoc.ChildrenFiltered("description").Html()
-			assert.EqualValues(t, "<p dir="auto">some <a href="https://commonmark.org/" rel="nofollow">commonmark</a>!</p>\n", description)
+			assert.Equal(t, "<p dir="auto">some <a href="https://commonmark.org/" rel="nofollow">commonmark</a>!</p>\n", description)
 		}
 	})
 	t.Run("Non-existent user", func(t *testing.T) {
···
 	stopwatch := unittest.AssertExistsAndLoadBean(t, &issues_model.Stopwatch{UserID: owner.ID})
 	issue := unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: stopwatch.IssueID})
 	if assert.Len(t, apiWatches, 1) {
-		assert.EqualValues(t, stopwatch.CreatedUnix.AsTime().Unix(), apiWatches[0].Created.Unix())
-		assert.EqualValues(t, issue.Index, apiWatches[0].IssueIndex)
-		assert.EqualValues(t, issue.Title, apiWatches[0].IssueTitle)
-		assert.EqualValues(t, repo.Name, apiWatches[0].RepoName)
-		assert.EqualValues(t, repo.OwnerName, apiWatches[0].RepoOwnerName)
+		assert.Equal(t, stopwatch.CreatedUnix.AsTime().Unix(), apiWatches[0].Created.Unix())
+		assert.Equal(t, issue.Index, apiWatches[0].IssueIndex)
+		assert.Equal(t, issue.Title, apiWatches[0].IssueTitle)
+		assert.Equal(t, repo.Name, apiWatches[0].RepoName)
+		assert.Equal(t, repo.OwnerName, apiWatches[0].RepoOwnerName)
 		assert.Positive(t, apiWatches[0].Seconds)
 	}
 }
···
 			assert.Equal(t, enabled, hintChecked)
 
 			link, _ := htmlDoc.Find("form[action='/user/settings/appearance/language'] a").Attr("href")
-			assert.EqualValues(t, "https://forgejo.org/docs/next/contributor/localization/", link)
+			assert.Equal(t, "https://forgejo.org/docs/next/contributor/localization/", link)
 		}
 
 		t.Run("view", func(t *testing.T) {
···
 		htmlDoc := NewHTMLParser(t, resp.Body)
 
 		userName := strings.TrimSpace(htmlDoc.Find(".profile-avatar-name .username").Text())
-		assert.EqualValues(t, "user2", userName)
+		assert.Equal(t, "user2", userName)
 	})
 }
 
···
 		sel := htmlDoc.doc.Find("a.name")
 		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()))
+			assert.Equal(t, repos[i], strings.TrimSpace(sel.Eq(i).Text()))
 		}
 	}
 }
···
 	authToken, err := auth_model.FindAuthToken(db.DefaultContext, lookupKey, auth_model.UserActivation)
 	require.NoError(t, err)
 	assert.False(t, authToken.IsExpired())
-	assert.EqualValues(t, authToken.HashedValidator, auth_model.HashValidator(rawValidator))
+	assert.Equal(t, authToken.HashedValidator, auth_model.HashValidator(rawValidator))
 
 	t.Run("No password", func(t *testing.T) {
 		defer tests.PrintCurrentTest(t)()
···
 	authToken, err := auth_model.FindAuthToken(db.DefaultContext, lookupKey, auth_model.PasswordReset)
 	require.NoError(t, err)
 	assert.False(t, authToken.IsExpired())
-	assert.EqualValues(t, authToken.HashedValidator, auth_model.HashValidator(rawValidator))
+	assert.Equal(t, authToken.HashedValidator, auth_model.HashValidator(rawValidator))
 
 	req = NewRequestWithValues(t, "POST", "/user/recover_account", map[string]string{
 		"_csrf":    GetCSRF(t, session, "/user/recover_account"),
···
 	authToken, err := auth_model.FindAuthToken(db.DefaultContext, lookupKey, auth_model.EmailActivation("[e-mail]"))
 	require.NoError(t, err)
 	assert.False(t, authToken.IsExpired())
-	assert.EqualValues(t, authToken.HashedValidator, auth_model.HashValidator(rawValidator))
+	assert.Equal(t, authToken.HashedValidator, auth_model.HashValidator(rawValidator))
 
 	req = NewRequestWithValues(t, "POST", "/user/activate_email", map[string]string{
 		"code":  code,

tests/integration/wiki_test.go

···
 func assertFileEqual(t *testing.T, p string, content []byte) {
 	bs, err := os.ReadFile(p)
 	require.NoError(t, err)
-	assert.EqualValues(t, content, bs)
+	assert.Equal(t, content, bs)
 }
 
 func TestRepoCloneWiki(t *testing.T) {
···
 		href, _ := firstAnchor.Attr("href")
 		pagePath := strings.TrimPrefix(href, "/user2/repo1/wiki/")
 
-		assert.EqualValues(t, expectedPagePaths[i], pagePath)
+		assert.Equal(t, expectedPagePaths[i], pagePath)
 	})
 }

tests/integration/xss_test.go

···
 	req = NewRequestf(t, "GET", "/%s", user.Name)
 	resp := session.MakeRequest(t, req, http.StatusOK)
 	htmlDoc := NewHTMLParser(t, resp.Body)
-	assert.EqualValues(t, 0, htmlDoc.doc.Find("script.evil").Length())
-	assert.EqualValues(t, fullName,
+	assert.Equal(t, 0, htmlDoc.doc.Find("script.evil").Length())
+	assert.Equal(t, fullName,
 		htmlDoc.doc.Find("div.content").Find(".header.text.center").Text(),
 	)
 }