diff --git a/phpstan-baseline.neon b/phpstan-baseline.neon
index ee8813feed..f5e9b316f5 100644
--- a/phpstan-baseline.neon
+++ b/phpstan-baseline.neon
@@ -15846,52 +15846,52 @@ parameters:
 			path: src/ZipExtension.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) with 'formula' and array\\{id\\: non\\-empty\\-string, name\\: string, precondition\\?\\: non\\-empty\\-string, formula\\: non\\-empty\\-string, test\\: non\\-empty\\-string, issue\\: string, recommendation\\: string, justification\\: string, \\.\\.\\.\\} will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) with 'formula' and array\\{id\\: non\\-empty\\-string, name\\: string, precondition\\?\\: non\\-empty\\-string, formula\\: non\\-empty\\-string, test\\: non\\-empty\\-string, issue\\: string, recommendation\\: string, justification\\: string, \\.\\.\\.\\} will always evaluate to true\\.$#"
 			count: 1
 			path: tests/classes/Advisory/RulesTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) with 'id' and array\\{id\\: non\\-empty\\-string, name\\: string, precondition\\?\\: non\\-empty\\-string, formula\\: non\\-empty\\-string, test\\: non\\-empty\\-string, issue\\: string, recommendation\\: string, justification\\: string, \\.\\.\\.\\} will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) with 'id' and array\\{id\\: non\\-empty\\-string, name\\: string, precondition\\?\\: non\\-empty\\-string, formula\\: non\\-empty\\-string, test\\: non\\-empty\\-string, issue\\: string, recommendation\\: string, justification\\: string, \\.\\.\\.\\} will always evaluate to true\\.$#"
 			count: 1
 			path: tests/classes/Advisory/RulesTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) with 'issue' and array\\{id\\: non\\-empty\\-string, name\\: string, precondition\\?\\: non\\-empty\\-string, formula\\: non\\-empty\\-string, test\\: non\\-empty\\-string, issue\\: string, recommendation\\: string, justification\\: string, \\.\\.\\.\\} will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) with 'issue' and array\\{id\\: non\\-empty\\-string, name\\: string, precondition\\?\\: non\\-empty\\-string, formula\\: non\\-empty\\-string, test\\: non\\-empty\\-string, issue\\: string, recommendation\\: string, justification\\: string, \\.\\.\\.\\} will always evaluate to true\\.$#"
 			count: 1
 			path: tests/classes/Advisory/RulesTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) with 'justification' and array\\{id\\: non\\-empty\\-string, name\\: string, precondition\\?\\: non\\-empty\\-string, formula\\: non\\-empty\\-string, test\\: non\\-empty\\-string, issue\\: string, recommendation\\: string, justification\\: string, \\.\\.\\.\\} will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) with 'justification' and array\\{id\\: non\\-empty\\-string, name\\: string, precondition\\?\\: non\\-empty\\-string, formula\\: non\\-empty\\-string, test\\: non\\-empty\\-string, issue\\: string, recommendation\\: string, justification\\: string, \\.\\.\\.\\} will always evaluate to true\\.$#"
 			count: 1
 			path: tests/classes/Advisory/RulesTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) with 'name' and array\\{id\\: non\\-empty\\-string, name\\: string, precondition\\?\\: non\\-empty\\-string, formula\\: non\\-empty\\-string, test\\: non\\-empty\\-string, issue\\: string, recommendation\\: string, justification\\: string, \\.\\.\\.\\} will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) with 'name' and array\\{id\\: non\\-empty\\-string, name\\: string, precondition\\?\\: non\\-empty\\-string, formula\\: non\\-empty\\-string, test\\: non\\-empty\\-string, issue\\: string, recommendation\\: string, justification\\: string, \\.\\.\\.\\} will always evaluate to true\\.$#"
 			count: 1
 			path: tests/classes/Advisory/RulesTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) with 'recommendation' and array\\{id\\: non\\-empty\\-string, name\\: string, precondition\\?\\: non\\-empty\\-string, formula\\: non\\-empty\\-string, test\\: non\\-empty\\-string, issue\\: string, recommendation\\: string, justification\\: string, \\.\\.\\.\\} will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) with 'recommendation' and array\\{id\\: non\\-empty\\-string, name\\: string, precondition\\?\\: non\\-empty\\-string, formula\\: non\\-empty\\-string, test\\: non\\-empty\\-string, issue\\: string, recommendation\\: string, justification\\: string, \\.\\.\\.\\} will always evaluate to true\\.$#"
 			count: 1
 			path: tests/classes/Advisory/RulesTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) with 'test' and array\\{id\\: non\\-empty\\-string, name\\: string, precondition\\?\\: non\\-empty\\-string, formula\\: non\\-empty\\-string, test\\: non\\-empty\\-string, issue\\: string, recommendation\\: string, justification\\: string, \\.\\.\\.\\} will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) with 'test' and array\\{id\\: non\\-empty\\-string, name\\: string, precondition\\?\\: non\\-empty\\-string, formula\\: non\\-empty\\-string, test\\: non\\-empty\\-string, issue\\: string, recommendation\\: string, justification\\: string, \\.\\.\\.\\} will always evaluate to true\\.$#"
 			count: 1
 			path: tests/classes/Advisory/RulesTest.php
 
 		-
-			message: "#^Parameter \\#2 \\$haystack of method PHPUnit\\\\Framework\\\\Assert\\:\\:assertStringContainsString\\(\\) expects string, mixed given\\.$#"
+			message: "#^Parameter \\#2 \\$haystack of static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertStringContainsString\\(\\) expects string, mixed given\\.$#"
 			count: 3
 			path: tests/classes/BrowseForeignersTest.php
 
 		-
-			message: "#^Parameter \\#2 \\$string of method PHPUnit\\\\Framework\\\\Assert\\:\\:assertStringEndsWith\\(\\) expects string, mixed given\\.$#"
+			message: "#^Parameter \\#2 \\$string of static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertStringEndsWith\\(\\) expects string, mixed given\\.$#"
 			count: 1
 			path: tests/classes/BrowseForeignersTest.php
 
 		-
-			message: "#^Parameter \\#2 \\$string of method PHPUnit\\\\Framework\\\\Assert\\:\\:assertStringStartsWith\\(\\) expects string, mixed given\\.$#"
+			message: "#^Parameter \\#2 \\$string of static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertStringStartsWith\\(\\) expects string, mixed given\\.$#"
 			count: 1
 			path: tests/classes/BrowseForeignersTest.php
 
@@ -15901,12 +15901,12 @@ parameters:
 			path: tests/classes/CacheTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertInstanceOf\\(\\) with 'PhpMyAdmin\\\\\\\\Charsets\\\\\\\\Charset' and PhpMyAdmin\\\\Charsets\\\\Charset will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertInstanceOf\\(\\) with 'PhpMyAdmin\\\\\\\\Charsets\\\\\\\\Charset' and PhpMyAdmin\\\\Charsets\\\\Charset will always evaluate to true\\.$#"
 			count: 1
 			path: tests/classes/Charsets/CharsetTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertInstanceOf\\(\\) with 'PhpMyAdmin\\\\\\\\Charsets\\\\\\\\Collation' and PhpMyAdmin\\\\Charsets\\\\Collation will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertInstanceOf\\(\\) with 'PhpMyAdmin\\\\\\\\Charsets\\\\\\\\Collation' and PhpMyAdmin\\\\Charsets\\\\Collation will always evaluate to true\\.$#"
 			count: 1
 			path: tests/classes/Charsets/CollationTest.php
 
@@ -15946,27 +15946,27 @@ parameters:
 			path: tests/classes/Config/DescriptionTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertIsArray\\(\\) with array\\<int\\<1, max\\>, non\\-empty\\-array\\<'AllowDeny'\\|'AllowNoPassword'\\|'AllowRoot'\\|'auth_http_realm'\\|'auth_type'\\|'bookmarktable'\\|'central_columns'\\|'column_info'\\|'compress'\\|'control_compress'\\|'control_hide…'\\|'control_socket'\\|'control_ssl'\\|'control_ssl_ca'\\|'control_ssl_ca_path'\\|'control_ssl_cert'\\|'control_ssl_ciphers'\\|'control_ssl_key'\\|'control_ssl_verify'\\|'controlhost'\\|'controlpass'\\|'controlport'\\|'controluser'\\|'designer_settings'\\|'DisableIS'\\|'export_templates'\\|'favorite'\\|'hide_db'\\|'history'\\|'host'\\|'LogoutURL'\\|'MaxTableUiprefs'\\|'navigationhiding'\\|'only_db'\\|'password'\\|'pdf_pages'\\|'pmadb'\\|'port'\\|'recent'\\|'relation'\\|'savedsearches'\\|'SessionTimeZone'\\|'SignonCookieParams'\\|'SignonScript'\\|'SignonSession'\\|'SignonURL'\\|'socket'\\|'ssl'\\|'ssl_ca'\\|'ssl_ca_path'\\|'ssl_cert'\\|'ssl_ciphers'\\|'ssl_key'\\|'ssl_verify'\\|'table_coords'\\|'table_info'\\|'table_uiprefs'\\|'tracking'\\|'user'\\|'userconfig'\\|'usergroups'\\|'users'\\|'verbose', array\\<array\\<string\\>\\|bool\\|int\\<0, max\\>\\|string\\>\\|bool\\|int\\<1, max\\>\\|string\\|null\\>\\> will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertIsArray\\(\\) with array\\<int\\<1, max\\>, non\\-empty\\-array\\<'AllowDeny'\\|'AllowNoPassword'\\|'AllowRoot'\\|'auth_http_realm'\\|'auth_type'\\|'bookmarktable'\\|'central_columns'\\|'column_info'\\|'compress'\\|'control_compress'\\|'control_hide…'\\|'control_socket'\\|'control_ssl'\\|'control_ssl_ca'\\|'control_ssl_ca_path'\\|'control_ssl_cert'\\|'control_ssl_ciphers'\\|'control_ssl_key'\\|'control_ssl_verify'\\|'controlhost'\\|'controlpass'\\|'controlport'\\|'controluser'\\|'designer_settings'\\|'DisableIS'\\|'export_templates'\\|'favorite'\\|'hide_db'\\|'history'\\|'host'\\|'LogoutURL'\\|'MaxTableUiprefs'\\|'navigationhiding'\\|'only_db'\\|'password'\\|'pdf_pages'\\|'pmadb'\\|'port'\\|'recent'\\|'relation'\\|'savedsearches'\\|'SessionTimeZone'\\|'SignonCookieParams'\\|'SignonScript'\\|'SignonSession'\\|'SignonURL'\\|'socket'\\|'ssl'\\|'ssl_ca'\\|'ssl_ca_path'\\|'ssl_cert'\\|'ssl_ciphers'\\|'ssl_key'\\|'ssl_verify'\\|'table_coords'\\|'table_info'\\|'table_uiprefs'\\|'tracking'\\|'user'\\|'userconfig'\\|'usergroups'\\|'users'\\|'verbose', array\\<array\\<string\\>\\|bool\\|int\\<0, max\\>\\|string\\>\\|bool\\|int\\<1, max\\>\\|string\\|null\\>\\> will always evaluate to true\\.$#"
 			count: 1
 			path: tests/classes/Config/DescriptionTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertIsArray\\(\\) with non\\-empty\\-array\\<'AllowDeny'\\|'AllowNoPassword'\\|'AllowRoot'\\|'auth_http_realm'\\|'auth_type'\\|'bookmarktable'\\|'central_columns'\\|'column_info'\\|'compress'\\|'control_compress'\\|'control_hide…'\\|'control_socket'\\|'control_ssl'\\|'control_ssl_ca'\\|'control_ssl_ca_path'\\|'control_ssl_cert'\\|'control_ssl_ciphers'\\|'control_ssl_key'\\|'control_ssl_verify'\\|'controlhost'\\|'controlpass'\\|'controlport'\\|'controluser'\\|'designer_settings'\\|'DisableIS'\\|'export_templates'\\|'favorite'\\|'hide_db'\\|'history'\\|'host'\\|'LogoutURL'\\|'MaxTableUiprefs'\\|'navigationhiding'\\|'only_db'\\|'password'\\|'pdf_pages'\\|'pmadb'\\|'port'\\|'recent'\\|'relation'\\|'savedsearches'\\|'SessionTimeZone'\\|'SignonCookieParams'\\|'SignonScript'\\|'SignonSession'\\|'SignonURL'\\|'socket'\\|'ssl'\\|'ssl_ca'\\|'ssl_ca_path'\\|'ssl_cert'\\|'ssl_ciphers'\\|'ssl_key'\\|'ssl_verify'\\|'table_coords'\\|'table_info'\\|'table_uiprefs'\\|'tracking'\\|'user'\\|'userconfig'\\|'usergroups'\\|'users'\\|'verbose', array\\<array\\<string\\>\\|bool\\|int\\<0, max\\>\\|string\\>\\|bool\\|int\\<1, max\\>\\|string\\|null\\> will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertIsArray\\(\\) with non\\-empty\\-array\\<'AllowDeny'\\|'AllowNoPassword'\\|'AllowRoot'\\|'auth_http_realm'\\|'auth_type'\\|'bookmarktable'\\|'central_columns'\\|'column_info'\\|'compress'\\|'control_compress'\\|'control_hide…'\\|'control_socket'\\|'control_ssl'\\|'control_ssl_ca'\\|'control_ssl_ca_path'\\|'control_ssl_cert'\\|'control_ssl_ciphers'\\|'control_ssl_key'\\|'control_ssl_verify'\\|'controlhost'\\|'controlpass'\\|'controlport'\\|'controluser'\\|'designer_settings'\\|'DisableIS'\\|'export_templates'\\|'favorite'\\|'hide_db'\\|'history'\\|'host'\\|'LogoutURL'\\|'MaxTableUiprefs'\\|'navigationhiding'\\|'only_db'\\|'password'\\|'pdf_pages'\\|'pmadb'\\|'port'\\|'recent'\\|'relation'\\|'savedsearches'\\|'SessionTimeZone'\\|'SignonCookieParams'\\|'SignonScript'\\|'SignonSession'\\|'SignonURL'\\|'socket'\\|'ssl'\\|'ssl_ca'\\|'ssl_ca_path'\\|'ssl_cert'\\|'ssl_ciphers'\\|'ssl_key'\\|'ssl_verify'\\|'table_coords'\\|'table_info'\\|'table_uiprefs'\\|'tracking'\\|'user'\\|'userconfig'\\|'usergroups'\\|'users'\\|'verbose', array\\<array\\<string\\>\\|bool\\|int\\<0, max\\>\\|string\\>\\|bool\\|int\\<1, max\\>\\|string\\|null\\> will always evaluate to true\\.$#"
 			count: 1
 			path: tests/classes/Config/DescriptionTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertNotNull\\(\\) with array\\<string\\>\\|bool\\|int\\<0, max\\>\\|string will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertNotNull\\(\\) with array\\<string\\>\\|bool\\|int\\<0, max\\>\\|string will always evaluate to true\\.$#"
 			count: 1
 			path: tests/classes/Config/DescriptionTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertNotNull\\(\\) with string will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertNotNull\\(\\) with string will always evaluate to true\\.$#"
 			count: 3
 			path: tests/classes/Config/DescriptionTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertTrue\\(\\) with null will always evaluate to false\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertTrue\\(\\) with null will always evaluate to false\\.$#"
 			count: 1
 			path: tests/classes/Config/FormDisplayTest.php
 
@@ -15976,12 +15976,12 @@ parameters:
 			path: tests/classes/Config/FormDisplayTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertInstanceOf\\(\\) with 'PhpMyAdmin\\\\\\\\Config\\\\\\\\Forms\\\\\\\\BaseFormList' and PhpMyAdmin\\\\Config\\\\Forms\\\\BaseFormList will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertInstanceOf\\(\\) with 'PhpMyAdmin\\\\\\\\Config\\\\\\\\Forms\\\\\\\\BaseFormList' and PhpMyAdmin\\\\Config\\\\Forms\\\\BaseFormList will always evaluate to true\\.$#"
 			count: 1
 			path: tests/classes/Config/Forms/FormListTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertNotNull\\(\\) with string will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertNotNull\\(\\) with string will always evaluate to true\\.$#"
 			count: 1
 			path: tests/classes/Config/Forms/FormListTest.php
 
@@ -16066,37 +16066,37 @@ parameters:
 			path: tests/classes/Config/Settings/SchemaTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertInstanceOf\\(\\) with 'PhpMyAdmin\\\\\\\\Config\\\\\\\\Settings\\\\\\\\Console' and PhpMyAdmin\\\\Config\\\\Settings\\\\Console will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertInstanceOf\\(\\) with 'PhpMyAdmin\\\\\\\\Config\\\\\\\\Settings\\\\\\\\Console' and PhpMyAdmin\\\\Config\\\\Settings\\\\Console will always evaluate to true\\.$#"
 			count: 1
 			path: tests/classes/Config/SettingsTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertInstanceOf\\(\\) with 'PhpMyAdmin\\\\\\\\Config\\\\\\\\Settings\\\\\\\\Debug' and PhpMyAdmin\\\\Config\\\\Settings\\\\Debug will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertInstanceOf\\(\\) with 'PhpMyAdmin\\\\\\\\Config\\\\\\\\Settings\\\\\\\\Debug' and PhpMyAdmin\\\\Config\\\\Settings\\\\Debug will always evaluate to true\\.$#"
 			count: 1
 			path: tests/classes/Config/SettingsTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertInstanceOf\\(\\) with 'PhpMyAdmin\\\\\\\\Config\\\\\\\\Settings\\\\\\\\Export' and PhpMyAdmin\\\\Config\\\\Settings\\\\Export will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertInstanceOf\\(\\) with 'PhpMyAdmin\\\\\\\\Config\\\\\\\\Settings\\\\\\\\Export' and PhpMyAdmin\\\\Config\\\\Settings\\\\Export will always evaluate to true\\.$#"
 			count: 1
 			path: tests/classes/Config/SettingsTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertInstanceOf\\(\\) with 'PhpMyAdmin\\\\\\\\Config\\\\\\\\Settings\\\\\\\\Import' and PhpMyAdmin\\\\Config\\\\Settings\\\\Import will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertInstanceOf\\(\\) with 'PhpMyAdmin\\\\\\\\Config\\\\\\\\Settings\\\\\\\\Import' and PhpMyAdmin\\\\Config\\\\Settings\\\\Import will always evaluate to true\\.$#"
 			count: 1
 			path: tests/classes/Config/SettingsTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertInstanceOf\\(\\) with 'PhpMyAdmin\\\\\\\\Config\\\\\\\\Settings\\\\\\\\Schema' and PhpMyAdmin\\\\Config\\\\Settings\\\\Schema will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertInstanceOf\\(\\) with 'PhpMyAdmin\\\\\\\\Config\\\\\\\\Settings\\\\\\\\Schema' and PhpMyAdmin\\\\Config\\\\Settings\\\\Schema will always evaluate to true\\.$#"
 			count: 1
 			path: tests/classes/Config/SettingsTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertInstanceOf\\(\\) with 'PhpMyAdmin\\\\\\\\Config\\\\\\\\Settings\\\\\\\\SqlQueryBox' and PhpMyAdmin\\\\Config\\\\Settings\\\\SqlQueryBox will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertInstanceOf\\(\\) with 'PhpMyAdmin\\\\\\\\Config\\\\\\\\Settings\\\\\\\\SqlQueryBox' and PhpMyAdmin\\\\Config\\\\Settings\\\\SqlQueryBox will always evaluate to true\\.$#"
 			count: 1
 			path: tests/classes/Config/SettingsTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertInstanceOf\\(\\) with 'PhpMyAdmin\\\\\\\\Config\\\\\\\\Settings\\\\\\\\Transformations' and PhpMyAdmin\\\\Config\\\\Settings\\\\Transformations will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertInstanceOf\\(\\) with 'PhpMyAdmin\\\\\\\\Config\\\\\\\\Settings\\\\\\\\Transformations' and PhpMyAdmin\\\\Config\\\\Settings\\\\Transformations will always evaluate to true\\.$#"
 			count: 1
 			path: tests/classes/Config/SettingsTest.php
 
@@ -16111,17 +16111,17 @@ parameters:
 			path: tests/classes/Config/SettingsTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) with arguments 'relation', array\\{version\\: string, user\\: string\\|null, db\\: string\\|null, bookmark\\: string\\|null, central_columns\\: string\\|null, column_info\\: string\\|null, designer_settings\\: string\\|null, export_templates\\: string\\|null, \\.\\.\\.\\} and 'The cache is…' will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) with arguments 'relation', array\\{version\\: string, user\\: string\\|null, db\\: string\\|null, bookmark\\: string\\|null, central_columns\\: string\\|null, column_info\\: string\\|null, designer_settings\\: string\\|null, export_templates\\: string\\|null, \\.\\.\\.\\} and 'The cache is…' will always evaluate to true\\.$#"
 			count: 3
 			path: tests/classes/ConfigStorage/RelationTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertSame\\(\\) with '' and '' will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertSame\\(\\) with '' and '' will always evaluate to true\\.$#"
 			count: 2
 			path: tests/classes/ConfigStorage/RelationTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertSame\\(\\) with 'db_pma' and 'db_pma' will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertSame\\(\\) with 'db_pma' and 'db_pma' will always evaluate to true\\.$#"
 			count: 1
 			path: tests/classes/ConfigStorage/RelationTest.php
 
@@ -16131,12 +16131,12 @@ parameters:
 			path: tests/classes/ConfigStorage/RelationTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) with 'Server' and array\\{PmaAbsoluteUri\\: string, AuthLog\\: string, AuthLogSuccess\\: bool, PmaNoRelation_DisableWarning\\: bool, SuhosinDisableWarning\\: bool, LoginCookieValidityDisableWarning\\: bool, ReservedWordDisableWarning\\: bool, TranslationWarningThreshold\\: int, \\.\\.\\.\\} will always evaluate to false\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) with 'Server' and array\\{PmaAbsoluteUri\\: string, AuthLog\\: string, AuthLogSuccess\\: bool, PmaNoRelation_DisableWarning\\: bool, SuhosinDisableWarning\\: bool, LoginCookieValidityDisableWarning\\: bool, ReservedWordDisableWarning\\: bool, TranslationWarningThreshold\\: int, \\.\\.\\.\\} will always evaluate to false\\.$#"
 			count: 1
 			path: tests/classes/ConfigTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertIsArray\\(\\) with array\\<int\\<1, max\\>, array\\{host\\: string, port\\: string, socket\\: string, ssl\\: bool, ssl_key\\: string\\|null, ssl_cert\\: string\\|null, ssl_ca\\: string\\|null, ssl_ca_path\\: string\\|null, \\.\\.\\.\\}\\> will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertIsArray\\(\\) with array\\<int\\<1, max\\>, array\\{host\\: string, port\\: string, socket\\: string, ssl\\: bool, ssl_key\\: string\\|null, ssl_cert\\: string\\|null, ssl_ca\\: string\\|null, ssl_ca_path\\: string\\|null, \\.\\.\\.\\}\\> will always evaluate to true\\.$#"
 			count: 1
 			path: tests/classes/ConfigTest.php
 
@@ -16206,22 +16206,22 @@ parameters:
 			path: tests/classes/Controllers/Database/StructureControllerTest.php
 
 		-
-			message: "#^Parameter \\#2 \\$array of method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayNotHasKey\\(\\) expects array\\|ArrayAccess, mixed given\\.$#"
+			message: "#^Parameter \\#2 \\$array of static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayNotHasKey\\(\\) expects array\\|ArrayAccess, mixed given\\.$#"
 			count: 1
 			path: tests/classes/Controllers/Database/StructureControllerTest.php
 
 		-
-			message: "#^Parameter \\#2 \\$haystack of method PHPUnit\\\\Framework\\\\Assert\\:\\:assertStringContainsString\\(\\) expects string, mixed given\\.$#"
+			message: "#^Parameter \\#2 \\$haystack of static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertStringContainsString\\(\\) expects string, mixed given\\.$#"
 			count: 4
 			path: tests/classes/Controllers/Database/StructureControllerTest.php
 
 		-
-			message: "#^Parameter \\#2 \\$haystack of method PHPUnit\\\\Framework\\\\Assert\\:\\:assertStringNotContainsString\\(\\) expects string, mixed given\\.$#"
+			message: "#^Parameter \\#2 \\$haystack of static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertStringNotContainsString\\(\\) expects string, mixed given\\.$#"
 			count: 1
 			path: tests/classes/Controllers/Database/StructureControllerTest.php
 
 		-
-			message: "#^Parameter \\#2 \\$haystack of method PHPUnit\\\\Framework\\\\Assert\\:\\:assertStringContainsString\\(\\) expects string, mixed given\\.$#"
+			message: "#^Parameter \\#2 \\$haystack of static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertStringContainsString\\(\\) expects string, mixed given\\.$#"
 			count: 4
 			path: tests/classes/Controllers/NavigationControllerTest.php
 
@@ -16236,12 +16236,12 @@ parameters:
 			path: tests/classes/Controllers/Server/BinlogControllerTest.php
 
 		-
-			message: "#^Parameter \\#2 \\$haystack of method PHPUnit\\\\Framework\\\\Assert\\:\\:assertStringContainsString\\(\\) expects string, mixed given\\.$#"
+			message: "#^Parameter \\#2 \\$haystack of static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertStringContainsString\\(\\) expects string, mixed given\\.$#"
 			count: 3
 			path: tests/classes/Controllers/Server/Databases/CreateControllerTest.php
 
 		-
-			message: "#^Parameter \\#2 \\$haystack of method PHPUnit\\\\Framework\\\\Assert\\:\\:assertStringContainsString\\(\\) expects string, mixed given\\.$#"
+			message: "#^Parameter \\#2 \\$haystack of static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertStringContainsString\\(\\) expects string, mixed given\\.$#"
 			count: 2
 			path: tests/classes/Controllers/Server/Databases/DestroyControllerTest.php
 
@@ -16346,7 +16346,7 @@ parameters:
 			path: tests/classes/CoreTest.php
 
 		-
-			message: "#^Parameter \\#2 \\$array of method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayNotHasKey\\(\\) expects array\\|ArrayAccess, mixed given\\.$#"
+			message: "#^Parameter \\#2 \\$array of static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayNotHasKey\\(\\) expects array\\|ArrayAccess, mixed given\\.$#"
 			count: 12
 			path: tests/classes/CoreTest.php
 
@@ -16356,7 +16356,7 @@ parameters:
 			path: tests/classes/Crypto/CryptoTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertIsArray\\(\\) with array\\<string\\> will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertIsArray\\(\\) with array\\<string\\> will always evaluate to true\\.$#"
 			count: 1
 			path: tests/classes/Database/CentralColumnsTest.php
 
@@ -16366,7 +16366,7 @@ parameters:
 			path: tests/classes/Database/CentralColumnsTest.php
 
 		-
-			message: "#^Parameter \\#1 \\$needle of method PHPUnit\\\\Framework\\\\Assert\\:\\:assertStringContainsString\\(\\) expects string, mixed given\\.$#"
+			message: "#^Parameter \\#1 \\$needle of static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertStringContainsString\\(\\) expects string, mixed given\\.$#"
 			count: 1
 			path: tests/classes/Database/CentralColumnsTest.php
 
@@ -16386,12 +16386,12 @@ parameters:
 			path: tests/classes/Database/DesignerTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertInstanceOf\\(\\) with 'PhpMyAdmin\\\\\\\\Dbal\\\\\\\\ResultInterface' and PhpMyAdmin\\\\Dbal\\\\ResultInterface will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertInstanceOf\\(\\) with 'PhpMyAdmin\\\\\\\\Dbal\\\\\\\\ResultInterface' and PhpMyAdmin\\\\Dbal\\\\ResultInterface will always evaluate to true\\.$#"
 			count: 1
 			path: tests/classes/DatabaseInterfaceTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertInstanceOf\\(\\) with 'PhpMyAdmin\\\\\\\\SystemDatabase' and PhpMyAdmin\\\\SystemDatabase will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertInstanceOf\\(\\) with 'PhpMyAdmin\\\\\\\\SystemDatabase' and PhpMyAdmin\\\\SystemDatabase will always evaluate to true\\.$#"
 			count: 1
 			path: tests/classes/DatabaseInterfaceTest.php
 
@@ -16481,7 +16481,7 @@ parameters:
 			path: tests/classes/Display/ResultsTest.php
 
 		-
-			message: "#^Parameter \\#2 \\$haystack of method PHPUnit\\\\Framework\\\\Assert\\:\\:assertStringContainsString\\(\\) expects string, mixed given\\.$#"
+			message: "#^Parameter \\#2 \\$haystack of static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertStringContainsString\\(\\) expects string, mixed given\\.$#"
 			count: 4
 			path: tests/classes/Display/ResultsTest.php
 
@@ -16501,12 +16501,12 @@ parameters:
 			path: tests/classes/Export/OptionsTest.php
 
 		-
-			message: "#^Parameter \\#2 \\$array of method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) expects array\\|ArrayAccess, mixed given\\.$#"
+			message: "#^Parameter \\#2 \\$array of static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) expects array\\|ArrayAccess, mixed given\\.$#"
 			count: 1
 			path: tests/classes/FlashMessagesTest.php
 
 		-
-			message: "#^Parameter \\#2 \\$array of method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayNotHasKey\\(\\) expects array\\|ArrayAccess, mixed given\\.$#"
+			message: "#^Parameter \\#2 \\$array of static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayNotHasKey\\(\\) expects array\\|ArrayAccess, mixed given\\.$#"
 			count: 1
 			path: tests/classes/FlashMessagesTest.php
 
@@ -16591,7 +16591,7 @@ parameters:
 			path: tests/classes/Html/GeneratorTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertTrue\\(\\) with true will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertTrue\\(\\) with true will always evaluate to true\\.$#"
 			count: 1
 			path: tests/classes/Import/AjaxTest.php
 
@@ -16666,152 +16666,152 @@ parameters:
 			path: tests/classes/Navigation/Nodes/NodeTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) with 'extra' and array\\{legendText\\: string, headText\\: string, queryError\\: bool, extra\\: PhpMyAdmin\\\\Message\\} will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) with 'extra' and array\\{legendText\\: string, headText\\: string, queryError\\: bool, extra\\: PhpMyAdmin\\\\Message\\} will always evaluate to true\\.$#"
 			count: 1
 			path: tests/classes/NormalizationTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) with 'extra' and array\\{legendText\\: string, headText\\: string, subText\\: string, extra\\: string, primary_key\\: string\\|false\\} will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) with 'extra' and array\\{legendText\\: string, headText\\: string, subText\\: string, extra\\: string, primary_key\\: string\\|false\\} will always evaluate to true\\.$#"
 			count: 1
 			path: tests/classes/NormalizationTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) with 'extra' and array\\{legendText\\: string, headText\\: string, subText\\: string, extra\\: string, primary_key\\: string\\} will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) with 'extra' and array\\{legendText\\: string, headText\\: string, subText\\: string, extra\\: string, primary_key\\: string\\} will always evaluate to true\\.$#"
 			count: 1
 			path: tests/classes/NormalizationTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) with 'extra' and array\\{legendText\\: string, headText\\: string, subText\\: string, extra\\: string\\} will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) with 'extra' and array\\{legendText\\: string, headText\\: string, subText\\: string, extra\\: string\\} will always evaluate to true\\.$#"
 			count: 2
 			path: tests/classes/NormalizationTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) with 'extra' and array\\{legendText\\: string, headText\\: string, subText\\: string, hasPrimaryKey\\: string, extra\\: string\\} will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) with 'extra' and array\\{legendText\\: string, headText\\: string, subText\\: string, hasPrimaryKey\\: string, extra\\: string\\} will always evaluate to true\\.$#"
 			count: 1
 			path: tests/classes/NormalizationTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) with 'hasPrimaryKey' and array\\{legendText\\: string, headText\\: string, subText\\: string, hasPrimaryKey\\: string, extra\\: string\\} will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) with 'hasPrimaryKey' and array\\{legendText\\: string, headText\\: string, subText\\: string, hasPrimaryKey\\: string, extra\\: string\\} will always evaluate to true\\.$#"
 			count: 1
 			path: tests/classes/NormalizationTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) with 'headText' and array\\{legendText\\: string, headText\\: string, queryError\\: bool, extra\\: PhpMyAdmin\\\\Message\\} will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) with 'headText' and array\\{legendText\\: string, headText\\: string, queryError\\: bool, extra\\: PhpMyAdmin\\\\Message\\} will always evaluate to true\\.$#"
 			count: 1
 			path: tests/classes/NormalizationTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) with 'headText' and array\\{legendText\\: string, headText\\: string, queryError\\: string\\|false, extra\\?\\: string\\} will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) with 'headText' and array\\{legendText\\: string, headText\\: string, queryError\\: string\\|false, extra\\?\\: string\\} will always evaluate to true\\.$#"
 			count: 1
 			path: tests/classes/NormalizationTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) with 'headText' and array\\{legendText\\: string, headText\\: string, subText\\: string, extra\\: string, primary_key\\: string\\|false\\} will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) with 'headText' and array\\{legendText\\: string, headText\\: string, subText\\: string, extra\\: string, primary_key\\: string\\|false\\} will always evaluate to true\\.$#"
 			count: 1
 			path: tests/classes/NormalizationTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) with 'headText' and array\\{legendText\\: string, headText\\: string, subText\\: string, extra\\: string, primary_key\\: string\\} will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) with 'headText' and array\\{legendText\\: string, headText\\: string, subText\\: string, extra\\: string, primary_key\\: string\\} will always evaluate to true\\.$#"
 			count: 1
 			path: tests/classes/NormalizationTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) with 'headText' and array\\{legendText\\: string, headText\\: string, subText\\: string, extra\\: string\\} will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) with 'headText' and array\\{legendText\\: string, headText\\: string, subText\\: string, extra\\: string\\} will always evaluate to true\\.$#"
 			count: 2
 			path: tests/classes/NormalizationTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) with 'headText' and array\\{legendText\\: string, headText\\: string, subText\\: string, hasPrimaryKey\\: string, extra\\: string\\} will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) with 'headText' and array\\{legendText\\: string, headText\\: string, subText\\: string, hasPrimaryKey\\: string, extra\\: string\\} will always evaluate to true\\.$#"
 			count: 1
 			path: tests/classes/NormalizationTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) with 'legendText' and array\\{legendText\\: string, headText\\: string, queryError\\: bool, extra\\: PhpMyAdmin\\\\Message\\} will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) with 'legendText' and array\\{legendText\\: string, headText\\: string, queryError\\: bool, extra\\: PhpMyAdmin\\\\Message\\} will always evaluate to true\\.$#"
 			count: 1
 			path: tests/classes/NormalizationTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) with 'legendText' and array\\{legendText\\: string, headText\\: string, queryError\\: string\\|false, extra\\?\\: string\\} will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) with 'legendText' and array\\{legendText\\: string, headText\\: string, queryError\\: string\\|false, extra\\?\\: string\\} will always evaluate to true\\.$#"
 			count: 1
 			path: tests/classes/NormalizationTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) with 'legendText' and array\\{legendText\\: string, headText\\: string, subText\\: string, extra\\: string, primary_key\\: string\\|false\\} will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) with 'legendText' and array\\{legendText\\: string, headText\\: string, subText\\: string, extra\\: string, primary_key\\: string\\|false\\} will always evaluate to true\\.$#"
 			count: 1
 			path: tests/classes/NormalizationTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) with 'legendText' and array\\{legendText\\: string, headText\\: string, subText\\: string, extra\\: string, primary_key\\: string\\} will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) with 'legendText' and array\\{legendText\\: string, headText\\: string, subText\\: string, extra\\: string, primary_key\\: string\\} will always evaluate to true\\.$#"
 			count: 1
 			path: tests/classes/NormalizationTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) with 'legendText' and array\\{legendText\\: string, headText\\: string, subText\\: string, extra\\: string\\} will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) with 'legendText' and array\\{legendText\\: string, headText\\: string, subText\\: string, extra\\: string\\} will always evaluate to true\\.$#"
 			count: 2
 			path: tests/classes/NormalizationTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) with 'legendText' and array\\{legendText\\: string, headText\\: string, subText\\: string, hasPrimaryKey\\: string, extra\\: string\\} will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) with 'legendText' and array\\{legendText\\: string, headText\\: string, subText\\: string, hasPrimaryKey\\: string, extra\\: string\\} will always evaluate to true\\.$#"
 			count: 1
 			path: tests/classes/NormalizationTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) with 'message' and array\\{queryError\\: bool, message\\: PhpMyAdmin\\\\Message\\} will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) with 'message' and array\\{queryError\\: bool, message\\: PhpMyAdmin\\\\Message\\} will always evaluate to true\\.$#"
 			count: 1
 			path: tests/classes/NormalizationTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) with 'primary_key' and array\\{legendText\\: string, headText\\: string, subText\\: string, extra\\: string, primary_key\\: string\\|false\\} will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) with 'primary_key' and array\\{legendText\\: string, headText\\: string, subText\\: string, extra\\: string, primary_key\\: string\\|false\\} will always evaluate to true\\.$#"
 			count: 1
 			path: tests/classes/NormalizationTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) with 'primary_key' and array\\{legendText\\: string, headText\\: string, subText\\: string, extra\\: string, primary_key\\: string\\} will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) with 'primary_key' and array\\{legendText\\: string, headText\\: string, subText\\: string, extra\\: string, primary_key\\: string\\} will always evaluate to true\\.$#"
 			count: 1
 			path: tests/classes/NormalizationTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) with 'queryError' and array\\{legendText\\: string, headText\\: string, queryError\\: bool, extra\\: PhpMyAdmin\\\\Message\\} will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) with 'queryError' and array\\{legendText\\: string, headText\\: string, queryError\\: bool, extra\\: PhpMyAdmin\\\\Message\\} will always evaluate to true\\.$#"
 			count: 1
 			path: tests/classes/NormalizationTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) with 'queryError' and array\\{legendText\\: string, headText\\: string, queryError\\: string\\|false, extra\\?\\: string\\} will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) with 'queryError' and array\\{legendText\\: string, headText\\: string, queryError\\: string\\|false, extra\\?\\: string\\} will always evaluate to true\\.$#"
 			count: 2
 			path: tests/classes/NormalizationTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) with 'queryError' and array\\{queryError\\: bool, message\\: PhpMyAdmin\\\\Message\\} will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) with 'queryError' and array\\{queryError\\: bool, message\\: PhpMyAdmin\\\\Message\\} will always evaluate to true\\.$#"
 			count: 1
 			path: tests/classes/NormalizationTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) with 'subText' and array\\{legendText\\: string, headText\\: string, subText\\: string, extra\\: string, primary_key\\: string\\|false\\} will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) with 'subText' and array\\{legendText\\: string, headText\\: string, subText\\: string, extra\\: string, primary_key\\: string\\|false\\} will always evaluate to true\\.$#"
 			count: 1
 			path: tests/classes/NormalizationTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) with 'subText' and array\\{legendText\\: string, headText\\: string, subText\\: string, extra\\: string, primary_key\\: string\\} will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) with 'subText' and array\\{legendText\\: string, headText\\: string, subText\\: string, extra\\: string, primary_key\\: string\\} will always evaluate to true\\.$#"
 			count: 1
 			path: tests/classes/NormalizationTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) with 'subText' and array\\{legendText\\: string, headText\\: string, subText\\: string, extra\\: string\\} will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) with 'subText' and array\\{legendText\\: string, headText\\: string, subText\\: string, extra\\: string\\} will always evaluate to true\\.$#"
 			count: 2
 			path: tests/classes/NormalizationTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) with 'subText' and array\\{legendText\\: string, headText\\: string, subText\\: string, hasPrimaryKey\\: string, extra\\: string\\} will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) with 'subText' and array\\{legendText\\: string, headText\\: string, subText\\: string, hasPrimaryKey\\: string, extra\\: string\\} will always evaluate to true\\.$#"
 			count: 1
 			path: tests/classes/NormalizationTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertInstanceOf\\(\\) with 'PhpMyAdmin\\\\\\\\Message' and PhpMyAdmin\\\\Message will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertInstanceOf\\(\\) with 'PhpMyAdmin\\\\\\\\Message' and PhpMyAdmin\\\\Message will always evaluate to true\\.$#"
 			count: 1
 			path: tests/classes/NormalizationTest.php
 
 		-
-			message: "#^Parameter \\#2 \\$haystack of method PHPUnit\\\\Framework\\\\Assert\\:\\:assertStringContainsString\\(\\) expects string, mixed given\\.$#"
+			message: "#^Parameter \\#2 \\$haystack of static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertStringContainsString\\(\\) expects string, mixed given\\.$#"
 			count: 1
 			path: tests/classes/NormalizationTest.php
 
@@ -16821,12 +16821,12 @@ parameters:
 			path: tests/classes/NormalizationTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertNotFalse\\(\\) with string will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertNotFalse\\(\\) with string will always evaluate to true\\.$#"
 			count: 1
 			path: tests/classes/OpenDocumentTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertInstanceOf\\(\\) with 'PhpMyAdmin\\\\\\\\StatementInfo' and PhpMyAdmin\\\\StatementInfo will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertInstanceOf\\(\\) with 'PhpMyAdmin\\\\\\\\StatementInfo' and PhpMyAdmin\\\\StatementInfo will always evaluate to true\\.$#"
 			count: 2
 			path: tests/classes/ParseAnalyzeTest.php
 
@@ -16836,7 +16836,7 @@ parameters:
 			path: tests/classes/Partitioning/TablePartitionDefinitionTest.php
 
 		-
-			message: "#^Parameter \\#2 \\$haystack of method PHPUnit\\\\Framework\\\\Assert\\:\\:assertStringContainsString\\(\\) expects string, mixed given\\.$#"
+			message: "#^Parameter \\#2 \\$haystack of static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertStringContainsString\\(\\) expects string, mixed given\\.$#"
 			count: 3
 			path: tests/classes/PdfTest.php
 
@@ -16851,7 +16851,7 @@ parameters:
 			path: tests/classes/Plugins/Auth/AuthenticationConfigTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertSame\\(\\) with 32 and 0 will always evaluate to false\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertSame\\(\\) with 32 and 0 will always evaluate to false\\.$#"
 			count: 1
 			path: tests/classes/Plugins/Auth/AuthenticationCookieTest.php
 
@@ -16901,7 +16901,7 @@ parameters:
 			path: tests/classes/Plugins/Auth/AuthenticationSignonTest.php
 
 		-
-			message: "#^Parameter \\#2 \\$haystack of method PHPUnit\\\\Framework\\\\Assert\\:\\:assertStringContainsString\\(\\) expects string, mixed given\\.$#"
+			message: "#^Parameter \\#2 \\$haystack of static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertStringContainsString\\(\\) expects string, mixed given\\.$#"
 			count: 1
 			path: tests/classes/Plugins/Export/ExportHtmlwordTest.php
 
@@ -16931,7 +16931,7 @@ parameters:
 			path: tests/classes/Plugins/Export/ExportOdtTest.php
 
 		-
-			message: "#^Parameter \\#2 \\$haystack of method PHPUnit\\\\Framework\\\\Assert\\:\\:assertStringContainsString\\(\\) expects string, mixed given\\.$#"
+			message: "#^Parameter \\#2 \\$haystack of static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertStringContainsString\\(\\) expects string, mixed given\\.$#"
 			count: 11
 			path: tests/classes/Plugins/Export/ExportOdtTest.php
 
@@ -16946,7 +16946,7 @@ parameters:
 			path: tests/classes/Plugins/Export/ExportSqlTest.php
 
 		-
-			message: "#^Parameter \\#2 \\$haystack of method PHPUnit\\\\Framework\\\\Assert\\:\\:assertStringContainsString\\(\\) expects string, mixed given\\.$#"
+			message: "#^Parameter \\#2 \\$haystack of static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertStringContainsString\\(\\) expects string, mixed given\\.$#"
 			count: 10
 			path: tests/classes/Plugins/Export/ExportSqlTest.php
 
@@ -16981,12 +16981,12 @@ parameters:
 			path: tests/classes/Plugins/Import/ImportCsvTest.php
 
 		-
-			message: "#^Parameter \\#2 \\$haystack of method PHPUnit\\\\Framework\\\\Assert\\:\\:assertStringContainsString\\(\\) expects string, mixed given\\.$#"
+			message: "#^Parameter \\#2 \\$haystack of static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertStringContainsString\\(\\) expects string, mixed given\\.$#"
 			count: 6
 			path: tests/classes/Plugins/Import/ImportCsvTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertTrue\\(\\) with 'auto' will always evaluate to false\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertTrue\\(\\) with 'auto' will always evaluate to false\\.$#"
 			count: 1
 			path: tests/classes/Plugins/Import/ImportLdiTest.php
 
@@ -17001,7 +17001,7 @@ parameters:
 			path: tests/classes/Plugins/Import/ImportLdiTest.php
 
 		-
-			message: "#^Parameter \\#2 \\$haystack of method PHPUnit\\\\Framework\\\\Assert\\:\\:assertStringContainsString\\(\\) expects string, mixed given\\.$#"
+			message: "#^Parameter \\#2 \\$haystack of static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertStringContainsString\\(\\) expects string, mixed given\\.$#"
 			count: 6
 			path: tests/classes/Plugins/Import/ImportLdiTest.php
 
@@ -17011,7 +17011,7 @@ parameters:
 			path: tests/classes/Plugins/Import/ImportMediawikiTest.php
 
 		-
-			message: "#^Parameter \\#2 \\$haystack of method PHPUnit\\\\Framework\\\\Assert\\:\\:assertStringContainsString\\(\\) expects string, mixed given\\.$#"
+			message: "#^Parameter \\#2 \\$haystack of static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertStringContainsString\\(\\) expects string, mixed given\\.$#"
 			count: 5
 			path: tests/classes/Plugins/Import/ImportMediawikiTest.php
 
@@ -17026,7 +17026,7 @@ parameters:
 			path: tests/classes/Plugins/Import/ImportOdsTest.php
 
 		-
-			message: "#^Parameter \\#2 \\$haystack of method PHPUnit\\\\Framework\\\\Assert\\:\\:assertStringContainsString\\(\\) expects string, mixed given\\.$#"
+			message: "#^Parameter \\#2 \\$haystack of static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertStringContainsString\\(\\) expects string, mixed given\\.$#"
 			count: 13
 			path: tests/classes/Plugins/Import/ImportOdsTest.php
 
@@ -17036,7 +17036,7 @@ parameters:
 			path: tests/classes/Plugins/Import/ImportShpTest.php
 
 		-
-			message: "#^Parameter \\#2 \\$haystack of method PHPUnit\\\\Framework\\\\Assert\\:\\:assertStringContainsString\\(\\) expects string, mixed given\\.$#"
+			message: "#^Parameter \\#2 \\$haystack of static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertStringContainsString\\(\\) expects string, mixed given\\.$#"
 			count: 7
 			path: tests/classes/Plugins/Import/ImportShpTest.php
 
@@ -17046,7 +17046,7 @@ parameters:
 			path: tests/classes/Plugins/Import/ImportSqlTest.php
 
 		-
-			message: "#^Parameter \\#2 \\$haystack of method PHPUnit\\\\Framework\\\\Assert\\:\\:assertStringContainsString\\(\\) expects string, mixed given\\.$#"
+			message: "#^Parameter \\#2 \\$haystack of static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertStringContainsString\\(\\) expects string, mixed given\\.$#"
 			count: 3
 			path: tests/classes/Plugins/Import/ImportSqlTest.php
 
@@ -17056,7 +17056,7 @@ parameters:
 			path: tests/classes/Plugins/Import/ImportXmlTest.php
 
 		-
-			message: "#^Parameter \\#2 \\$haystack of method PHPUnit\\\\Framework\\\\Assert\\:\\:assertStringContainsString\\(\\) expects string, mixed given\\.$#"
+			message: "#^Parameter \\#2 \\$haystack of static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertStringContainsString\\(\\) expects string, mixed given\\.$#"
 			count: 5
 			path: tests/classes/Plugins/Import/ImportXmlTest.php
 
@@ -17066,17 +17066,17 @@ parameters:
 			path: tests/classes/Plugins/Transformations/TransformationPluginsTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertIsArray\\(\\) with array\\<int, PhpMyAdmin\\\\Plugins\\\\ExportPlugin\\> will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertIsArray\\(\\) with array\\<int, PhpMyAdmin\\\\Plugins\\\\ExportPlugin\\> will always evaluate to true\\.$#"
 			count: 1
 			path: tests/classes/PluginsTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertIsArray\\(\\) with array\\<int, PhpMyAdmin\\\\Plugins\\\\ImportPlugin\\> will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertIsArray\\(\\) with array\\<int, PhpMyAdmin\\\\Plugins\\\\ImportPlugin\\> will always evaluate to true\\.$#"
 			count: 1
 			path: tests/classes/PluginsTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertIsArray\\(\\) with array\\<int, PhpMyAdmin\\\\Plugins\\\\SchemaPlugin\\> will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertIsArray\\(\\) with array\\<int, PhpMyAdmin\\\\Plugins\\\\SchemaPlugin\\> will always evaluate to true\\.$#"
 			count: 1
 			path: tests/classes/PluginsTest.php
 
@@ -17086,7 +17086,7 @@ parameters:
 			path: tests/classes/PluginsTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertInstanceOf\\(\\) with 'PhpMyAdmin\\\\\\\\Properties\\\\\\\\Options\\\\\\\\OptionsPropertyGroup' and PhpMyAdmin\\\\Properties\\\\Options\\\\OptionsPropertyGroup&PHPUnit\\\\Framework\\\\MockObject\\\\MockObject will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertInstanceOf\\(\\) with 'PhpMyAdmin\\\\\\\\Properties\\\\\\\\Options\\\\\\\\OptionsPropertyGroup' and PhpMyAdmin\\\\Properties\\\\Options\\\\OptionsPropertyGroup&PHPUnit\\\\Framework\\\\MockObject\\\\MockObject will always evaluate to true\\.$#"
 			count: 1
 			path: tests/classes/Properties/Options/OptionsPropertyGroupTest.php
 
@@ -17096,7 +17096,7 @@ parameters:
 			path: tests/classes/Replication/ReplicationGuiTest.php
 
 		-
-			message: "#^Parameter \\#1 \\$directory of method PHPUnit\\\\Framework\\\\Assert\\:\\:assertDirectoryIsWritable\\(\\) expects string, mixed given\\.$#"
+			message: "#^Parameter \\#1 \\$directory of static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertDirectoryIsWritable\\(\\) expects string, mixed given\\.$#"
 			count: 1
 			path: tests/classes/Routing/RoutingTest.php
 
@@ -17106,22 +17106,22 @@ parameters:
 			path: tests/classes/Routing/RoutingTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertInstanceOf\\(\\) with 'PhpMyAdmin\\\\\\\\Server\\\\\\\\Plugin' and PhpMyAdmin\\\\Server\\\\Plugin will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertInstanceOf\\(\\) with 'PhpMyAdmin\\\\\\\\Server\\\\\\\\Plugin' and PhpMyAdmin\\\\Server\\\\Plugin will always evaluate to true\\.$#"
 			count: 1
 			path: tests/classes/Server/PluginTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertInstanceOf\\(\\) with 'PhpMyAdmin\\\\\\\\Server\\\\\\\\Plugin' and PhpMyAdmin\\\\Server\\\\Plugin will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertInstanceOf\\(\\) with 'PhpMyAdmin\\\\\\\\Server\\\\\\\\Plugin' and PhpMyAdmin\\\\Server\\\\Plugin will always evaluate to true\\.$#"
 			count: 2
 			path: tests/classes/Server/PluginsTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertIsArray\\(\\) with array\\<PhpMyAdmin\\\\Server\\\\Plugin\\> will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertIsArray\\(\\) with array\\<PhpMyAdmin\\\\Server\\\\Plugin\\> will always evaluate to true\\.$#"
 			count: 2
 			path: tests/classes/Server/PluginsTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertIsArray\\(\\) with array\\<int\\|string, string\\> will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertIsArray\\(\\) with array\\<int\\|string, string\\> will always evaluate to true\\.$#"
 			count: 1
 			path: tests/classes/Server/PluginsTest.php
 
@@ -17131,12 +17131,12 @@ parameters:
 			path: tests/classes/Server/PluginsTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) with 0 and array\\{string, PhpMyAdmin\\\\Message\\} will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) with 0 and array\\{string, PhpMyAdmin\\\\Message\\} will always evaluate to true\\.$#"
 			count: 3
 			path: tests/classes/Server/PrivilegesTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) with 1 and array\\{string, PhpMyAdmin\\\\Message\\} will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayHasKey\\(\\) with 1 and array\\{string, PhpMyAdmin\\\\Message\\} will always evaluate to true\\.$#"
 			count: 3
 			path: tests/classes/Server/PrivilegesTest.php
 
@@ -17176,7 +17176,7 @@ parameters:
 			path: tests/classes/Server/SelectTest.php
 
 		-
-			message: "#^Parameter \\#1 \\$needle of method PHPUnit\\\\Framework\\\\Assert\\:\\:assertStringContainsString\\(\\) expects string, mixed given\\.$#"
+			message: "#^Parameter \\#1 \\$needle of static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertStringContainsString\\(\\) expects string, mixed given\\.$#"
 			count: 4
 			path: tests/classes/Server/SelectTest.php
 
@@ -17186,7 +17186,7 @@ parameters:
 			path: tests/classes/Server/SelectTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertInstanceOf\\(\\) with 'PhpMyAdmin\\\\\\\\Server\\\\\\\\SysInfo\\\\\\\\Base' and PhpMyAdmin\\\\Server\\\\SysInfo\\\\Base will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertInstanceOf\\(\\) with 'PhpMyAdmin\\\\\\\\Server\\\\\\\\SysInfo\\\\\\\\Base' and PhpMyAdmin\\\\Server\\\\SysInfo\\\\Base will always evaluate to true\\.$#"
 			count: 1
 			path: tests/classes/Server/SysInfo/SysInfoTest.php
 
@@ -17261,7 +17261,7 @@ parameters:
 			path: tests/classes/Stubs/ResponseRenderer.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertInstanceOf\\(\\) with 'PhpMyAdmin\\\\\\\\Table\\\\\\\\Table' and PhpMyAdmin\\\\Table\\\\Table will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertInstanceOf\\(\\) with 'PhpMyAdmin\\\\\\\\Table\\\\\\\\Table' and PhpMyAdmin\\\\Table\\\\Table will always evaluate to true\\.$#"
 			count: 1
 			path: tests/classes/Table/TableTest.php
 
@@ -17271,27 +17271,27 @@ parameters:
 			path: tests/classes/Table/TableTest.php
 
 		-
-			message: "#^Parameter \\#2 \\$haystack of method PHPUnit\\\\Framework\\\\Assert\\:\\:assertStringContainsString\\(\\) expects string, mixed given\\.$#"
+			message: "#^Parameter \\#2 \\$haystack of static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertStringContainsString\\(\\) expects string, mixed given\\.$#"
 			count: 3
 			path: tests/classes/Table/TableTest.php
 
 		-
-			message: "#^Parameter \\#2 \\$haystack of method PHPUnit\\\\Framework\\\\Assert\\:\\:assertStringNotContainsString\\(\\) expects string, mixed given\\.$#"
+			message: "#^Parameter \\#2 \\$haystack of static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertStringNotContainsString\\(\\) expects string, mixed given\\.$#"
 			count: 1
 			path: tests/classes/Table/TableTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertIsArray\\(\\) with array will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertIsArray\\(\\) with array will always evaluate to true\\.$#"
 			count: 1
 			path: tests/classes/Theme/ThemeManagerTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertTrue\\(\\) with true will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertTrue\\(\\) with true will always evaluate to true\\.$#"
 			count: 1
 			path: tests/classes/Theme/ThemeManagerTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertInstanceOf\\(\\) with 'PhpMyAdmin\\\\\\\\Theme\\\\\\\\Theme' and PhpMyAdmin\\\\Theme\\\\Theme will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertInstanceOf\\(\\) with 'PhpMyAdmin\\\\\\\\Theme\\\\\\\\Theme' and PhpMyAdmin\\\\Theme\\\\Theme will always evaluate to true\\.$#"
 			count: 1
 			path: tests/classes/Theme/ThemeTest.php
 
@@ -17311,7 +17311,7 @@ parameters:
 			path: tests/classes/Tracking/TrackingTest.php
 
 		-
-			message: "#^Parameter \\#2 \\$haystack of method PHPUnit\\\\Framework\\\\Assert\\:\\:assertStringContainsString\\(\\) expects string, mixed given\\.$#"
+			message: "#^Parameter \\#2 \\$haystack of static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertStringContainsString\\(\\) expects string, mixed given\\.$#"
 			count: 5
 			path: tests/classes/Tracking/TrackingTest.php
 
@@ -17381,7 +17381,7 @@ parameters:
 			path: tests/classes/UserPreferencesTest.php
 
 		-
-			message: "#^Parameter \\#2 \\$haystack of method PHPUnit\\\\Framework\\\\Assert\\:\\:assertCount\\(\\) expects Countable\\|iterable, mixed given\\.$#"
+			message: "#^Parameter \\#2 \\$haystack of static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertCount\\(\\) expects Countable\\|iterable, mixed given\\.$#"
 			count: 1
 			path: tests/classes/UserPreferencesTest.php
 
@@ -17421,7 +17421,7 @@ parameters:
 			path: tests/classes/UtilTest.php
 
 		-
-			message: "#^Parameter \\#2 \\$array of method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayNotHasKey\\(\\) expects array\\|ArrayAccess, mixed given\\.$#"
+			message: "#^Parameter \\#2 \\$array of static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayNotHasKey\\(\\) expects array\\|ArrayAccess, mixed given\\.$#"
 			count: 2
 			path: tests/classes/UtilTest.php
 
@@ -17441,12 +17441,12 @@ parameters:
 			path: tests/classes/Utils/HttpRequestTest.php
 
 		-
-			message: "#^Parameter \\#1 \\$needle of method PHPUnit\\\\Framework\\\\Assert\\:\\:assertStringContainsString\\(\\) expects string, mixed given\\.$#"
+			message: "#^Parameter \\#1 \\$needle of static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertStringContainsString\\(\\) expects string, mixed given\\.$#"
 			count: 1
 			path: tests/classes/Utils/HttpRequestTest.php
 
 		-
-			message: "#^Parameter \\#2 \\$haystack of method PHPUnit\\\\Framework\\\\Assert\\:\\:assertStringContainsString\\(\\) expects string, mixed given\\.$#"
+			message: "#^Parameter \\#2 \\$haystack of static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertStringContainsString\\(\\) expects string, mixed given\\.$#"
 			count: 1
 			path: tests/classes/Utils/HttpRequestTest.php
 
@@ -17466,7 +17466,7 @@ parameters:
 			path: tests/classes/Utils/SessionCacheTest.php
 
 		-
-			message: "#^Parameter \\#2 \\$array of method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayNotHasKey\\(\\) expects array\\|ArrayAccess, mixed given\\.$#"
+			message: "#^Parameter \\#2 \\$array of static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertArrayNotHasKey\\(\\) expects array\\|ArrayAccess, mixed given\\.$#"
 			count: 2
 			path: tests/classes/Utils/SessionCacheTest.php
 
@@ -17486,27 +17486,27 @@ parameters:
 			path: tests/classes/VersionInformationTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertIsBool\\(\\) with true will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertIsBool\\(\\) with true will always evaluate to true\\.$#"
 			count: 1
 			path: tests/classes/VersionTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertIsInt\\(\\) with 0 will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertIsInt\\(\\) with 0 will always evaluate to true\\.$#"
 			count: 2
 			path: tests/classes/VersionTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertIsInt\\(\\) with 6 will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertIsInt\\(\\) with 6 will always evaluate to true\\.$#"
 			count: 1
 			path: tests/classes/VersionTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertIsString\\(\\) with 'dev' will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertIsString\\(\\) with 'dev' will always evaluate to true\\.$#"
 			count: 1
 			path: tests/classes/VersionTest.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertIsString\\(\\) with non\\-falsy\\-string will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertIsString\\(\\) with non\\-falsy\\-string will always evaluate to true\\.$#"
 			count: 1
 			path: tests/classes/VersionTest.php
 
@@ -17561,7 +17561,7 @@ parameters:
 			path: tests/config.e2e.inc.php
 
 		-
-			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertNotNull\\(\\) with Facebook\\\\WebDriver\\\\Remote\\\\RemoteWebElement will always evaluate to true\\.$#"
+			message: "#^Call to static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertNotNull\\(\\) with Facebook\\\\WebDriver\\\\Remote\\\\RemoteWebElement will always evaluate to true\\.$#"
 			count: 1
 			path: tests/selenium/Database/OperationsTest.php
 
diff --git a/phpstan.neon.dist b/phpstan.neon.dist
index e8a7574f59..d5a8ed7b3b 100644
--- a/phpstan.neon.dist
+++ b/phpstan.neon.dist
@@ -26,12 +26,3 @@ parameters:
     checkDynamicProperties: true
     checkTooWideReturnTypesInProtectedAndPublicMethods: true
     checkImplicitMixed: true
-    ignoreErrors:
-        -
-            message: '#Dynamic call to static method PHPUnit\\Framework\\Assert::[a-zA-Z]+\(\)\.#'
-            paths:
-                - tests/classes/*
-                - tests/selenium/*
-        -
-            message: '#Dynamic call to static method PHPUnit\\Framework\\TestCase::[a-zA-Z]+\(\)\.#'
-            path: tests/classes/*
diff --git a/tests/classes/Advisory/AdvisorTest.php b/tests/classes/Advisory/AdvisorTest.php
index eff15a3245..7188d9be99 100644
--- a/tests/classes/Advisory/AdvisorTest.php
+++ b/tests/classes/Advisory/AdvisorTest.php
@@ -35,7 +35,7 @@ class AdvisorTest extends AbstractTestCase
     public function testAdvisorBytime(float $time, string $expected): void
     {
         $result = Advisor::byTime($time, 2);
-        $this->assertEquals($expected, $result);
+        self::assertEquals($expected, $result);
     }
 
     /** @return mixed[][] */
@@ -69,14 +69,14 @@ class AdvisorTest extends AbstractTestCase
         $advisor->addRule('fired', $rule);
         $runResult = $advisor->getRunResult();
         if ($error !== null) {
-            $this->assertEquals([$error], $runResult['errors']);
+            self::assertEquals([$error], $runResult['errors']);
         }
 
         if ($runResult['fired'] === [] && $expected === []) {
             return;
         }
 
-        $this->assertEquals([$expected], $runResult['fired']);
+        self::assertEquals([$expected], $runResult['fired']);
     }
 
     /**
diff --git a/tests/classes/Advisory/RulesTest.php b/tests/classes/Advisory/RulesTest.php
index c107b62a39..7c608a9c25 100644
--- a/tests/classes/Advisory/RulesTest.php
+++ b/tests/classes/Advisory/RulesTest.php
@@ -18,16 +18,16 @@ class RulesTest extends TestCase
     public function testRules(callable $rulesFactory): void
     {
         $rules = $rulesFactory();
-        $this->assertNotEmpty($rules);
+        self::assertNotEmpty($rules);
         foreach ($rules as $rule) {
-            $this->assertArrayHasKey('id', $rule);
-            $this->assertArrayHasKey('name', $rule);
-            $this->assertArrayHasKey('formula', $rule);
-            $this->assertArrayHasKey('test', $rule);
-            $this->assertArrayHasKey('issue', $rule);
-            $this->assertArrayHasKey('recommendation', $rule);
-            $this->assertArrayHasKey('justification', $rule);
-            $this->assertContainsOnly('string', $rule);
+            self::assertArrayHasKey('id', $rule);
+            self::assertArrayHasKey('name', $rule);
+            self::assertArrayHasKey('formula', $rule);
+            self::assertArrayHasKey('test', $rule);
+            self::assertArrayHasKey('issue', $rule);
+            self::assertArrayHasKey('recommendation', $rule);
+            self::assertArrayHasKey('justification', $rule);
+            self::assertContainsOnly('string', $rule);
         }
     }
 
diff --git a/tests/classes/ApplicationTest.php b/tests/classes/ApplicationTest.php
index c16b9ac0c9..d9dad5064f 100644
--- a/tests/classes/ApplicationTest.php
+++ b/tests/classes/ApplicationTest.php
@@ -27,10 +27,10 @@ final class ApplicationTest extends AbstractTestCase
     #[BackupStaticProperties(true)]
     public function testRunWithConfigError(): void
     {
-        $errorHandler = $this->createStub(ErrorHandler::class);
+        $errorHandler = self::createStub(ErrorHandler::class);
 
-        $config = $this->createMock(Config::class);
-        $config->expects($this->once())->method('loadAndCheck')
+        $config = self::createMock(Config::class);
+        $config->expects(self::once())->method('loadAndCheck')
             ->willThrowException(new ConfigException('Failed to load phpMyAdmin configuration.'));
         $config->config = new Config\Settings([]);
 
@@ -45,6 +45,6 @@ final class ApplicationTest extends AbstractTestCase
         $application->run();
 
         $output = $this->getActualOutputForAssertion();
-        $this->assertSame($expected, $output);
+        self::assertSame($expected, $output);
     }
 }
diff --git a/tests/classes/BookmarkTest.php b/tests/classes/BookmarkTest.php
index 39697cc60e..4301246ee0 100644
--- a/tests/classes/BookmarkTest.php
+++ b/tests/classes/BookmarkTest.php
@@ -63,7 +63,7 @@ class BookmarkTest extends AbstractTestCase
             Config::getInstance()->selectedServer['user'],
             'sakila',
         );
-        $this->assertContainsOnlyInstancesOf(Bookmark::class, $actual);
+        self::assertContainsOnlyInstancesOf(Bookmark::class, $actual);
         $this->dummyDbi->assertAllSelectsConsumed();
     }
 
@@ -78,7 +78,7 @@ class BookmarkTest extends AbstractTestCase
             ['id', 'dbase', 'user', 'label', 'query'],
         );
         $dbi = DatabaseInterface::getInstance();
-        $this->assertNull(
+        self::assertNull(
             (new BookmarkRepository($dbi, new Relation($dbi)))->get(
                 Config::getInstance()->selectedServer['user'],
                 1,
@@ -103,7 +103,7 @@ class BookmarkTest extends AbstractTestCase
             'root',
             'phpmyadmin',
         );
-        $this->assertNotFalse($bookmark);
-        $this->assertTrue($bookmark->save());
+        self::assertNotFalse($bookmark);
+        self::assertTrue($bookmark->save());
     }
 }
diff --git a/tests/classes/BrowseForeignersTest.php b/tests/classes/BrowseForeignersTest.php
index 77a68e0186..2059311963 100644
--- a/tests/classes/BrowseForeignersTest.php
+++ b/tests/classes/BrowseForeignersTest.php
@@ -30,18 +30,18 @@ class BrowseForeignersTest extends AbstractTestCase
      */
     public function testGetForeignLimit(): void
     {
-        $this->assertNull(
+        self::assertNull(
             $this->browseForeigners->getForeignLimit('Show all'),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'LIMIT 0, 25 ',
             $this->browseForeigners->getForeignLimit(null),
         );
 
         $_POST['pos'] = 10;
 
-        $this->assertEquals(
+        self::assertEquals(
             'LIMIT 10, 25 ',
             $this->browseForeigners->getForeignLimit(null),
         );
@@ -50,12 +50,12 @@ class BrowseForeignersTest extends AbstractTestCase
         $config->set('MaxRows', 50);
         $browseForeigners = new BrowseForeigners(new Template(), $config, new ThemeManager());
 
-        $this->assertEquals(
+        self::assertEquals(
             'LIMIT 10, 50 ',
             $browseForeigners->getForeignLimit(null),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'LIMIT 10, 50 ',
             $browseForeigners->getForeignLimit('xyz'),
         );
@@ -66,7 +66,7 @@ class BrowseForeignersTest extends AbstractTestCase
      */
     public function testGetHtmlForGotoPage(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             '',
             $this->callFunction(
                 $this->browseForeigners,
@@ -81,7 +81,7 @@ class BrowseForeignersTest extends AbstractTestCase
         $foreignData['disp_row'] = [];
         $foreignData['the_total'] = 5;
 
-        $this->assertEquals(
+        self::assertEquals(
             '',
             $this->callFunction(
                 $this->browseForeigners,
@@ -99,15 +99,15 @@ class BrowseForeignersTest extends AbstractTestCase
             [$foreignData],
         );
 
-        $this->assertStringStartsWith('Page number:', $result);
+        self::assertStringStartsWith('Page number:', $result);
 
-        $this->assertStringEndsWith('</select>', $result);
+        self::assertStringEndsWith('</select>', $result);
 
-        $this->assertStringContainsString('<select class="pageselector ajax" name="pos"', $result);
+        self::assertStringContainsString('<select class="pageselector ajax" name="pos"', $result);
 
-        $this->assertStringContainsString('<option selected="selected" style="font-weight: bold" value="0">', $result);
+        self::assertStringContainsString('<option selected="selected" style="font-weight: bold" value="0">', $result);
 
-        $this->assertStringContainsString('<option  value="25"', $result);
+        self::assertStringContainsString('<option  value="25"', $result);
     }
 
     /**
@@ -117,7 +117,7 @@ class BrowseForeignersTest extends AbstractTestCase
     {
         $desc = 'foobar<baz';
 
-        $this->assertEquals(
+        self::assertEquals(
             ['foobar<baz', ''],
             $this->callFunction(
                 $this->browseForeigners,
@@ -131,7 +131,7 @@ class BrowseForeignersTest extends AbstractTestCase
         $config->set('LimitChars', 5);
         $browseForeigners = new BrowseForeigners(new Template(), $config, new ThemeManager());
 
-        $this->assertEquals(
+        self::assertEquals(
             ['fooba...', 'foobar<baz'],
             $this->callFunction(
                 $browseForeigners,
@@ -165,36 +165,36 @@ class BrowseForeignersTest extends AbstractTestCase
             $currentValue,
         );
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             '<form class="ajax" '
             . 'id="browse_foreign_form" name="browse_foreign_from" '
             . 'action="index.php?route=/browse-foreigners',
             $result,
         );
-        $this->assertStringContainsString('" method="post">', $result);
+        self::assertStringContainsString('" method="post">', $result);
 
-        $this->assertStringContainsString('<fieldset class="row g-3 align-items-center mb-3">', $result);
+        self::assertStringContainsString('<fieldset class="row g-3 align-items-center mb-3">', $result);
 
-        $this->assertStringContainsString('<input type="hidden" name="field" value="foo">', $result);
+        self::assertStringContainsString('<input type="hidden" name="field" value="foo">', $result);
 
-        $this->assertStringContainsString('<input type="hidden" name="fieldkey" value="bar">', $result);
+        self::assertStringContainsString('<input type="hidden" name="fieldkey" value="bar">', $result);
 
-        $this->assertStringContainsString('<input type="hidden" name="rownumber" value="1">', $result);
+        self::assertStringContainsString('<input type="hidden" name="rownumber" value="1">', $result);
 
-        $this->assertStringContainsString('<div class="col-auto">', $result);
-        $this->assertStringContainsString('<label class="form-label" for="input_foreign_filter">', $result);
-        $this->assertStringContainsString(
+        self::assertStringContainsString('<div class="col-auto">', $result);
+        self::assertStringContainsString('<label class="form-label" for="input_foreign_filter">', $result);
+        self::assertStringContainsString(
             '<input class="form-control" type="text" name="foreign_filter" '
             . 'id="input_foreign_filter" value="5" data-old="5">',
             $result,
         );
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             '<input class="btn btn-primary" type="submit" name="submit_foreign_filter" value="Go">',
             $result,
         );
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             '<table class="table table-striped table-hover" id="browse_foreign_table">',
             $result,
         );
@@ -210,11 +210,11 @@ class BrowseForeignersTest extends AbstractTestCase
             $currentValue,
         );
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             '<table class="table table-striped table-hover" id="browse_foreign_table">',
             $result,
         );
 
-        $this->assertStringContainsString('<th>', $result);
+        self::assertStringContainsString('<th>', $result);
     }
 }
diff --git a/tests/classes/CacheTest.php b/tests/classes/CacheTest.php
index f2edf0161f..c8b9f2f648 100644
--- a/tests/classes/CacheTest.php
+++ b/tests/classes/CacheTest.php
@@ -30,62 +30,62 @@ class CacheTest extends AbstractTestCase
     #[DataProvider('dataProviderCacheKeyValues')]
     public function testCacheHas(string $cacheKey, mixed $valueToCache): void
     {
-        $this->assertFalse(Cache::has($cacheKey));
+        self::assertFalse(Cache::has($cacheKey));
         Cache::set($cacheKey, $valueToCache);
-        $this->assertTrue(Cache::has($cacheKey));
+        self::assertTrue(Cache::has($cacheKey));
         Cache::remove($cacheKey);
-        $this->assertFalse(Cache::has($cacheKey));
+        self::assertFalse(Cache::has($cacheKey));
     }
 
     #[DataProvider('dataProviderCacheKeyValues')]
     public function testCachePurge(string $cacheKey, mixed $valueToCache): void
     {
-        $this->assertFalse(Cache::has($cacheKey));
+        self::assertFalse(Cache::has($cacheKey));
         Cache::set($cacheKey, $valueToCache);
-        $this->assertTrue(Cache::has($cacheKey));
+        self::assertTrue(Cache::has($cacheKey));
         Cache::purge();
-        $this->assertFalse(Cache::has($cacheKey));
+        self::assertFalse(Cache::has($cacheKey));
     }
 
     #[DataProvider('dataProviderCacheKeyValues')]
     public function testCacheSet(string $cacheKey, mixed $valueToCache): void
     {
-        $this->assertFalse(Cache::has($cacheKey));
+        self::assertFalse(Cache::has($cacheKey));
         Cache::set($cacheKey, $valueToCache);
-        $this->assertTrue(Cache::has($cacheKey));
+        self::assertTrue(Cache::has($cacheKey));
     }
 
     #[DataProvider('dataProviderCacheKeyValues')]
     public function testCacheGet(string $cacheKey, mixed $valueToCache): void
     {
-        $this->assertFalse(Cache::has($cacheKey));
+        self::assertFalse(Cache::has($cacheKey));
         Cache::set($cacheKey, $valueToCache);
-        $this->assertTrue(Cache::has($cacheKey));
-        $this->assertSame(Cache::get($cacheKey), $valueToCache);
+        self::assertTrue(Cache::has($cacheKey));
+        self::assertSame(Cache::get($cacheKey), $valueToCache);
     }
 
     #[DataProvider('dataProviderCacheKeyValues')]
     public function testCacheGetDefaultValue(string $cacheKey, mixed $valueToCache): void
     {
-        $this->assertFalse(Cache::has($cacheKey));
+        self::assertFalse(Cache::has($cacheKey));
         Cache::set($cacheKey, $valueToCache);
-        $this->assertTrue(Cache::has($cacheKey));
-        $this->assertSame(Cache::get($cacheKey, null), $valueToCache);
+        self::assertTrue(Cache::has($cacheKey));
+        self::assertSame(Cache::get($cacheKey, null), $valueToCache);
         Cache::remove($cacheKey);
-        $this->assertFalse(Cache::has($cacheKey));
-        $this->assertNull(Cache::get($cacheKey, null));
+        self::assertFalse(Cache::has($cacheKey));
+        self::assertNull(Cache::get($cacheKey, null));
         $defaultValue = new stdClass();
-        $this->assertSame($defaultValue, Cache::get($cacheKey, $defaultValue));
-        $this->assertFalse(Cache::get($cacheKey, false));
+        self::assertSame($defaultValue, Cache::get($cacheKey, $defaultValue));
+        self::assertFalse(Cache::get($cacheKey, false));
     }
 
     #[DataProvider('dataProviderCacheKeyValues')]
     public function testCacheRemove(string $cacheKey, mixed $valueToCache): void
     {
-        $this->assertFalse(Cache::has($cacheKey));
+        self::assertFalse(Cache::has($cacheKey));
         Cache::set($cacheKey, $valueToCache);
-        $this->assertTrue(Cache::has($cacheKey));
+        self::assertTrue(Cache::has($cacheKey));
         Cache::remove($cacheKey);
-        $this->assertFalse(Cache::has($cacheKey));
+        self::assertFalse(Cache::has($cacheKey));
     }
 }
diff --git a/tests/classes/Charsets/CharsetTest.php b/tests/classes/Charsets/CharsetTest.php
index 413537420f..fbe59d8c3a 100644
--- a/tests/classes/Charsets/CharsetTest.php
+++ b/tests/classes/Charsets/CharsetTest.php
@@ -22,10 +22,10 @@ class CharsetTest extends AbstractTestCase
 
         $charset = Charset::fromServer($serverCharset);
 
-        $this->assertInstanceOf(Charset::class, $charset);
-        $this->assertSame('utf8', $charset->getName());
-        $this->assertSame('utf8_general_ci', $charset->getDefaultCollation());
-        $this->assertSame('UTF-8 Unicode', $charset->getDescription());
-        $this->assertSame(3, $charset->getMaxLength());
+        self::assertInstanceOf(Charset::class, $charset);
+        self::assertSame('utf8', $charset->getName());
+        self::assertSame('utf8_general_ci', $charset->getDefaultCollation());
+        self::assertSame('UTF-8 Unicode', $charset->getDescription());
+        self::assertSame(3, $charset->getMaxLength());
     }
 }
diff --git a/tests/classes/Charsets/CollationTest.php b/tests/classes/Charsets/CollationTest.php
index c5daf921ba..7fc61daae3 100644
--- a/tests/classes/Charsets/CollationTest.php
+++ b/tests/classes/Charsets/CollationTest.php
@@ -26,15 +26,15 @@ class CollationTest extends AbstractTestCase
 
         $collation = Collation::fromServer($serverCollation);
 
-        $this->assertInstanceOf(Collation::class, $collation);
-        $this->assertSame('utf8_general_ci', $collation->getName());
-        $this->assertSame('Unicode, case-insensitive', $collation->getDescription());
-        $this->assertSame('utf8', $collation->getCharset());
-        $this->assertSame(33, $collation->getId());
-        $this->assertTrue($collation->isDefault());
-        $this->assertTrue($collation->isCompiled());
-        $this->assertSame(1, $collation->getSortLength());
-        $this->assertSame('PAD SPACE', $collation->getPadAttribute());
+        self::assertInstanceOf(Collation::class, $collation);
+        self::assertSame('utf8_general_ci', $collation->getName());
+        self::assertSame('Unicode, case-insensitive', $collation->getDescription());
+        self::assertSame('utf8', $collation->getCharset());
+        self::assertSame(33, $collation->getId());
+        self::assertTrue($collation->isDefault());
+        self::assertTrue($collation->isCompiled());
+        self::assertSame(1, $collation->getSortLength());
+        self::assertSame('PAD SPACE', $collation->getPadAttribute());
     }
 
     /**
@@ -47,7 +47,7 @@ class CollationTest extends AbstractTestCase
     public function testBuildDescription(string $collation, string $description): void
     {
         $actual = Collation::fromServer(['Collation' => $collation]);
-        $this->assertEquals($description, $actual->getDescription());
+        self::assertEquals($description, $actual->getDescription());
     }
 
     /** @return array<array{string, string}> */
diff --git a/tests/classes/CharsetsTest.php b/tests/classes/CharsetsTest.php
index 20b1d44955..c9fca7a2c7 100644
--- a/tests/classes/CharsetsTest.php
+++ b/tests/classes/CharsetsTest.php
@@ -34,19 +34,19 @@ class CharsetsTest extends AbstractTestCase
         );
 
         $charset = Charsets::getServerCharset($dbi, false);
-        $this->assertSame('utf8', $charset->getName());
+        self::assertSame('utf8', $charset->getName());
 
         $charset = Charsets::getServerCharset($dbi, false);
-        $this->assertSame('Unknown', $charset->getName());
+        self::assertSame('Unknown', $charset->getName());
 
         $charset = Charsets::getServerCharset($dbi, false);
-        $this->assertSame('utf8', $charset->getName());
+        self::assertSame('utf8', $charset->getName());
 
         $charset = Charsets::getServerCharset($dbi, false);
-        $this->assertSame('utf8mb4', $charset->getName());
+        self::assertSame('utf8mb4', $charset->getName());
 
         $charset = Charsets::getServerCharset($dbi, false);
-        $this->assertSame('utf8mb4', $charset->getName());
+        self::assertSame('utf8mb4', $charset->getName());
 
         $dummyDbi->assertAllQueriesConsumed();
     }
@@ -54,19 +54,19 @@ class CharsetsTest extends AbstractTestCase
     public function testFindCollationByName(): void
     {
         $dbi = $this->createDatabaseInterface();
-        $this->assertNull(Charsets::findCollationByName($dbi, false, ''));
-        $this->assertNull(Charsets::findCollationByName($dbi, false, 'invalid'));
+        self::assertNull(Charsets::findCollationByName($dbi, false, ''));
+        self::assertNull(Charsets::findCollationByName($dbi, false, 'invalid'));
         $actual = Charsets::findCollationByName($dbi, false, 'utf8_general_ci');
-        $this->assertInstanceOf(Charsets\Collation::class, $actual);
-        $this->assertSame('utf8_general_ci', $actual->getName());
+        self::assertInstanceOf(Charsets\Collation::class, $actual);
+        self::assertSame('utf8_general_ci', $actual->getName());
     }
 
     public function testGetCharsetsWithIS(): void
     {
         $dbi = $this->createDatabaseInterface();
         $charsets = Charsets::getCharsets($dbi, false);
-        $this->assertCount(4, $charsets);
-        $this->assertContainsOnlyInstancesOf(Charsets\Charset::class, $charsets);
+        self::assertCount(4, $charsets);
+        self::assertContainsOnlyInstancesOf(Charsets\Charset::class, $charsets);
     }
 
     public function testGetCharsetsWithoutIS(): void
@@ -85,18 +85,18 @@ class CharsetsTest extends AbstractTestCase
         );
 
         $charsets = Charsets::getCharsets($dbi, true);
-        $this->assertCount(4, $charsets);
-        $this->assertContainsOnlyInstancesOf(Charsets\Charset::class, $charsets);
+        self::assertCount(4, $charsets);
+        self::assertContainsOnlyInstancesOf(Charsets\Charset::class, $charsets);
     }
 
     public function testGetCollationsWithIS(): void
     {
         $dbi = $this->createDatabaseInterface();
         $collations = Charsets::getCollations($dbi, false);
-        $this->assertCount(4, $collations);
-        $this->assertContainsOnly('array', $collations);
+        self::assertCount(4, $collations);
+        self::assertContainsOnly('array', $collations);
         foreach ($collations as $collation) {
-            $this->assertContainsOnlyInstancesOf(Charsets\Collation::class, $collation);
+            self::assertContainsOnlyInstancesOf(Charsets\Collation::class, $collation);
         }
     }
 
@@ -105,10 +105,10 @@ class CharsetsTest extends AbstractTestCase
         $dbi = $this->createDatabaseInterface();
         $dbi->setVersion(['@@version' => '10.10.0-MariaDB']);
         $collations = Charsets::getCollations($dbi, false);
-        $this->assertCount(4, $collations);
-        $this->assertContainsOnly('array', $collations);
+        self::assertCount(4, $collations);
+        self::assertContainsOnly('array', $collations);
         foreach ($collations as $collation) {
-            $this->assertContainsOnlyInstancesOf(Charsets\Collation::class, $collation);
+            self::assertContainsOnlyInstancesOf(Charsets\Collation::class, $collation);
         }
     }
 
@@ -129,10 +129,10 @@ class CharsetsTest extends AbstractTestCase
         );
 
         $collations = Charsets::getCollations($dbi, true);
-        $this->assertCount(4, $collations);
-        $this->assertContainsOnly('array', $collations);
+        self::assertCount(4, $collations);
+        self::assertContainsOnly('array', $collations);
         foreach ($collations as $collation) {
-            $this->assertContainsOnlyInstancesOf(Charsets\Collation::class, $collation);
+            self::assertContainsOnlyInstancesOf(Charsets\Collation::class, $collation);
         }
     }
 }
diff --git a/tests/classes/CheckUserPrivilegesTest.php b/tests/classes/CheckUserPrivilegesTest.php
index 46d3544d3c..96743b598f 100644
--- a/tests/classes/CheckUserPrivilegesTest.php
+++ b/tests/classes/CheckUserPrivilegesTest.php
@@ -45,10 +45,10 @@ class CheckUserPrivilegesTest extends AbstractTestCase
         // call the to-be-tested function
         $this->checkUserPrivileges->checkRequiredPrivilegesForAdjust($showGrants);
 
-        $this->assertTrue(UserPrivileges::$column);
-        $this->assertTrue(UserPrivileges::$database);
-        $this->assertTrue(UserPrivileges::$routines);
-        $this->assertTrue(UserPrivileges::$table);
+        self::assertTrue(UserPrivileges::$column);
+        self::assertTrue(UserPrivileges::$database);
+        self::assertTrue(UserPrivileges::$routines);
+        self::assertTrue(UserPrivileges::$table);
 
         // re-initialise the privileges
         $this->setUp();
@@ -59,10 +59,10 @@ class CheckUserPrivilegesTest extends AbstractTestCase
         // call the to-be-tested function
         $this->checkUserPrivileges->checkRequiredPrivilegesForAdjust($showGrants);
 
-        $this->assertTrue(UserPrivileges::$column);
-        $this->assertTrue(UserPrivileges::$database);
-        $this->assertTrue(UserPrivileges::$routines);
-        $this->assertTrue(UserPrivileges::$table);
+        self::assertTrue(UserPrivileges::$column);
+        self::assertTrue(UserPrivileges::$database);
+        self::assertTrue(UserPrivileges::$routines);
+        self::assertTrue(UserPrivileges::$table);
 
         // re-initialise the privileges
         $this->setUp();
@@ -73,10 +73,10 @@ class CheckUserPrivilegesTest extends AbstractTestCase
         // call the to-be-tested function
         $this->checkUserPrivileges->checkRequiredPrivilegesForAdjust($showGrants);
 
-        $this->assertTrue(UserPrivileges::$column);
-        $this->assertTrue(UserPrivileges::$database);
-        $this->assertTrue(UserPrivileges::$routines);
-        $this->assertTrue(UserPrivileges::$table);
+        self::assertTrue(UserPrivileges::$column);
+        self::assertTrue(UserPrivileges::$database);
+        self::assertTrue(UserPrivileges::$routines);
+        self::assertTrue(UserPrivileges::$table);
 
         // re-initialise the privileges
         $this->setUp();
@@ -87,9 +87,9 @@ class CheckUserPrivilegesTest extends AbstractTestCase
         // call the to-be-tested function
         $this->checkUserPrivileges->checkRequiredPrivilegesForAdjust($showGrants);
 
-        $this->assertFalse(UserPrivileges::$column);
-        $this->assertTrue(UserPrivileges::$database);
-        $this->assertFalse(UserPrivileges::$routines);
-        $this->assertFalse(UserPrivileges::$table);
+        self::assertFalse(UserPrivileges::$column);
+        self::assertTrue(UserPrivileges::$database);
+        self::assertFalse(UserPrivileges::$routines);
+        self::assertFalse(UserPrivileges::$table);
     }
 }
diff --git a/tests/classes/Command/SetVersionCommandTest.php b/tests/classes/Command/SetVersionCommandTest.php
index f4a940006c..f2c1878d73 100644
--- a/tests/classes/Command/SetVersionCommandTest.php
+++ b/tests/classes/Command/SetVersionCommandTest.php
@@ -55,7 +55,7 @@ class SetVersionCommandTest extends AbstractTestCase
     public function testGetGeneratedClassInvalidVersion(string $version): void
     {
         if (! class_exists(Command::class)) {
-            $this->markTestSkipped('The Symfony Console is missing');
+            self::markTestSkipped('The Symfony Console is missing');
         }
 
         $this->expectException(RangeException::class);
@@ -167,7 +167,7 @@ class SetVersionCommandTest extends AbstractTestCase
     public function testGetGeneratedClassValidVersion(string $version, string $content): void
     {
         if (! class_exists(Command::class)) {
-            $this->markTestSkipped('The Symfony Console is missing');
+            self::markTestSkipped('The Symfony Console is missing');
         }
 
         $output = $this->callFunction(
@@ -197,7 +197,7 @@ final class Version
 }
 
 PHP;
-        $this->assertSame(
+        self::assertSame(
             sprintf($template, $content),
             $output,
         );
diff --git a/tests/classes/Command/TwigLintCommandTest.php b/tests/classes/Command/TwigLintCommandTest.php
index 7b7e89117d..5192a11878 100644
--- a/tests/classes/Command/TwigLintCommandTest.php
+++ b/tests/classes/Command/TwigLintCommandTest.php
@@ -28,7 +28,7 @@ class TwigLintCommandTest extends AbstractTestCase
     public function setUp(): void
     {
         if (! class_exists(Command::class)) {
-            $this->markTestSkipped('The Symfony Console is missing');
+            self::markTestSkipped('The Symfony Console is missing');
         }
 
         parent::setUp();
@@ -44,7 +44,7 @@ class TwigLintCommandTest extends AbstractTestCase
             TEST_PATH . 'tests/classes/_data/file_listing/subfolder/one.ini',
         ]);
 
-        $this->assertSame('key=value' . "\n", $contents);
+        self::assertSame('key=value' . "\n", $contents);
     }
 
     public function testFindFiles(): void
@@ -55,7 +55,7 @@ class TwigLintCommandTest extends AbstractTestCase
         // Sort results to avoid file system test specific failures
         sort($filesFound, SORT_NATURAL);
 
-        $this->assertEquals([
+        self::assertEquals([
             $path . DIRECTORY_SEPARATOR . 'one.txt',
             $path . DIRECTORY_SEPARATOR . 'subfolder' . DIRECTORY_SEPARATOR . 'one.ini',
             $path . DIRECTORY_SEPARATOR . 'subfolder' . DIRECTORY_SEPARATOR . 'zero.txt',
@@ -71,7 +71,7 @@ class TwigLintCommandTest extends AbstractTestCase
         // Sort results to avoid file system test specific failures
         sort($filesInfos, SORT_REGULAR);
 
-        $this->assertEquals([
+        self::assertEquals([
             ['template' => '', 'file' => $path . DIRECTORY_SEPARATOR . 'one.txt', 'valid' => true],
             ['template' => '', 'file' => $path . DIRECTORY_SEPARATOR . 'two.md', 'valid' => true],
             [
@@ -93,13 +93,13 @@ class TwigLintCommandTest extends AbstractTestCase
             ->onlyMethods(['getTemplateContents', 'findFiles'])
             ->getMock();
 
-        $command->expects($this->exactly(1))
+        $command->expects(self::exactly(1))
             ->method('findFiles')
             ->willReturn(
                 ['foo.twig', 'foo-invalid.twig'],
             );
 
-        $command->expects($this->exactly(2))->method('getTemplateContents')->willReturnMap([
+        $command->expects(self::exactly(2))->method('getTemplateContents')->willReturnMap([
             ['foo.twig', '{{ file }}'],
             ['foo-invalid.twig', '{{ file }'],
         ]);
@@ -108,7 +108,7 @@ class TwigLintCommandTest extends AbstractTestCase
             TEST_PATH . 'tests/classes/_data/file_listing',
         ]);
 
-        $this->assertEquals([
+        self::assertEquals([
             ['template' => '{{ file }}', 'file' => 'foo.twig', 'valid' => true],
             [
                 'template' => '{{ file }',
@@ -127,14 +127,14 @@ class TwigLintCommandTest extends AbstractTestCase
     {
         $context = $this->callFunction($this->command, TwigLintCommand::class, 'getContext', ['{{ file }', 0]);
 
-        $this->assertEquals([1 => '{{ file }'], $context);
+        self::assertEquals([1 => '{{ file }'], $context);
 
         $context = $this->callFunction($this->command, TwigLintCommand::class, 'getContext', ['{{ file }', 3]);
 
-        $this->assertEquals([1 => '{{ file }'], $context);
+        self::assertEquals([1 => '{{ file }'], $context);
 
         $context = $this->callFunction($this->command, TwigLintCommand::class, 'getContext', ['{{ file }', 5]);
 
-        $this->assertEquals([], $context);
+        self::assertEquals([], $context);
     }
 }
diff --git a/tests/classes/Command/WriteGitRevisionCommandTest.php b/tests/classes/Command/WriteGitRevisionCommandTest.php
index 8bec067022..761b926272 100644
--- a/tests/classes/Command/WriteGitRevisionCommandTest.php
+++ b/tests/classes/Command/WriteGitRevisionCommandTest.php
@@ -20,14 +20,14 @@ class WriteGitRevisionCommandTest extends AbstractTestCase
     public function testGetGeneratedClassValidVersion(): void
     {
         if (! class_exists(Command::class)) {
-            $this->markTestSkipped('The Symfony Console is missing');
+            self::markTestSkipped('The Symfony Console is missing');
         }
 
         $this->command = $this->getMockBuilder(WriteGitRevisionCommand::class)
             ->onlyMethods(['gitCli'])
             ->getMock();
 
-        $this->command->expects($this->exactly(3))->method('gitCli')->willReturnMap([
+        $this->command->expects(self::exactly(3))->method('gitCli')->willReturnMap([
             ['describe --always', 'RELEASE_5_1_0-638-g1c018e2a6c'],
             ['log -1 --format="%H"', '1c018e2a6c6d518c4a2dde059e49f33af67c4636'],
             ['symbolic-ref -q HEAD', 'refs/heads/cli-rev-info'],
@@ -57,7 +57,7 @@ return [
 ];
 
 PHP;
-        $this->assertSame(
+        self::assertSame(
             sprintf(
                 $template,
                 'RELEASE_5_1_0-638-g1c018e2a6c',
diff --git a/tests/classes/Config/ConfigFileTest.php b/tests/classes/Config/ConfigFileTest.php
index 0e25058293..9c1a399154 100644
--- a/tests/classes/Config/ConfigFileTest.php
+++ b/tests/classes/Config/ConfigFileTest.php
@@ -54,20 +54,20 @@ class ConfigFileTest extends AbstractTestCase
     public function testNewObjectState(): void
     {
         // Check default dynamic values
-        $this->assertEquals(
+        self::assertEquals(
             [],
             $this->object->getConfig(),
         );
 
         // Check environment state
-        $this->assertEquals(
+        self::assertEquals(
             [],
             $_SESSION['ConfigFile1'],
         );
 
         // Validate default value used in tests
         $defaultValue = $this->object->getDefault(self::SIMPLE_KEY_WITH_DEFAULT_VALUE);
-        $this->assertNotNull($defaultValue);
+        self::assertNotNull($defaultValue);
     }
 
     /**
@@ -89,7 +89,7 @@ class ConfigFileTest extends AbstractTestCase
         $this->object->set(self::SIMPLE_KEY_WITH_DEFAULT_VALUE, $defaultSimpleValue);
         $this->object->set('Servers/1/host', $defaultHost);
         $this->object->set('Servers/2/host', $defaultHost);
-        $this->assertEmpty($this->object->getConfig());
+        self::assertEmpty($this->object->getConfig());
 
         /**
          * Case 2: persistent keys should be always present in flat array,
@@ -97,8 +97,8 @@ class ConfigFileTest extends AbstractTestCase
          */
         $this->object->setPersistKeys(array_keys($defaultConfig));
         $this->object->resetConfigData();
-        $this->assertEmpty($this->object->getConfig());
-        $this->assertEquals(
+        self::assertEmpty($this->object->getConfig());
+        self::assertEquals(
             $defaultConfig,
             $this->object->getConfigArray(),
         );
@@ -108,7 +108,7 @@ class ConfigFileTest extends AbstractTestCase
          * even if set to default values
          */
         $this->object->set('Servers/2/host', $defaultHost);
-        $this->assertEquals(
+        self::assertEquals(
             ['Servers' => [2 => ['host' => $defaultHost]]],
             $this->object->getConfig(),
         );
@@ -127,7 +127,7 @@ class ConfigFileTest extends AbstractTestCase
         $this->object->set('b', 2);
         $this->object->set('c', 3);
 
-        $this->assertEquals(
+        self::assertEquals(
             ['a' => 1, 'c' => 3],
             $this->object->getConfig(),
         );
@@ -138,7 +138,7 @@ class ConfigFileTest extends AbstractTestCase
         $this->object->setAllowedKeys(null);
         $this->object->set('b', 2);
 
-        $this->assertEquals(
+        self::assertEquals(
             ['a' => 1, 'b' => 2, 'c' => 3],
             $this->object->getConfig(),
         );
@@ -156,11 +156,11 @@ class ConfigFileTest extends AbstractTestCase
         $this->object->set('Servers/1/passthrough2', 2);
         $this->object->updateWithGlobalConfig(['Servers/value1' => 3]);
 
-        $this->assertEquals(
+        self::assertEquals(
             ['Servers' => [1 => ['passthrough1' => 1, 'passthrough2' => 2, 'value1' => 3]]],
             $this->object->getConfig(),
         );
-        $this->assertEquals(
+        self::assertEquals(
             3,
             $this->object->get('Servers/1/value1'),
         );
@@ -175,8 +175,8 @@ class ConfigFileTest extends AbstractTestCase
 
         $this->object->resetConfigData();
 
-        $this->assertEmpty($this->object->getConfig());
-        $this->assertEmpty($this->object->getConfigArray());
+        self::assertEmpty($this->object->getConfig());
+        self::assertEmpty($this->object->getConfigArray());
     }
 
     /**
@@ -187,11 +187,11 @@ class ConfigFileTest extends AbstractTestCase
         $this->object->set('abc', 'should be deleted by setConfigData');
         $this->object->setConfigData(['a' => 'b']);
 
-        $this->assertEquals(
+        self::assertEquals(
             ['a' => 'b'],
             $this->object->getConfig(),
         );
-        $this->assertEquals(
+        self::assertEquals(
             ['a' => 'b'],
             $this->object->getConfigArray(),
         );
@@ -208,29 +208,29 @@ class ConfigFileTest extends AbstractTestCase
         $this->object->set('Servers/4/host', $nonDefaultHost);
         $this->object->set('Servers/5/host', $defaultHost);
         $this->object->set('Servers/6/host', $defaultHost, 'Servers/6/host');
-        $this->assertEquals(
+        self::assertEquals(
             $nonDefaultHost,
             $this->object->get('Servers/4/host'),
         );
-        $this->assertEquals(
+        self::assertEquals(
             null,
             $this->object->get('Servers/5/host'),
         );
-        $this->assertEquals(
+        self::assertEquals(
             $defaultHost,
             $this->object->get('Servers/6/host'),
         );
 
         // return default value for nonexistent keys
-        $this->assertNull(
+        self::assertNull(
             $this->object->get('key not excist'),
         );
-        $this->assertEquals(
+        self::assertEquals(
             [1],
             $this->object->get('key not excist', [1]),
         );
         $default = new stdClass();
-        $this->assertInstanceOf(
+        self::assertInstanceOf(
             stdClass::class,
             $this->object->get('key not excist', $default),
         );
@@ -245,7 +245,7 @@ class ConfigFileTest extends AbstractTestCase
 
         // default values are not written
         $this->object->set(self::SIMPLE_KEY_WITH_DEFAULT_VALUE, $defaultValue);
-        $this->assertEmpty($this->object->getConfig());
+        self::assertEmpty($this->object->getConfig());
     }
 
     /**
@@ -260,7 +260,7 @@ class ConfigFileTest extends AbstractTestCase
             [self::SIMPLE_KEY_WITH_DEFAULT_VALUE => $defaultValue],
         );
         $this->object->set(self::SIMPLE_KEY_WITH_DEFAULT_VALUE, $defaultValue);
-        $this->assertEmpty($this->object->getConfig());
+        self::assertEmpty($this->object->getConfig());
 
         // but if config.inc.php differs from the default values,
         // allow to overwrite with value from the default values
@@ -269,7 +269,7 @@ class ConfigFileTest extends AbstractTestCase
             [self::SIMPLE_KEY_WITH_DEFAULT_VALUE => $configIncPhpValue],
         );
         $this->object->set(self::SIMPLE_KEY_WITH_DEFAULT_VALUE, $defaultValue);
-        $this->assertEquals(
+        self::assertEquals(
             [self::SIMPLE_KEY_WITH_DEFAULT_VALUE => $defaultValue],
             $this->object->getConfig(),
         );
@@ -284,16 +284,16 @@ class ConfigFileTest extends AbstractTestCase
         $flatDefaultConfig = $this->object->getFlatDefaultConfig();
 
         $defaultValue = $this->object->getDefault(self::SIMPLE_KEY_WITH_DEFAULT_VALUE);
-        $this->assertEquals($defaultValue, $flatDefaultConfig[self::SIMPLE_KEY_WITH_DEFAULT_VALUE]);
+        self::assertEquals($defaultValue, $flatDefaultConfig[self::SIMPLE_KEY_WITH_DEFAULT_VALUE]);
 
         $localhostValue = $this->object->getDefault('Servers/1/host');
-        $this->assertEquals($localhostValue, $flatDefaultConfig['Servers/1/host']);
+        self::assertEquals($localhostValue, $flatDefaultConfig['Servers/1/host']);
 
         $settings = new Settings([]);
         $cfg = $settings->asArray();
 
-        $this->assertGreaterThanOrEqual(100, count($cfg));
-        $this->assertGreaterThanOrEqual(count($cfg), count($flatDefaultConfig));
+        self::assertGreaterThanOrEqual(100, count($cfg));
+        self::assertGreaterThanOrEqual(count($cfg), count($flatDefaultConfig));
     }
 
     /**
@@ -305,7 +305,7 @@ class ConfigFileTest extends AbstractTestCase
         $this->object->set('key2', 'value');
         $this->object->updateWithGlobalConfig(['key' => 'ABC']);
 
-        $this->assertEquals(
+        self::assertEquals(
             ['key' => 'ABC', 'key2' => 'value'],
             $this->object->getConfig(),
         );
@@ -316,12 +316,12 @@ class ConfigFileTest extends AbstractTestCase
      */
     public function testGetCanonicalPath(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             'Servers/1/abcd',
             $this->object->getCanonicalPath('Servers/2/abcd'),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'Servers/foo/bar',
             $this->object->getCanonicalPath('Servers/foo/bar'),
         );
@@ -334,14 +334,14 @@ class ConfigFileTest extends AbstractTestCase
     {
         $cfgDb = $this->object->getAllowedValues();
         // verify that $cfg_db read from config.values.php is valid
-        $this->assertGreaterThanOrEqual(20, count($cfgDb));
+        self::assertGreaterThanOrEqual(20, count($cfgDb));
 
-        $this->assertEquals(
+        self::assertEquals(
             $cfgDb['Servers'][1]['port'],
             $this->object->getDbEntry('Servers/1/port'),
         );
-        $this->assertNull($this->object->getDbEntry('no such key'));
-        $this->assertEquals(
+        self::assertNull($this->object->getDbEntry('no such key'));
+        self::assertEquals(
             [1],
             $this->object->getDbEntry('no such key', [1]),
         );
@@ -358,7 +358,7 @@ class ConfigFileTest extends AbstractTestCase
         $this->object->set('Servers/4/x', 4);
         $this->object->set('ServerDefault', 3);
 
-        $this->assertEquals(
+        self::assertEquals(
             4,
             $this->object->getServerCount(),
         );
@@ -366,20 +366,20 @@ class ConfigFileTest extends AbstractTestCase
         $this->object->removeServer(2);
         $this->object->removeServer(2);
 
-        $this->assertEquals(
+        self::assertEquals(
             2,
             $this->object->getServerCount(),
         );
 
-        $this->assertLessThanOrEqual(
+        self::assertLessThanOrEqual(
             2,
             $this->object->get('ServerDefault'),
         );
-        $this->assertEquals(
+        self::assertEquals(
             ['Servers' => [1 => ['x' => 1], 2 => ['x' => 4]]],
             $this->object->getConfig(),
         );
-        $this->assertEquals(
+        self::assertEquals(
             ['Servers/1/x' => 1, 'Servers/2/x' => 4],
             $this->object->getConfigArray(),
         );
@@ -393,7 +393,7 @@ class ConfigFileTest extends AbstractTestCase
         $this->object->set('Servers/1/x', 'a');
         $this->object->set('Servers/2/x', 'b');
 
-        $this->assertEquals(
+        self::assertEquals(
             [1 => ['x' => 'a'], 2 => ['x' => 'b']],
             $this->object->getServers(),
         );
@@ -404,7 +404,7 @@ class ConfigFileTest extends AbstractTestCase
      */
     public function testGetServerDSN(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             '',
             $this->object->getServerDSN(1),
         );
@@ -421,7 +421,7 @@ class ConfigFileTest extends AbstractTestCase
                 ],
             ],
         );
-        $this->assertEquals(
+        self::assertEquals(
             'mysqli://testUser@example.com:21',
             $this->object->getServerDSN(1),
         );
@@ -440,7 +440,7 @@ class ConfigFileTest extends AbstractTestCase
                 ],
             ],
         );
-        $this->assertEquals(
+        self::assertEquals(
             'mysqli://testUser@123',
             $this->object->getServerDSN(1),
         );
@@ -458,7 +458,7 @@ class ConfigFileTest extends AbstractTestCase
                 ],
             ],
         );
-        $this->assertEquals(
+        self::assertEquals(
             'mysqli://testUser:***@example.com:21',
             $this->object->getServerDSN(1),
         );
@@ -469,19 +469,19 @@ class ConfigFileTest extends AbstractTestCase
      */
     public function testGetServerName(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             '',
             $this->object->getServerName(1),
         );
 
         $this->object->set('Servers/1/host', 'example.com');
-        $this->assertEquals(
+        self::assertEquals(
             'example.com',
             $this->object->getServerName(1),
         );
 
         $this->object->set('Servers/1/verbose', 'testData');
-        $this->assertEquals(
+        self::assertEquals(
             'testData',
             $this->object->getServerName(1),
         );
@@ -496,7 +496,7 @@ class ConfigFileTest extends AbstractTestCase
         $this->object->set('Array/test', ['x', 'y']);
         $defaultValue = $this->object->getDefault(self::SIMPLE_KEY_WITH_DEFAULT_VALUE);
 
-        $this->assertEquals(
+        self::assertEquals(
             [self::SIMPLE_KEY_WITH_DEFAULT_VALUE => $defaultValue, 'Array/test' => ['x', 'y']],
             $this->object->getConfigArray(),
         );
diff --git a/tests/classes/Config/DescriptionTest.php b/tests/classes/Config/DescriptionTest.php
index e3520fa562..5c119f4920 100644
--- a/tests/classes/Config/DescriptionTest.php
+++ b/tests/classes/Config/DescriptionTest.php
@@ -35,7 +35,7 @@ class DescriptionTest extends AbstractTestCase
     #[DataProvider('getValues')]
     public function testGet(string $item, string $type, string $expected): void
     {
-        $this->assertEquals($expected, Descriptions::get($item, $type));
+        self::assertEquals($expected, Descriptions::get($item, $type));
     }
 
     /**
@@ -72,9 +72,9 @@ class DescriptionTest extends AbstractTestCase
      */
     public function assertGet(string $key): void
     {
-        $this->assertNotNull(Descriptions::get($key, 'name'));
-        $this->assertNotNull(Descriptions::get($key, 'desc'));
-        $this->assertNotNull(Descriptions::get($key, 'cmt'));
+        self::assertNotNull(Descriptions::get($key, 'name'));
+        self::assertNotNull(Descriptions::get($key, 'desc'));
+        self::assertNotNull(Descriptions::get($key, 'cmt'));
     }
 
     /**
@@ -90,8 +90,8 @@ class DescriptionTest extends AbstractTestCase
         foreach ($cfg as $key => $value) {
             $this->assertGet($key);
             if ($key === 'Servers') {
-                $this->assertIsArray($value);
-                $this->assertIsArray($value[1]);
+                self::assertIsArray($value);
+                self::assertIsArray($value[1]);
                 foreach ($value[1] as $item => $val) {
                     $this->assertGet($key . '/1/' . $item);
                     if ($item !== 'AllowDeny') {
@@ -99,12 +99,12 @@ class DescriptionTest extends AbstractTestCase
                     }
 
                     foreach ($val as $second => $val2) {
-                        $this->assertNotNull($val2);
+                        self::assertNotNull($val2);
                         $this->assertGet($key . '/1/' . $item . '/' . $second);
                     }
                 }
             } elseif (in_array($key, $nested)) {
-                $this->assertIsArray($value);
+                self::assertIsArray($value);
                 foreach (array_keys($value) as $item) {
                     $this->assertGet($key . '/' . $item);
                 }
diff --git a/tests/classes/Config/FormDisplayTemplateTest.php b/tests/classes/Config/FormDisplayTemplateTest.php
index 945a232f3f..c6d446587b 100644
--- a/tests/classes/Config/FormDisplayTemplateTest.php
+++ b/tests/classes/Config/FormDisplayTemplateTest.php
@@ -52,31 +52,31 @@ class FormDisplayTemplateTest extends AbstractTestCase
             $opts,
         );
 
-        $this->assertStringContainsString('<tr class="group-header-field group-header-1 disabled-field">', $result);
+        self::assertStringContainsString('<tr class="group-header-field group-header-1 disabled-field">', $result);
 
-        $this->assertStringContainsString('<label for="test/path">', $result);
+        self::assertStringContainsString('<label for="test/path">', $result);
 
-        $this->assertStringContainsString('<a href="https://example.com/" target="documentation"', $result);
+        self::assertStringContainsString('<a href="https://example.com/" target="documentation"', $result);
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             '<img src="themes/dot.gif" title="Documentation" alt="Documentation" class="icon ic_b_help"',
             $result,
         );
 
-        $this->assertStringContainsString('<span class="disabled-notice"', $result);
+        self::assertStringContainsString('<span class="disabled-notice"', $result);
 
-        $this->assertStringContainsString('<small>', $result);
+        self::assertStringContainsString('<small>', $result);
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             '<input type="text" name="test/path" id="test/path" value="val" class="w-75 custom field-error">',
             $result,
         );
 
-        $this->assertStringContainsString('<a class="restore-default hide" href="#test/path"', $result);
+        self::assertStringContainsString('<a class="restore-default hide" href="#test/path"', $result);
 
-        $this->assertStringContainsString('<dl class="inline_errors">', $result);
-        $this->assertStringContainsString('<dd>e1</dd>', $result);
-        $this->assertStringContainsString('</dl>', $result);
+        self::assertStringContainsString('<dl class="inline_errors">', $result);
+        self::assertStringContainsString('<dd>e1</dd>', $result);
+        self::assertStringContainsString('</dl>', $result);
 
         // second case
 
@@ -99,18 +99,18 @@ class FormDisplayTemplateTest extends AbstractTestCase
             $opts,
         );
 
-        $this->assertStringContainsString('<tr class="group-field group-field-1">', $result);
+        self::assertStringContainsString('<tr class="group-field group-field-1">', $result);
 
-        $this->assertStringContainsString('<input type="checkbox" name="test/path" id="test/path" checked>', $result);
+        self::assertStringContainsString('<input type="checkbox" name="test/path" id="test/path" checked>', $result);
 
-        $this->assertStringContainsString('<a class="userprefs-comment" title="userprefsComment">', $result);
+        self::assertStringContainsString('<a class="userprefs-comment" title="userprefsComment">', $result);
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             '<td class="userprefs-allow" title="Allow users to customize this value">',
             $result,
         );
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             '<a class="set-value hide" href="#test/path=setVal" title="Set value: setVal">',
             $result,
         );
@@ -129,7 +129,7 @@ class FormDisplayTemplateTest extends AbstractTestCase
             $opts,
         );
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             '<input type="text" size="25" name="test/path" id="test/path" value="val" class="">',
             $result,
         );
@@ -145,7 +145,7 @@ class FormDisplayTemplateTest extends AbstractTestCase
             $opts,
         );
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             '<input type="number" name="test/path" id="test/path" value="val" class="">',
             $result,
         );
@@ -155,13 +155,13 @@ class FormDisplayTemplateTest extends AbstractTestCase
         $opts['values_disabled'] = [1, 2];
         $opts['values'] = [1 => 'test', 'key1' => true, 'key2' => false];
         $result = $this->formDisplayTemplate->displayInput('test/path', 'testName', 'select', true, '', true, $opts);
-        $this->assertStringContainsString('<select name="test/path" id="test/path" class="w-75">', $result);
+        self::assertStringContainsString('<select name="test/path" id="test/path" class="w-75">', $result);
 
-        $this->assertStringContainsString('<option value="1" selected disabled>', $result);
+        self::assertStringContainsString('<option value="1" selected disabled>', $result);
 
-        $this->assertStringContainsString('<option value="key1">', $result);
+        self::assertStringContainsString('<option value="key1">', $result);
 
-        $this->assertStringContainsString('<option value="key2">', $result);
+        self::assertStringContainsString('<option value="key2">', $result);
 
         // select case 2
         $opts['values_escaped'] = false;
@@ -169,10 +169,10 @@ class FormDisplayTemplateTest extends AbstractTestCase
         $opts['values'] = ['a<b' => 'c&d', 'key1' => true, 'key2' => false];
         $result = $this->formDisplayTemplate->displayInput('test/path', 'testName', 'select', false, '', true, $opts);
 
-        $this->assertStringContainsString('<select name="test/path" id="test/path" class="w-75">', $result);
+        self::assertStringContainsString('<select name="test/path" id="test/path" class="w-75">', $result);
 
         // assertContains doesn't seem to work with htmlentities
-        $this->assertStringContainsString('<option value="a&lt;b">c&amp;d</option>', $result);
+        self::assertStringContainsString('<option value="a&lt;b">c&amp;d</option>', $result);
 
         // list
         $result = $this->formDisplayTemplate->displayInput(
@@ -185,7 +185,7 @@ class FormDisplayTemplateTest extends AbstractTestCase
             $opts,
         );
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             '<textarea cols="35" rows="5" name="test/path" id="test/path" class="">',
             $result,
         );
@@ -196,7 +196,7 @@ class FormDisplayTemplateTest extends AbstractTestCase
      */
     public function testDisplayGroupHeader(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             '',
             $this->formDisplayTemplate->displayGroupHeader(''),
         );
@@ -207,7 +207,7 @@ class FormDisplayTemplateTest extends AbstractTestCase
 
         $result = $this->formDisplayTemplate->displayGroupHeader('headerText');
 
-        $this->assertStringContainsString('<tr class="group-header group-header-4">', $result);
+        self::assertStringContainsString('<tr class="group-header group-header-4">', $result);
 
         // without PMA_SETUP
         $this->config->set('is_setup', false);
@@ -216,7 +216,7 @@ class FormDisplayTemplateTest extends AbstractTestCase
 
         $result = $this->formDisplayTemplate->displayGroupHeader('headerText');
 
-        $this->assertStringContainsString('<tr class="group-header group-header-4">', $result);
+        self::assertStringContainsString('<tr class="group-header group-header-4">', $result);
     }
 
     /**
@@ -226,7 +226,7 @@ class FormDisplayTemplateTest extends AbstractTestCase
     {
         $this->formDisplayTemplate->group = 3;
         $this->formDisplayTemplate->displayGroupFooter();
-        $this->assertEquals(2, $this->formDisplayTemplate->group);
+        self::assertEquals(2, $this->formDisplayTemplate->group);
     }
 
     /**
@@ -240,7 +240,7 @@ class FormDisplayTemplateTest extends AbstractTestCase
 
         $this->formDisplayTemplate->addJsValidate('testID', $validators, $js);
 
-        $this->assertEquals(
+        self::assertEquals(
             [
                 'window.Config.registerFieldValidator(\'testID\', \'\\\';\', true, '
                 . '["\\\\r\\\\n\\\\\''
diff --git a/tests/classes/Config/FormDisplayTest.php b/tests/classes/Config/FormDisplayTest.php
index 0e7bcc179e..4e0289dbfb 100644
--- a/tests/classes/Config/FormDisplayTest.php
+++ b/tests/classes/Config/FormDisplayTest.php
@@ -62,18 +62,18 @@ class FormDisplayTest extends AbstractTestCase
 
         $this->object->registerForm('pma_testform', $array, 2);
         $forms = $attrForms->getValue($this->object);
-        $this->assertInstanceOf(Form::class, $forms['pma_testform']);
+        self::assertInstanceOf(Form::class, $forms['pma_testform']);
 
         $attrSystemPaths = $reflection->getProperty('systemPaths');
 
-        $this->assertEquals(
+        self::assertEquals(
             ['Servers/2/test' => 'Servers/1/test', 'Servers/2/:group:end:0' => 'Servers/1/:group:end:0'],
             $attrSystemPaths->getValue($this->object),
         );
 
         $attrTranslatedPaths = $reflection->getProperty('translatedPaths');
 
-        $this->assertEquals(
+        self::assertEquals(
             ['Servers/2/test' => 'Servers-2-test', 'Servers/2/:group:end:0' => 'Servers-2-:group:end:0'],
             $attrTranslatedPaths->getValue($this->object),
         );
@@ -85,7 +85,7 @@ class FormDisplayTest extends AbstractTestCase
     #[Group('medium')]
     public function testProcess(): void
     {
-        $this->assertFalse(
+        self::assertFalse(
             $this->object->process(true, true),
         );
 
@@ -97,18 +97,18 @@ class FormDisplayTest extends AbstractTestCase
         $attrForms = new ReflectionProperty(FormDisplay::class, 'forms');
         $attrForms->setValue($this->object, [1, 2, 3]);
 
-        $this->object->expects($this->once())
+        $this->object->expects(self::once())
             ->method('save')
             ->with([0, 1, 2], false)
             ->willReturn(true);
 
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->process(false, false),
         );
 
         $attrForms->setValue($this->object, []);
 
-        $this->assertFalse(
+        self::assertFalse(
             $this->object->process(false, false),
         );
     }
@@ -128,7 +128,7 @@ class FormDisplayTest extends AbstractTestCase
 
         $result = $this->object->displayErrors();
 
-        $this->assertSame($result, '');
+        self::assertSame($result, '');
 
         $arr = ['Servers/1/test' => ['e1'], 'foobar' => ['e2', 'e3']];
 
@@ -141,11 +141,11 @@ class FormDisplayTest extends AbstractTestCase
 
         $result = $this->object->displayErrors();
 
-        $this->assertStringContainsString('<dt>Servers/1/test2</dt>', $result);
-        $this->assertStringContainsString('<dd>e1</dd>', $result);
-        $this->assertStringContainsString('<dt>Form_foobar</dt>', $result);
-        $this->assertStringContainsString('<dd>e2</dd>', $result);
-        $this->assertStringContainsString('<dd>e3</dd>', $result);
+        self::assertStringContainsString('<dt>Servers/1/test2</dt>', $result);
+        self::assertStringContainsString('<dd>e1</dd>', $result);
+        self::assertStringContainsString('<dt>Form_foobar</dt>', $result);
+        self::assertStringContainsString('<dd>e2</dd>', $result);
+        self::assertStringContainsString('<dd>e3</dd>', $result);
     }
 
     /**
@@ -174,7 +174,7 @@ class FormDisplayTest extends AbstractTestCase
 
         $this->object->fixErrors();
 
-        $this->assertEquals(
+        self::assertEquals(
             ['Servers' => ['1' => ['test' => 'localhost']]],
             $_SESSION['ConfigFile2'],
         );
@@ -189,7 +189,7 @@ class FormDisplayTest extends AbstractTestCase
 
         $arr = ['foo' => 'var'];
         $value = 'foo';
-        $this->assertTrue(
+        self::assertTrue(
             $attrValidateSelect->invokeArgs(
                 $this->object,
                 [&$value, $arr],
@@ -198,20 +198,20 @@ class FormDisplayTest extends AbstractTestCase
 
         $arr = ['' => 'foobar'];
         $value = '';
-        $this->assertTrue(
+        self::assertTrue(
             $attrValidateSelect->invokeArgs(
                 $this->object,
                 [&$value, $arr],
             ),
         );
-        $this->assertEquals(
+        self::assertEquals(
             'string',
             gettype($value),
         );
 
         $arr = [0 => 'foobar'];
         $value = 0;
-        $this->assertTrue(
+        self::assertTrue(
             $attrValidateSelect->invokeArgs(
                 $this->object,
                 [&$value, $arr],
@@ -220,7 +220,7 @@ class FormDisplayTest extends AbstractTestCase
 
         $arr = ['1' => 'foobar'];
         $value = 0;
-        $this->assertFalse(
+        self::assertFalse(
             $attrValidateSelect->invokeArgs(
                 $this->object,
                 [&$value, $arr],
@@ -233,14 +233,14 @@ class FormDisplayTest extends AbstractTestCase
      */
     public function testHasErrors(): void
     {
-        $this->assertFalse($this->object->hasErrors());
+        self::assertFalse($this->object->hasErrors());
 
         (new ReflectionProperty(FormDisplay::class, 'errors'))->setValue(
             $this->object,
             [1, 2],
         );
 
-        $this->assertTrue($this->object->hasErrors());
+        self::assertTrue($this->object->hasErrors());
     }
 
     /**
@@ -248,18 +248,18 @@ class FormDisplayTest extends AbstractTestCase
      */
     public function testGetDocLink(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             'index.php?route=/url&url='
             . 'https%3A%2F%2Fdocs.phpmyadmin.net%2Fen%2Flatest%2Fconfig.html%23cfg_Servers_3_test_2_',
             $this->object->getDocLink('Servers/3/test/2/'),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             '',
             $this->object->getDocLink('Import'),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             '',
             $this->object->getDocLink('Export'),
         );
@@ -272,12 +272,12 @@ class FormDisplayTest extends AbstractTestCase
     {
         $method = new ReflectionMethod(FormDisplay::class, 'getOptName');
 
-        $this->assertEquals(
+        self::assertEquals(
             'Servers_',
             $method->invoke($this->object, 'Servers/1/'),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'Servers_23_',
             $method->invoke($this->object, 'Servers/1/23/'),
         );
@@ -293,7 +293,7 @@ class FormDisplayTest extends AbstractTestCase
         $attrUserprefs = new ReflectionProperty(FormDisplay::class, 'userprefsDisallow');
 
         $method->invoke($this->object, null);
-        $this->assertEquals(
+        self::assertEquals(
             [],
             $attrUserprefs->getValue($this->object),
         );
@@ -328,7 +328,7 @@ class FormDisplayTest extends AbstractTestCase
 
         $expect['comment_warning'] = 1;
 
-        $this->assertEquals($expect, $opts);
+        self::assertEquals($expect, $opts);
 
         // ZipDump, GZipDump, BZipDump
         $method->invokeArgs(
@@ -346,9 +346,9 @@ class FormDisplayTest extends AbstractTestCase
             'due to missing function gzcompress.';
         }
 
-        $this->assertEquals($comment, $opts['comment']);
+        self::assertEquals($comment, $opts['comment']);
 
-        $this->assertTrue($opts['comment_warning']);
+        self::assertTrue($opts['comment_warning']);
 
         $method->invokeArgs(
             $this->object,
@@ -365,9 +365,9 @@ class FormDisplayTest extends AbstractTestCase
             'due to missing function gzencode.';
         }
 
-        $this->assertEquals($comment, $opts['comment']);
+        self::assertEquals($comment, $opts['comment']);
 
-        $this->assertTrue($opts['comment_warning']);
+        self::assertTrue($opts['comment_warning']);
 
         $method->invokeArgs(
             $this->object,
@@ -384,9 +384,9 @@ class FormDisplayTest extends AbstractTestCase
             'due to missing function bzcompress.';
         }
 
-        $this->assertEquals($comment, $opts['comment']);
+        self::assertEquals($comment, $opts['comment']);
 
-        $this->assertTrue($opts['comment_warning']);
+        self::assertTrue($opts['comment_warning']);
 
         $config = Config::getInstance();
         $config->set('is_setup', false);
@@ -400,20 +400,20 @@ class FormDisplayTest extends AbstractTestCase
             ['MaxDbList', &$opts],
         );
 
-        $this->assertEquals('maximum 10', $opts['comment']);
+        self::assertEquals('maximum 10', $opts['comment']);
 
         $method->invokeArgs(
             $this->object,
             ['MaxTableList', &$opts],
         );
 
-        $this->assertEquals('maximum 10', $opts['comment']);
+        self::assertEquals('maximum 10', $opts['comment']);
 
         $method->invokeArgs(
             $this->object,
             ['QueryHistoryMax', &$opts],
         );
 
-        $this->assertEquals('maximum 10', $opts['comment']);
+        self::assertEquals('maximum 10', $opts['comment']);
     }
 }
diff --git a/tests/classes/Config/FormTest.php b/tests/classes/Config/FormTest.php
index 2a57d84b39..38638ed118 100644
--- a/tests/classes/Config/FormTest.php
+++ b/tests/classes/Config/FormTest.php
@@ -53,9 +53,9 @@ class FormTest extends AbstractTestCase
     #[Group('medium')]
     public function testContructor(): void
     {
-        $this->assertEquals(1, $this->object->index);
-        $this->assertEquals('pma_form_name', $this->object->name);
-        $this->assertArrayHasKey('pma_form1', $this->object->fields);
+        self::assertEquals(1, $this->object->index);
+        self::assertEquals('pma_form_name', $this->object->name);
+        self::assertArrayHasKey('pma_form1', $this->object->fields);
     }
 
     /**
@@ -68,11 +68,11 @@ class FormTest extends AbstractTestCase
             ['7' => 'Seven'],
         );
 
-        $this->assertNull(
+        self::assertNull(
             $this->object->getOptionType('123/4/5/6'),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'Seven',
             $this->object->getOptionType('123/4/5/7'),
         );
@@ -83,17 +83,17 @@ class FormTest extends AbstractTestCase
      */
     public function testGetOptionValueList(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             ['NHibernate C# DO', 'NHibernate XML'],
             $this->object->getOptionValueList('Export/codegen_format'),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             ['auto' => 'auto', '1' => 1, '0' => 0],
             $this->object->getOptionValueList('OBGzip'),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             ['none' => 'Nowhere', 'left' => 'Left', 'right' => 'Right', 'both' => 'Both'],
             $this->object->getOptionValueList('RowActionLinks'),
         );
@@ -113,16 +113,16 @@ class FormTest extends AbstractTestCase
 
         $result = $this->object->fields;
 
-        $this->assertCount(4, $result);
+        self::assertCount(4, $result);
 
-        $this->assertEquals('pma_form1', $result['pma_form1']);
+        self::assertEquals('pma_form1', $result['pma_form1']);
 
-        $this->assertEquals('pma_form2', $result['pma_form2']);
+        self::assertEquals('pma_form2', $result['pma_form2']);
 
-        $this->assertEquals('preffoo/foo/bar/test', $result[0]);
+        self::assertEquals('preffoo/foo/bar/test', $result[0]);
 
         // needs regexp because the counter is static
-        $this->assertMatchesRegularExpression('/^preffoo\/foo\/bar\/\:group\:end\:\d+$/', $result[1]);
+        self::assertMatchesRegularExpression('/^preffoo\/foo\/bar\/\:group\:end\:\d+$/', $result[1]);
     }
 
     /**
@@ -139,22 +139,22 @@ class FormTest extends AbstractTestCase
 
         $result = $this->object->fields;
 
-        $this->assertCount(2, $result);
+        self::assertCount(2, $result);
 
-        $this->assertEquals('foo/bar/test', $result['test']);
+        self::assertEquals('foo/bar/test', $result['test']);
 
         unset($result['test']);
 
         // needs regexp because the counter is static
         $key = array_keys($result)[0];
-        $this->assertIsString($key);
+        self::assertIsString($key);
 
-        $this->assertMatchesRegularExpression('/^\:group\:end\:(\d+)$/', $key);
+        self::assertMatchesRegularExpression('/^\:group\:end\:(\d+)$/', $key);
 
         preg_match('/^\:group\:end\:(\d+)$/', $key, $matches);
         $digit = $matches[1];
 
-        $this->assertEquals('foo/bar/:group:end:' . $digit, $result[':group:end:' . $digit]);
+        self::assertEquals('foo/bar/:group:end:' . $digit, $result[':group:end:' . $digit]);
     }
 
     /**
@@ -176,7 +176,7 @@ class FormTest extends AbstractTestCase
 
         $method->invoke($this->object, null);
 
-        $this->assertEquals(
+        self::assertEquals(
             ['pma_form1' => 'integer', 'pma_form2' => 'select', ':group:end:0' => 'group', '1' => 'NULL'],
             $attrFieldsTypes->getValue($this->object),
         );
@@ -192,16 +192,16 @@ class FormTest extends AbstractTestCase
             ->onlyMethods(['readFormPaths', 'readTypes'])
             ->getMock();
 
-        $this->object->expects($this->exactly(1))
+        $this->object->expects(self::exactly(1))
             ->method('readFormPaths')
             ->with(['testForm']);
 
-        $this->object->expects($this->exactly(1))
+        $this->object->expects(self::exactly(1))
             ->method('readTypes');
 
         $this->object->loadForm('pmaform', ['testForm']);
 
-        $this->assertEquals('pmaform', $this->object->name);
+        self::assertEquals('pmaform', $this->object->name);
     }
 
     /**
@@ -214,7 +214,7 @@ class FormTest extends AbstractTestCase
             ->onlyMethods(['readFormPaths', 'readTypes'])
             ->getMock();
 
-        $this->object->expects($this->exactly(1))->method('readFormPaths')->with([
+        $this->object->expects(self::exactly(1))->method('readFormPaths')->with([
             ':group:OpenDocument-OpenOffice 試算表',
             'group:test/data',
             'Export/ods_columns',
diff --git a/tests/classes/Config/Forms/FormListTest.php b/tests/classes/Config/Forms/FormListTest.php
index 5d39324ac6..60d3e8c173 100644
--- a/tests/classes/Config/Forms/FormListTest.php
+++ b/tests/classes/Config/Forms/FormListTest.php
@@ -45,23 +45,23 @@ class FormListTest extends AbstractTestCase
         $cf = new ConfigFile(Config::getInstance()->baseSettings);
 
         /* Static API */
-        $this->assertTrue($class::isValid('Export'));
-        $this->assertEquals($prefix, $class::get('Export'));
+        self::assertTrue($class::isValid('Export'));
+        self::assertEquals($prefix, $class::get('Export'));
         foreach ($class::getAllFormNames() as $form) {
             $formClass = $class::get($form);
-            $this->assertNotNull($formClass);
-            $this->assertNotNull($formClass::getName());
+            self::assertNotNull($formClass);
+            self::assertNotNull($formClass::getName());
         }
 
-        $this->assertContains('Export/texytext_columns', $class::getFields());
+        self::assertContains('Export/texytext_columns', $class::getFields());
 
         /* Instance handling */
         $forms = new $class($cf);
-        $this->assertInstanceOf(BaseFormList::class, $forms);
-        $this->assertFalse($forms->process());
+        self::assertInstanceOf(BaseFormList::class, $forms);
+        self::assertFalse($forms->process());
         $forms->fixErrors();
-        $this->assertFalse($forms->hasErrors());
-        $this->assertEquals('', $forms->displayErrors());
+        self::assertFalse($forms->hasErrors());
+        self::assertEquals('', $forms->displayErrors());
     }
 
     /**
diff --git a/tests/classes/Config/PageSettingsTest.php b/tests/classes/Config/PageSettingsTest.php
index 6e461dd154..1f386bfa8a 100644
--- a/tests/classes/Config/PageSettingsTest.php
+++ b/tests/classes/Config/PageSettingsTest.php
@@ -47,7 +47,7 @@ class PageSettingsTest extends AbstractTestCase
         $object = new PageSettings(new UserPreferences($dbi, new Relation($dbi), new Template()));
         $object->init('NonExistent');
 
-        $this->assertEquals('', $object->getHTML());
+        self::assertEquals('', $object->getHTML());
     }
 
     /**
@@ -67,7 +67,7 @@ class PageSettingsTest extends AbstractTestCase
         $html = $object->getHTML();
 
         // Test some sample parts
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             '<div id="page_settings_modal">'
             . '<div class="page_settings">'
             . '<form method="post" '
@@ -76,9 +76,9 @@ class PageSettingsTest extends AbstractTestCase
             $html,
         );
 
-        $this->assertStringContainsString('<input type="hidden" name="submit_save" value="Browse">', $html);
+        self::assertStringContainsString('<input type="hidden" name="submit_save" value="Browse">', $html);
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             "window.Config.registerFieldValidator('MaxRows', 'validatePositiveNumber', true);\n"
             . "window.Config.registerFieldValidator('RepeatCells', 'validateNonNegativeNumber', true);\n"
             . "window.Config.registerFieldValidator('LimitChars', 'validatePositiveNumber', true);\n",
@@ -100,8 +100,8 @@ class PageSettingsTest extends AbstractTestCase
         $html = $pageSettings->getHTML();
 
         // Test some sample parts
-        $this->assertStringContainsString('<div id="pma_navigation_settings">', $html);
+        self::assertStringContainsString('<div id="pma_navigation_settings">', $html);
 
-        $this->assertStringContainsString('<input type="hidden" name="submit_save" value="Navi">', $html);
+        self::assertStringContainsString('<input type="hidden" name="submit_save" value="Navi">', $html);
     }
 }
diff --git a/tests/classes/Config/ServerConfigChecksTest.php b/tests/classes/Config/ServerConfigChecksTest.php
index 20d9c6d28a..09b6f1f921 100644
--- a/tests/classes/Config/ServerConfigChecksTest.php
+++ b/tests/classes/Config/ServerConfigChecksTest.php
@@ -77,7 +77,7 @@ class ServerConfigChecksTest extends AbstractTestCase
 
         $configChecker->performConfigChecks();
 
-        $this->assertEquals(
+        self::assertEquals(
             [
                 'Servers/1/ssl',
                 'Servers/1/auth_type',
@@ -90,7 +90,7 @@ class ServerConfigChecksTest extends AbstractTestCase
             array_keys($_SESSION['messages']['notice']),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             ['LoginCookieValidity', 'GZipDump', 'BZipDump', 'ZipDump_import', 'ZipDump_export'],
             array_keys($_SESSION['messages']['error']),
         );
@@ -120,14 +120,14 @@ class ServerConfigChecksTest extends AbstractTestCase
          * @psalm-suppress TypeDoesNotContainType
          */
         $secret = $_SESSION[$this->sessionID]['blowfish_secret'] ?? '';
-        $this->assertIsString($secret);
-        $this->assertSame(SODIUM_CRYPTO_SECRETBOX_KEYBYTES, mb_strlen($secret, '8bit'));
+        self::assertIsString($secret);
+        self::assertSame(SODIUM_CRYPTO_SECRETBOX_KEYBYTES, mb_strlen($secret, '8bit'));
         $messages = $_SESSION['messages'] ?? null;
-        $this->assertIsArray($messages);
-        $this->assertArrayHasKey('notice', $messages);
-        $this->assertIsArray($messages['notice']);
-        $this->assertArrayHasKey('blowfish_secret_created', $messages['notice']);
-        $this->assertArrayNotHasKey('error', $messages);
+        self::assertIsArray($messages);
+        self::assertArrayHasKey('notice', $messages);
+        self::assertIsArray($messages['notice']);
+        self::assertArrayHasKey('blowfish_secret_created', $messages['notice']);
+        self::assertArrayNotHasKey('error', $messages);
     }
 
     /**
@@ -150,14 +150,14 @@ class ServerConfigChecksTest extends AbstractTestCase
          * @psalm-suppress TypeDoesNotContainType
          */
         $secret = $_SESSION[$this->sessionID]['blowfish_secret'] ?? '';
-        $this->assertIsString($secret);
-        $this->assertSame(SODIUM_CRYPTO_SECRETBOX_KEYBYTES, mb_strlen($secret, '8bit'));
+        self::assertIsString($secret);
+        self::assertSame(SODIUM_CRYPTO_SECRETBOX_KEYBYTES, mb_strlen($secret, '8bit'));
         $messages = $_SESSION['messages'] ?? null;
-        $this->assertIsArray($messages);
-        $this->assertArrayHasKey('notice', $messages);
-        $this->assertIsArray($messages['notice']);
-        $this->assertArrayHasKey('blowfish_secret_created', $messages['notice']);
-        $this->assertArrayNotHasKey('error', $messages);
+        self::assertIsArray($messages);
+        self::assertArrayHasKey('notice', $messages);
+        self::assertIsArray($messages['notice']);
+        self::assertArrayHasKey('blowfish_secret_created', $messages['notice']);
+        self::assertArrayNotHasKey('error', $messages);
     }
 
     /**
@@ -178,13 +178,13 @@ class ServerConfigChecksTest extends AbstractTestCase
          * @psalm-suppress TypeDoesNotContainType
          */
         $secret = $_SESSION[$this->sessionID]['blowfish_secret'] ?? '';
-        $this->assertIsString($secret);
-        $this->assertSame(SODIUM_CRYPTO_SECRETBOX_KEYBYTES, mb_strlen($secret, '8bit'));
+        self::assertIsString($secret);
+        self::assertSame(SODIUM_CRYPTO_SECRETBOX_KEYBYTES, mb_strlen($secret, '8bit'));
         $messages = $_SESSION['messages'] ?? null;
-        $this->assertIsArray($messages);
-        $this->assertArrayHasKey('notice', $messages);
-        $this->assertIsArray($messages['notice']);
-        $this->assertArrayNotHasKey('blowfish_secret_created', $messages['notice']);
-        $this->assertArrayNotHasKey('error', $messages);
+        self::assertIsArray($messages);
+        self::assertArrayHasKey('notice', $messages);
+        self::assertIsArray($messages['notice']);
+        self::assertArrayNotHasKey('blowfish_secret_created', $messages['notice']);
+        self::assertArrayNotHasKey('error', $messages);
     }
 }
diff --git a/tests/classes/Config/Settings/ConsoleTest.php b/tests/classes/Config/Settings/ConsoleTest.php
index 5a608e212d..59104b8ca1 100644
--- a/tests/classes/Config/Settings/ConsoleTest.php
+++ b/tests/classes/Config/Settings/ConsoleTest.php
@@ -18,8 +18,8 @@ class ConsoleTest extends TestCase
         $console = new Console(['StartHistory' => $actual]);
         $consoleArray = $console->asArray();
         // phpcs:ignore Squiz.NamingConventions.ValidVariableName.MemberNotCamelCaps
-        $this->assertSame($expected, $console->StartHistory);
-        $this->assertSame($expected, $consoleArray['StartHistory']);
+        self::assertSame($expected, $console->StartHistory);
+        self::assertSame($expected, $consoleArray['StartHistory']);
     }
 
     /** @return iterable<string, array{mixed, bool}> */
@@ -37,8 +37,8 @@ class ConsoleTest extends TestCase
         $console = new Console(['AlwaysExpand' => $actual]);
         $consoleArray = $console->asArray();
         // phpcs:ignore Squiz.NamingConventions.ValidVariableName.MemberNotCamelCaps
-        $this->assertSame($expected, $console->AlwaysExpand);
-        $this->assertSame($expected, $consoleArray['AlwaysExpand']);
+        self::assertSame($expected, $console->AlwaysExpand);
+        self::assertSame($expected, $consoleArray['AlwaysExpand']);
     }
 
     #[DataProvider('booleanWithDefaultTrueProvider')]
@@ -47,8 +47,8 @@ class ConsoleTest extends TestCase
         $console = new Console(['CurrentQuery' => $actual]);
         $consoleArray = $console->asArray();
         // phpcs:ignore Squiz.NamingConventions.ValidVariableName.MemberNotCamelCaps
-        $this->assertSame($expected, $console->CurrentQuery);
-        $this->assertSame($expected, $consoleArray['CurrentQuery']);
+        self::assertSame($expected, $console->CurrentQuery);
+        self::assertSame($expected, $consoleArray['CurrentQuery']);
     }
 
     /** @return iterable<string, array{mixed, bool}> */
@@ -66,8 +66,8 @@ class ConsoleTest extends TestCase
         $console = new Console(['EnterExecutes' => $actual]);
         $consoleArray = $console->asArray();
         // phpcs:ignore Squiz.NamingConventions.ValidVariableName.MemberNotCamelCaps
-        $this->assertSame($expected, $console->EnterExecutes);
-        $this->assertSame($expected, $consoleArray['EnterExecutes']);
+        self::assertSame($expected, $console->EnterExecutes);
+        self::assertSame($expected, $consoleArray['EnterExecutes']);
     }
 
     #[DataProvider('booleanWithDefaultFalseProvider')]
@@ -76,8 +76,8 @@ class ConsoleTest extends TestCase
         $console = new Console(['DarkTheme' => $actual]);
         $consoleArray = $console->asArray();
         // phpcs:ignore Squiz.NamingConventions.ValidVariableName.MemberNotCamelCaps
-        $this->assertSame($expected, $console->DarkTheme);
-        $this->assertSame($expected, $consoleArray['DarkTheme']);
+        self::assertSame($expected, $console->DarkTheme);
+        self::assertSame($expected, $consoleArray['DarkTheme']);
     }
 
     #[DataProvider('valuesForModeProvider')]
@@ -86,8 +86,8 @@ class ConsoleTest extends TestCase
         $console = new Console(['Mode' => $actual]);
         $consoleArray = $console->asArray();
         // phpcs:ignore Squiz.NamingConventions.ValidVariableName.MemberNotCamelCaps
-        $this->assertSame($expected, $console->Mode);
-        $this->assertSame($expected, $consoleArray['Mode']);
+        self::assertSame($expected, $console->Mode);
+        self::assertSame($expected, $consoleArray['Mode']);
     }
 
     /** @return iterable<string, array{mixed, string}> */
@@ -106,8 +106,8 @@ class ConsoleTest extends TestCase
         $console = new Console(['Height' => $actual]);
         $consoleArray = $console->asArray();
         // phpcs:ignore Squiz.NamingConventions.ValidVariableName.MemberNotCamelCaps
-        $this->assertSame($expected, $console->Height);
-        $this->assertSame($expected, $consoleArray['Height']);
+        self::assertSame($expected, $console->Height);
+        self::assertSame($expected, $consoleArray['Height']);
     }
 
     /** @return iterable<string, array{mixed, int}> */
@@ -125,8 +125,8 @@ class ConsoleTest extends TestCase
         $console = new Console(['GroupQueries' => $actual]);
         $consoleArray = $console->asArray();
         // phpcs:ignore Squiz.NamingConventions.ValidVariableName.MemberNotCamelCaps
-        $this->assertSame($expected, $console->GroupQueries);
-        $this->assertSame($expected, $consoleArray['GroupQueries']);
+        self::assertSame($expected, $console->GroupQueries);
+        self::assertSame($expected, $consoleArray['GroupQueries']);
     }
 
     #[DataProvider('valuesForOrderByProvider')]
@@ -135,8 +135,8 @@ class ConsoleTest extends TestCase
         $console = new Console(['OrderBy' => $actual]);
         $consoleArray = $console->asArray();
         // phpcs:ignore Squiz.NamingConventions.ValidVariableName.MemberNotCamelCaps
-        $this->assertSame($expected, $console->OrderBy);
-        $this->assertSame($expected, $consoleArray['OrderBy']);
+        self::assertSame($expected, $console->OrderBy);
+        self::assertSame($expected, $consoleArray['OrderBy']);
     }
 
     /** @return iterable<string, array{mixed, string}> */
@@ -155,8 +155,8 @@ class ConsoleTest extends TestCase
         $console = new Console(['Order' => $actual]);
         $consoleArray = $console->asArray();
         // phpcs:ignore Squiz.NamingConventions.ValidVariableName.MemberNotCamelCaps
-        $this->assertSame($expected, $console->Order);
-        $this->assertSame($expected, $consoleArray['Order']);
+        self::assertSame($expected, $console->Order);
+        self::assertSame($expected, $consoleArray['Order']);
     }
 
     /** @return iterable<string, array{mixed, string}> */
diff --git a/tests/classes/Config/Settings/DebugTest.php b/tests/classes/Config/Settings/DebugTest.php
index 0a871bcc97..d70eaf8540 100644
--- a/tests/classes/Config/Settings/DebugTest.php
+++ b/tests/classes/Config/Settings/DebugTest.php
@@ -17,8 +17,8 @@ class DebugTest extends TestCase
     {
         $debug = new Debug(['sql' => $actual]);
         $debugArray = $debug->asArray();
-        $this->assertSame($expected, $debug->sql);
-        $this->assertSame($expected, $debugArray['sql']);
+        self::assertSame($expected, $debug->sql);
+        self::assertSame($expected, $debugArray['sql']);
     }
 
     #[DataProvider('booleanWithDefaultFalseProvider')]
@@ -26,8 +26,8 @@ class DebugTest extends TestCase
     {
         $debug = new Debug(['sqllog' => $actual]);
         $debugArray = $debug->asArray();
-        $this->assertSame($expected, $debug->sqllog);
-        $this->assertSame($expected, $debugArray['sqllog']);
+        self::assertSame($expected, $debug->sqllog);
+        self::assertSame($expected, $debugArray['sqllog']);
     }
 
     #[DataProvider('booleanWithDefaultFalseProvider')]
@@ -35,8 +35,8 @@ class DebugTest extends TestCase
     {
         $debug = new Debug(['demo' => $actual]);
         $debugArray = $debug->asArray();
-        $this->assertSame($expected, $debug->demo);
-        $this->assertSame($expected, $debugArray['demo']);
+        self::assertSame($expected, $debug->demo);
+        self::assertSame($expected, $debugArray['demo']);
     }
 
     #[DataProvider('booleanWithDefaultFalseProvider')]
@@ -44,8 +44,8 @@ class DebugTest extends TestCase
     {
         $debug = new Debug(['simple2fa' => $actual]);
         $debugArray = $debug->asArray();
-        $this->assertSame($expected, $debug->simple2fa);
-        $this->assertSame($expected, $debugArray['simple2fa']);
+        self::assertSame($expected, $debug->simple2fa);
+        self::assertSame($expected, $debugArray['simple2fa']);
     }
 
     /** @return iterable<string, array{mixed, bool}> */
diff --git a/tests/classes/Config/Settings/ExportTest.php b/tests/classes/Config/Settings/ExportTest.php
index 880f575f75..18ce9d3704 100644
--- a/tests/classes/Config/Settings/ExportTest.php
+++ b/tests/classes/Config/Settings/ExportTest.php
@@ -18,8 +18,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['format' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->format);
-        $this->assertSame($expected, $exportArray['format']);
+        self::assertSame($expected, $export->format);
+        self::assertSame($expected, $exportArray['format']);
     }
 
     /** @return iterable<string, array{mixed, string}> */
@@ -47,8 +47,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['method' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->method);
-        $this->assertSame($expected, $exportArray['method']);
+        self::assertSame($expected, $export->method);
+        self::assertSame($expected, $exportArray['method']);
     }
 
     /** @return iterable<string, array{mixed, string}> */
@@ -66,8 +66,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['compression' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->compression);
-        $this->assertSame($expected, $exportArray['compression']);
+        self::assertSame($expected, $export->compression);
+        self::assertSame($expected, $exportArray['compression']);
     }
 
     /** @return iterable<string, array{mixed, string}> */
@@ -85,8 +85,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['lock_tables' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->lock_tables);
-        $this->assertSame($expected, $exportArray['lock_tables']);
+        self::assertSame($expected, $export->lock_tables);
+        self::assertSame($expected, $exportArray['lock_tables']);
     }
 
     /** @return iterable<string, array{mixed, bool}> */
@@ -103,8 +103,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['as_separate_files' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->as_separate_files);
-        $this->assertSame($expected, $exportArray['as_separate_files']);
+        self::assertSame($expected, $export->as_separate_files);
+        self::assertSame($expected, $exportArray['as_separate_files']);
     }
 
     #[DataProvider('booleanWithDefaultTrueProvider')]
@@ -112,8 +112,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['asfile' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->asfile);
-        $this->assertSame($expected, $exportArray['asfile']);
+        self::assertSame($expected, $export->asfile);
+        self::assertSame($expected, $exportArray['asfile']);
     }
 
     /** @return iterable<string, array{mixed, bool}> */
@@ -130,8 +130,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['charset' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->charset);
-        $this->assertSame($expected, $exportArray['charset']);
+        self::assertSame($expected, $export->charset);
+        self::assertSame($expected, $exportArray['charset']);
     }
 
     /** @return iterable<string, array{mixed, string}> */
@@ -148,8 +148,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['onserver' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->onserver);
-        $this->assertSame($expected, $exportArray['onserver']);
+        self::assertSame($expected, $export->onserver);
+        self::assertSame($expected, $exportArray['onserver']);
     }
 
     #[DataProvider('booleanWithDefaultFalseProvider')]
@@ -157,8 +157,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['onserver_overwrite' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->onserver_overwrite);
-        $this->assertSame($expected, $exportArray['onserver_overwrite']);
+        self::assertSame($expected, $export->onserver_overwrite);
+        self::assertSame($expected, $exportArray['onserver_overwrite']);
     }
 
     #[DataProvider('booleanWithDefaultFalseProvider')]
@@ -166,8 +166,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['quick_export_onserver' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->quick_export_onserver);
-        $this->assertSame($expected, $exportArray['quick_export_onserver']);
+        self::assertSame($expected, $export->quick_export_onserver);
+        self::assertSame($expected, $exportArray['quick_export_onserver']);
     }
 
     #[DataProvider('booleanWithDefaultFalseProvider')]
@@ -175,8 +175,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['quick_export_onserver_overwrite' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->quick_export_onserver_overwrite);
-        $this->assertSame($expected, $exportArray['quick_export_onserver_overwrite']);
+        self::assertSame($expected, $export->quick_export_onserver_overwrite);
+        self::assertSame($expected, $exportArray['quick_export_onserver_overwrite']);
     }
 
     #[DataProvider('booleanWithDefaultTrueProvider')]
@@ -184,8 +184,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['remember_file_template' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->remember_file_template);
-        $this->assertSame($expected, $exportArray['remember_file_template']);
+        self::assertSame($expected, $export->remember_file_template);
+        self::assertSame($expected, $exportArray['remember_file_template']);
     }
 
     #[DataProvider('valuesForFileTemplateTableProvider')]
@@ -193,8 +193,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['file_template_table' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->file_template_table);
-        $this->assertSame($expected, $exportArray['file_template_table']);
+        self::assertSame($expected, $export->file_template_table);
+        self::assertSame($expected, $exportArray['file_template_table']);
     }
 
     /** @return iterable<string, array{mixed, string}> */
@@ -211,8 +211,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['file_template_database' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->file_template_database);
-        $this->assertSame($expected, $exportArray['file_template_database']);
+        self::assertSame($expected, $export->file_template_database);
+        self::assertSame($expected, $exportArray['file_template_database']);
     }
 
     /** @return iterable<string, array{mixed, string}> */
@@ -229,8 +229,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['file_template_server' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->file_template_server);
-        $this->assertSame($expected, $exportArray['file_template_server']);
+        self::assertSame($expected, $export->file_template_server);
+        self::assertSame($expected, $exportArray['file_template_server']);
     }
 
     /** @return iterable<string, array{mixed, string}> */
@@ -247,8 +247,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['codegen_structure_or_data' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->codegen_structure_or_data);
-        $this->assertSame($expected, $exportArray['codegen_structure_or_data']);
+        self::assertSame($expected, $export->codegen_structure_or_data);
+        self::assertSame($expected, $exportArray['codegen_structure_or_data']);
     }
 
     /** @return iterable<string, array{mixed, string}> */
@@ -266,8 +266,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['codegen_format' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->codegen_format);
-        $this->assertSame($expected, $exportArray['codegen_format']);
+        self::assertSame($expected, $export->codegen_format);
+        self::assertSame($expected, $exportArray['codegen_format']);
     }
 
     /** @return iterable<string, array{mixed, int}> */
@@ -286,8 +286,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['ods_columns' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->ods_columns);
-        $this->assertSame($expected, $exportArray['ods_columns']);
+        self::assertSame($expected, $export->ods_columns);
+        self::assertSame($expected, $exportArray['ods_columns']);
     }
 
     #[DataProvider('valuesForOdsNullProvider')]
@@ -295,8 +295,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['ods_null' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->ods_null);
-        $this->assertSame($expected, $exportArray['ods_null']);
+        self::assertSame($expected, $export->ods_null);
+        self::assertSame($expected, $exportArray['ods_null']);
     }
 
     /** @return iterable<string, array{mixed, string}> */
@@ -313,8 +313,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['odt_structure_or_data' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->odt_structure_or_data);
-        $this->assertSame($expected, $exportArray['odt_structure_or_data']);
+        self::assertSame($expected, $export->odt_structure_or_data);
+        self::assertSame($expected, $exportArray['odt_structure_or_data']);
     }
 
     /** @return iterable<string, array{mixed, string}> */
@@ -332,8 +332,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['odt_columns' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->odt_columns);
-        $this->assertSame($expected, $exportArray['odt_columns']);
+        self::assertSame($expected, $export->odt_columns);
+        self::assertSame($expected, $exportArray['odt_columns']);
     }
 
     #[DataProvider('booleanWithDefaultTrueProvider')]
@@ -341,8 +341,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['odt_relation' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->odt_relation);
-        $this->assertSame($expected, $exportArray['odt_relation']);
+        self::assertSame($expected, $export->odt_relation);
+        self::assertSame($expected, $exportArray['odt_relation']);
     }
 
     #[DataProvider('booleanWithDefaultTrueProvider')]
@@ -350,8 +350,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['odt_comments' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->odt_comments);
-        $this->assertSame($expected, $exportArray['odt_comments']);
+        self::assertSame($expected, $export->odt_comments);
+        self::assertSame($expected, $exportArray['odt_comments']);
     }
 
     #[DataProvider('booleanWithDefaultTrueProvider')]
@@ -359,8 +359,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['odt_mime' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->odt_mime);
-        $this->assertSame($expected, $exportArray['odt_mime']);
+        self::assertSame($expected, $export->odt_mime);
+        self::assertSame($expected, $exportArray['odt_mime']);
     }
 
     #[DataProvider('valuesForOdtNullProvider')]
@@ -368,8 +368,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['odt_null' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->odt_null);
-        $this->assertSame($expected, $exportArray['odt_null']);
+        self::assertSame($expected, $export->odt_null);
+        self::assertSame($expected, $exportArray['odt_null']);
     }
 
     /** @return iterable<string, array{mixed, string}> */
@@ -386,8 +386,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['htmlword_structure_or_data' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->htmlword_structure_or_data);
-        $this->assertSame($expected, $exportArray['htmlword_structure_or_data']);
+        self::assertSame($expected, $export->htmlword_structure_or_data);
+        self::assertSame($expected, $exportArray['htmlword_structure_or_data']);
     }
 
     #[DataProvider('booleanWithDefaultFalseProvider')]
@@ -395,8 +395,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['htmlword_columns' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->htmlword_columns);
-        $this->assertSame($expected, $exportArray['htmlword_columns']);
+        self::assertSame($expected, $export->htmlword_columns);
+        self::assertSame($expected, $exportArray['htmlword_columns']);
     }
 
     #[DataProvider('valuesForHtmlwordNullProvider')]
@@ -404,8 +404,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['htmlword_null' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->htmlword_null);
-        $this->assertSame($expected, $exportArray['htmlword_null']);
+        self::assertSame($expected, $export->htmlword_null);
+        self::assertSame($expected, $exportArray['htmlword_null']);
     }
 
     /** @return iterable<string, array{mixed, string}> */
@@ -422,8 +422,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['texytext_structure_or_data' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->texytext_structure_or_data);
-        $this->assertSame($expected, $exportArray['texytext_structure_or_data']);
+        self::assertSame($expected, $export->texytext_structure_or_data);
+        self::assertSame($expected, $exportArray['texytext_structure_or_data']);
     }
 
     #[DataProvider('booleanWithDefaultFalseProvider')]
@@ -431,8 +431,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['texytext_columns' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->texytext_columns);
-        $this->assertSame($expected, $exportArray['texytext_columns']);
+        self::assertSame($expected, $export->texytext_columns);
+        self::assertSame($expected, $exportArray['texytext_columns']);
     }
 
     #[DataProvider('valuesForTexytextNullProvider')]
@@ -440,8 +440,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['texytext_null' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->texytext_null);
-        $this->assertSame($expected, $exportArray['texytext_null']);
+        self::assertSame($expected, $export->texytext_null);
+        self::assertSame($expected, $exportArray['texytext_null']);
     }
 
     /** @return iterable<string, array{mixed, string}> */
@@ -458,8 +458,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['csv_columns' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->csv_columns);
-        $this->assertSame($expected, $exportArray['csv_columns']);
+        self::assertSame($expected, $export->csv_columns);
+        self::assertSame($expected, $exportArray['csv_columns']);
     }
 
     #[DataProvider('structureOrDataWithDefaultDataProvider')]
@@ -467,8 +467,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['csv_structure_or_data' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->csv_structure_or_data);
-        $this->assertSame($expected, $exportArray['csv_structure_or_data']);
+        self::assertSame($expected, $export->csv_structure_or_data);
+        self::assertSame($expected, $exportArray['csv_structure_or_data']);
     }
 
     #[DataProvider('valuesForCsvNullProvider')]
@@ -476,8 +476,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['csv_null' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->csv_null);
-        $this->assertSame($expected, $exportArray['csv_null']);
+        self::assertSame($expected, $export->csv_null);
+        self::assertSame($expected, $exportArray['csv_null']);
     }
 
     /** @return iterable<string, array{mixed, string}> */
@@ -494,8 +494,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['csv_separator' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->csv_separator);
-        $this->assertSame($expected, $exportArray['csv_separator']);
+        self::assertSame($expected, $export->csv_separator);
+        self::assertSame($expected, $exportArray['csv_separator']);
     }
 
     /** @return iterable<string, array{mixed, string}> */
@@ -512,8 +512,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['csv_enclosed' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->csv_enclosed);
-        $this->assertSame($expected, $exportArray['csv_enclosed']);
+        self::assertSame($expected, $export->csv_enclosed);
+        self::assertSame($expected, $exportArray['csv_enclosed']);
     }
 
     /** @return iterable<string, array{mixed, string}> */
@@ -530,8 +530,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['csv_escaped' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->csv_escaped);
-        $this->assertSame($expected, $exportArray['csv_escaped']);
+        self::assertSame($expected, $export->csv_escaped);
+        self::assertSame($expected, $exportArray['csv_escaped']);
     }
 
     /** @return iterable<string, array{mixed, string}> */
@@ -548,8 +548,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['csv_terminated' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->csv_terminated);
-        $this->assertSame($expected, $exportArray['csv_terminated']);
+        self::assertSame($expected, $export->csv_terminated);
+        self::assertSame($expected, $exportArray['csv_terminated']);
     }
 
     /** @return iterable<string, array{mixed, string}> */
@@ -566,8 +566,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['csv_removeCRLF' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->csv_removeCRLF);
-        $this->assertSame($expected, $exportArray['csv_removeCRLF']);
+        self::assertSame($expected, $export->csv_removeCRLF);
+        self::assertSame($expected, $exportArray['csv_removeCRLF']);
     }
 
     #[DataProvider('booleanWithDefaultTrueProvider')]
@@ -575,8 +575,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['excel_columns' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->excel_columns);
-        $this->assertSame($expected, $exportArray['excel_columns']);
+        self::assertSame($expected, $export->excel_columns);
+        self::assertSame($expected, $exportArray['excel_columns']);
     }
 
     #[DataProvider('valuesForExcelNullProvider')]
@@ -584,8 +584,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['excel_null' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->excel_null);
-        $this->assertSame($expected, $exportArray['excel_null']);
+        self::assertSame($expected, $export->excel_null);
+        self::assertSame($expected, $exportArray['excel_null']);
     }
 
     /** @return iterable<string, array{mixed, string}> */
@@ -602,8 +602,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['excel_edition' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->excel_edition);
-        $this->assertSame($expected, $exportArray['excel_edition']);
+        self::assertSame($expected, $export->excel_edition);
+        self::assertSame($expected, $exportArray['excel_edition']);
     }
 
     /** @return iterable<string, array{mixed, string}> */
@@ -621,8 +621,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['excel_removeCRLF' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->excel_removeCRLF);
-        $this->assertSame($expected, $exportArray['excel_removeCRLF']);
+        self::assertSame($expected, $export->excel_removeCRLF);
+        self::assertSame($expected, $exportArray['excel_removeCRLF']);
     }
 
     #[DataProvider('structureOrDataWithDefaultDataProvider')]
@@ -630,8 +630,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['excel_structure_or_data' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->excel_structure_or_data);
-        $this->assertSame($expected, $exportArray['excel_structure_or_data']);
+        self::assertSame($expected, $export->excel_structure_or_data);
+        self::assertSame($expected, $exportArray['excel_structure_or_data']);
     }
 
     #[DataProvider('structureOrDataWithDefaultStructureOrDataProvider')]
@@ -639,8 +639,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['latex_structure_or_data' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->latex_structure_or_data);
-        $this->assertSame($expected, $exportArray['latex_structure_or_data']);
+        self::assertSame($expected, $export->latex_structure_or_data);
+        self::assertSame($expected, $exportArray['latex_structure_or_data']);
     }
 
     #[DataProvider('booleanWithDefaultTrueProvider')]
@@ -648,8 +648,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['latex_columns' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->latex_columns);
-        $this->assertSame($expected, $exportArray['latex_columns']);
+        self::assertSame($expected, $export->latex_columns);
+        self::assertSame($expected, $exportArray['latex_columns']);
     }
 
     #[DataProvider('booleanWithDefaultTrueProvider')]
@@ -657,8 +657,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['latex_relation' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->latex_relation);
-        $this->assertSame($expected, $exportArray['latex_relation']);
+        self::assertSame($expected, $export->latex_relation);
+        self::assertSame($expected, $exportArray['latex_relation']);
     }
 
     #[DataProvider('booleanWithDefaultTrueProvider')]
@@ -666,8 +666,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['latex_comments' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->latex_comments);
-        $this->assertSame($expected, $exportArray['latex_comments']);
+        self::assertSame($expected, $export->latex_comments);
+        self::assertSame($expected, $exportArray['latex_comments']);
     }
 
     #[DataProvider('booleanWithDefaultTrueProvider')]
@@ -675,8 +675,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['latex_mime' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->latex_mime);
-        $this->assertSame($expected, $exportArray['latex_mime']);
+        self::assertSame($expected, $export->latex_mime);
+        self::assertSame($expected, $exportArray['latex_mime']);
     }
 
     #[DataProvider('valuesForLatexNullProvider')]
@@ -684,8 +684,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['latex_null' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->latex_null);
-        $this->assertSame($expected, $exportArray['latex_null']);
+        self::assertSame($expected, $export->latex_null);
+        self::assertSame($expected, $exportArray['latex_null']);
     }
 
     /** @return iterable<string, array{mixed, string}> */
@@ -702,8 +702,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['latex_caption' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->latex_caption);
-        $this->assertSame($expected, $exportArray['latex_caption']);
+        self::assertSame($expected, $export->latex_caption);
+        self::assertSame($expected, $exportArray['latex_caption']);
     }
 
     #[DataProvider('valuesForLatexStructureCaptionProvider')]
@@ -711,8 +711,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['latex_structure_caption' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->latex_structure_caption);
-        $this->assertSame($expected, $exportArray['latex_structure_caption']);
+        self::assertSame($expected, $export->latex_structure_caption);
+        self::assertSame($expected, $exportArray['latex_structure_caption']);
     }
 
     /** @return iterable<string, array{mixed, string}> */
@@ -729,8 +729,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['latex_structure_continued_caption' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->latex_structure_continued_caption);
-        $this->assertSame($expected, $exportArray['latex_structure_continued_caption']);
+        self::assertSame($expected, $export->latex_structure_continued_caption);
+        self::assertSame($expected, $exportArray['latex_structure_continued_caption']);
     }
 
     /** @return iterable<string, array{mixed, string}> */
@@ -747,8 +747,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['latex_data_caption' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->latex_data_caption);
-        $this->assertSame($expected, $exportArray['latex_data_caption']);
+        self::assertSame($expected, $export->latex_data_caption);
+        self::assertSame($expected, $exportArray['latex_data_caption']);
     }
 
     /** @return iterable<string, array{mixed, string}> */
@@ -765,8 +765,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['latex_data_continued_caption' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->latex_data_continued_caption);
-        $this->assertSame($expected, $exportArray['latex_data_continued_caption']);
+        self::assertSame($expected, $export->latex_data_continued_caption);
+        self::assertSame($expected, $exportArray['latex_data_continued_caption']);
     }
 
     /** @return iterable<string, array{mixed, string}> */
@@ -783,8 +783,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['latex_data_label' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->latex_data_label);
-        $this->assertSame($expected, $exportArray['latex_data_label']);
+        self::assertSame($expected, $export->latex_data_label);
+        self::assertSame($expected, $exportArray['latex_data_label']);
     }
 
     /** @return iterable<string, array{mixed, string}> */
@@ -801,8 +801,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['latex_structure_label' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->latex_structure_label);
-        $this->assertSame($expected, $exportArray['latex_structure_label']);
+        self::assertSame($expected, $export->latex_structure_label);
+        self::assertSame($expected, $exportArray['latex_structure_label']);
     }
 
     /** @return iterable<string, array{mixed, string}> */
@@ -819,8 +819,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['mediawiki_structure_or_data' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->mediawiki_structure_or_data);
-        $this->assertSame($expected, $exportArray['mediawiki_structure_or_data']);
+        self::assertSame($expected, $export->mediawiki_structure_or_data);
+        self::assertSame($expected, $exportArray['mediawiki_structure_or_data']);
     }
 
     #[DataProvider('booleanWithDefaultTrueProvider')]
@@ -828,8 +828,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['mediawiki_caption' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->mediawiki_caption);
-        $this->assertSame($expected, $exportArray['mediawiki_caption']);
+        self::assertSame($expected, $export->mediawiki_caption);
+        self::assertSame($expected, $exportArray['mediawiki_caption']);
     }
 
     #[DataProvider('booleanWithDefaultTrueProvider')]
@@ -837,8 +837,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['mediawiki_headers' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->mediawiki_headers);
-        $this->assertSame($expected, $exportArray['mediawiki_headers']);
+        self::assertSame($expected, $export->mediawiki_headers);
+        self::assertSame($expected, $exportArray['mediawiki_headers']);
     }
 
     #[DataProvider('structureOrDataWithDefaultDataProvider')]
@@ -846,8 +846,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['ods_structure_or_data' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->ods_structure_or_data);
-        $this->assertSame($expected, $exportArray['ods_structure_or_data']);
+        self::assertSame($expected, $export->ods_structure_or_data);
+        self::assertSame($expected, $exportArray['ods_structure_or_data']);
     }
 
     #[DataProvider('structureOrDataWithDefaultDataProvider')]
@@ -855,8 +855,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['pdf_structure_or_data' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->pdf_structure_or_data);
-        $this->assertSame($expected, $exportArray['pdf_structure_or_data']);
+        self::assertSame($expected, $export->pdf_structure_or_data);
+        self::assertSame($expected, $exportArray['pdf_structure_or_data']);
     }
 
     #[DataProvider('structureOrDataWithDefaultDataProvider')]
@@ -864,8 +864,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['phparray_structure_or_data' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->phparray_structure_or_data);
-        $this->assertSame($expected, $exportArray['phparray_structure_or_data']);
+        self::assertSame($expected, $export->phparray_structure_or_data);
+        self::assertSame($expected, $exportArray['phparray_structure_or_data']);
     }
 
     #[DataProvider('structureOrDataWithDefaultDataProvider')]
@@ -873,8 +873,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['json_structure_or_data' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->json_structure_or_data);
-        $this->assertSame($expected, $exportArray['json_structure_or_data']);
+        self::assertSame($expected, $export->json_structure_or_data);
+        self::assertSame($expected, $exportArray['json_structure_or_data']);
     }
 
     #[DataProvider('booleanWithDefaultFalseProvider')]
@@ -882,8 +882,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['json_pretty_print' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->json_pretty_print);
-        $this->assertSame($expected, $exportArray['json_pretty_print']);
+        self::assertSame($expected, $export->json_pretty_print);
+        self::assertSame($expected, $exportArray['json_pretty_print']);
     }
 
     #[DataProvider('booleanWithDefaultTrueProvider')]
@@ -891,8 +891,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['json_unicode' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->json_unicode);
-        $this->assertSame($expected, $exportArray['json_unicode']);
+        self::assertSame($expected, $export->json_unicode);
+        self::assertSame($expected, $exportArray['json_unicode']);
     }
 
     #[DataProvider('structureOrDataWithDefaultStructureOrDataProvider')]
@@ -900,8 +900,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['sql_structure_or_data' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->sql_structure_or_data);
-        $this->assertSame($expected, $exportArray['sql_structure_or_data']);
+        self::assertSame($expected, $export->sql_structure_or_data);
+        self::assertSame($expected, $exportArray['sql_structure_or_data']);
     }
 
     #[DataProvider('valuesForSqlCompatibilityProvider')]
@@ -909,8 +909,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['sql_compatibility' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->sql_compatibility);
-        $this->assertSame($expected, $exportArray['sql_compatibility']);
+        self::assertSame($expected, $export->sql_compatibility);
+        self::assertSame($expected, $exportArray['sql_compatibility']);
     }
 
     /** @return iterable<string, array{mixed, string}> */
@@ -935,8 +935,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['sql_include_comments' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->sql_include_comments);
-        $this->assertSame($expected, $exportArray['sql_include_comments']);
+        self::assertSame($expected, $export->sql_include_comments);
+        self::assertSame($expected, $exportArray['sql_include_comments']);
     }
 
     #[DataProvider('booleanWithDefaultFalseProvider')]
@@ -944,8 +944,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['sql_disable_fk' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->sql_disable_fk);
-        $this->assertSame($expected, $exportArray['sql_disable_fk']);
+        self::assertSame($expected, $export->sql_disable_fk);
+        self::assertSame($expected, $exportArray['sql_disable_fk']);
     }
 
     #[DataProvider('booleanWithDefaultFalseProvider')]
@@ -953,8 +953,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['sql_views_as_tables' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->sql_views_as_tables);
-        $this->assertSame($expected, $exportArray['sql_views_as_tables']);
+        self::assertSame($expected, $export->sql_views_as_tables);
+        self::assertSame($expected, $exportArray['sql_views_as_tables']);
     }
 
     #[DataProvider('booleanWithDefaultFalseProvider')]
@@ -962,8 +962,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['sql_metadata' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->sql_metadata);
-        $this->assertSame($expected, $exportArray['sql_metadata']);
+        self::assertSame($expected, $export->sql_metadata);
+        self::assertSame($expected, $exportArray['sql_metadata']);
     }
 
     #[DataProvider('booleanWithDefaultTrueProvider')]
@@ -971,8 +971,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['sql_use_transaction' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->sql_use_transaction);
-        $this->assertSame($expected, $exportArray['sql_use_transaction']);
+        self::assertSame($expected, $export->sql_use_transaction);
+        self::assertSame($expected, $exportArray['sql_use_transaction']);
     }
 
     #[DataProvider('booleanWithDefaultFalseProvider')]
@@ -980,8 +980,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['sql_create_database' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->sql_create_database);
-        $this->assertSame($expected, $exportArray['sql_create_database']);
+        self::assertSame($expected, $export->sql_create_database);
+        self::assertSame($expected, $exportArray['sql_create_database']);
     }
 
     #[DataProvider('booleanWithDefaultFalseProvider')]
@@ -989,8 +989,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['sql_drop_database' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->sql_drop_database);
-        $this->assertSame($expected, $exportArray['sql_drop_database']);
+        self::assertSame($expected, $export->sql_drop_database);
+        self::assertSame($expected, $exportArray['sql_drop_database']);
     }
 
     #[DataProvider('booleanWithDefaultFalseProvider')]
@@ -998,8 +998,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['sql_drop_table' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->sql_drop_table);
-        $this->assertSame($expected, $exportArray['sql_drop_table']);
+        self::assertSame($expected, $export->sql_drop_table);
+        self::assertSame($expected, $exportArray['sql_drop_table']);
     }
 
     #[DataProvider('booleanWithDefaultFalseProvider')]
@@ -1007,8 +1007,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['sql_if_not_exists' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->sql_if_not_exists);
-        $this->assertSame($expected, $exportArray['sql_if_not_exists']);
+        self::assertSame($expected, $export->sql_if_not_exists);
+        self::assertSame($expected, $exportArray['sql_if_not_exists']);
     }
 
     #[DataProvider('booleanWithDefaultFalseProvider')]
@@ -1016,8 +1016,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['sql_view_current_user' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->sql_view_current_user);
-        $this->assertSame($expected, $exportArray['sql_view_current_user']);
+        self::assertSame($expected, $export->sql_view_current_user);
+        self::assertSame($expected, $exportArray['sql_view_current_user']);
     }
 
     #[DataProvider('booleanWithDefaultFalseProvider')]
@@ -1025,8 +1025,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['sql_or_replace_view' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->sql_or_replace_view);
-        $this->assertSame($expected, $exportArray['sql_or_replace_view']);
+        self::assertSame($expected, $export->sql_or_replace_view);
+        self::assertSame($expected, $exportArray['sql_or_replace_view']);
     }
 
     #[DataProvider('booleanWithDefaultTrueProvider')]
@@ -1034,8 +1034,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['sql_procedure_function' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->sql_procedure_function);
-        $this->assertSame($expected, $exportArray['sql_procedure_function']);
+        self::assertSame($expected, $export->sql_procedure_function);
+        self::assertSame($expected, $exportArray['sql_procedure_function']);
     }
 
     #[DataProvider('booleanWithDefaultTrueProvider')]
@@ -1043,8 +1043,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['sql_create_table' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->sql_create_table);
-        $this->assertSame($expected, $exportArray['sql_create_table']);
+        self::assertSame($expected, $export->sql_create_table);
+        self::assertSame($expected, $exportArray['sql_create_table']);
     }
 
     #[DataProvider('booleanWithDefaultTrueProvider')]
@@ -1052,8 +1052,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['sql_create_view' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->sql_create_view);
-        $this->assertSame($expected, $exportArray['sql_create_view']);
+        self::assertSame($expected, $export->sql_create_view);
+        self::assertSame($expected, $exportArray['sql_create_view']);
     }
 
     #[DataProvider('booleanWithDefaultTrueProvider')]
@@ -1061,8 +1061,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['sql_create_trigger' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->sql_create_trigger);
-        $this->assertSame($expected, $exportArray['sql_create_trigger']);
+        self::assertSame($expected, $export->sql_create_trigger);
+        self::assertSame($expected, $exportArray['sql_create_trigger']);
     }
 
     #[DataProvider('booleanWithDefaultTrueProvider')]
@@ -1070,8 +1070,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['sql_auto_increment' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->sql_auto_increment);
-        $this->assertSame($expected, $exportArray['sql_auto_increment']);
+        self::assertSame($expected, $export->sql_auto_increment);
+        self::assertSame($expected, $exportArray['sql_auto_increment']);
     }
 
     #[DataProvider('booleanWithDefaultTrueProvider')]
@@ -1079,8 +1079,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['sql_backquotes' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->sql_backquotes);
-        $this->assertSame($expected, $exportArray['sql_backquotes']);
+        self::assertSame($expected, $export->sql_backquotes);
+        self::assertSame($expected, $exportArray['sql_backquotes']);
     }
 
     #[DataProvider('booleanWithDefaultFalseProvider')]
@@ -1088,8 +1088,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['sql_dates' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->sql_dates);
-        $this->assertSame($expected, $exportArray['sql_dates']);
+        self::assertSame($expected, $export->sql_dates);
+        self::assertSame($expected, $exportArray['sql_dates']);
     }
 
     #[DataProvider('booleanWithDefaultFalseProvider')]
@@ -1097,8 +1097,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['sql_relation' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->sql_relation);
-        $this->assertSame($expected, $exportArray['sql_relation']);
+        self::assertSame($expected, $export->sql_relation);
+        self::assertSame($expected, $exportArray['sql_relation']);
     }
 
     #[DataProvider('booleanWithDefaultFalseProvider')]
@@ -1106,8 +1106,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['sql_truncate' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->sql_truncate);
-        $this->assertSame($expected, $exportArray['sql_truncate']);
+        self::assertSame($expected, $export->sql_truncate);
+        self::assertSame($expected, $exportArray['sql_truncate']);
     }
 
     #[DataProvider('booleanWithDefaultFalseProvider')]
@@ -1115,8 +1115,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['sql_delayed' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->sql_delayed);
-        $this->assertSame($expected, $exportArray['sql_delayed']);
+        self::assertSame($expected, $export->sql_delayed);
+        self::assertSame($expected, $exportArray['sql_delayed']);
     }
 
     #[DataProvider('booleanWithDefaultFalseProvider')]
@@ -1124,8 +1124,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['sql_ignore' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->sql_ignore);
-        $this->assertSame($expected, $exportArray['sql_ignore']);
+        self::assertSame($expected, $export->sql_ignore);
+        self::assertSame($expected, $exportArray['sql_ignore']);
     }
 
     #[DataProvider('booleanWithDefaultTrueProvider')]
@@ -1133,8 +1133,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['sql_utc_time' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->sql_utc_time);
-        $this->assertSame($expected, $exportArray['sql_utc_time']);
+        self::assertSame($expected, $export->sql_utc_time);
+        self::assertSame($expected, $exportArray['sql_utc_time']);
     }
 
     #[DataProvider('booleanWithDefaultTrueProvider')]
@@ -1142,8 +1142,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['sql_hex_for_binary' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->sql_hex_for_binary);
-        $this->assertSame($expected, $exportArray['sql_hex_for_binary']);
+        self::assertSame($expected, $export->sql_hex_for_binary);
+        self::assertSame($expected, $exportArray['sql_hex_for_binary']);
     }
 
     #[DataProvider('valuesForSqlTypeProvider')]
@@ -1151,8 +1151,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['sql_type' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->sql_type);
-        $this->assertSame($expected, $exportArray['sql_type']);
+        self::assertSame($expected, $export->sql_type);
+        self::assertSame($expected, $exportArray['sql_type']);
     }
 
     /** @return iterable<string, array{mixed, string}> */
@@ -1170,8 +1170,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['sql_max_query_size' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->sql_max_query_size);
-        $this->assertSame($expected, $exportArray['sql_max_query_size']);
+        self::assertSame($expected, $export->sql_max_query_size);
+        self::assertSame($expected, $exportArray['sql_max_query_size']);
     }
 
     /** @return iterable<string, array{mixed, int}> */
@@ -1188,8 +1188,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['sql_mime' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->sql_mime);
-        $this->assertSame($expected, $exportArray['sql_mime']);
+        self::assertSame($expected, $export->sql_mime);
+        self::assertSame($expected, $exportArray['sql_mime']);
     }
 
     #[DataProvider('valuesForSqlHeaderCommentProvider')]
@@ -1197,8 +1197,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['sql_header_comment' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->sql_header_comment);
-        $this->assertSame($expected, $exportArray['sql_header_comment']);
+        self::assertSame($expected, $export->sql_header_comment);
+        self::assertSame($expected, $exportArray['sql_header_comment']);
     }
 
     /** @return iterable<string, array{mixed, string}> */
@@ -1215,8 +1215,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['sql_insert_syntax' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->sql_insert_syntax);
-        $this->assertSame($expected, $exportArray['sql_insert_syntax']);
+        self::assertSame($expected, $export->sql_insert_syntax);
+        self::assertSame($expected, $exportArray['sql_insert_syntax']);
     }
 
     /** @return iterable<string, array{mixed, string}> */
@@ -1236,8 +1236,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['pdf_report_title' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->pdf_report_title);
-        $this->assertSame($expected, $exportArray['pdf_report_title']);
+        self::assertSame($expected, $export->pdf_report_title);
+        self::assertSame($expected, $exportArray['pdf_report_title']);
     }
 
     /** @return iterable<string, array{mixed, string}> */
@@ -1254,8 +1254,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['xml_structure_or_data' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->xml_structure_or_data);
-        $this->assertSame($expected, $exportArray['xml_structure_or_data']);
+        self::assertSame($expected, $export->xml_structure_or_data);
+        self::assertSame($expected, $exportArray['xml_structure_or_data']);
     }
 
     #[DataProvider('booleanWithDefaultTrueProvider')]
@@ -1263,8 +1263,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['xml_export_struc' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->xml_export_struc);
-        $this->assertSame($expected, $exportArray['xml_export_struc']);
+        self::assertSame($expected, $export->xml_export_struc);
+        self::assertSame($expected, $exportArray['xml_export_struc']);
     }
 
     #[DataProvider('booleanWithDefaultTrueProvider')]
@@ -1272,8 +1272,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['xml_export_events' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->xml_export_events);
-        $this->assertSame($expected, $exportArray['xml_export_events']);
+        self::assertSame($expected, $export->xml_export_events);
+        self::assertSame($expected, $exportArray['xml_export_events']);
     }
 
     #[DataProvider('booleanWithDefaultTrueProvider')]
@@ -1281,8 +1281,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['xml_export_functions' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->xml_export_functions);
-        $this->assertSame($expected, $exportArray['xml_export_functions']);
+        self::assertSame($expected, $export->xml_export_functions);
+        self::assertSame($expected, $exportArray['xml_export_functions']);
     }
 
     #[DataProvider('booleanWithDefaultTrueProvider')]
@@ -1290,8 +1290,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['xml_export_procedures' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->xml_export_procedures);
-        $this->assertSame($expected, $exportArray['xml_export_procedures']);
+        self::assertSame($expected, $export->xml_export_procedures);
+        self::assertSame($expected, $exportArray['xml_export_procedures']);
     }
 
     #[DataProvider('booleanWithDefaultTrueProvider')]
@@ -1299,8 +1299,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['xml_export_tables' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->xml_export_tables);
-        $this->assertSame($expected, $exportArray['xml_export_tables']);
+        self::assertSame($expected, $export->xml_export_tables);
+        self::assertSame($expected, $exportArray['xml_export_tables']);
     }
 
     #[DataProvider('booleanWithDefaultTrueProvider')]
@@ -1308,8 +1308,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['xml_export_triggers' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->xml_export_triggers);
-        $this->assertSame($expected, $exportArray['xml_export_triggers']);
+        self::assertSame($expected, $export->xml_export_triggers);
+        self::assertSame($expected, $exportArray['xml_export_triggers']);
     }
 
     #[DataProvider('booleanWithDefaultTrueProvider')]
@@ -1317,8 +1317,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['xml_export_views' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->xml_export_views);
-        $this->assertSame($expected, $exportArray['xml_export_views']);
+        self::assertSame($expected, $export->xml_export_views);
+        self::assertSame($expected, $exportArray['xml_export_views']);
     }
 
     #[DataProvider('booleanWithDefaultTrueProvider')]
@@ -1326,8 +1326,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['xml_export_contents' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->xml_export_contents);
-        $this->assertSame($expected, $exportArray['xml_export_contents']);
+        self::assertSame($expected, $export->xml_export_contents);
+        self::assertSame($expected, $exportArray['xml_export_contents']);
     }
 
     #[DataProvider('structureOrDataWithDefaultDataProvider')]
@@ -1335,8 +1335,8 @@ class ExportTest extends TestCase
     {
         $export = new Export(['yaml_structure_or_data' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->yaml_structure_or_data);
-        $this->assertSame($expected, $exportArray['yaml_structure_or_data']);
+        self::assertSame($expected, $export->yaml_structure_or_data);
+        self::assertSame($expected, $exportArray['yaml_structure_or_data']);
     }
 
     #[DataProvider('booleanWithDefaultFalseProvider')]
@@ -1344,7 +1344,7 @@ class ExportTest extends TestCase
     {
         $export = new Export(['remove_definer_from_definitions' => $actual]);
         $exportArray = $export->asArray();
-        $this->assertSame($expected, $export->remove_definer_from_definitions);
-        $this->assertSame($expected, $exportArray['remove_definer_from_definitions']);
+        self::assertSame($expected, $export->remove_definer_from_definitions);
+        self::assertSame($expected, $exportArray['remove_definer_from_definitions']);
     }
 }
diff --git a/tests/classes/Config/Settings/ImportTest.php b/tests/classes/Config/Settings/ImportTest.php
index 3eb12bb396..c72e56a193 100644
--- a/tests/classes/Config/Settings/ImportTest.php
+++ b/tests/classes/Config/Settings/ImportTest.php
@@ -18,8 +18,8 @@ class ImportTest extends TestCase
     {
         $import = new Import(['format' => $actual]);
         $importArray = $import->asArray();
-        $this->assertSame($expected, $import->format);
-        $this->assertSame($expected, $importArray['format']);
+        self::assertSame($expected, $import->format);
+        self::assertSame($expected, $importArray['format']);
     }
 
     /** @return iterable<string, array{mixed, string}> */
@@ -38,8 +38,8 @@ class ImportTest extends TestCase
     {
         $import = new Import(['charset' => $actual]);
         $importArray = $import->asArray();
-        $this->assertSame($expected, $import->charset);
-        $this->assertSame($expected, $importArray['charset']);
+        self::assertSame($expected, $import->charset);
+        self::assertSame($expected, $importArray['charset']);
     }
 
     /** @return iterable<string, array{mixed, string}> */
@@ -56,8 +56,8 @@ class ImportTest extends TestCase
     {
         $import = new Import(['allow_interrupt' => $actual]);
         $importArray = $import->asArray();
-        $this->assertSame($expected, $import->allow_interrupt);
-        $this->assertSame($expected, $importArray['allow_interrupt']);
+        self::assertSame($expected, $import->allow_interrupt);
+        self::assertSame($expected, $importArray['allow_interrupt']);
     }
 
     /** @return iterable<string, array{mixed, bool}> */
@@ -74,8 +74,8 @@ class ImportTest extends TestCase
     {
         $import = new Import(['skip_queries' => $actual]);
         $importArray = $import->asArray();
-        $this->assertSame($expected, $import->skip_queries);
-        $this->assertSame($expected, $importArray['skip_queries']);
+        self::assertSame($expected, $import->skip_queries);
+        self::assertSame($expected, $importArray['skip_queries']);
     }
 
     /** @return iterable<string, array{mixed, int}> */
@@ -93,8 +93,8 @@ class ImportTest extends TestCase
     {
         $import = new Import(['sql_compatibility' => $actual]);
         $importArray = $import->asArray();
-        $this->assertSame($expected, $import->sql_compatibility);
-        $this->assertSame($expected, $importArray['sql_compatibility']);
+        self::assertSame($expected, $import->sql_compatibility);
+        self::assertSame($expected, $importArray['sql_compatibility']);
     }
 
     /** @return iterable<string, array{mixed, string}> */
@@ -119,8 +119,8 @@ class ImportTest extends TestCase
     {
         $import = new Import(['sql_no_auto_value_on_zero' => $actual]);
         $importArray = $import->asArray();
-        $this->assertSame($expected, $import->sql_no_auto_value_on_zero);
-        $this->assertSame($expected, $importArray['sql_no_auto_value_on_zero']);
+        self::assertSame($expected, $import->sql_no_auto_value_on_zero);
+        self::assertSame($expected, $importArray['sql_no_auto_value_on_zero']);
     }
 
     #[DataProvider('booleanWithDefaultFalseProvider')]
@@ -128,8 +128,8 @@ class ImportTest extends TestCase
     {
         $import = new Import(['sql_read_as_multibytes' => $actual]);
         $importArray = $import->asArray();
-        $this->assertSame($expected, $import->sql_read_as_multibytes);
-        $this->assertSame($expected, $importArray['sql_read_as_multibytes']);
+        self::assertSame($expected, $import->sql_read_as_multibytes);
+        self::assertSame($expected, $importArray['sql_read_as_multibytes']);
     }
 
     /** @return iterable<string, array{mixed, bool}> */
@@ -146,8 +146,8 @@ class ImportTest extends TestCase
     {
         $import = new Import(['csv_replace' => $actual]);
         $importArray = $import->asArray();
-        $this->assertSame($expected, $import->csv_replace);
-        $this->assertSame($expected, $importArray['csv_replace']);
+        self::assertSame($expected, $import->csv_replace);
+        self::assertSame($expected, $importArray['csv_replace']);
     }
 
     #[DataProvider('booleanWithDefaultFalseProvider')]
@@ -155,8 +155,8 @@ class ImportTest extends TestCase
     {
         $import = new Import(['csv_ignore' => $actual]);
         $importArray = $import->asArray();
-        $this->assertSame($expected, $import->csv_ignore);
-        $this->assertSame($expected, $importArray['csv_ignore']);
+        self::assertSame($expected, $import->csv_ignore);
+        self::assertSame($expected, $importArray['csv_ignore']);
     }
 
     #[DataProvider('valuesForCsvTerminatedProvider')]
@@ -164,8 +164,8 @@ class ImportTest extends TestCase
     {
         $import = new Import(['csv_terminated' => $actual]);
         $importArray = $import->asArray();
-        $this->assertSame($expected, $import->csv_terminated);
-        $this->assertSame($expected, $importArray['csv_terminated']);
+        self::assertSame($expected, $import->csv_terminated);
+        self::assertSame($expected, $importArray['csv_terminated']);
     }
 
     /** @return iterable<string, array{mixed, string}> */
@@ -182,8 +182,8 @@ class ImportTest extends TestCase
     {
         $import = new Import(['csv_enclosed' => $actual]);
         $importArray = $import->asArray();
-        $this->assertSame($expected, $import->csv_enclosed);
-        $this->assertSame($expected, $importArray['csv_enclosed']);
+        self::assertSame($expected, $import->csv_enclosed);
+        self::assertSame($expected, $importArray['csv_enclosed']);
     }
 
     /** @return iterable<string, array{mixed, string}> */
@@ -200,8 +200,8 @@ class ImportTest extends TestCase
     {
         $import = new Import(['csv_escaped' => $actual]);
         $importArray = $import->asArray();
-        $this->assertSame($expected, $import->csv_escaped);
-        $this->assertSame($expected, $importArray['csv_escaped']);
+        self::assertSame($expected, $import->csv_escaped);
+        self::assertSame($expected, $importArray['csv_escaped']);
     }
 
     /** @return iterable<string, array{mixed, string}> */
@@ -218,8 +218,8 @@ class ImportTest extends TestCase
     {
         $import = new Import(['csv_new_line' => $actual]);
         $importArray = $import->asArray();
-        $this->assertSame($expected, $import->csv_new_line);
-        $this->assertSame($expected, $importArray['csv_new_line']);
+        self::assertSame($expected, $import->csv_new_line);
+        self::assertSame($expected, $importArray['csv_new_line']);
     }
 
     /** @return iterable<string, array{mixed, string}> */
@@ -236,8 +236,8 @@ class ImportTest extends TestCase
     {
         $import = new Import(['csv_columns' => $actual]);
         $importArray = $import->asArray();
-        $this->assertSame($expected, $import->csv_columns);
-        $this->assertSame($expected, $importArray['csv_columns']);
+        self::assertSame($expected, $import->csv_columns);
+        self::assertSame($expected, $importArray['csv_columns']);
     }
 
     /** @return iterable<string, array{mixed, string}> */
@@ -254,8 +254,8 @@ class ImportTest extends TestCase
     {
         $import = new Import(['csv_col_names' => $actual]);
         $importArray = $import->asArray();
-        $this->assertSame($expected, $import->csv_col_names);
-        $this->assertSame($expected, $importArray['csv_col_names']);
+        self::assertSame($expected, $import->csv_col_names);
+        self::assertSame($expected, $importArray['csv_col_names']);
     }
 
     #[DataProvider('booleanWithDefaultFalseProvider')]
@@ -263,8 +263,8 @@ class ImportTest extends TestCase
     {
         $import = new Import(['ldi_replace' => $actual]);
         $importArray = $import->asArray();
-        $this->assertSame($expected, $import->ldi_replace);
-        $this->assertSame($expected, $importArray['ldi_replace']);
+        self::assertSame($expected, $import->ldi_replace);
+        self::assertSame($expected, $importArray['ldi_replace']);
     }
 
     #[DataProvider('booleanWithDefaultFalseProvider')]
@@ -272,8 +272,8 @@ class ImportTest extends TestCase
     {
         $import = new Import(['ldi_ignore' => $actual]);
         $importArray = $import->asArray();
-        $this->assertSame($expected, $import->ldi_ignore);
-        $this->assertSame($expected, $importArray['ldi_ignore']);
+        self::assertSame($expected, $import->ldi_ignore);
+        self::assertSame($expected, $importArray['ldi_ignore']);
     }
 
     #[DataProvider('valuesForLdiTerminatedProvider')]
@@ -281,8 +281,8 @@ class ImportTest extends TestCase
     {
         $import = new Import(['ldi_terminated' => $actual]);
         $importArray = $import->asArray();
-        $this->assertSame($expected, $import->ldi_terminated);
-        $this->assertSame($expected, $importArray['ldi_terminated']);
+        self::assertSame($expected, $import->ldi_terminated);
+        self::assertSame($expected, $importArray['ldi_terminated']);
     }
 
     /** @return iterable<string, array{mixed, string}> */
@@ -299,8 +299,8 @@ class ImportTest extends TestCase
     {
         $import = new Import(['ldi_enclosed' => $actual]);
         $importArray = $import->asArray();
-        $this->assertSame($expected, $import->ldi_enclosed);
-        $this->assertSame($expected, $importArray['ldi_enclosed']);
+        self::assertSame($expected, $import->ldi_enclosed);
+        self::assertSame($expected, $importArray['ldi_enclosed']);
     }
 
     /** @return iterable<string, array{mixed, string}> */
@@ -317,8 +317,8 @@ class ImportTest extends TestCase
     {
         $import = new Import(['ldi_escaped' => $actual]);
         $importArray = $import->asArray();
-        $this->assertSame($expected, $import->ldi_escaped);
-        $this->assertSame($expected, $importArray['ldi_escaped']);
+        self::assertSame($expected, $import->ldi_escaped);
+        self::assertSame($expected, $importArray['ldi_escaped']);
     }
 
     /** @return iterable<string, array{mixed, string}> */
@@ -335,8 +335,8 @@ class ImportTest extends TestCase
     {
         $import = new Import(['ldi_new_line' => $actual]);
         $importArray = $import->asArray();
-        $this->assertSame($expected, $import->ldi_new_line);
-        $this->assertSame($expected, $importArray['ldi_new_line']);
+        self::assertSame($expected, $import->ldi_new_line);
+        self::assertSame($expected, $importArray['ldi_new_line']);
     }
 
     /** @return iterable<string, array{mixed, string}> */
@@ -353,8 +353,8 @@ class ImportTest extends TestCase
     {
         $import = new Import(['ldi_columns' => $actual]);
         $importArray = $import->asArray();
-        $this->assertSame($expected, $import->ldi_columns);
-        $this->assertSame($expected, $importArray['ldi_columns']);
+        self::assertSame($expected, $import->ldi_columns);
+        self::assertSame($expected, $importArray['ldi_columns']);
     }
 
     /** @return iterable<string, array{mixed, string}> */
@@ -371,8 +371,8 @@ class ImportTest extends TestCase
     {
         $import = new Import(['ldi_local_option' => $actual]);
         $importArray = $import->asArray();
-        $this->assertSame($expected, $import->ldi_local_option);
-        $this->assertSame($expected, $importArray['ldi_local_option']);
+        self::assertSame($expected, $import->ldi_local_option);
+        self::assertSame($expected, $importArray['ldi_local_option']);
     }
 
     /** @return iterable<string, array{mixed, string|bool}> */
@@ -390,8 +390,8 @@ class ImportTest extends TestCase
     {
         $import = new Import(['ods_col_names' => $actual]);
         $importArray = $import->asArray();
-        $this->assertSame($expected, $import->ods_col_names);
-        $this->assertSame($expected, $importArray['ods_col_names']);
+        self::assertSame($expected, $import->ods_col_names);
+        self::assertSame($expected, $importArray['ods_col_names']);
     }
 
     #[DataProvider('booleanWithDefaultTrueProvider')]
@@ -399,8 +399,8 @@ class ImportTest extends TestCase
     {
         $import = new Import(['ods_empty_rows' => $actual]);
         $importArray = $import->asArray();
-        $this->assertSame($expected, $import->ods_empty_rows);
-        $this->assertSame($expected, $importArray['ods_empty_rows']);
+        self::assertSame($expected, $import->ods_empty_rows);
+        self::assertSame($expected, $importArray['ods_empty_rows']);
     }
 
     #[DataProvider('booleanWithDefaultTrueProvider')]
@@ -408,8 +408,8 @@ class ImportTest extends TestCase
     {
         $import = new Import(['ods_recognize_percentages' => $actual]);
         $importArray = $import->asArray();
-        $this->assertSame($expected, $import->ods_recognize_percentages);
-        $this->assertSame($expected, $importArray['ods_recognize_percentages']);
+        self::assertSame($expected, $import->ods_recognize_percentages);
+        self::assertSame($expected, $importArray['ods_recognize_percentages']);
     }
 
     #[DataProvider('booleanWithDefaultTrueProvider')]
@@ -417,7 +417,7 @@ class ImportTest extends TestCase
     {
         $import = new Import(['ods_recognize_currency' => $actual]);
         $importArray = $import->asArray();
-        $this->assertSame($expected, $import->ods_recognize_currency);
-        $this->assertSame($expected, $importArray['ods_recognize_currency']);
+        self::assertSame($expected, $import->ods_recognize_currency);
+        self::assertSame($expected, $importArray['ods_recognize_currency']);
     }
 }
diff --git a/tests/classes/Config/Settings/SchemaTest.php b/tests/classes/Config/Settings/SchemaTest.php
index b093736631..2d9ec741f2 100644
--- a/tests/classes/Config/Settings/SchemaTest.php
+++ b/tests/classes/Config/Settings/SchemaTest.php
@@ -59,9 +59,9 @@ class SchemaTest extends TestCase
         $schemaArray = $settings->asArray();
 
         foreach (array_keys($expectedValues) as $key) {
-            $this->assertSame($expected[$key], $settings->$key);
-            $this->assertArrayHasKey($key, $schemaArray);
-            $this->assertSame($expected[$key], $schemaArray[$key]);
+            self::assertSame($expected[$key], $settings->$key);
+            self::assertArrayHasKey($key, $schemaArray);
+            self::assertSame($expected[$key], $schemaArray[$key]);
         }
     }
 
diff --git a/tests/classes/Config/Settings/ServerTest.php b/tests/classes/Config/Settings/ServerTest.php
index 08ff98f796..738407cc09 100644
--- a/tests/classes/Config/Settings/ServerTest.php
+++ b/tests/classes/Config/Settings/ServerTest.php
@@ -17,8 +17,8 @@ class ServerTest extends TestCase
     {
         $server = new Server(['host' => $actual]);
         $serverArray = $server->asArray();
-        $this->assertSame($expected, $server->host);
-        $this->assertSame($expected, $serverArray['host']);
+        self::assertSame($expected, $server->host);
+        self::assertSame($expected, $serverArray['host']);
     }
 
     /** @return iterable<string, array{mixed, string}> */
@@ -35,8 +35,8 @@ class ServerTest extends TestCase
     {
         $server = new Server(['port' => $actual]);
         $serverArray = $server->asArray();
-        $this->assertSame($expected, $server->port);
-        $this->assertSame($expected, $serverArray['port']);
+        self::assertSame($expected, $server->port);
+        self::assertSame($expected, $serverArray['port']);
     }
 
     /** @return iterable<string, array{mixed, string}> */
@@ -53,8 +53,8 @@ class ServerTest extends TestCase
     {
         $server = new Server(['socket' => $actual]);
         $serverArray = $server->asArray();
-        $this->assertSame($expected, $server->socket);
-        $this->assertSame($expected, $serverArray['socket']);
+        self::assertSame($expected, $server->socket);
+        self::assertSame($expected, $serverArray['socket']);
     }
 
     /** @return iterable<string, array{mixed, string}> */
@@ -71,8 +71,8 @@ class ServerTest extends TestCase
     {
         $server = new Server(['ssl' => $actual]);
         $serverArray = $server->asArray();
-        $this->assertSame($expected, $server->ssl);
-        $this->assertSame($expected, $serverArray['ssl']);
+        self::assertSame($expected, $server->ssl);
+        self::assertSame($expected, $serverArray['ssl']);
     }
 
     /** @return iterable<string, array{mixed, bool}> */
@@ -89,8 +89,8 @@ class ServerTest extends TestCase
     {
         $server = new Server(['ssl_key' => $actual]);
         $serverArray = $server->asArray();
-        $this->assertSame($expected, $server->sslKey);
-        $this->assertSame($expected, $serverArray['ssl_key']);
+        self::assertSame($expected, $server->sslKey);
+        self::assertSame($expected, $serverArray['ssl_key']);
     }
 
     /** @return iterable<string, array{mixed, string|null}> */
@@ -107,8 +107,8 @@ class ServerTest extends TestCase
     {
         $server = new Server(['ssl_cert' => $actual]);
         $serverArray = $server->asArray();
-        $this->assertSame($expected, $server->sslCert);
-        $this->assertSame($expected, $serverArray['ssl_cert']);
+        self::assertSame($expected, $server->sslCert);
+        self::assertSame($expected, $serverArray['ssl_cert']);
     }
 
     #[DataProvider('valuesForSslOptionsProvider')]
@@ -116,8 +116,8 @@ class ServerTest extends TestCase
     {
         $server = new Server(['ssl_ca' => $actual]);
         $serverArray = $server->asArray();
-        $this->assertSame($expected, $server->sslCa);
-        $this->assertSame($expected, $serverArray['ssl_ca']);
+        self::assertSame($expected, $server->sslCa);
+        self::assertSame($expected, $serverArray['ssl_ca']);
     }
 
     #[DataProvider('valuesForSslOptionsProvider')]
@@ -125,8 +125,8 @@ class ServerTest extends TestCase
     {
         $server = new Server(['ssl_ca_path' => $actual]);
         $serverArray = $server->asArray();
-        $this->assertSame($expected, $server->sslCaPath);
-        $this->assertSame($expected, $serverArray['ssl_ca_path']);
+        self::assertSame($expected, $server->sslCaPath);
+        self::assertSame($expected, $serverArray['ssl_ca_path']);
     }
 
     #[DataProvider('valuesForSslOptionsProvider')]
@@ -134,8 +134,8 @@ class ServerTest extends TestCase
     {
         $server = new Server(['ssl_ciphers' => $actual]);
         $serverArray = $server->asArray();
-        $this->assertSame($expected, $server->sslCiphers);
-        $this->assertSame($expected, $serverArray['ssl_ciphers']);
+        self::assertSame($expected, $server->sslCiphers);
+        self::assertSame($expected, $serverArray['ssl_ciphers']);
     }
 
     #[DataProvider('booleanWithDefaultTrueProvider')]
@@ -143,8 +143,8 @@ class ServerTest extends TestCase
     {
         $server = new Server(['ssl_verify' => $actual]);
         $serverArray = $server->asArray();
-        $this->assertSame($expected, $server->sslVerify);
-        $this->assertSame($expected, $serverArray['ssl_verify']);
+        self::assertSame($expected, $server->sslVerify);
+        self::assertSame($expected, $serverArray['ssl_verify']);
     }
 
     /** @return iterable<string, array{mixed, bool}> */
@@ -161,8 +161,8 @@ class ServerTest extends TestCase
     {
         $server = new Server(['compress' => $actual]);
         $serverArray = $server->asArray();
-        $this->assertSame($expected, $server->compress);
-        $this->assertSame($expected, $serverArray['compress']);
+        self::assertSame($expected, $server->compress);
+        self::assertSame($expected, $serverArray['compress']);
     }
 
     #[DataProvider('valuesForControlHostProvider')]
@@ -170,8 +170,8 @@ class ServerTest extends TestCase
     {
         $server = new Server(['controlhost' => $actual]);
         $serverArray = $server->asArray();
-        $this->assertSame($expected, $server->controlHost);
-        $this->assertSame($expected, $serverArray['controlhost']);
+        self::assertSame($expected, $server->controlHost);
+        self::assertSame($expected, $serverArray['controlhost']);
     }
 
     #[DataProvider('valuesForControlHostProvider')]
@@ -179,8 +179,8 @@ class ServerTest extends TestCase
     {
         $server = new Server(['control_host' => $actual]);
         $serverArray = $server->asArray();
-        $this->assertSame($expected, $server->controlHost);
-        $this->assertSame($expected, $serverArray['controlhost']);
+        self::assertSame($expected, $server->controlHost);
+        self::assertSame($expected, $serverArray['controlhost']);
     }
 
     /** @return iterable<string, array{mixed, string}> */
@@ -197,8 +197,8 @@ class ServerTest extends TestCase
     {
         $server = new Server(['controlport' => $actual]);
         $serverArray = $server->asArray();
-        $this->assertSame($expected, $server->controlPort);
-        $this->assertSame($expected, $serverArray['controlport']);
+        self::assertSame($expected, $server->controlPort);
+        self::assertSame($expected, $serverArray['controlport']);
     }
 
     #[DataProvider('valuesForControlPortProvider')]
@@ -206,8 +206,8 @@ class ServerTest extends TestCase
     {
         $server = new Server(['control_port' => $actual]);
         $serverArray = $server->asArray();
-        $this->assertSame($expected, $server->controlPort);
-        $this->assertSame($expected, $serverArray['controlport']);
+        self::assertSame($expected, $server->controlPort);
+        self::assertSame($expected, $serverArray['controlport']);
     }
 
     /** @return iterable<string, array{mixed, string}> */
@@ -224,8 +224,8 @@ class ServerTest extends TestCase
     {
         $server = new Server(['controluser' => $actual]);
         $serverArray = $server->asArray();
-        $this->assertSame($expected, $server->controlUser);
-        $this->assertSame($expected, $serverArray['controluser']);
+        self::assertSame($expected, $server->controlUser);
+        self::assertSame($expected, $serverArray['controluser']);
     }
 
     #[DataProvider('valuesForControlUserProvider')]
@@ -233,8 +233,8 @@ class ServerTest extends TestCase
     {
         $server = new Server(['control_user' => $actual]);
         $serverArray = $server->asArray();
-        $this->assertSame($expected, $server->controlUser);
-        $this->assertSame($expected, $serverArray['controluser']);
+        self::assertSame($expected, $server->controlUser);
+        self::assertSame($expected, $serverArray['controluser']);
     }
 
     /** @return iterable<string, array{mixed, string}> */
@@ -251,8 +251,8 @@ class ServerTest extends TestCase
     {
         $server = new Server(['controlpass' => $actual]);
         $serverArray = $server->asArray();
-        $this->assertSame($expected, $server->controlPass);
-        $this->assertSame($expected, $serverArray['controlpass']);
+        self::assertSame($expected, $server->controlPass);
+        self::assertSame($expected, $serverArray['controlpass']);
     }
 
     #[DataProvider('valuesForControlPassProvider')]
@@ -260,8 +260,8 @@ class ServerTest extends TestCase
     {
         $server = new Server(['control_pass' => $actual]);
         $serverArray = $server->asArray();
-        $this->assertSame($expected, $server->controlPass);
-        $this->assertSame($expected, $serverArray['controlpass']);
+        self::assertSame($expected, $server->controlPass);
+        self::assertSame($expected, $serverArray['controlpass']);
     }
 
     #[DataProvider('valuesForControlPassProvider')]
@@ -269,8 +269,8 @@ class ServerTest extends TestCase
     {
         $server = new Server(['control_password' => $actual]);
         $serverArray = $server->asArray();
-        $this->assertSame($expected, $server->controlPass);
-        $this->assertSame($expected, $serverArray['controlpass']);
+        self::assertSame($expected, $server->controlPass);
+        self::assertSame($expected, $serverArray['controlpass']);
     }
 
     /** @return iterable<string, array{mixed, string}> */
@@ -287,8 +287,8 @@ class ServerTest extends TestCase
     {
         $server = new Server(['control_socket' => $actual]);
         $serverArray = $server->asArray();
-        $this->assertSame($expected, $server->controlSocket);
-        $this->assertSame($expected, $serverArray['control_socket']);
+        self::assertSame($expected, $server->controlSocket);
+        self::assertSame($expected, $serverArray['control_socket']);
     }
 
     /** @return iterable<string, array{mixed, string|null}> */
@@ -305,8 +305,8 @@ class ServerTest extends TestCase
     {
         $server = new Server(['control_ssl' => $actual]);
         $serverArray = $server->asArray();
-        $this->assertSame($expected, $server->controlSsl);
-        $this->assertSame($expected, $serverArray['control_ssl']);
+        self::assertSame($expected, $server->controlSsl);
+        self::assertSame($expected, $serverArray['control_ssl']);
     }
 
     /** @return iterable<string, array{mixed, bool|null}> */
@@ -323,8 +323,8 @@ class ServerTest extends TestCase
     {
         $server = new Server(['control_ssl_key' => $actual]);
         $serverArray = $server->asArray();
-        $this->assertSame($expected, $server->controlSslKey);
-        $this->assertSame($expected, $serverArray['control_ssl_key']);
+        self::assertSame($expected, $server->controlSslKey);
+        self::assertSame($expected, $serverArray['control_ssl_key']);
     }
 
     #[DataProvider('valuesForSslOptionsProvider')]
@@ -332,8 +332,8 @@ class ServerTest extends TestCase
     {
         $server = new Server(['control_ssl_cert' => $actual]);
         $serverArray = $server->asArray();
-        $this->assertSame($expected, $server->controlSslCert);
-        $this->assertSame($expected, $serverArray['control_ssl_cert']);
+        self::assertSame($expected, $server->controlSslCert);
+        self::assertSame($expected, $serverArray['control_ssl_cert']);
     }
 
     #[DataProvider('valuesForSslOptionsProvider')]
@@ -341,8 +341,8 @@ class ServerTest extends TestCase
     {
         $server = new Server(['control_ssl_ca' => $actual]);
         $serverArray = $server->asArray();
-        $this->assertSame($expected, $server->controlSslCa);
-        $this->assertSame($expected, $serverArray['control_ssl_ca']);
+        self::assertSame($expected, $server->controlSslCa);
+        self::assertSame($expected, $serverArray['control_ssl_ca']);
     }
 
     #[DataProvider('valuesForSslOptionsProvider')]
@@ -350,8 +350,8 @@ class ServerTest extends TestCase
     {
         $server = new Server(['control_ssl_ca_path' => $actual]);
         $serverArray = $server->asArray();
-        $this->assertSame($expected, $server->controlSslCaPath);
-        $this->assertSame($expected, $serverArray['control_ssl_ca_path']);
+        self::assertSame($expected, $server->controlSslCaPath);
+        self::assertSame($expected, $serverArray['control_ssl_ca_path']);
     }
 
     #[DataProvider('valuesForSslOptionsProvider')]
@@ -359,8 +359,8 @@ class ServerTest extends TestCase
     {
         $server = new Server(['control_ssl_ciphers' => $actual]);
         $serverArray = $server->asArray();
-        $this->assertSame($expected, $server->controlSslCiphers);
-        $this->assertSame($expected, $serverArray['control_ssl_ciphers']);
+        self::assertSame($expected, $server->controlSslCiphers);
+        self::assertSame($expected, $serverArray['control_ssl_ciphers']);
     }
 
     #[DataProvider('valuesForControlSslVerifyProvider')]
@@ -368,8 +368,8 @@ class ServerTest extends TestCase
     {
         $server = new Server(['control_ssl_verify' => $actual]);
         $serverArray = $server->asArray();
-        $this->assertSame($expected, $server->controlSslVerify);
-        $this->assertSame($expected, $serverArray['control_ssl_verify']);
+        self::assertSame($expected, $server->controlSslVerify);
+        self::assertSame($expected, $serverArray['control_ssl_verify']);
     }
 
     /** @return iterable<string, array{mixed, bool|null}> */
@@ -386,8 +386,8 @@ class ServerTest extends TestCase
     {
         $server = new Server(['control_compress' => $actual]);
         $serverArray = $server->asArray();
-        $this->assertSame($expected, $server->controlCompress);
-        $this->assertSame($expected, $serverArray['control_compress']);
+        self::assertSame($expected, $server->controlCompress);
+        self::assertSame($expected, $serverArray['control_compress']);
     }
 
     /** @return iterable<string, array{mixed, bool|null}> */
@@ -404,8 +404,8 @@ class ServerTest extends TestCase
     {
         $server = new Server(['control_hide_connection_errors' => $actual]);
         $serverArray = $server->asArray();
-        $this->assertSame($expected, $server->controlHideConnectionErrors);
-        $this->assertSame($expected, $serverArray['control_hide_connection_errors']);
+        self::assertSame($expected, $server->controlHideConnectionErrors);
+        self::assertSame($expected, $serverArray['control_hide_connection_errors']);
     }
 
     /** @return iterable<string, array{mixed, bool|null}> */
@@ -422,8 +422,8 @@ class ServerTest extends TestCase
     {
         $server = new Server(['auth_type' => $actual]);
         $serverArray = $server->asArray();
-        $this->assertSame($expected, $server->authType);
-        $this->assertSame($expected, $serverArray['auth_type']);
+        self::assertSame($expected, $server->authType);
+        self::assertSame($expected, $serverArray['auth_type']);
     }
 
     /** @return iterable<string, array{mixed, string}> */
@@ -442,8 +442,8 @@ class ServerTest extends TestCase
     {
         $server = new Server(['auth_http_realm' => $actual]);
         $serverArray = $server->asArray();
-        $this->assertSame($expected, $server->authHttpRealm);
-        $this->assertSame($expected, $serverArray['auth_http_realm']);
+        self::assertSame($expected, $server->authHttpRealm);
+        self::assertSame($expected, $serverArray['auth_http_realm']);
     }
 
     /** @return iterable<string, array{mixed, string}> */
@@ -460,8 +460,8 @@ class ServerTest extends TestCase
     {
         $server = new Server(['user' => $actual]);
         $serverArray = $server->asArray();
-        $this->assertSame($expected, $server->user);
-        $this->assertSame($expected, $serverArray['user']);
+        self::assertSame($expected, $server->user);
+        self::assertSame($expected, $serverArray['user']);
     }
 
     /** @return iterable<string, array{mixed, string}> */
@@ -478,8 +478,8 @@ class ServerTest extends TestCase
     {
         $server = new Server(['password' => $actual]);
         $serverArray = $server->asArray();
-        $this->assertSame($expected, $server->password);
-        $this->assertSame($expected, $serverArray['password']);
+        self::assertSame($expected, $server->password);
+        self::assertSame($expected, $serverArray['password']);
     }
 
     /** @return iterable<string, array{mixed, string}> */
@@ -496,8 +496,8 @@ class ServerTest extends TestCase
     {
         $server = new Server(['SignonSession' => $actual]);
         $serverArray = $server->asArray();
-        $this->assertSame($expected, $server->signonSession);
-        $this->assertSame($expected, $serverArray['SignonSession']);
+        self::assertSame($expected, $server->signonSession);
+        self::assertSame($expected, $serverArray['SignonSession']);
     }
 
     /** @return iterable<string, array{mixed, string}> */
@@ -515,8 +515,8 @@ class ServerTest extends TestCase
     {
         $server = new Server(['SignonCookieParams' => $actual]);
         $serverArray = $server->asArray();
-        $this->assertSame($expected, $server->signonCookieParams);
-        $this->assertSame($expected, $serverArray['SignonCookieParams']);
+        self::assertSame($expected, $server->signonCookieParams);
+        self::assertSame($expected, $serverArray['SignonCookieParams']);
     }
 
     /** @return iterable<string, array{mixed, array<string, int|string|bool>}> */
@@ -584,8 +584,8 @@ class ServerTest extends TestCase
     {
         $server = new Server(['SignonScript' => $actual]);
         $serverArray = $server->asArray();
-        $this->assertSame($expected, $server->signonScript);
-        $this->assertSame($expected, $serverArray['SignonScript']);
+        self::assertSame($expected, $server->signonScript);
+        self::assertSame($expected, $serverArray['SignonScript']);
     }
 
     /** @return iterable<string, array{mixed, string}> */
@@ -602,8 +602,8 @@ class ServerTest extends TestCase
     {
         $server = new Server(['SignonURL' => $actual]);
         $serverArray = $server->asArray();
-        $this->assertSame($expected, $server->signonUrl);
-        $this->assertSame($expected, $serverArray['SignonURL']);
+        self::assertSame($expected, $server->signonUrl);
+        self::assertSame($expected, $serverArray['SignonURL']);
     }
 
     /** @return iterable<string, array{mixed, string}> */
@@ -620,8 +620,8 @@ class ServerTest extends TestCase
     {
         $server = new Server(['LogoutURL' => $actual]);
         $serverArray = $server->asArray();
-        $this->assertSame($expected, $server->logoutUrl);
-        $this->assertSame($expected, $serverArray['LogoutURL']);
+        self::assertSame($expected, $server->logoutUrl);
+        self::assertSame($expected, $serverArray['LogoutURL']);
     }
 
     /** @return iterable<string, array{mixed, string}> */
@@ -639,8 +639,8 @@ class ServerTest extends TestCase
     {
         $server = new Server(['only_db' => $actual]);
         $serverArray = $server->asArray();
-        $this->assertSame($expected, $server->onlyDb);
-        $this->assertSame($expected, $serverArray['only_db']);
+        self::assertSame($expected, $server->onlyDb);
+        self::assertSame($expected, $serverArray['only_db']);
     }
 
     /** @return iterable<string, array{mixed, string|string[]}> */
@@ -658,8 +658,8 @@ class ServerTest extends TestCase
     {
         $server = new Server(['hide_db' => $actual]);
         $serverArray = $server->asArray();
-        $this->assertSame($expected, $server->hideDb);
-        $this->assertSame($expected, $serverArray['hide_db']);
+        self::assertSame($expected, $server->hideDb);
+        self::assertSame($expected, $serverArray['hide_db']);
     }
 
     /** @return iterable<string, array{mixed, string}> */
@@ -676,8 +676,8 @@ class ServerTest extends TestCase
     {
         $server = new Server(['verbose' => $actual]);
         $serverArray = $server->asArray();
-        $this->assertSame($expected, $server->verbose);
-        $this->assertSame($expected, $serverArray['verbose']);
+        self::assertSame($expected, $server->verbose);
+        self::assertSame($expected, $serverArray['verbose']);
     }
 
     /** @return iterable<string, array{mixed, string}> */
@@ -694,8 +694,8 @@ class ServerTest extends TestCase
     {
         $server = new Server(['pmadb' => $actual]);
         $serverArray = $server->asArray();
-        $this->assertSame($expected, $server->pmaDb);
-        $this->assertSame($expected, $serverArray['pmadb']);
+        self::assertSame($expected, $server->pmaDb);
+        self::assertSame($expected, $serverArray['pmadb']);
     }
 
     /** @return iterable<string, array{mixed, string}> */
@@ -712,8 +712,8 @@ class ServerTest extends TestCase
     {
         $server = new Server(['bookmarktable' => $actual]);
         $serverArray = $server->asArray();
-        $this->assertSame($expected, $server->bookmarkTable);
-        $this->assertSame($expected, $serverArray['bookmarktable']);
+        self::assertSame($expected, $server->bookmarkTable);
+        self::assertSame($expected, $serverArray['bookmarktable']);
     }
 
     /** @return iterable<string, array{mixed, string|false}> */
@@ -731,8 +731,8 @@ class ServerTest extends TestCase
     {
         $server = new Server(['relation' => $actual]);
         $serverArray = $server->asArray();
-        $this->assertSame($expected, $server->relation);
-        $this->assertSame($expected, $serverArray['relation']);
+        self::assertSame($expected, $server->relation);
+        self::assertSame($expected, $serverArray['relation']);
     }
 
     #[DataProvider('valuesForConfigStorageTablesProvider')]
@@ -740,8 +740,8 @@ class ServerTest extends TestCase
     {
         $server = new Server(['table_info' => $actual]);
         $serverArray = $server->asArray();
-        $this->assertSame($expected, $server->tableInfo);
-        $this->assertSame($expected, $serverArray['table_info']);
+        self::assertSame($expected, $server->tableInfo);
+        self::assertSame($expected, $serverArray['table_info']);
     }
 
     #[DataProvider('valuesForConfigStorageTablesProvider')]
@@ -749,8 +749,8 @@ class ServerTest extends TestCase
     {
         $server = new Server(['pdf_pages' => $actual]);
         $serverArray = $server->asArray();
-        $this->assertSame($expected, $server->pdfPages);
-        $this->assertSame($expected, $serverArray['pdf_pages']);
+        self::assertSame($expected, $server->pdfPages);
+        self::assertSame($expected, $serverArray['pdf_pages']);
     }
 
     #[DataProvider('valuesForConfigStorageTablesProvider')]
@@ -758,8 +758,8 @@ class ServerTest extends TestCase
     {
         $server = new Server(['column_info' => $actual]);
         $serverArray = $server->asArray();
-        $this->assertSame($expected, $server->columnInfo);
-        $this->assertSame($expected, $serverArray['column_info']);
+        self::assertSame($expected, $server->columnInfo);
+        self::assertSame($expected, $serverArray['column_info']);
     }
 
     #[DataProvider('valuesForConfigStorageTablesProvider')]
@@ -767,8 +767,8 @@ class ServerTest extends TestCase
     {
         $server = new Server(['history' => $actual]);
         $serverArray = $server->asArray();
-        $this->assertSame($expected, $server->history);
-        $this->assertSame($expected, $serverArray['history']);
+        self::assertSame($expected, $server->history);
+        self::assertSame($expected, $serverArray['history']);
     }
 
     #[DataProvider('valuesForConfigStorageTablesProvider')]
@@ -776,8 +776,8 @@ class ServerTest extends TestCase
     {
         $server = new Server(['recent' => $actual]);
         $serverArray = $server->asArray();
-        $this->assertSame($expected, $server->recent);
-        $this->assertSame($expected, $serverArray['recent']);
+        self::assertSame($expected, $server->recent);
+        self::assertSame($expected, $serverArray['recent']);
     }
 
     #[DataProvider('valuesForConfigStorageTablesProvider')]
@@ -785,8 +785,8 @@ class ServerTest extends TestCase
     {
         $server = new Server(['favorite' => $actual]);
         $serverArray = $server->asArray();
-        $this->assertSame($expected, $server->favorite);
-        $this->assertSame($expected, $serverArray['favorite']);
+        self::assertSame($expected, $server->favorite);
+        self::assertSame($expected, $serverArray['favorite']);
     }
 
     #[DataProvider('valuesForConfigStorageTablesProvider')]
@@ -794,8 +794,8 @@ class ServerTest extends TestCase
     {
         $server = new Server(['table_uiprefs' => $actual]);
         $serverArray = $server->asArray();
-        $this->assertSame($expected, $server->tableUiPrefs);
-        $this->assertSame($expected, $serverArray['table_uiprefs']);
+        self::assertSame($expected, $server->tableUiPrefs);
+        self::assertSame($expected, $serverArray['table_uiprefs']);
     }
 
     #[DataProvider('valuesForConfigStorageTablesProvider')]
@@ -803,8 +803,8 @@ class ServerTest extends TestCase
     {
         $server = new Server(['tracking' => $actual]);
         $serverArray = $server->asArray();
-        $this->assertSame($expected, $server->tracking);
-        $this->assertSame($expected, $serverArray['tracking']);
+        self::assertSame($expected, $server->tracking);
+        self::assertSame($expected, $serverArray['tracking']);
     }
 
     #[DataProvider('valuesForConfigStorageTablesProvider')]
@@ -812,8 +812,8 @@ class ServerTest extends TestCase
     {
         $server = new Server(['userconfig' => $actual]);
         $serverArray = $server->asArray();
-        $this->assertSame($expected, $server->userConfig);
-        $this->assertSame($expected, $serverArray['userconfig']);
+        self::assertSame($expected, $server->userConfig);
+        self::assertSame($expected, $serverArray['userconfig']);
     }
 
     #[DataProvider('valuesForConfigStorageTablesProvider')]
@@ -821,8 +821,8 @@ class ServerTest extends TestCase
     {
         $server = new Server(['users' => $actual]);
         $serverArray = $server->asArray();
-        $this->assertSame($expected, $server->users);
-        $this->assertSame($expected, $serverArray['users']);
+        self::assertSame($expected, $server->users);
+        self::assertSame($expected, $serverArray['users']);
     }
 
     #[DataProvider('valuesForConfigStorageTablesProvider')]
@@ -830,8 +830,8 @@ class ServerTest extends TestCase
     {
         $server = new Server(['usergroups' => $actual]);
         $serverArray = $server->asArray();
-        $this->assertSame($expected, $server->userGroups);
-        $this->assertSame($expected, $serverArray['usergroups']);
+        self::assertSame($expected, $server->userGroups);
+        self::assertSame($expected, $serverArray['usergroups']);
     }
 
     #[DataProvider('valuesForConfigStorageTablesProvider')]
@@ -839,8 +839,8 @@ class ServerTest extends TestCase
     {
         $server = new Server(['navigationhiding' => $actual]);
         $serverArray = $server->asArray();
-        $this->assertSame($expected, $server->navigationHiding);
-        $this->assertSame($expected, $serverArray['navigationhiding']);
+        self::assertSame($expected, $server->navigationHiding);
+        self::assertSame($expected, $serverArray['navigationhiding']);
     }
 
     #[DataProvider('valuesForConfigStorageTablesProvider')]
@@ -848,8 +848,8 @@ class ServerTest extends TestCase
     {
         $server = new Server(['savedsearches' => $actual]);
         $serverArray = $server->asArray();
-        $this->assertSame($expected, $server->savedSearches);
-        $this->assertSame($expected, $serverArray['savedsearches']);
+        self::assertSame($expected, $server->savedSearches);
+        self::assertSame($expected, $serverArray['savedsearches']);
     }
 
     #[DataProvider('valuesForConfigStorageTablesProvider')]
@@ -857,8 +857,8 @@ class ServerTest extends TestCase
     {
         $server = new Server(['central_columns' => $actual]);
         $serverArray = $server->asArray();
-        $this->assertSame($expected, $server->centralColumns);
-        $this->assertSame($expected, $serverArray['central_columns']);
+        self::assertSame($expected, $server->centralColumns);
+        self::assertSame($expected, $serverArray['central_columns']);
     }
 
     #[DataProvider('valuesForConfigStorageTablesProvider')]
@@ -866,8 +866,8 @@ class ServerTest extends TestCase
     {
         $server = new Server(['designer_settings' => $actual]);
         $serverArray = $server->asArray();
-        $this->assertSame($expected, $server->designerSettings);
-        $this->assertSame($expected, $serverArray['designer_settings']);
+        self::assertSame($expected, $server->designerSettings);
+        self::assertSame($expected, $serverArray['designer_settings']);
     }
 
     #[DataProvider('valuesForConfigStorageTablesProvider')]
@@ -875,8 +875,8 @@ class ServerTest extends TestCase
     {
         $server = new Server(['export_templates' => $actual]);
         $serverArray = $server->asArray();
-        $this->assertSame($expected, $server->exportTemplates);
-        $this->assertSame($expected, $serverArray['export_templates']);
+        self::assertSame($expected, $server->exportTemplates);
+        self::assertSame($expected, $serverArray['export_templates']);
     }
 
     #[DataProvider('valuesForMaxTableUiPrefsProvider')]
@@ -884,8 +884,8 @@ class ServerTest extends TestCase
     {
         $server = new Server(['MaxTableUiprefs' => $actual]);
         $serverArray = $server->asArray();
-        $this->assertSame($expected, $server->maxTableUiPrefs);
-        $this->assertSame($expected, $serverArray['MaxTableUiprefs']);
+        self::assertSame($expected, $server->maxTableUiPrefs);
+        self::assertSame($expected, $serverArray['MaxTableUiprefs']);
     }
 
     /** @return iterable<string, array{mixed, int}> */
@@ -903,8 +903,8 @@ class ServerTest extends TestCase
     {
         $server = new Server(['SessionTimeZone' => $actual]);
         $serverArray = $server->asArray();
-        $this->assertSame($expected, $server->sessionTimeZone);
-        $this->assertSame($expected, $serverArray['SessionTimeZone']);
+        self::assertSame($expected, $server->sessionTimeZone);
+        self::assertSame($expected, $serverArray['SessionTimeZone']);
     }
 
     /** @return iterable<string, array{mixed, string}> */
@@ -921,8 +921,8 @@ class ServerTest extends TestCase
     {
         $server = new Server(['AllowRoot' => $actual]);
         $serverArray = $server->asArray();
-        $this->assertSame($expected, $server->allowRoot);
-        $this->assertSame($expected, $serverArray['AllowRoot']);
+        self::assertSame($expected, $server->allowRoot);
+        self::assertSame($expected, $serverArray['AllowRoot']);
     }
 
     #[DataProvider('booleanWithDefaultFalseProvider')]
@@ -930,8 +930,8 @@ class ServerTest extends TestCase
     {
         $server = new Server(['AllowNoPassword' => $actual]);
         $serverArray = $server->asArray();
-        $this->assertSame($expected, $server->allowNoPassword);
-        $this->assertSame($expected, $serverArray['AllowNoPassword']);
+        self::assertSame($expected, $server->allowNoPassword);
+        self::assertSame($expected, $serverArray['AllowNoPassword']);
     }
 
     /** @param array<string, string|string[]> $expected */
@@ -940,8 +940,8 @@ class ServerTest extends TestCase
     {
         $server = new Server(['AllowDeny' => $actual]);
         $serverArray = $server->asArray();
-        $this->assertSame($expected, $server->allowDeny);
-        $this->assertSame($expected, $serverArray['AllowDeny']);
+        self::assertSame($expected, $server->allowDeny);
+        self::assertSame($expected, $serverArray['AllowDeny']);
     }
 
     /** @return iterable<string, array{mixed, array<string, string|string[]>}> */
@@ -970,8 +970,8 @@ class ServerTest extends TestCase
     {
         $server = new Server(['DisableIS' => $actual]);
         $serverArray = $server->asArray();
-        $this->assertSame($expected, $server->disableIS);
-        $this->assertSame($expected, $serverArray['DisableIS']);
+        self::assertSame($expected, $server->disableIS);
+        self::assertSame($expected, $serverArray['DisableIS']);
     }
 
     #[DataProvider('booleanWithDefaultFalseProvider')]
@@ -979,8 +979,8 @@ class ServerTest extends TestCase
     {
         $server = new Server(['tracking_version_auto_create' => $actual]);
         $serverArray = $server->asArray();
-        $this->assertSame($expected, $server->trackingVersionAutoCreate);
-        $this->assertSame($expected, $serverArray['tracking_version_auto_create']);
+        self::assertSame($expected, $server->trackingVersionAutoCreate);
+        self::assertSame($expected, $serverArray['tracking_version_auto_create']);
     }
 
     #[DataProvider('valuesForTrackingDefaultStatementsProvider')]
@@ -988,8 +988,8 @@ class ServerTest extends TestCase
     {
         $server = new Server(['tracking_default_statements' => $actual]);
         $serverArray = $server->asArray();
-        $this->assertSame($expected, $server->trackingDefaultStatements);
-        $this->assertSame($expected, $serverArray['tracking_default_statements']);
+        self::assertSame($expected, $server->trackingDefaultStatements);
+        self::assertSame($expected, $serverArray['tracking_default_statements']);
     }
 
     /** @return iterable<string, array{mixed, string}> */
@@ -1011,8 +1011,8 @@ class ServerTest extends TestCase
     {
         $server = new Server(['tracking_add_drop_view' => $actual]);
         $serverArray = $server->asArray();
-        $this->assertSame($expected, $server->trackingAddDropView);
-        $this->assertSame($expected, $serverArray['tracking_add_drop_view']);
+        self::assertSame($expected, $server->trackingAddDropView);
+        self::assertSame($expected, $serverArray['tracking_add_drop_view']);
     }
 
     #[DataProvider('booleanWithDefaultTrueProvider')]
@@ -1020,8 +1020,8 @@ class ServerTest extends TestCase
     {
         $server = new Server(['tracking_add_drop_table' => $actual]);
         $serverArray = $server->asArray();
-        $this->assertSame($expected, $server->trackingAddDropTable);
-        $this->assertSame($expected, $serverArray['tracking_add_drop_table']);
+        self::assertSame($expected, $server->trackingAddDropTable);
+        self::assertSame($expected, $serverArray['tracking_add_drop_table']);
     }
 
     #[DataProvider('booleanWithDefaultTrueProvider')]
@@ -1029,8 +1029,8 @@ class ServerTest extends TestCase
     {
         $server = new Server(['tracking_add_drop_database' => $actual]);
         $serverArray = $server->asArray();
-        $this->assertSame($expected, $server->trackingAddDropDatabase);
-        $this->assertSame($expected, $serverArray['tracking_add_drop_database']);
+        self::assertSame($expected, $server->trackingAddDropDatabase);
+        self::assertSame($expected, $serverArray['tracking_add_drop_database']);
     }
 
     #[DataProvider('booleanWithDefaultFalseProvider')]
@@ -1038,7 +1038,7 @@ class ServerTest extends TestCase
     {
         $server = new Server(['hide_connection_errors' => $actual]);
         $serverArray = $server->asArray();
-        $this->assertSame($expected, $server->hideConnectionErrors);
-        $this->assertSame($expected, $serverArray['hide_connection_errors']);
+        self::assertSame($expected, $server->hideConnectionErrors);
+        self::assertSame($expected, $serverArray['hide_connection_errors']);
     }
 }
diff --git a/tests/classes/Config/Settings/SqlQueryBoxTest.php b/tests/classes/Config/Settings/SqlQueryBoxTest.php
index 7bd8d53fd1..7b52f146c4 100644
--- a/tests/classes/Config/Settings/SqlQueryBoxTest.php
+++ b/tests/classes/Config/Settings/SqlQueryBoxTest.php
@@ -18,8 +18,8 @@ class SqlQueryBoxTest extends TestCase
         $sqlQueryBox = new SqlQueryBox(['Edit' => $actual]);
         $sqlQueryBoxArray = $sqlQueryBox->asArray();
         // phpcs:ignore Squiz.NamingConventions.ValidVariableName.MemberNotCamelCaps
-        $this->assertSame($expected, $sqlQueryBox->Edit);
-        $this->assertSame($expected, $sqlQueryBoxArray['Edit']);
+        self::assertSame($expected, $sqlQueryBox->Edit);
+        self::assertSame($expected, $sqlQueryBoxArray['Edit']);
     }
 
     #[DataProvider('booleanWithDefaultTrueProvider')]
@@ -28,8 +28,8 @@ class SqlQueryBoxTest extends TestCase
         $sqlQueryBox = new SqlQueryBox(['Explain' => $actual]);
         $sqlQueryBoxArray = $sqlQueryBox->asArray();
         // phpcs:ignore Squiz.NamingConventions.ValidVariableName.MemberNotCamelCaps
-        $this->assertSame($expected, $sqlQueryBox->Explain);
-        $this->assertSame($expected, $sqlQueryBoxArray['Explain']);
+        self::assertSame($expected, $sqlQueryBox->Explain);
+        self::assertSame($expected, $sqlQueryBoxArray['Explain']);
     }
 
     #[DataProvider('booleanWithDefaultTrueProvider')]
@@ -38,8 +38,8 @@ class SqlQueryBoxTest extends TestCase
         $sqlQueryBox = new SqlQueryBox(['ShowAsPHP' => $actual]);
         $sqlQueryBoxArray = $sqlQueryBox->asArray();
         // phpcs:ignore Squiz.NamingConventions.ValidVariableName.MemberNotCamelCaps
-        $this->assertSame($expected, $sqlQueryBox->ShowAsPHP);
-        $this->assertSame($expected, $sqlQueryBoxArray['ShowAsPHP']);
+        self::assertSame($expected, $sqlQueryBox->ShowAsPHP);
+        self::assertSame($expected, $sqlQueryBoxArray['ShowAsPHP']);
     }
 
     #[DataProvider('booleanWithDefaultTrueProvider')]
@@ -48,8 +48,8 @@ class SqlQueryBoxTest extends TestCase
         $sqlQueryBox = new SqlQueryBox(['Refresh' => $actual]);
         $sqlQueryBoxArray = $sqlQueryBox->asArray();
         // phpcs:ignore Squiz.NamingConventions.ValidVariableName.MemberNotCamelCaps
-        $this->assertSame($expected, $sqlQueryBox->Refresh);
-        $this->assertSame($expected, $sqlQueryBoxArray['Refresh']);
+        self::assertSame($expected, $sqlQueryBox->Refresh);
+        self::assertSame($expected, $sqlQueryBoxArray['Refresh']);
     }
 
     /** @return iterable<string, array{mixed, bool}> */
diff --git a/tests/classes/Config/Settings/TransformationsTest.php b/tests/classes/Config/Settings/TransformationsTest.php
index 59780d3b20..65f385a1cc 100644
--- a/tests/classes/Config/Settings/TransformationsTest.php
+++ b/tests/classes/Config/Settings/TransformationsTest.php
@@ -19,8 +19,8 @@ class TransformationsTest extends TestCase
         $transformations = new Transformations(['Substring' => $actual]);
         $transformationsArray = $transformations->asArray();
         // phpcs:ignore Squiz.NamingConventions.ValidVariableName.MemberNotCamelCaps
-        $this->assertSame($expected, $transformations->Substring);
-        $this->assertSame($expected, $transformationsArray['Substring']);
+        self::assertSame($expected, $transformations->Substring);
+        self::assertSame($expected, $transformationsArray['Substring']);
     }
 
     /** @return iterable<string, array{mixed, array<int, int|string>}> */
@@ -44,8 +44,8 @@ class TransformationsTest extends TestCase
         $transformations = new Transformations(['Bool2Text' => $actual]);
         $transformationsArray = $transformations->asArray();
         // phpcs:ignore Squiz.NamingConventions.ValidVariableName.MemberNotCamelCaps
-        $this->assertSame($expected, $transformations->Bool2Text);
-        $this->assertSame($expected, $transformationsArray['Bool2Text']);
+        self::assertSame($expected, $transformations->Bool2Text);
+        self::assertSame($expected, $transformationsArray['Bool2Text']);
     }
 
     /** @return iterable<string, array{mixed, array<int, string>}> */
@@ -67,8 +67,8 @@ class TransformationsTest extends TestCase
         $transformations = new Transformations(['External' => $actual]);
         $transformationsArray = $transformations->asArray();
         // phpcs:ignore Squiz.NamingConventions.ValidVariableName.MemberNotCamelCaps
-        $this->assertSame($expected, $transformations->External);
-        $this->assertSame($expected, $transformationsArray['External']);
+        self::assertSame($expected, $transformations->External);
+        self::assertSame($expected, $transformationsArray['External']);
     }
 
     /** @return iterable<string, array{mixed, array<int, int|string>}> */
@@ -93,8 +93,8 @@ class TransformationsTest extends TestCase
         $transformations = new Transformations(['PreApPend' => $actual]);
         $transformationsArray = $transformations->asArray();
         // phpcs:ignore Squiz.NamingConventions.ValidVariableName.MemberNotCamelCaps
-        $this->assertSame($expected, $transformations->PreApPend);
-        $this->assertSame($expected, $transformationsArray['PreApPend']);
+        self::assertSame($expected, $transformations->PreApPend);
+        self::assertSame($expected, $transformationsArray['PreApPend']);
     }
 
     /** @return iterable<string, array{mixed, array<int, string>}> */
@@ -116,8 +116,8 @@ class TransformationsTest extends TestCase
         $transformations = new Transformations(['Hex' => $actual]);
         $transformationsArray = $transformations->asArray();
         // phpcs:ignore Squiz.NamingConventions.ValidVariableName.MemberNotCamelCaps
-        $this->assertSame($expected, $transformations->Hex);
-        $this->assertSame($expected, $transformationsArray['Hex']);
+        self::assertSame($expected, $transformations->Hex);
+        self::assertSame($expected, $transformationsArray['Hex']);
     }
 
     /** @return iterable<string, array{mixed, array<int, int>}> */
@@ -138,8 +138,8 @@ class TransformationsTest extends TestCase
         $transformations = new Transformations(['DateFormat' => $actual]);
         $transformationsArray = $transformations->asArray();
         // phpcs:ignore Squiz.NamingConventions.ValidVariableName.MemberNotCamelCaps
-        $this->assertSame($expected, $transformations->DateFormat);
-        $this->assertSame($expected, $transformationsArray['DateFormat']);
+        self::assertSame($expected, $transformations->DateFormat);
+        self::assertSame($expected, $transformationsArray['DateFormat']);
     }
 
     /** @return iterable<string, array{mixed, array<int, int|string>}> */
@@ -163,8 +163,8 @@ class TransformationsTest extends TestCase
         $transformations = new Transformations(['Inline' => $actual]);
         $transformationsArray = $transformations->asArray();
         // phpcs:ignore Squiz.NamingConventions.ValidVariableName.MemberNotCamelCaps
-        $this->assertSame($expected, $transformations->Inline);
-        $this->assertSame($expected, $transformationsArray['Inline']);
+        self::assertSame($expected, $transformations->Inline);
+        self::assertSame($expected, $transformationsArray['Inline']);
     }
 
     /** @return iterable<string, array{mixed, array<int|string, int|string|array<string, string>|null>}> */
@@ -195,8 +195,8 @@ class TransformationsTest extends TestCase
         $transformations = new Transformations(['TextImageLink' => $actual]);
         $transformationsArray = $transformations->asArray();
         // phpcs:ignore Squiz.NamingConventions.ValidVariableName.MemberNotCamelCaps
-        $this->assertSame($expected, $transformations->TextImageLink);
-        $this->assertSame($expected, $transformationsArray['TextImageLink']);
+        self::assertSame($expected, $transformations->TextImageLink);
+        self::assertSame($expected, $transformationsArray['TextImageLink']);
     }
 
     /** @return iterable<string, array{mixed, array<int, int|string|null>}> */
@@ -220,8 +220,8 @@ class TransformationsTest extends TestCase
         $transformations = new Transformations(['TextLink' => $actual]);
         $transformationsArray = $transformations->asArray();
         // phpcs:ignore Squiz.NamingConventions.ValidVariableName.MemberNotCamelCaps
-        $this->assertSame($expected, $transformations->TextLink);
-        $this->assertSame($expected, $transformationsArray['TextLink']);
+        self::assertSame($expected, $transformations->TextLink);
+        self::assertSame($expected, $transformationsArray['TextLink']);
     }
 
     /** @return iterable<string, array{mixed, array<int, string|bool|null>}> */
diff --git a/tests/classes/Config/SettingsTest.php b/tests/classes/Config/SettingsTest.php
index c3d30c1689..530b889ab4 100644
--- a/tests/classes/Config/SettingsTest.php
+++ b/tests/classes/Config/SettingsTest.php
@@ -264,43 +264,43 @@ class SettingsTest extends TestCase
         $settingsArray = $settings->asArray();
         foreach (array_keys($expectedValues) as $key) {
             if ($key === 'Console') {
-                $this->assertInstanceOf(Console::class, $settings->Console);
+                self::assertInstanceOf(Console::class, $settings->Console);
                 continue;
             }
 
             if ($key === 'DBG') {
-                $this->assertInstanceOf(Debug::class, $settings->DBG);
+                self::assertInstanceOf(Debug::class, $settings->DBG);
                 continue;
             }
 
             if ($key === 'Export') {
-                $this->assertInstanceOf(Export::class, $settings->Export);
+                self::assertInstanceOf(Export::class, $settings->Export);
                 continue;
             }
 
             if ($key === 'Import') {
-                $this->assertInstanceOf(Import::class, $settings->Import);
+                self::assertInstanceOf(Import::class, $settings->Import);
                 continue;
             }
 
             if ($key === 'Schema') {
-                $this->assertInstanceOf(Schema::class, $settings->Schema);
+                self::assertInstanceOf(Schema::class, $settings->Schema);
                 continue;
             }
 
             if ($key === 'SQLQuery') {
-                $this->assertInstanceOf(SqlQueryBox::class, $settings->SQLQuery);
+                self::assertInstanceOf(SqlQueryBox::class, $settings->SQLQuery);
                 continue;
             }
 
             if ($key === 'DefaultTransformations') {
-                $this->assertInstanceOf(Transformations::class, $settings->DefaultTransformations);
+                self::assertInstanceOf(Transformations::class, $settings->DefaultTransformations);
                 continue;
             }
 
-            $this->assertSame($expected[$key], $settings->$key);
-            $this->assertArrayHasKey($key, $settingsArray);
-            $this->assertSame($expected[$key], $settingsArray[$key]);
+            self::assertSame($expected[$key], $settings->$key);
+            self::assertArrayHasKey($key, $settingsArray);
+            self::assertSame($expected[$key], $settingsArray[$key]);
         }
     }
 
@@ -994,8 +994,8 @@ class SettingsTest extends TestCase
     {
         $settings = new Settings(['PmaAbsoluteUri' => $actual]);
         $settingsArray = $settings->asArray();
-        $this->assertSame($expected, $settings->PmaAbsoluteUri);
-        $this->assertSame($expected, $settingsArray['PmaAbsoluteUri']);
+        self::assertSame($expected, $settings->PmaAbsoluteUri);
+        self::assertSame($expected, $settingsArray['PmaAbsoluteUri']);
     }
 
     /** @return iterable<string, array{mixed, string}> */
@@ -1012,8 +1012,8 @@ class SettingsTest extends TestCase
     {
         $settings = new Settings(['AuthLog' => $actual]);
         $settingsArray = $settings->asArray();
-        $this->assertSame($expected, $settings->authLog);
-        $this->assertSame($expected, $settingsArray['AuthLog']);
+        self::assertSame($expected, $settings->authLog);
+        self::assertSame($expected, $settingsArray['AuthLog']);
     }
 
     /** @return iterable<string, array{mixed, string}> */
@@ -1030,8 +1030,8 @@ class SettingsTest extends TestCase
     {
         $settings = new Settings(['AuthLogSuccess' => $actual]);
         $settingsArray = $settings->asArray();
-        $this->assertSame($expected, $settings->authLogSuccess);
-        $this->assertSame($expected, $settingsArray['AuthLogSuccess']);
+        self::assertSame($expected, $settings->authLogSuccess);
+        self::assertSame($expected, $settingsArray['AuthLogSuccess']);
     }
 
     #[DataProvider('booleanWithDefaultFalseProvider')]
@@ -1039,8 +1039,8 @@ class SettingsTest extends TestCase
     {
         $settings = new Settings(['PmaNoRelation_DisableWarning' => $actual]);
         $settingsArray = $settings->asArray();
-        $this->assertSame($expected, $settings->PmaNoRelation_DisableWarning);
-        $this->assertSame($expected, $settingsArray['PmaNoRelation_DisableWarning']);
+        self::assertSame($expected, $settings->PmaNoRelation_DisableWarning);
+        self::assertSame($expected, $settingsArray['PmaNoRelation_DisableWarning']);
     }
 
     #[DataProvider('booleanWithDefaultFalseProvider')]
@@ -1048,8 +1048,8 @@ class SettingsTest extends TestCase
     {
         $settings = new Settings(['SuhosinDisableWarning' => $actual]);
         $settingsArray = $settings->asArray();
-        $this->assertSame($expected, $settings->SuhosinDisableWarning);
-        $this->assertSame($expected, $settingsArray['SuhosinDisableWarning']);
+        self::assertSame($expected, $settings->SuhosinDisableWarning);
+        self::assertSame($expected, $settingsArray['SuhosinDisableWarning']);
     }
 
     #[DataProvider('booleanWithDefaultFalseProvider')]
@@ -1057,8 +1057,8 @@ class SettingsTest extends TestCase
     {
         $settings = new Settings(['LoginCookieValidityDisableWarning' => $actual]);
         $settingsArray = $settings->asArray();
-        $this->assertSame($expected, $settings->LoginCookieValidityDisableWarning);
-        $this->assertSame($expected, $settingsArray['LoginCookieValidityDisableWarning']);
+        self::assertSame($expected, $settings->LoginCookieValidityDisableWarning);
+        self::assertSame($expected, $settingsArray['LoginCookieValidityDisableWarning']);
     }
 
     #[DataProvider('booleanWithDefaultFalseProvider')]
@@ -1066,8 +1066,8 @@ class SettingsTest extends TestCase
     {
         $settings = new Settings(['ReservedWordDisableWarning' => $actual]);
         $settingsArray = $settings->asArray();
-        $this->assertSame($expected, $settings->ReservedWordDisableWarning);
-        $this->assertSame($expected, $settingsArray['ReservedWordDisableWarning']);
+        self::assertSame($expected, $settings->ReservedWordDisableWarning);
+        self::assertSame($expected, $settingsArray['ReservedWordDisableWarning']);
     }
 
     #[DataProvider('valuesForTranslationWarningThresholdProvider')]
@@ -1075,8 +1075,8 @@ class SettingsTest extends TestCase
     {
         $settings = new Settings(['TranslationWarningThreshold' => $actual]);
         $settingsArray = $settings->asArray();
-        $this->assertSame($expected, $settings->TranslationWarningThreshold);
-        $this->assertSame($expected, $settingsArray['TranslationWarningThreshold']);
+        self::assertSame($expected, $settings->TranslationWarningThreshold);
+        self::assertSame($expected, $settingsArray['TranslationWarningThreshold']);
     }
 
     /** @return iterable<string, array{mixed, int}> */
@@ -1094,8 +1094,8 @@ class SettingsTest extends TestCase
     {
         $settings = new Settings(['AllowThirdPartyFraming' => $actual]);
         $settingsArray = $settings->asArray();
-        $this->assertSame($expected, $settings->AllowThirdPartyFraming);
-        $this->assertSame($expected, $settingsArray['AllowThirdPartyFraming']);
+        self::assertSame($expected, $settings->AllowThirdPartyFraming);
+        self::assertSame($expected, $settingsArray['AllowThirdPartyFraming']);
     }
 
     /** @return iterable<string, array{mixed, bool|string}> */
@@ -1113,8 +1113,8 @@ class SettingsTest extends TestCase
     {
         $settings = new Settings(['blowfish_secret' => $actual]);
         $settingsArray = $settings->asArray();
-        $this->assertSame($expected, $settings->blowfish_secret);
-        $this->assertSame($expected, $settingsArray['blowfish_secret']);
+        self::assertSame($expected, $settings->blowfish_secret);
+        self::assertSame($expected, $settingsArray['blowfish_secret']);
     }
 
     /** @return iterable<string, array{mixed, string}> */
@@ -1132,9 +1132,9 @@ class SettingsTest extends TestCase
     {
         $settings = new Settings(['Servers' => $actual]);
         $settingsArray = $settings->asArray();
-        $this->assertEquals($expected, $settings->Servers);
+        self::assertEquals($expected, $settings->Servers);
         $expectedArray = array_map(static fn (Server $server): array => $server->asArray(), $expected);
-        $this->assertSame($expectedArray, $settingsArray['Servers']);
+        self::assertSame($expectedArray, $settingsArray['Servers']);
     }
 
     /** @return iterable<string, array{mixed, array<int, Server>}> */
@@ -1160,8 +1160,8 @@ class SettingsTest extends TestCase
     {
         $settings = new Settings(['ServerDefault' => $actual]);
         $settingsArray = $settings->asArray();
-        $this->assertSame($expected, $settings->ServerDefault);
-        $this->assertSame($expected, $settingsArray['ServerDefault']);
+        self::assertSame($expected, $settings->ServerDefault);
+        self::assertSame($expected, $settingsArray['ServerDefault']);
     }
 
     /** @return iterable<string, array{mixed, int}> */
@@ -1178,8 +1178,8 @@ class SettingsTest extends TestCase
     {
         $settings = new Settings(['VersionCheck' => $actual]);
         $settingsArray = $settings->asArray();
-        $this->assertSame($expected, $settings->VersionCheck);
-        $this->assertSame($expected, $settingsArray['VersionCheck']);
+        self::assertSame($expected, $settings->VersionCheck);
+        self::assertSame($expected, $settingsArray['VersionCheck']);
     }
 
     #[DataProvider('valuesForProxyUrlProvider')]
@@ -1187,8 +1187,8 @@ class SettingsTest extends TestCase
     {
         $settings = new Settings(['ProxyUrl' => $actual]);
         $settingsArray = $settings->asArray();
-        $this->assertSame($expected, $settings->ProxyUrl);
-        $this->assertSame($expected, $settingsArray['ProxyUrl']);
+        self::assertSame($expected, $settings->ProxyUrl);
+        self::assertSame($expected, $settingsArray['ProxyUrl']);
     }
 
     /** @return iterable<string, array{mixed, string}> */
@@ -1205,8 +1205,8 @@ class SettingsTest extends TestCase
     {
         $settings = new Settings(['ProxyUser' => $actual]);
         $settingsArray = $settings->asArray();
-        $this->assertSame($expected, $settings->ProxyUser);
-        $this->assertSame($expected, $settingsArray['ProxyUser']);
+        self::assertSame($expected, $settings->ProxyUser);
+        self::assertSame($expected, $settingsArray['ProxyUser']);
     }
 
     /** @return iterable<string, array{mixed, string}> */
@@ -1223,8 +1223,8 @@ class SettingsTest extends TestCase
     {
         $settings = new Settings(['ProxyPass' => $actual]);
         $settingsArray = $settings->asArray();
-        $this->assertSame($expected, $settings->ProxyPass);
-        $this->assertSame($expected, $settingsArray['ProxyPass']);
+        self::assertSame($expected, $settings->ProxyPass);
+        self::assertSame($expected, $settingsArray['ProxyPass']);
     }
 
     /** @return iterable<string, array{mixed, string}> */
@@ -1241,8 +1241,8 @@ class SettingsTest extends TestCase
     {
         $settings = new Settings(['MaxDbList' => $actual]);
         $settingsArray = $settings->asArray();
-        $this->assertSame($expected, $settings->MaxDbList);
-        $this->assertSame($expected, $settingsArray['MaxDbList']);
+        self::assertSame($expected, $settings->MaxDbList);
+        self::assertSame($expected, $settingsArray['MaxDbList']);
     }
 
     /** @return iterable<string, array{mixed, int}> */
@@ -1259,8 +1259,8 @@ class SettingsTest extends TestCase
     {
         $settings = new Settings(['MaxTableList' => $actual]);
         $settingsArray = $settings->asArray();
-        $this->assertSame($expected, $settings->MaxTableList);
-        $this->assertSame($expected, $settingsArray['MaxTableList']);
+        self::assertSame($expected, $settings->MaxTableList);
+        self::assertSame($expected, $settingsArray['MaxTableList']);
     }
 
     /** @return iterable<string, array{mixed, int}> */
@@ -1277,8 +1277,8 @@ class SettingsTest extends TestCase
     {
         $settings = new Settings(['ShowHint' => $actual]);
         $settingsArray = $settings->asArray();
-        $this->assertSame($expected, $settings->ShowHint);
-        $this->assertSame($expected, $settingsArray['ShowHint']);
+        self::assertSame($expected, $settings->ShowHint);
+        self::assertSame($expected, $settingsArray['ShowHint']);
     }
 
     #[DataProvider('valuesForMaxCharactersInDisplayedSQLProvider')]
@@ -1286,8 +1286,8 @@ class SettingsTest extends TestCase
     {
         $settings = new Settings(['MaxCharactersInDisplayedSQL' => $actual]);
         $settingsArray = $settings->asArray();
-        $this->assertSame($expected, $settings->MaxCharactersInDisplayedSQL);
-        $this->assertSame($expected, $settingsArray['MaxCharactersInDisplayedSQL']);
+        self::assertSame($expected, $settings->MaxCharactersInDisplayedSQL);
+        self::assertSame($expected, $settingsArray['MaxCharactersInDisplayedSQL']);
     }
 
     /** @return iterable<string, array{mixed, int}> */
@@ -1304,8 +1304,8 @@ class SettingsTest extends TestCase
     {
         $settings = new Settings(['OBGzip' => $actual]);
         $settingsArray = $settings->asArray();
-        $this->assertSame($expected, $settings->OBGzip);
-        $this->assertSame($expected, $settingsArray['OBGzip']);
+        self::assertSame($expected, $settings->OBGzip);
+        self::assertSame($expected, $settingsArray['OBGzip']);
     }
 
     /** @return iterable<string, array{mixed, string|bool}> */
@@ -1323,8 +1323,8 @@ class SettingsTest extends TestCase
     {
         $settings = new Settings(['PersistentConnections' => $actual]);
         $settingsArray = $settings->asArray();
-        $this->assertSame($expected, $settings->PersistentConnections);
-        $this->assertSame($expected, $settingsArray['PersistentConnections']);
+        self::assertSame($expected, $settings->PersistentConnections);
+        self::assertSame($expected, $settingsArray['PersistentConnections']);
     }
 
     #[DataProvider('valuesForExecTimeLimitProvider')]
@@ -1332,8 +1332,8 @@ class SettingsTest extends TestCase
     {
         $settings = new Settings(['ExecTimeLimit' => $actual]);
         $settingsArray = $settings->asArray();
-        $this->assertSame($expected, $settings->ExecTimeLimit);
-        $this->assertSame($expected, $settingsArray['ExecTimeLimit']);
+        self::assertSame($expected, $settings->ExecTimeLimit);
+        self::assertSame($expected, $settingsArray['ExecTimeLimit']);
     }
 
     /** @return iterable<string, array{mixed, int}> */
@@ -1350,8 +1350,8 @@ class SettingsTest extends TestCase
     {
         $settings = new Settings(['SessionSavePath' => $actual]);
         $settingsArray = $settings->asArray();
-        $this->assertSame($expected, $settings->SessionSavePath);
-        $this->assertSame($expected, $settingsArray['SessionSavePath']);
+        self::assertSame($expected, $settings->SessionSavePath);
+        self::assertSame($expected, $settingsArray['SessionSavePath']);
     }
 
     /** @return iterable<string, array{mixed, string}> */
@@ -1368,8 +1368,8 @@ class SettingsTest extends TestCase
     {
         $settings = new Settings(['ShowAll' => $actual]);
         $settingsArray = $settings->asArray();
-        $this->assertSame($expected, $settings->showAll);
-        $this->assertSame($expected, $settingsArray['ShowAll']);
+        self::assertSame($expected, $settings->showAll);
+        self::assertSame($expected, $settingsArray['ShowAll']);
     }
 
     /** @return iterable<string, array{mixed, bool}> */
@@ -1386,8 +1386,8 @@ class SettingsTest extends TestCase
     {
         $settings = new Settings(['MaxRows' => $actual]);
         $settingsArray = $settings->asArray();
-        $this->assertSame($expected, $settings->maxRows);
-        $this->assertSame($expected, $settingsArray['MaxRows']);
+        self::assertSame($expected, $settings->maxRows);
+        self::assertSame($expected, $settingsArray['MaxRows']);
     }
 
     /** @return iterable<string, array{mixed, int}> */
@@ -1404,8 +1404,8 @@ class SettingsTest extends TestCase
     {
         $settings = new Settings(['LimitChars' => $actual]);
         $settingsArray = $settings->asArray();
-        $this->assertSame($expected, $settings->limitChars);
-        $this->assertSame($expected, $settingsArray['LimitChars']);
+        self::assertSame($expected, $settings->limitChars);
+        self::assertSame($expected, $settingsArray['LimitChars']);
     }
 
     /** @return iterable<string, array{mixed, int}> */
@@ -1422,8 +1422,8 @@ class SettingsTest extends TestCase
     {
         $settings = new Settings(['RepeatCells' => $actual]);
         $settingsArray = $settings->asArray();
-        $this->assertSame($expected, $settings->repeatCells);
-        $this->assertSame($expected, $settingsArray['RepeatCells']);
+        self::assertSame($expected, $settings->repeatCells);
+        self::assertSame($expected, $settingsArray['RepeatCells']);
     }
 
     /** @return iterable<string, array{mixed, int}> */
@@ -1440,8 +1440,8 @@ class SettingsTest extends TestCase
     {
         $settings = new Settings(['ZeroConf' => $actual]);
         $settingsArray = $settings->asArray();
-        $this->assertSame($expected, $settings->zeroConf);
-        $this->assertSame($expected, $settingsArray['ZeroConf']);
+        self::assertSame($expected, $settings->zeroConf);
+        self::assertSame($expected, $settingsArray['ZeroConf']);
     }
 
     /** @return iterable<string, array{mixed, bool}> */
@@ -1459,8 +1459,8 @@ class SettingsTest extends TestCase
     {
         $settings = new Settings(['MysqlMinVersion' => $actual]);
         $settingsArray = $settings->asArray();
-        $this->assertSame($expected, $settings->mysqlMinVersion);
-        $this->assertSame($expected, $settingsArray['MysqlMinVersion']);
+        self::assertSame($expected, $settings->mysqlMinVersion);
+        self::assertSame($expected, $settingsArray['MysqlMinVersion']);
     }
 
     /** @return iterable<string, array{mixed, array{internal: int, human: string}}> */
diff --git a/tests/classes/ConfigStorage/RelationCleanupTest.php b/tests/classes/ConfigStorage/RelationCleanupTest.php
index aca9b0d6be..ab5e005f1e 100644
--- a/tests/classes/ConfigStorage/RelationCleanupTest.php
+++ b/tests/classes/ConfigStorage/RelationCleanupTest.php
@@ -17,15 +17,15 @@ class RelationCleanupTest extends AbstractTestCase
 {
     public function testColumnWithoutRelations(): void
     {
-        $dbi = $this->createMock(DatabaseInterface::class);
-        $dbi->expects($this->never())->method('queryAsControlUser');
+        $dbi = self::createMock(DatabaseInterface::class);
+        $dbi->expects(self::never())->method('queryAsControlUser');
 
         (new RelationCleanup($dbi, new Relation($dbi)))->column('database', 'table', 'column');
     }
 
     public function testColumnWithRelations(): void
     {
-        $relation = $this->createStub(Relation::class);
+        $relation = self::createStub(Relation::class);
         $relation->method('getRelationParameters')->willReturn(RelationParameters::fromArray([
             'user' => 'user',
             'db' => 'pmadb',
@@ -37,11 +37,11 @@ class RelationCleanupTest extends AbstractTestCase
             'column_info' => 'column_info',
         ]));
 
-        $dbi = $this->createMock(DatabaseInterface::class);
-        $dbi->expects($this->any())->method('quoteString')
+        $dbi = self::createMock(DatabaseInterface::class);
+        $dbi->expects(self::any())->method('quoteString')
             ->willReturnCallback(static fn (string $string): string => "'" . $string . "'");
-        $result = $this->createStub(ResultInterface::class);
-        $dbi->expects($this->exactly(4))->method('queryAsControlUser')->willReturnMap([
+        $result = self::createStub(ResultInterface::class);
+        $dbi->expects(self::exactly(4))->method('queryAsControlUser')->willReturnMap([
             [
                 "DELETE FROM `pmadb`.`column_info` WHERE db_name = 'database' AND"
                 . " table_name = 'table' AND column_name = 'column'",
@@ -69,15 +69,15 @@ class RelationCleanupTest extends AbstractTestCase
 
     public function testTableWithoutRelations(): void
     {
-        $dbi = $this->createMock(DatabaseInterface::class);
-        $dbi->expects($this->never())->method('queryAsControlUser');
+        $dbi = self::createMock(DatabaseInterface::class);
+        $dbi->expects(self::never())->method('queryAsControlUser');
 
         (new RelationCleanup($dbi, new Relation($dbi)))->table('database', 'table');
     }
 
     public function testTableWithRelations(): void
     {
-        $relation = $this->createStub(Relation::class);
+        $relation = self::createStub(Relation::class);
         $relation->method('getRelationParameters')->willReturn(RelationParameters::fromArray([
             'user' => 'user',
             'db' => 'pmadb',
@@ -96,11 +96,11 @@ class RelationCleanupTest extends AbstractTestCase
             'navigationhiding' => 'navigationhiding',
         ]));
 
-        $dbi = $this->createMock(DatabaseInterface::class);
-        $dbi->expects($this->any())->method('quoteString')
+        $dbi = self::createMock(DatabaseInterface::class);
+        $dbi->expects(self::any())->method('quoteString')
             ->willReturnCallback(static fn (string $string): string => "'" . $string . "'");
-        $result = $this->createStub(ResultInterface::class);
-        $dbi->expects($this->exactly(7))->method('queryAsControlUser')->willReturnMap([
+        $result = self::createStub(ResultInterface::class);
+        $dbi->expects(self::exactly(7))->method('queryAsControlUser')->willReturnMap([
             ["DELETE FROM `pmadb`.`column_info` WHERE db_name = 'database' AND table_name = 'table'", $result],
             ["DELETE FROM `pmadb`.`table_info` WHERE db_name = 'database' AND table_name = 'table'", $result],
             ["DELETE FROM `pmadb`.`table_coords` WHERE db_name = 'database' AND table_name = 'table'", $result],
@@ -119,15 +119,15 @@ class RelationCleanupTest extends AbstractTestCase
 
     public function testDatabaseWithoutRelations(): void
     {
-        $dbi = $this->createMock(DatabaseInterface::class);
-        $dbi->expects($this->never())->method('queryAsControlUser');
+        $dbi = self::createMock(DatabaseInterface::class);
+        $dbi->expects(self::never())->method('queryAsControlUser');
 
         (new RelationCleanup($dbi, new Relation($dbi)))->database('database');
     }
 
     public function testDatabaseWithRelations(): void
     {
-        $relation = $this->createStub(Relation::class);
+        $relation = self::createStub(Relation::class);
         $relation->method('getRelationParameters')->willReturn(RelationParameters::fromArray([
             'user' => 'user',
             'db' => 'pmadb',
@@ -152,11 +152,11 @@ class RelationCleanupTest extends AbstractTestCase
             'central_columns' => 'central_columns',
         ]));
 
-        $dbi = $this->createMock(DatabaseInterface::class);
-        $dbi->expects($this->any())->method('quoteString')
+        $dbi = self::createMock(DatabaseInterface::class);
+        $dbi->expects(self::any())->method('quoteString')
             ->willReturnCallback(static fn (string $string): string => "'" . $string . "'");
-        $result = $this->createStub(ResultInterface::class);
-        $dbi->expects($this->exactly(11))->method('queryAsControlUser')->willReturnMap([
+        $result = self::createStub(ResultInterface::class);
+        $dbi->expects(self::exactly(11))->method('queryAsControlUser')->willReturnMap([
             ["DELETE FROM `pmadb`.`column_info` WHERE db_name = 'database'", $result],
             ["DELETE FROM `pmadb`.`bookmark` WHERE dbase = 'database'", $result],
             ["DELETE FROM `pmadb`.`table_info` WHERE db_name = 'database'", $result],
@@ -175,15 +175,15 @@ class RelationCleanupTest extends AbstractTestCase
 
     public function testUserWithoutRelations(): void
     {
-        $dbi = $this->createMock(DatabaseInterface::class);
-        $dbi->expects($this->never())->method('queryAsControlUser');
+        $dbi = self::createMock(DatabaseInterface::class);
+        $dbi->expects(self::never())->method('queryAsControlUser');
 
         (new RelationCleanup($dbi, new Relation($dbi)))->user('user');
     }
 
     public function testUserWithRelations(): void
     {
-        $relation = $this->createStub(Relation::class);
+        $relation = self::createStub(Relation::class);
         $relation->method('getRelationParameters')->willReturn(RelationParameters::fromArray([
             'user' => 'user',
             'db' => 'pmadb',
@@ -210,11 +210,11 @@ class RelationCleanupTest extends AbstractTestCase
             'designer_settings' => 'designer_settings',
         ]));
 
-        $dbi = $this->createMock(DatabaseInterface::class);
-        $dbi->expects($this->any())->method('quoteString')
+        $dbi = self::createMock(DatabaseInterface::class);
+        $dbi->expects(self::any())->method('quoteString')
             ->willReturnCallback(static fn (string $string): string => "'" . $string . "'");
-        $result = $this->createStub(ResultInterface::class);
-        $dbi->expects($this->exactly(10))->method('queryAsControlUser')->willReturnMap([
+        $result = self::createStub(ResultInterface::class);
+        $dbi->expects(self::exactly(10))->method('queryAsControlUser')->willReturnMap([
             ["DELETE FROM `pmadb`.`bookmark` WHERE `user` = 'user'", $result],
             ["DELETE FROM `pmadb`.`history` WHERE `username` = 'user'", $result],
             ["DELETE FROM `pmadb`.`recent` WHERE `username` = 'user'", $result],
diff --git a/tests/classes/ConfigStorage/RelationParametersTest.php b/tests/classes/ConfigStorage/RelationParametersTest.php
index b818c90b28..3f342349d1 100644
--- a/tests/classes/ConfigStorage/RelationParametersTest.php
+++ b/tests/classes/ConfigStorage/RelationParametersTest.php
@@ -52,37 +52,37 @@ class RelationParametersTest extends TestCase
 {
     public function testFeaturesWithTwoTables(): void
     {
-        $this->assertNull(RelationParameters::fromArray([
+        self::assertNull(RelationParameters::fromArray([
             'db' => 'db',
             'pdf_pages' => 'pdf_pages',
             'table_coords' => ' invalid ',
             'pdfwork' => true,
         ])->pdfFeature);
-        $this->assertNull(RelationParameters::fromArray([
+        self::assertNull(RelationParameters::fromArray([
             'db' => 'db',
             'pdf_pages' => ' invalid ',
             'table_coords' => 'table_coords',
             'pdfwork' => true,
         ])->pdfFeature);
-        $this->assertNull(RelationParameters::fromArray([
+        self::assertNull(RelationParameters::fromArray([
             'db' => 'db',
             'relation' => 'relation',
             'table_info' => ' invalid ',
             'displaywork' => true,
         ])->displayFeature);
-        $this->assertNull(RelationParameters::fromArray([
+        self::assertNull(RelationParameters::fromArray([
             'db' => 'db',
             'relation' => ' invalid ',
             'table_info' => 'table_info',
             'displaywork' => true,
         ])->displayFeature);
-        $this->assertNull(RelationParameters::fromArray([
+        self::assertNull(RelationParameters::fromArray([
             'db' => 'db',
             'usergroups' => 'usergroups',
             'users' => ' invalid ',
             'menuwork' => true,
         ])->configurableMenusFeature);
-        $this->assertNull(RelationParameters::fromArray([
+        self::assertNull(RelationParameters::fromArray([
             'db' => 'db',
             'usergroups' => ' invalid ',
             'users' => 'users',
@@ -102,18 +102,15 @@ class RelationParametersTest extends TestCase
             'displaywork' => true,
             'relwork' => true,
         ]);
-        $this->assertNotNull($relationParameters->browserTransformationFeature);
-        $this->assertNotNull($relationParameters->columnCommentsFeature);
-        $this->assertNotNull($relationParameters->displayFeature);
-        $this->assertNotNull($relationParameters->relationFeature);
-        $this->assertSame(
+        self::assertNotNull($relationParameters->browserTransformationFeature);
+        self::assertNotNull($relationParameters->columnCommentsFeature);
+        self::assertNotNull($relationParameters->displayFeature);
+        self::assertNotNull($relationParameters->relationFeature);
+        self::assertSame(
             $relationParameters->browserTransformationFeature->columnInfo,
             $relationParameters->columnCommentsFeature->columnInfo,
         );
-        $this->assertSame(
-            $relationParameters->relationFeature->relation,
-            $relationParameters->displayFeature->relation,
-        );
+        self::assertSame($relationParameters->relationFeature->relation, $relationParameters->displayFeature->relation);
 
         $relationParameters = RelationParameters::fromArray([
             'db' => 'db',
@@ -125,10 +122,10 @@ class RelationParametersTest extends TestCase
             'displaywork' => true,
             'relwork' => false,
         ]);
-        $this->assertNull($relationParameters->browserTransformationFeature);
-        $this->assertNotNull($relationParameters->columnCommentsFeature);
-        $this->assertNotNull($relationParameters->displayFeature);
-        $this->assertNull($relationParameters->relationFeature);
+        self::assertNull($relationParameters->browserTransformationFeature);
+        self::assertNotNull($relationParameters->columnCommentsFeature);
+        self::assertNotNull($relationParameters->displayFeature);
+        self::assertNull($relationParameters->relationFeature);
     }
 
     public function testFeaturesHaveSameDatabase(): void
@@ -173,44 +170,44 @@ class RelationParametersTest extends TestCase
             'uiprefswork' => true,
             'userconfigwork' => true,
         ]);
-        $this->assertInstanceOf(DatabaseName::class, $relationParameters->db);
-        $this->assertEquals('db', $relationParameters->db->getName());
-        $this->assertNotNull($relationParameters->bookmarkFeature);
-        $this->assertSame($relationParameters->db, $relationParameters->bookmarkFeature->database);
-        $this->assertNotNull($relationParameters->browserTransformationFeature);
-        $this->assertSame($relationParameters->db, $relationParameters->browserTransformationFeature->database);
-        $this->assertNotNull($relationParameters->centralColumnsFeature);
-        $this->assertSame($relationParameters->db, $relationParameters->centralColumnsFeature->database);
-        $this->assertNotNull($relationParameters->columnCommentsFeature);
-        $this->assertSame($relationParameters->db, $relationParameters->columnCommentsFeature->database);
-        $this->assertNotNull($relationParameters->configurableMenusFeature);
-        $this->assertSame($relationParameters->db, $relationParameters->configurableMenusFeature->database);
-        $this->assertNotNull($relationParameters->databaseDesignerSettingsFeature);
-        $this->assertSame($relationParameters->db, $relationParameters->databaseDesignerSettingsFeature->database);
-        $this->assertNotNull($relationParameters->displayFeature);
-        $this->assertSame($relationParameters->db, $relationParameters->displayFeature->database);
-        $this->assertNotNull($relationParameters->exportTemplatesFeature);
-        $this->assertSame($relationParameters->db, $relationParameters->exportTemplatesFeature->database);
-        $this->assertNotNull($relationParameters->favoriteTablesFeature);
-        $this->assertSame($relationParameters->db, $relationParameters->favoriteTablesFeature->database);
-        $this->assertNotNull($relationParameters->navigationItemsHidingFeature);
-        $this->assertSame($relationParameters->db, $relationParameters->navigationItemsHidingFeature->database);
-        $this->assertNotNull($relationParameters->pdfFeature);
-        $this->assertSame($relationParameters->db, $relationParameters->pdfFeature->database);
-        $this->assertNotNull($relationParameters->recentlyUsedTablesFeature);
-        $this->assertSame($relationParameters->db, $relationParameters->recentlyUsedTablesFeature->database);
-        $this->assertNotNull($relationParameters->relationFeature);
-        $this->assertSame($relationParameters->db, $relationParameters->relationFeature->database);
-        $this->assertNotNull($relationParameters->savedQueryByExampleSearchesFeature);
-        $this->assertSame($relationParameters->db, $relationParameters->savedQueryByExampleSearchesFeature->database);
-        $this->assertNotNull($relationParameters->sqlHistoryFeature);
-        $this->assertSame($relationParameters->db, $relationParameters->sqlHistoryFeature->database);
-        $this->assertNotNull($relationParameters->trackingFeature);
-        $this->assertSame($relationParameters->db, $relationParameters->trackingFeature->database);
-        $this->assertNotNull($relationParameters->uiPreferencesFeature);
-        $this->assertSame($relationParameters->db, $relationParameters->uiPreferencesFeature->database);
-        $this->assertNotNull($relationParameters->userPreferencesFeature);
-        $this->assertSame($relationParameters->db, $relationParameters->userPreferencesFeature->database);
+        self::assertInstanceOf(DatabaseName::class, $relationParameters->db);
+        self::assertEquals('db', $relationParameters->db->getName());
+        self::assertNotNull($relationParameters->bookmarkFeature);
+        self::assertSame($relationParameters->db, $relationParameters->bookmarkFeature->database);
+        self::assertNotNull($relationParameters->browserTransformationFeature);
+        self::assertSame($relationParameters->db, $relationParameters->browserTransformationFeature->database);
+        self::assertNotNull($relationParameters->centralColumnsFeature);
+        self::assertSame($relationParameters->db, $relationParameters->centralColumnsFeature->database);
+        self::assertNotNull($relationParameters->columnCommentsFeature);
+        self::assertSame($relationParameters->db, $relationParameters->columnCommentsFeature->database);
+        self::assertNotNull($relationParameters->configurableMenusFeature);
+        self::assertSame($relationParameters->db, $relationParameters->configurableMenusFeature->database);
+        self::assertNotNull($relationParameters->databaseDesignerSettingsFeature);
+        self::assertSame($relationParameters->db, $relationParameters->databaseDesignerSettingsFeature->database);
+        self::assertNotNull($relationParameters->displayFeature);
+        self::assertSame($relationParameters->db, $relationParameters->displayFeature->database);
+        self::assertNotNull($relationParameters->exportTemplatesFeature);
+        self::assertSame($relationParameters->db, $relationParameters->exportTemplatesFeature->database);
+        self::assertNotNull($relationParameters->favoriteTablesFeature);
+        self::assertSame($relationParameters->db, $relationParameters->favoriteTablesFeature->database);
+        self::assertNotNull($relationParameters->navigationItemsHidingFeature);
+        self::assertSame($relationParameters->db, $relationParameters->navigationItemsHidingFeature->database);
+        self::assertNotNull($relationParameters->pdfFeature);
+        self::assertSame($relationParameters->db, $relationParameters->pdfFeature->database);
+        self::assertNotNull($relationParameters->recentlyUsedTablesFeature);
+        self::assertSame($relationParameters->db, $relationParameters->recentlyUsedTablesFeature->database);
+        self::assertNotNull($relationParameters->relationFeature);
+        self::assertSame($relationParameters->db, $relationParameters->relationFeature->database);
+        self::assertNotNull($relationParameters->savedQueryByExampleSearchesFeature);
+        self::assertSame($relationParameters->db, $relationParameters->savedQueryByExampleSearchesFeature->database);
+        self::assertNotNull($relationParameters->sqlHistoryFeature);
+        self::assertSame($relationParameters->db, $relationParameters->sqlHistoryFeature->database);
+        self::assertNotNull($relationParameters->trackingFeature);
+        self::assertSame($relationParameters->db, $relationParameters->trackingFeature->database);
+        self::assertNotNull($relationParameters->uiPreferencesFeature);
+        self::assertSame($relationParameters->db, $relationParameters->uiPreferencesFeature->database);
+        self::assertNotNull($relationParameters->userPreferencesFeature);
+        self::assertSame($relationParameters->db, $relationParameters->userPreferencesFeature->database);
     }
 
     public function testHasAllFeatures(): void
@@ -255,10 +252,10 @@ class RelationParametersTest extends TestCase
             'uiprefswork' => true,
             'userconfigwork' => true,
         ];
-        $this->assertFalse(RelationParameters::fromArray([])->hasAllFeatures());
-        $this->assertTrue(RelationParameters::fromArray($params)->hasAllFeatures());
+        self::assertFalse(RelationParameters::fromArray([])->hasAllFeatures());
+        self::assertTrue(RelationParameters::fromArray($params)->hasAllFeatures());
         $params['bookmarkwork'] = false;
-        $this->assertFalse(RelationParameters::fromArray($params)->hasAllFeatures());
+        self::assertFalse(RelationParameters::fromArray($params)->hasAllFeatures());
     }
 
     /**
@@ -268,7 +265,7 @@ class RelationParametersTest extends TestCase
     #[DataProvider('providerForTestToArray')]
     public function testToArray(array $params, array $expected): void
     {
-        $this->assertSame($expected, RelationParameters::fromArray($params)->toArray());
+        self::assertSame($expected, RelationParameters::fromArray($params)->toArray());
     }
 
     /** @return array<string, array<int, array<string, mixed>>> */
diff --git a/tests/classes/ConfigStorage/RelationTest.php b/tests/classes/ConfigStorage/RelationTest.php
index 4fe0a1157f..9a7006911f 100644
--- a/tests/classes/ConfigStorage/RelationTest.php
+++ b/tests/classes/ConfigStorage/RelationTest.php
@@ -42,7 +42,7 @@ class RelationTest extends AbstractTestCase
         $dummyDbi->addSelectDb('phpmyadmin');
         $db = 'information_schema';
         $table = 'CHARACTER_SETS';
-        $this->assertEquals(
+        self::assertEquals(
             'DESCRIPTION',
             $relation->getDisplayField($db, $table),
         );
@@ -50,14 +50,14 @@ class RelationTest extends AbstractTestCase
 
         $db = 'information_schema';
         $table = 'TABLES';
-        $this->assertEquals(
+        self::assertEquals(
             'TABLE_COMMENT',
             $relation->getDisplayField($db, $table),
         );
 
         $db = 'information_schema';
         $table = 'PMA';
-        $this->assertSame(
+        self::assertSame(
             '',
             $relation->getDisplayField($db, $table),
         );
@@ -80,7 +80,7 @@ class RelationTest extends AbstractTestCase
             new ColumnFull('field1', 'int(11)', null, false, '', null, '', '', 'Comment1'),
             new ColumnFull('field2', 'text', null, false, '', null, '', '', 'Comment1'),
         ];
-        $dbi->expects($this->any())->method('getColumns')
+        $dbi->expects(self::any())->method('getColumns')
             ->willReturn($getColumnsResult);
 
         $relation = new Relation($dbi);
@@ -88,14 +88,14 @@ class RelationTest extends AbstractTestCase
         DatabaseInterface::$instance = $dbi;
 
         $db = 'information_schema';
-        $this->assertEquals(
+        self::assertEquals(
             [''],
             $relation->getComments($db),
         );
 
         $db = 'information_schema';
         $table = 'TABLES';
-        $this->assertEquals(
+        self::assertEquals(
             ['field1' => 'Comment1', 'field2' => 'Comment1'],
             $relation->getComments($db, $table),
         );
@@ -106,18 +106,18 @@ class RelationTest extends AbstractTestCase
      */
     public function testPMATryUpgradeTransformations(): void
     {
-        $resultStub = $this->createMock(DummyResult::class);
+        $resultStub = self::createMock(DummyResult::class);
 
         $dbi = $this->getMockBuilder(DatabaseInterface::class)
             ->disableOriginalConstructor()
             ->getMock();
-        $dbi->expects($this->any())
+        $dbi->expects(self::any())
             ->method('tryQueryAsControlUser')
             ->willReturn($resultStub);
-        $resultStub->expects($this->any())
+        $resultStub->expects(self::any())
             ->method('numRows')
             ->willReturn(0);
-        $dbi->expects($this->any())
+        $dbi->expects(self::any())
             ->method('getError')
             ->willReturn('Error', '');
         DatabaseInterface::$instance = $dbi;
@@ -130,17 +130,17 @@ class RelationTest extends AbstractTestCase
 
         // Case 1
         $actual = $relation->tryUpgradeTransformations();
-        $this->assertFalse($actual);
+        self::assertFalse($actual);
 
         // Case 2
         $actual = $relation->tryUpgradeTransformations();
-        $this->assertTrue($actual);
+        self::assertTrue($actual);
     }
 
     public function testSearchColumnInForeignersError(): void
     {
         $relation = new Relation($this->createDatabaseInterface());
-        $this->assertFalse($relation->searchColumnInForeigners([], 'id'));
+        self::assertFalse($relation->searchColumnInForeigners([], 'id'));
     }
 
     /**
@@ -179,7 +179,7 @@ class RelationTest extends AbstractTestCase
         $expected['on_delete'] = 'CASCADE';
         $expected['on_update'] = 'CASCADE';
 
-        $this->assertEquals($expected, $foreigner);
+        self::assertEquals($expected, $foreigner);
     }
 
     public function testFixPmaTablesNothingWorks(): void
@@ -251,7 +251,7 @@ class RelationTest extends AbstractTestCase
             'userconfigwork' => true,
             'userconfig' => 'pma__userconfig',
         ]);
-        $this->assertSame($relationParameters->toArray(), $relation->getRelationParameters()->toArray());
+        self::assertSame($relationParameters->toArray(), $relation->getRelationParameters()->toArray());
 
         $dummyDbi->assertAllQueriesConsumed();
         $dummyDbi->assertAllSelectsConsumed();
@@ -510,20 +510,20 @@ class RelationTest extends AbstractTestCase
             true,
         );
 
-        $this->assertSame('', $config->selectedServer['pmadb']);
+        self::assertSame('', $config->selectedServer['pmadb']);
 
         (new ReflectionProperty(Relation::class, 'cache'))->setValue(null, null);
 
         $relation->fixPmaTables('db_pma', true);
-        $this->assertArrayNotHasKey('message', $GLOBALS);
-        $this->assertSame('db_pma', $config->selectedServer['pmadb']);
+        self::assertArrayNotHasKey('message', $GLOBALS);
+        self::assertSame('db_pma', $config->selectedServer['pmadb']);
 
         $relationParameters = RelationParameters::fromArray([
             'db' => 'db_pma',
             'userconfigwork' => true,
             'userconfig' => 'pma__userconfig',
         ]);
-        $this->assertSame($relationParameters->toArray(), $relation->getRelationParameters()->toArray());
+        self::assertSame($relationParameters->toArray(), $relation->getRelationParameters()->toArray());
 
         $dummyDbi->assertAllQueriesConsumed();
         $dummyDbi->assertAllSelectsConsumed();
@@ -790,22 +790,22 @@ class RelationTest extends AbstractTestCase
             true,
         );
 
-        $this->assertSame('db_pma', $config->selectedServer['pmadb']);
+        self::assertSame('db_pma', $config->selectedServer['pmadb']);
 
         (new ReflectionProperty(Relation::class, 'cache'))->setValue(null, null);
 
         $dummyDbi->addSelectDb('db_pma');
         $dummyDbi->addSelectDb('db_pma');
         $relation->fixPmaTables('db_pma', true);
-        $this->assertArrayNotHasKey('message', $GLOBALS);
-        $this->assertSame('db_pma', $config->selectedServer['pmadb']);
+        self::assertArrayNotHasKey('message', $GLOBALS);
+        self::assertSame('db_pma', $config->selectedServer['pmadb']);
 
         $relationParameters = RelationParameters::fromArray([
             'db' => 'db_pma',
             'userconfigwork' => true,
             'userconfig' => 'pma__userconfig',
         ]);
-        $this->assertSame($relationParameters->toArray(), $relation->getRelationParameters()->toArray());
+        self::assertSame($relationParameters->toArray(), $relation->getRelationParameters()->toArray());
 
         $dummyDbi->assertAllQueriesConsumed();
         $dummyDbi->assertAllSelectsConsumed();
@@ -865,17 +865,17 @@ class RelationTest extends AbstractTestCase
         );
         $dummyDbi->addSelectDb('db_pma');
 
-        $this->assertSame('', $config->selectedServer['pmadb']);
+        self::assertSame('', $config->selectedServer['pmadb']);
 
         (new ReflectionProperty(Relation::class, 'cache'))->setValue(null, null);
 
         $relation->fixPmaTables('db_pma', true);
 
-        $this->assertArrayHasKey('message', $GLOBALS);
-        $this->assertSame('MYSQL_ERROR', $GLOBALS['message']);
-        $this->assertSame('', $config->selectedServer['pmadb']);
+        self::assertArrayHasKey('message', $GLOBALS);
+        self::assertSame('MYSQL_ERROR', $GLOBALS['message']);
+        self::assertSame('', $config->selectedServer['pmadb']);
 
-        $this->assertNull((new ReflectionProperty(Relation::class, 'cache'))->getValue());
+        self::assertNull((new ReflectionProperty(Relation::class, 'cache'))->getValue());
 
         $dummyDbi->assertAllQueriesConsumed();
         $dummyDbi->assertAllErrorCodesConsumed();
@@ -902,13 +902,13 @@ class RelationTest extends AbstractTestCase
         );
         $dummyDbi->addSelectDb('phpmyadmin');
 
-        $this->assertArrayNotHasKey('errno', $GLOBALS);
+        self::assertArrayNotHasKey('errno', $GLOBALS);
 
-        $this->assertTrue(
+        self::assertTrue(
             $relation->createPmaDatabase('phpmyadmin'),
         );
 
-        $this->assertArrayNotHasKey('message', $GLOBALS);
+        self::assertArrayNotHasKey('message', $GLOBALS);
 
         $dummyDbi->assertAllQueriesConsumed();
         $dummyDbi->assertAllErrorCodesConsumed();
@@ -928,12 +928,12 @@ class RelationTest extends AbstractTestCase
 
         $GLOBALS['errno'] = 1044;// ER_DBACCESS_DENIED_ERROR
 
-        $this->assertFalse(
+        self::assertFalse(
             $relation->createPmaDatabase('phpmyadmin'),
         );
 
-        $this->assertArrayHasKey('message', $GLOBALS);
-        $this->assertSame(
+        self::assertArrayHasKey('message', $GLOBALS);
+        self::assertSame(
             'You do not have necessary privileges to create a database named'
             . ' \'phpmyadmin\'. You may go to \'Operations\' tab of any'
             . ' database to set up the phpMyAdmin configuration storage there.',
@@ -957,12 +957,12 @@ class RelationTest extends AbstractTestCase
 
         $GLOBALS['errno'] = 1040;
 
-        $this->assertFalse(
+        self::assertFalse(
             $relation->createPmaDatabase('pma_1040'),
         );
 
-        $this->assertArrayHasKey('message', $GLOBALS);
-        $this->assertSame('Too many connections', $GLOBALS['message']);
+        self::assertArrayHasKey('message', $GLOBALS);
+        self::assertSame('Too many connections', $GLOBALS['message']);
 
         $dummyDbi->assertAllQueriesConsumed();
         $dummyDbi->assertAllErrorCodesConsumed();
@@ -1363,7 +1363,7 @@ class RelationTest extends AbstractTestCase
             ]),
         ];
 
-        $this->assertSame(
+        self::assertSame(
             $data,
             $relation->getCreateTableSqlQueries([]),
         );
@@ -1390,7 +1390,7 @@ class RelationTest extends AbstractTestCase
             '  DEFAULT CHARACTER SET utf8 COLLATE utf8_bin;',
         ]);
 
-        $this->assertSame(
+        self::assertSame(
             $data,
             $relation->getCreateTableSqlQueries(['pma__export_templates' => 'db_exporttemplates_pma']),
         );
@@ -1436,9 +1436,9 @@ class RelationTest extends AbstractTestCase
 
         // Should all be false for server = 0
         $relationParameters = RelationParameters::fromArray([]);
-        $this->assertSame($relationParameters->toArray(), $relation->getRelationParameters()->toArray());
+        self::assertSame($relationParameters->toArray(), $relation->getRelationParameters()->toArray());
 
-        $this->assertEquals([
+        self::assertEquals([
             'userconfig' => 'pma__userconfig',
             'pmadb' => false,// This is the expected value for server = 0
         ], $config->selectedServer);
@@ -1503,9 +1503,9 @@ class RelationTest extends AbstractTestCase
             'userconfigwork' => true,
             'userconfig' => 'pma__userconfig',
         ]);
-        $this->assertSame($relationParameters->toArray(), $relation->getRelationParameters()->toArray());
+        self::assertSame($relationParameters->toArray(), $relation->getRelationParameters()->toArray());
 
-        $this->assertSame([
+        self::assertSame([
             'user' => '',
             'pmadb' => 'phpmyadmin',
             'bookmarktable' => '',
@@ -1589,9 +1589,9 @@ class RelationTest extends AbstractTestCase
             'userconfigwork' => false,
             'userconfig' => 'pma__userconfig',
         ]);
-        $this->assertSame($relationParameters->toArray(), $relation->getRelationParameters()->toArray());
+        self::assertSame($relationParameters->toArray(), $relation->getRelationParameters()->toArray());
 
-        $this->assertSame([
+        self::assertSame([
             'user' => '',
             'pmadb' => 'phpmyadmin',
             'bookmarktable' => '',
@@ -1670,7 +1670,7 @@ class RelationTest extends AbstractTestCase
         $relation = new Relation($dbi);
         $relation->initRelationParamsCache();
 
-        $this->assertArrayHasKey(
+        self::assertArrayHasKey(
             'relation',
             $relation->getRelationParameters()->toArray(),
             'The cache is expected to be filled because the custom override'
@@ -1698,9 +1698,9 @@ class RelationTest extends AbstractTestCase
             'userconfigwork' => true,
             'userconfig' => 'pma__userconfig_custom',
         ]);
-        $this->assertSame($relationParameters->toArray(), $relationData->toArray());
+        self::assertSame($relationParameters->toArray(), $relationData->toArray());
 
-        $this->assertSame([
+        self::assertSame([
             'user' => '',
             'pmadb' => 'PMA-storage',
             'bookmarktable' => '',
@@ -1785,7 +1785,7 @@ class RelationTest extends AbstractTestCase
          * The method above does't initialize Relation param cache.
          * A proper test is needed to verify that the user disabled features result in disabled Relation cache.
          */
-        $this->assertArrayHasKey(
+        self::assertArrayHasKey(
             'relation',
             $relation->getRelationParameters()->toArray(),
             'The cache is expected to be filled because the custom override'
@@ -1816,10 +1816,10 @@ class RelationTest extends AbstractTestCase
             'trackingwork' => false,
             'tracking' => false,
         ]);
-        $this->assertSame($relationParameters->toArray(), $relationData->toArray());
-        $this->assertNull($relationParameters->trackingFeature, 'The feature should not be enabled');
+        self::assertSame($relationParameters->toArray(), $relationData->toArray());
+        self::assertNull($relationParameters->trackingFeature, 'The feature should not be enabled');
 
-        $this->assertSame([
+        self::assertSame([
             'user' => '',
             'pmadb' => 'PMA-storage',
             'bookmarktable' => '',
@@ -1904,7 +1904,7 @@ class RelationTest extends AbstractTestCase
         $relation = new Relation($dbi);
         $relation->initRelationParamsCache();
 
-        $this->assertArrayHasKey(
+        self::assertArrayHasKey(
             'relation',
             $relation->getRelationParameters()->toArray(),
             'The cache is expected to be filled because the custom override'
@@ -1924,10 +1924,10 @@ class RelationTest extends AbstractTestCase
             'favorite' => 'pma__favorite_custom',
             'favoritework' => true,
         ]);
-        $this->assertSame($relationParameters->toArray(), $relationData->toArray());
-        $this->assertNull($relationParameters->trackingFeature, 'The feature should not be enabled');
+        self::assertSame($relationParameters->toArray(), $relationData->toArray());
+        self::assertNull($relationParameters->trackingFeature, 'The feature should not be enabled');
 
-        $this->assertSame([
+        self::assertSame([
             'user' => '',
             'pmadb' => 'PMA-storage',
             'bookmarktable' => '',
@@ -1984,8 +1984,8 @@ class RelationTest extends AbstractTestCase
 
         $relation = new Relation($dbi);
 
-        $this->assertFalse($relation->arePmadbTablesDefined());
-        $this->assertFalse($relation->arePmadbTablesAllDisabled());
+        self::assertFalse($relation->arePmadbTablesDefined());
+        self::assertFalse($relation->arePmadbTablesAllDisabled());
 
         $config->selectedServer['bookmarktable'] = '';
         $config->selectedServer['relation'] = '';
@@ -2007,8 +2007,8 @@ class RelationTest extends AbstractTestCase
         $config->selectedServer['designer_settings'] = '';
         $config->selectedServer['export_templates'] = '';
 
-        $this->assertFalse($relation->arePmadbTablesDefined());
-        $this->assertFalse($relation->arePmadbTablesAllDisabled());
+        self::assertFalse($relation->arePmadbTablesDefined());
+        self::assertFalse($relation->arePmadbTablesAllDisabled());
 
         $config->selectedServer['bookmarktable'] = 'pma__bookmark';
         $config->selectedServer['relation'] = 'pma__relation';
@@ -2030,8 +2030,8 @@ class RelationTest extends AbstractTestCase
         $config->selectedServer['designer_settings'] = 'pma__designer_settings';
         $config->selectedServer['export_templates'] = 'pma__export_templates';
 
-        $this->assertTrue($relation->arePmadbTablesDefined());
-        $this->assertFalse($relation->arePmadbTablesAllDisabled());
+        self::assertTrue($relation->arePmadbTablesDefined());
+        self::assertFalse($relation->arePmadbTablesAllDisabled());
 
         $config->selectedServer['bookmarktable'] = 'pma__bookmark';
         $config->selectedServer['relation'] = 'pma__relation';
@@ -2053,8 +2053,8 @@ class RelationTest extends AbstractTestCase
         $config->selectedServer['designer_settings'] = 'pma__designer_settings';
         $config->selectedServer['export_templates'] = 'pma__export_templates';
 
-        $this->assertTrue($relation->arePmadbTablesDefined());
-        $this->assertFalse($relation->arePmadbTablesAllDisabled());
+        self::assertTrue($relation->arePmadbTablesDefined());
+        self::assertFalse($relation->arePmadbTablesAllDisabled());
 
         $config->selectedServer['bookmarktable'] = 'pma__bookmark';
         $config->selectedServer['relation'] = 'pma__relation';
@@ -2076,8 +2076,8 @@ class RelationTest extends AbstractTestCase
         $config->selectedServer['designer_settings'] = 'pma__designer_settings';
         $config->selectedServer['export_templates'] = 'pma__export_templates';
 
-        $this->assertFalse($relation->arePmadbTablesDefined());
-        $this->assertFalse($relation->arePmadbTablesAllDisabled());
+        self::assertFalse($relation->arePmadbTablesDefined());
+        self::assertFalse($relation->arePmadbTablesAllDisabled());
 
         $config->selectedServer['bookmarktable'] = false; //'pma__bookmark';
         $config->selectedServer['relation'] = false; //'pma__relation';
@@ -2099,8 +2099,8 @@ class RelationTest extends AbstractTestCase
         $config->selectedServer['designer_settings'] = false; //'pma__designer_settings';
         $config->selectedServer['export_templates'] = false; //'pma__export_templates';
 
-        $this->assertFalse($relation->arePmadbTablesDefined());
-        $this->assertTrue($relation->arePmadbTablesAllDisabled());
+        self::assertFalse($relation->arePmadbTablesDefined());
+        self::assertTrue($relation->arePmadbTablesAllDisabled());
     }
 
     /**
diff --git a/tests/classes/ConfigStorage/UserGroupsTest.php b/tests/classes/ConfigStorage/UserGroupsTest.php
index a14603cbe6..b1716a234d 100644
--- a/tests/classes/ConfigStorage/UserGroupsTest.php
+++ b/tests/classes/ConfigStorage/UserGroupsTest.php
@@ -49,24 +49,24 @@ class UserGroupsTest extends AbstractTestCase
     {
         $expectedQuery = 'SELECT * FROM `pmadb`.`usergroups` ORDER BY `usergroup` ASC';
 
-        $resultStub = $this->createMock(DummyResult::class);
+        $resultStub = self::createMock(DummyResult::class);
 
         $dbi = $this->getMockBuilder(DatabaseInterface::class)
             ->disableOriginalConstructor()
             ->getMock();
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('tryQueryAsControlUser')
             ->with($expectedQuery)
             ->willReturn($resultStub);
-        $resultStub->expects($this->once())
+        $resultStub->expects(self::once())
             ->method('numRows')
             ->willReturn(0);
         DatabaseInterface::$instance = $dbi;
 
         $html = UserGroups::getHtmlForUserGroupsTable($this->configurableMenusFeature);
-        $this->assertStringNotContainsString('<table id="userGroupsTable">', $html);
+        self::assertStringNotContainsString('<table id="userGroupsTable">', $html);
         $urlTag = '<a class="btn btn-primary" href="' . Url::getFromRoute('/server/user-groups', ['addUserGroup' => 1]);
-        $this->assertStringContainsString($urlTag, $html);
+        self::assertStringContainsString($urlTag, $html);
     }
 
     /**
@@ -75,14 +75,14 @@ class UserGroupsTest extends AbstractTestCase
     public function testGetHtmlForUserGroupsTableWithUserGroups(): void
     {
         $html = UserGroups::getHtmlForUserGroupsTable($this->configurableMenusFeature);
-        $this->assertStringContainsString('<td>user&lt;br&gt;group</td>', $html);
+        self::assertStringContainsString('<td>user&lt;br&gt;group</td>', $html);
         $urlTag = '<a class="" href="' . Url::getFromRoute('/server/user-groups') . '" data-post="'
             . Url::getCommon(['viewUsers' => 1, 'userGroup' => 'user<br>group'], '');
-        $this->assertStringContainsString($urlTag, $html);
+        self::assertStringContainsString($urlTag, $html);
         $urlTag = '<a class="" href="' . Url::getFromRoute('/server/user-groups') . '" data-post="'
             . Url::getCommon(['editUserGroup' => 1, 'userGroup' => 'user<br>group'], '');
-        $this->assertStringContainsString($urlTag, $html);
-        $this->assertStringContainsString(
+        self::assertStringContainsString($urlTag, $html);
+        self::assertStringContainsString(
             '<button type="button" class="btn btn-link" data-bs-toggle="modal"'
             . ' data-bs-target="#deleteUserGroupModal" data-user-group="user&lt;br&gt;group">',
             $html,
@@ -97,13 +97,13 @@ class UserGroupsTest extends AbstractTestCase
         $userDelQuery = 'DELETE FROM `pmadb`.`users` WHERE `usergroup`=\'ug\'';
         $userGrpDelQuery = 'DELETE FROM `pmadb`.`usergroups` WHERE `usergroup`=\'ug\'';
 
-        $result = $this->createStub(ResultInterface::class);
-        $dbi = $this->createMock(DatabaseInterface::class);
-        $dbi->expects($this->exactly(2))->method('queryAsControlUser')->willReturnMap([
+        $result = self::createStub(ResultInterface::class);
+        $dbi = self::createMock(DatabaseInterface::class);
+        $dbi->expects(self::exactly(2))->method('queryAsControlUser')->willReturnMap([
             [$userDelQuery, $result],
             [$userGrpDelQuery, $result],
         ]);
-        $dbi->expects($this->any())->method('quoteString')
+        $dbi->expects(self::any())->method('quoteString')
             ->willReturnCallback(static fn (string $string): string => "'" . $string . "'");
 
         UserGroups::delete($dbi, $this->configurableMenusFeature, 'ug');
@@ -116,41 +116,41 @@ class UserGroupsTest extends AbstractTestCase
     {
         // adding a user group
         $html = UserGroups::getHtmlToEditUserGroup($this->configurableMenusFeature);
-        $this->assertStringContainsString('<input type="hidden" name="addUserGroupSubmit" value="1"', $html);
-        $this->assertStringContainsString('<input class="form-control" type="text" name="userGroup"', $html);
+        self::assertStringContainsString('<input type="hidden" name="addUserGroupSubmit" value="1"', $html);
+        self::assertStringContainsString('<input class="form-control" type="text" name="userGroup"', $html);
 
-        $resultStub = $this->createMock(DummyResult::class);
+        $resultStub = self::createMock(DummyResult::class);
 
         $expectedQuery = 'SELECT * FROM `pmadb`.`usergroups` WHERE `usergroup`=\'user<br>group\'';
         $dbi = $this->getMockBuilder(DatabaseInterface::class)
             ->disableOriginalConstructor()
             ->getMock();
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('tryQueryAsControlUser')
             ->with($expectedQuery)
             ->willReturn($resultStub);
-        $resultStub->expects($this->exactly(1))
+        $resultStub->expects(self::exactly(1))
             ->method('getIterator')
             ->willReturnCallback(static function (): Generator {
                 yield from [['usergroup' => 'user<br>group', 'tab' => 'server_sql', 'allowed' => 'Y']];
             });
-        $dbi->expects($this->any())->method('quoteString')
+        $dbi->expects(self::any())->method('quoteString')
             ->willReturnCallback(static fn (string $string): string => "'" . $string . "'");
 
         DatabaseInterface::$instance = $dbi;
 
         // editing a user group
         $html = UserGroups::getHtmlToEditUserGroup($this->configurableMenusFeature, 'user<br>group');
-        $this->assertStringContainsString('Edit user group: \'user&lt;br&gt;group\'', $html);
-        $this->assertStringContainsString('<input type="hidden" name="userGroup" value="user&lt;br&gt;group"', $html);
-        $this->assertStringContainsString('<input type="hidden" name="editUserGroupSubmit" value="1"', $html);
-        $this->assertStringContainsString('<input type="hidden" name="editUserGroupSubmit" value="1"', $html);
-        $this->assertStringContainsString(
+        self::assertStringContainsString('Edit user group: \'user&lt;br&gt;group\'', $html);
+        self::assertStringContainsString('<input type="hidden" name="userGroup" value="user&lt;br&gt;group"', $html);
+        self::assertStringContainsString('<input type="hidden" name="editUserGroupSubmit" value="1"', $html);
+        self::assertStringContainsString('<input type="hidden" name="editUserGroupSubmit" value="1"', $html);
+        self::assertStringContainsString(
             '<input class="form-check-input checkall" type="checkbox"'
             . ' checked="checked" name="server_sql" id="server_sql" value="Y">',
             $html,
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             '<input class="form-check-input checkall" type="checkbox"'
             . ' name="server_databases" id="server_databases" value="Y">',
             $html,
@@ -166,8 +166,8 @@ class UserGroupsTest extends AbstractTestCase
         $dummyDbi->addResult('SELECT `username` FROM `pmadb`.`users` WHERE `usergroup`=\'user<br>group\'', []);
 
         $output = UserGroups::getHtmlForListingUsersofAGroup($this->configurableMenusFeature, 'user<br>group');
-        $this->assertStringContainsString('Users of \'user&lt;br&gt;group\' user group', $output);
-        $this->assertStringContainsString('No users were found belonging to this user group.', $output);
+        self::assertStringContainsString('Users of \'user&lt;br&gt;group\' user group', $output);
+        self::assertStringContainsString('No users were found belonging to this user group.', $output);
     }
 
     public function testGetHtmlForListingUsersOfAGroupWithUsers(): void
@@ -183,11 +183,11 @@ class UserGroupsTest extends AbstractTestCase
         );
 
         $output = UserGroups::getHtmlForListingUsersofAGroup($this->configurableMenusFeature, 'user<br>group');
-        $this->assertStringContainsString('Users of \'user&lt;br&gt;group\' user group', $output);
-        $this->assertStringContainsString('<td>1</td>', $output);
-        $this->assertStringContainsString('<td>user&lt;br&gt;one</td>', $output);
-        $this->assertStringContainsString('<td>2</td>', $output);
-        $this->assertStringContainsString('<td>user&lt;br&gt;two</td>', $output);
-        $this->assertStringNotContainsString('No users were found belonging to this user group.', $output);
+        self::assertStringContainsString('Users of \'user&lt;br&gt;group\' user group', $output);
+        self::assertStringContainsString('<td>1</td>', $output);
+        self::assertStringContainsString('<td>user&lt;br&gt;one</td>', $output);
+        self::assertStringContainsString('<td>2</td>', $output);
+        self::assertStringContainsString('<td>user&lt;br&gt;two</td>', $output);
+        self::assertStringNotContainsString('No users were found belonging to this user group.', $output);
     }
 }
diff --git a/tests/classes/ConfigTest.php b/tests/classes/ConfigTest.php
index 235af49856..76740aa47d 100644
--- a/tests/classes/ConfigTest.php
+++ b/tests/classes/ConfigTest.php
@@ -91,18 +91,18 @@ class ConfigTest extends AbstractTestCase
         $defaultConfig = $this->createConfig();
         $tmpConfig = tempnam('./', 'config.test.inc.php');
         if ($tmpConfig === false) {
-            $this->markTestSkipped('Creating a temporary file does not work');
+            self::markTestSkipped('Creating a temporary file does not work');
         }
 
-        $this->assertFileExists($tmpConfig);
+        self::assertFileExists($tmpConfig);
 
         // end of setup
 
         // Test loading an empty file does not change the default config
         $config = new Config();
         $config->loadAndCheck($tmpConfig);
-        $this->assertSame($defaultConfig->settings, $config->settings);
-        $this->assertEquals($defaultConfig->getSettings(), $config->getSettings());
+        self::assertSame($defaultConfig->settings, $config->settings);
+        self::assertEquals($defaultConfig->getSettings(), $config->getSettings());
 
         $contents = <<<'PHP'
 <?php
@@ -115,15 +115,15 @@ PHP;
         $config = new Config();
         $config->loadAndCheck($tmpConfig);
         $defaultConfig->set('environment', 'development');
-        $this->assertSame($defaultConfig->settings, $config->settings);
-        $this->assertArrayHasKey('environment', $config->settings);
-        $this->assertSame($config->settings['environment'], 'development');
-        $this->assertArrayNotHasKey('UnknownKey', $config->settings);
-        $this->assertEquals($defaultConfig->getSettings(), $config->getSettings());
+        self::assertSame($defaultConfig->settings, $config->settings);
+        self::assertArrayHasKey('environment', $config->settings);
+        self::assertSame($config->settings['environment'], 'development');
+        self::assertArrayNotHasKey('UnknownKey', $config->settings);
+        self::assertEquals($defaultConfig->getSettings(), $config->getSettings());
 
         // Teardown
         unlink($tmpConfig);
-        $this->assertFalse(file_exists($tmpConfig));
+        self::assertFalse(file_exists($tmpConfig));
     }
 
     /**
@@ -134,7 +134,7 @@ PHP;
     {
         $this->object->checkSystem();
 
-        $this->assertIsBool($this->object->get('PMA_IS_WINDOWS'));
+        self::assertIsBool($this->object->get('PMA_IS_WINDOWS'));
     }
 
     /**
@@ -147,13 +147,13 @@ PHP;
         $this->object->set('PMA_USR_BROWSER_AGENT', 'IE');
         $this->object->set('PMA_USR_BROWSER_VER', 6);
         $this->object->checkOutputCompression();
-        $this->assertTrue($this->object->get('OBGzip'));
+        self::assertTrue($this->object->get('OBGzip'));
 
         $this->object->set('OBGzip', 'auto');
         $this->object->set('PMA_USR_BROWSER_AGENT', 'MOZILLA');
         $this->object->set('PMA_USR_BROWSER_VER', 5);
         $this->object->checkOutputCompression();
-        $this->assertTrue($this->object->get('OBGzip'));
+        self::assertTrue($this->object->get('OBGzip'));
     }
 
     /**
@@ -173,14 +173,14 @@ PHP;
     ): void {
         $_SERVER['HTTP_USER_AGENT'] = $agent;
         $this->object->checkClient();
-        $this->assertEquals($os, $this->object->get('PMA_USR_OS'));
-        $this->assertEquals($browser, $this->object->get('PMA_USR_BROWSER_AGENT'));
+        self::assertEquals($os, $this->object->get('PMA_USR_OS'));
+        self::assertEquals($browser, $this->object->get('PMA_USR_BROWSER_AGENT'));
 
         if ($version === null) {
             return;
         }
 
-        $this->assertEquals(
+        self::assertEquals(
             $version,
             $this->object->get('PMA_USR_BROWSER_VER'),
         );
@@ -258,17 +258,17 @@ PHP;
     {
         $this->object->set('GD2Available', 'yes');
         $this->object->checkGd2();
-        $this->assertEquals(1, $this->object->get('PMA_IS_GD2'));
+        self::assertEquals(1, $this->object->get('PMA_IS_GD2'));
 
         $this->object->set('GD2Available', 'no');
         $this->object->checkGd2();
-        $this->assertEquals(0, $this->object->get('PMA_IS_GD2'));
+        self::assertEquals(0, $this->object->get('PMA_IS_GD2'));
 
         $this->object->set('GD2Available', 'auto');
 
         if (! function_exists('imagecreatetruecolor')) {
             $this->object->checkGd2();
-            $this->assertEquals(
+            self::assertEquals(
                 0,
                 $this->object->get('PMA_IS_GD2'),
                 'imagecreatetruecolor does not exist, PMA_IS_GD2 should be 0',
@@ -279,13 +279,13 @@ PHP;
             $this->object->checkGd2();
             $gdNfo = gd_info();
             if (str_contains($gdNfo['GD Version'], '2.')) {
-                $this->assertEquals(
+                self::assertEquals(
                     1,
                     $this->object->get('PMA_IS_GD2'),
                     'GD Version >= 2, PMA_IS_GD2 should be 1',
                 );
             } else {
-                $this->assertEquals(
+                self::assertEquals(
                     0,
                     $this->object->get('PMA_IS_GD2'),
                     'GD Version < 2, PMA_IS_GD2 should be 0',
@@ -305,13 +305,13 @@ PHP;
 
         // TODO: The variable $v clearly is incorrect. Was this meant to be $a?
         if (str_contains($v, '2.')) {
-            $this->assertEquals(
+            self::assertEquals(
                 1,
                 $this->object->get('PMA_IS_GD2'),
                 'PMA_IS_GD2 should be 1',
             );
         } else {
-            $this->assertEquals(
+            self::assertEquals(
                 0,
                 $this->object->get('PMA_IS_GD2'),
                 'PMA_IS_GD2 should be 0',
@@ -328,21 +328,21 @@ PHP;
 
         if (defined('PHP_OS')) {
             if (stristr(PHP_OS, 'darwin')) {
-                $this->assertFalse($this->object->get('PMA_IS_WINDOWS'));
+                self::assertFalse($this->object->get('PMA_IS_WINDOWS'));
             } elseif (stristr(PHP_OS, 'win')) {
-                $this->assertTrue($this->object->get('PMA_IS_WINDOWS'));
+                self::assertTrue($this->object->get('PMA_IS_WINDOWS'));
             } elseif (stristr(PHP_OS, 'OS/2')) {
-                $this->assertTrue($this->object->get('PMA_IS_WINDOWS'));
+                self::assertTrue($this->object->get('PMA_IS_WINDOWS'));
             } elseif (stristr(PHP_OS, 'Linux')) {
-                $this->assertFalse($this->object->get('PMA_IS_WINDOWS'));
+                self::assertFalse($this->object->get('PMA_IS_WINDOWS'));
             } else {
-                $this->markTestIncomplete('Not known PHP_OS: ' . PHP_OS);
+                self::markTestIncomplete('Not known PHP_OS: ' . PHP_OS);
             }
         } else {
-            $this->assertEquals(0, $this->object->get('PMA_IS_WINDOWS'));
+            self::assertEquals(0, $this->object->get('PMA_IS_WINDOWS'));
 
             define('PHP_OS', 'Windows');
-            $this->assertTrue($this->object->get('PMA_IS_WINDOWS'));
+            self::assertTrue($this->object->get('PMA_IS_WINDOWS'));
         }
     }
 
@@ -351,11 +351,11 @@ PHP;
         $object = new Config();
         $settings = new Settings([]);
         $config = $settings->asArray();
-        $this->assertIsArray($config['Servers']);
-        $this->assertEquals($settings, $object->getSettings());
-        $this->assertEquals($config, $object->default);
-        $this->assertSame($config, $object->settings);
-        $this->assertSame($config, $object->baseSettings);
+        self::assertIsArray($config['Servers']);
+        self::assertEquals($settings, $object->getSettings());
+        self::assertEquals($config, $object->default);
+        self::assertSame($config, $object->settings);
+        self::assertSame($config, $object->baseSettings);
     }
 
     /**
@@ -364,13 +364,13 @@ PHP;
     public function testCheckConfigSource(): void
     {
         $this->object->setSource('unexisted.config.php');
-        $this->assertFalse($this->object->checkConfigSource());
-        $this->assertEquals(0, $this->object->sourceMtime);
+        self::assertFalse($this->object->checkConfigSource());
+        self::assertEquals(0, $this->object->sourceMtime);
 
         $this->object->setSource(TEST_PATH . 'tests/test_data/config.inc.php');
 
-        $this->assertNotEmpty($this->object->getSource());
-        $this->assertTrue($this->object->checkConfigSource());
+        self::assertNotEmpty($this->object->getSource());
+        self::assertTrue($this->object->checkConfigSource());
     }
 
     /**
@@ -378,11 +378,11 @@ PHP;
      */
     public function testGetAndSet(): void
     {
-        $this->assertNull($this->object->get('unresisting_setting'));
+        self::assertNull($this->object->get('unresisting_setting'));
 
         $this->object->set('test_setting', 'test_value');
 
-        $this->assertEquals('test_value', $this->object->get('test_setting'));
+        self::assertEquals('test_value', $this->object->get('test_setting'));
     }
 
     /**
@@ -392,11 +392,11 @@ PHP;
     {
         echo $this->object->getSource();
 
-        $this->assertEmpty($this->object->getSource(), 'Source is null by default');
+        self::assertEmpty($this->object->getSource(), 'Source is null by default');
 
         $this->object->setSource(ROOT_PATH . 'config.sample.inc.php');
 
-        $this->assertEquals(
+        self::assertEquals(
             ROOT_PATH . 'config.sample.inc.php',
             $this->object->getSource(),
             'Cant set new source',
@@ -444,7 +444,7 @@ PHP;
 
         $this->object->set('is_https', null);
         $this->object->set('PmaAbsoluteUri', $pmaAbsoluteUri);
-        $this->assertEquals($expected, $this->object->isHttps());
+        self::assertEquals($expected, $this->object->isHttps());
     }
 
     /**
@@ -500,7 +500,7 @@ PHP;
         $_SERVER['REQUEST_URI'] = '';
         $_SERVER['PATH_INFO'] = '';
         $this->object->set('PmaAbsoluteUri', $absolute);
-        $this->assertEquals($expected, $this->object->getRootPath());
+        self::assertEquals($expected, $this->object->getRootPath());
     }
 
     /**
@@ -534,9 +534,9 @@ PHP;
     public function testLoad(string $source, bool $result): void
     {
         if ($result) {
-            $this->assertTrue($this->object->load($source));
+            self::assertTrue($this->object->load($source));
         } else {
-            $this->assertFalse($this->object->load($source));
+            self::assertFalse($this->object->load($source));
         }
     }
 
@@ -560,12 +560,12 @@ PHP;
     {
         $this->object->setUserValue(null, 'lang', 'cs', 'en');
         $this->object->setUserValue('TEST_COOKIE_USER_VAL', '', 'cfg_val_1');
-        $this->assertEquals(
+        self::assertEquals(
             $this->object->getUserValue('TEST_COOKIE_USER_VAL', 'fail'),
             'cfg_val_1',
         );
         $this->object->setUserValue(null, 'NavigationWidth', 300);
-        $this->assertSame($this->object->settings['NavigationWidth'], 300);
+        self::assertSame($this->object->settings['NavigationWidth'], 300);
     }
 
     /**
@@ -573,7 +573,7 @@ PHP;
      */
     public function testGetUserValue(): void
     {
-        $this->assertEquals($this->object->getUserValue('test_val', 'val'), 'val');
+        self::assertEquals($this->object->getUserValue('test_val', 'val'), 'val');
     }
 
     /**
@@ -584,15 +584,15 @@ PHP;
         //load file permissions for the current permissions file
         $perms = @fileperms($this->object->getSource());
         //testing for permissions for no configuration file
-        $this->assertFalse($perms !== false && ($perms & 2));
+        self::assertFalse($perms !== false && ($perms & 2));
 
         //load file permissions for the current permissions file
         $perms = @fileperms($this->permTestObj->getSource());
 
         if ($perms !== false && ($perms & 2)) {
-            $this->assertTrue((bool) $this->permTestObj->get('PMA_IS_WINDOWS'));
+            self::assertTrue((bool) $this->permTestObj->get('PMA_IS_WINDOWS'));
         } else {
-            $this->assertFalse((bool) $this->permTestObj->get('PMA_IS_WINDOWS'));
+            self::assertFalse((bool) $this->permTestObj->get('PMA_IS_WINDOWS'));
         }
     }
 
@@ -602,7 +602,7 @@ PHP;
     public function testSetCookie(): void
     {
         $this->object->set('is_https', false);
-        $this->assertFalse(
+        self::assertFalse(
             $this->object->setCookie(
                 'TEST_DEF_COOKIE',
                 'test_def_123',
@@ -610,7 +610,7 @@ PHP;
             ),
         );
 
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->setCookie(
                 'TEST_CONFIG_COOKIE',
                 'test_val_123',
@@ -619,7 +619,7 @@ PHP;
             ),
         );
 
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->setCookie(
                 'TEST_CONFIG_COOKIE',
                 '',
@@ -628,7 +628,7 @@ PHP;
         );
 
         $_COOKIE['TEST_MANUAL_COOKIE'] = 'some_test_val';
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->setCookie(
                 'TEST_MANUAL_COOKIE',
                 'other',
@@ -644,14 +644,14 @@ PHP;
     public function testGetTempDir(): void
     {
         $dir = realpath(sys_get_temp_dir());
-        $this->assertNotFalse($dir);
-        $this->assertDirectoryExists($dir);
-        $this->assertDirectoryIsWritable($dir);
+        self::assertNotFalse($dir);
+        self::assertDirectoryExists($dir);
+        self::assertDirectoryIsWritable($dir);
 
         (new ReflectionProperty(Config::class, 'tempDir'))->setValue(null, []);
         $this->object->set('TempDir', $dir . DIRECTORY_SEPARATOR);
         // Check no double slash is here
-        $this->assertEquals(
+        self::assertEquals(
             $dir . DIRECTORY_SEPARATOR . 'upload',
             $this->object->getTempDir('upload'),
         );
@@ -665,13 +665,13 @@ PHP;
     public function testGetUploadTempDir(): void
     {
         $dir = realpath(sys_get_temp_dir());
-        $this->assertNotFalse($dir);
-        $this->assertDirectoryExists($dir);
-        $this->assertDirectoryIsWritable($dir);
+        self::assertNotFalse($dir);
+        self::assertDirectoryExists($dir);
+        self::assertDirectoryIsWritable($dir);
 
         $this->object->set('TempDir', $dir . DIRECTORY_SEPARATOR);
 
-        $this->assertEquals(
+        self::assertEquals(
             $this->object->getTempDir('upload'),
             $this->object->getUploadTempDir(),
         );
@@ -690,19 +690,19 @@ PHP;
         $config = new Config();
         $config->config = new Settings(['Servers' => $settings, 'ServerDefault' => 1]);
         $selectedServer = $config->selectServer($request);
-        $this->assertSame($expected, $selectedServer);
-        $this->assertGreaterThanOrEqual(0, $selectedServer);
-        $this->assertArrayHasKey('Server', $config->settings);
-        $this->assertSame($expected, $config->server);
+        self::assertSame($expected, $selectedServer);
+        self::assertGreaterThanOrEqual(0, $selectedServer);
+        self::assertArrayHasKey('Server', $config->settings);
+        self::assertSame($expected, $config->server);
         if ($expected >= 1) {
-            $this->assertTrue($config->hasSelectedServer());
+            self::assertTrue($config->hasSelectedServer());
             $expectedServer = $config->config->Servers[$expected]->asArray();
-            $this->assertSame($expectedServer, $config->settings['Server']);
-            $this->assertSame($expectedServer, $config->selectedServer);
+            self::assertSame($expectedServer, $config->settings['Server']);
+            self::assertSame($expectedServer, $config->selectedServer);
         } else {
-            $this->assertFalse($config->hasSelectedServer());
-            $this->assertSame([], $config->settings['Server']);
-            $this->assertSame((new Server())->asArray(), $config->selectedServer);
+            self::assertFalse($config->hasSelectedServer());
+            self::assertSame([], $config->settings['Server']);
+            self::assertSame((new Server())->asArray(), $config->selectedServer);
         }
     }
 
@@ -738,7 +738,7 @@ PHP;
     public function testGetConnectionParams(array $serverCfg, ConnectionType $connectionType, array $expected): void
     {
         $result = Config::getConnectionParams(new Server($serverCfg), $connectionType);
-        $this->assertEquals(new Server($expected), $result);
+        self::assertEquals(new Server($expected), $result);
     }
 
     /**
@@ -880,7 +880,7 @@ PHP;
     ): void {
         $actual = Config::getConnectionParams(new Server(['host' => $host, 'port' => $port]), $connectionType);
         $expected = new Server(['host' => $expectedHost, 'port' => $expectedPort]);
-        $this->assertEquals($expected, $actual);
+        self::assertEquals($expected, $actual);
     }
 
     /** @psalm-return iterable<string, array{ConnectionType, string, string, string, string}> */
diff --git a/tests/classes/ConsoleTest.php b/tests/classes/ConsoleTest.php
index 4b59548fc1..a8bed36d85 100644
--- a/tests/classes/ConsoleTest.php
+++ b/tests/classes/ConsoleTest.php
@@ -22,7 +22,7 @@ class ConsoleTest extends AbstractTestCase
         $relation = new Relation($dbi);
         $bookmarkRepository = new BookmarkRepository($dbi, $relation);
         $console = new Console($relation, new Template(), $bookmarkRepository);
-        $this->assertEquals(['console.js'], $console->getScripts());
+        self::assertEquals(['console.js'], $console->getScripts());
     }
 
     public function testSetAjax(): void
@@ -33,10 +33,10 @@ class ConsoleTest extends AbstractTestCase
         $bookmarkRepository = new BookmarkRepository($dbi, $relation);
         $console = new Console($relation, new Template(), $bookmarkRepository);
 
-        $this->assertFalse($isAjax->getValue($console));
+        self::assertFalse($isAjax->getValue($console));
         $console->setAjax(true);
-        $this->assertTrue($isAjax->getValue($console));
+        self::assertTrue($isAjax->getValue($console));
         $console->setAjax(false);
-        $this->assertFalse($isAjax->getValue($console));
+        self::assertFalse($isAjax->getValue($console));
     }
 }
diff --git a/tests/classes/Controllers/AbstractControllerTest.php b/tests/classes/Controllers/AbstractControllerTest.php
index b74da5bdd6..223e5c3d28 100644
--- a/tests/classes/Controllers/AbstractControllerTest.php
+++ b/tests/classes/Controllers/AbstractControllerTest.php
@@ -48,9 +48,9 @@ class AbstractControllerTest extends AbstractTestCase
         $message .= '[br]';
         $expected = Message::error($message)->getDisplay();
 
-        $this->assertFalse($controller->testCheckParameters(['param1', 'param2']));
-        $this->assertSame($expected, $response->getHTMLResult());
-        $this->assertSame(400, $response->getResponse()->getStatusCode());
+        self::assertFalse($controller->testCheckParameters(['param1', 'param2']));
+        self::assertSame($expected, $response->getHTMLResult());
+        self::assertSame(400, $response->getResponse()->getStatusCode());
     }
 
     public function testCheckParametersWithAllParameters(): void
@@ -71,8 +71,8 @@ class AbstractControllerTest extends AbstractTestCase
         $GLOBALS['param1'] = 'param1';
         $GLOBALS['param2'] = 'param2';
 
-        $this->assertTrue($controller->testCheckParameters(['param1', 'param2']));
-        $this->assertSame(200, $response->getResponse()->getStatusCode());
+        self::assertTrue($controller->testCheckParameters(['param1', 'param2']));
+        self::assertSame(200, $response->getResponse()->getStatusCode());
     }
 
     public function testSendErrorResponseWithJson(): void
@@ -90,10 +90,10 @@ class AbstractControllerTest extends AbstractTestCase
 
         $controller->testSendErrorResponse('Error message.', 404);
 
-        $this->assertSame(404, $response->getResponse()->getStatusCode());
-        $this->assertFalse($response->hasSuccessState());
-        $this->assertSame('', $response->getHTMLResult());
-        $this->assertSame(['isErrorResponse' => true, 'message' => 'Error message.'], $response->getJSONResult());
+        self::assertSame(404, $response->getResponse()->getStatusCode());
+        self::assertFalse($response->hasSuccessState());
+        self::assertSame('', $response->getHTMLResult());
+        self::assertSame(['isErrorResponse' => true, 'message' => 'Error message.'], $response->getJSONResult());
     }
 
     public function testSendErrorResponseWithHtml(): void
@@ -111,12 +111,12 @@ class AbstractControllerTest extends AbstractTestCase
 
         $controller->testSendErrorResponse('Error message.', 404);
 
-        $this->assertSame(404, $response->getResponse()->getStatusCode());
-        $this->assertFalse($response->hasSuccessState());
-        $this->assertSame(
+        self::assertSame(404, $response->getResponse()->getStatusCode());
+        self::assertFalse($response->hasSuccessState());
+        self::assertSame(
             Message::error('Error message.')->getDisplay(),
             $response->getHTMLResult(),
         );
-        $this->assertSame([], $response->getJSONResult());
+        self::assertSame([], $response->getJSONResult());
     }
 }
diff --git a/tests/classes/Controllers/BrowseForeignersControllerTest.php b/tests/classes/Controllers/BrowseForeignersControllerTest.php
index bd3cb8204a..30c6643ad6 100644
--- a/tests/classes/Controllers/BrowseForeignersControllerTest.php
+++ b/tests/classes/Controllers/BrowseForeignersControllerTest.php
@@ -27,7 +27,7 @@ final class BrowseForeignersControllerTest extends AbstractTestCase
         $config = Config::getInstance();
         $config->selectedServer['DisableIS'] = true;
 
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('getParsedBodyParam')->willReturnMap([
             ['db', null, 'sakila'],
             ['table', null, 'film_actor'],
@@ -165,6 +165,6 @@ HTML;
             new Relation($dbi),
         ))($request);
 
-        $this->assertSame($expected, $response->getHTMLResult());
+        self::assertSame($expected, $response->getHTMLResult());
     }
 }
diff --git a/tests/classes/Controllers/CheckRelationsControllerTest.php b/tests/classes/Controllers/CheckRelationsControllerTest.php
index 735f393293..b4a68aac7a 100644
--- a/tests/classes/Controllers/CheckRelationsControllerTest.php
+++ b/tests/classes/Controllers/CheckRelationsControllerTest.php
@@ -38,7 +38,7 @@ class CheckRelationsControllerTest extends AbstractTestCase
         Current::$database = '';
         Current::$table = '';
 
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('getParsedBodyParam')->willReturnMap([
             ['create_pmadb', null, null],
             ['fixall_pmadb', null, null],
@@ -53,12 +53,12 @@ class CheckRelationsControllerTest extends AbstractTestCase
 
         $actual = $response->getHTMLResult();
 
-        $this->assertStringContainsString('phpMyAdmin configuration storage', $actual);
-        $this->assertStringContainsString(
+        self::assertStringContainsString('phpMyAdmin configuration storage', $actual);
+        self::assertStringContainsString(
             'Configuration of pmadb…      <span class="text-danger"><strong>not OK</strong></span>',
             $actual,
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             'Create</a> a database named \'phpmyadmin\' and setup the phpMyAdmin configuration storage there.',
             $actual,
         );
diff --git a/tests/classes/Controllers/CollationConnectionControllerTest.php b/tests/classes/Controllers/CollationConnectionControllerTest.php
index 4d6f97f293..a71e0a596d 100644
--- a/tests/classes/Controllers/CollationConnectionControllerTest.php
+++ b/tests/classes/Controllers/CollationConnectionControllerTest.php
@@ -18,15 +18,15 @@ class CollationConnectionControllerTest extends AbstractTestCase
 {
     public function testInvoke(): void
     {
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('getParsedBodyParam')->willReturnMap([['collation_connection', null, 'utf8mb4_general_ci']]);
 
-        $response = $this->createMock(ResponseRenderer::class);
-        $response->expects($this->once())->method('redirect')
+        $response = self::createMock(ResponseRenderer::class);
+        $response->expects(self::once())->method('redirect')
             ->with('index.php?route=/' . Url::getCommonRaw([], '&'));
 
-        $config = $this->createMock(Config::class);
-        $config->expects($this->once())->method('setUserValue')
+        $config = self::createMock(Config::class);
+        $config->expects(self::once())->method('setUserValue')
             ->with(null, 'DefaultConnectionCollation', 'utf8mb4_general_ci', 'utf8mb4_unicode_ci');
 
         (new CollationConnectionController(
diff --git a/tests/classes/Controllers/Console/Bookmark/AddControllerTest.php b/tests/classes/Controllers/Console/Bookmark/AddControllerTest.php
index 8e22818778..af900910e5 100644
--- a/tests/classes/Controllers/Console/Bookmark/AddControllerTest.php
+++ b/tests/classes/Controllers/Console/Bookmark/AddControllerTest.php
@@ -25,7 +25,7 @@ class AddControllerTest extends AbstractTestCase
         $dbi = $this->createDatabaseInterface();
         DatabaseInterface::$instance = $dbi;
         $response = new ResponseRenderer();
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('getParsedBodyParam')->willReturnMap([
             ['db', null, null],
             ['label', null, null],
@@ -36,7 +36,7 @@ class AddControllerTest extends AbstractTestCase
         $bookmarkRepository = new BookmarkRepository($dbi, $relation);
         $controller = new AddController($response, new Template(), $bookmarkRepository);
         $controller($request);
-        $this->assertSame(['message' => 'Incomplete params'], $response->getJSONResult());
+        self::assertSame(['message' => 'Incomplete params'], $response->getJSONResult());
     }
 
     public function testWithoutRelationParameters(): void
@@ -46,7 +46,7 @@ class AddControllerTest extends AbstractTestCase
         $dbi = $this->createDatabaseInterface();
         DatabaseInterface::$instance = $dbi;
         $response = new ResponseRenderer();
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('getParsedBodyParam')->willReturnMap([
             ['db', null, 'test'],
             ['label', null, 'test'],
@@ -57,7 +57,7 @@ class AddControllerTest extends AbstractTestCase
         $bookmarkRepository = new BookmarkRepository($dbi, $relation);
         $controller = new AddController($response, new Template(), $bookmarkRepository);
         $controller($request);
-        $this->assertSame(['message' => 'Failed'], $response->getJSONResult());
+        self::assertSame(['message' => 'Failed'], $response->getJSONResult());
     }
 
     public function testWithValidParameters(): void
@@ -80,7 +80,7 @@ class AddControllerTest extends AbstractTestCase
         $dbi = $this->createDatabaseInterface($dbiDummy);
         DatabaseInterface::$instance = $dbi;
         $response = new ResponseRenderer();
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('getParsedBodyParam')->willReturnMap([
             ['db', null, 'test_db'],
             ['label', null, 'test_label'],
@@ -91,7 +91,7 @@ class AddControllerTest extends AbstractTestCase
         $bookmarkRepository = new BookmarkRepository($dbi, $relation);
         $controller = new AddController($response, new Template(), $bookmarkRepository);
         $controller($request);
-        $this->assertSame(
+        self::assertSame(
             [
                 'message' => 'Succeeded',
                 'data' => [
diff --git a/tests/classes/Controllers/Console/Bookmark/RefreshControllerTest.php b/tests/classes/Controllers/Console/Bookmark/RefreshControllerTest.php
index a018b4bc21..a31a16d90f 100644
--- a/tests/classes/Controllers/Console/Bookmark/RefreshControllerTest.php
+++ b/tests/classes/Controllers/Console/Bookmark/RefreshControllerTest.php
@@ -31,7 +31,7 @@ class RefreshControllerTest extends AbstractTestCase
             $template,
             new Console($relation, $template, $bookmarkRepository),
         );
-        $controller($this->createStub(ServerRequest::class));
-        $this->assertSame(['console_message_bookmark' => ''], $response->getJSONResult());
+        $controller(self::createStub(ServerRequest::class));
+        self::assertSame(['console_message_bookmark' => ''], $response->getJSONResult());
     }
 }
diff --git a/tests/classes/Controllers/Database/EventsControllerTest.php b/tests/classes/Controllers/Database/EventsControllerTest.php
index ffc0a6f16e..e0767ac805 100644
--- a/tests/classes/Controllers/Database/EventsControllerTest.php
+++ b/tests/classes/Controllers/Database/EventsControllerTest.php
@@ -187,7 +187,7 @@ final class EventsControllerTest extends AbstractTestCase
 HTML;
         // phpcs:enable
 
-        $this->assertSame($expected, $actual);
+        self::assertSame($expected, $actual);
     }
 
     public function testWithoutEvents(): void
@@ -314,6 +314,6 @@ HTML;
 HTML;
         // phpcs:enable
 
-        $this->assertSame($expected, $actual);
+        self::assertSame($expected, $actual);
     }
 }
diff --git a/tests/classes/Controllers/Database/MultiTableQuery/TablesControllerTest.php b/tests/classes/Controllers/Database/MultiTableQuery/TablesControllerTest.php
index 4106c6a83b..f17e50c9ea 100644
--- a/tests/classes/Controllers/Database/MultiTableQuery/TablesControllerTest.php
+++ b/tests/classes/Controllers/Database/MultiTableQuery/TablesControllerTest.php
@@ -39,10 +39,10 @@ class TablesControllerTest extends AbstractTestCase
         $responseRenderer = new ResponseRenderer();
         $multiTableQueryController = new TablesController($responseRenderer, new Template(), $this->dbi);
 
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('getQueryParam')->willReturn($_GET['tables'], $_GET['db']);
         $multiTableQueryController($request);
-        $this->assertSame(
+        self::assertSame(
             [
                 'foreignKeyConstrains' => [
                     [
diff --git a/tests/classes/Controllers/Database/PrivilegesControllerTest.php b/tests/classes/Controllers/Database/PrivilegesControllerTest.php
index 6800e2f237..0ea9fb1e27 100644
--- a/tests/classes/Controllers/Database/PrivilegesControllerTest.php
+++ b/tests/classes/Controllers/Database/PrivilegesControllerTest.php
@@ -58,11 +58,11 @@ class PrivilegesControllerTest extends AbstractTestCase
 
         $privileges = [];
 
-        $serverPrivileges = $this->createMock(Privileges::class);
+        $serverPrivileges = self::createMock(Privileges::class);
         $serverPrivileges->method('getAllPrivileges')
             ->willReturn($privileges);
 
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('getParam')->willReturnMap([['db', null, 'test_db']]);
 
         $response = new ResponseRenderer();
@@ -74,34 +74,34 @@ class PrivilegesControllerTest extends AbstractTestCase
         ))($request);
         $actual = $response->getHTMLResult();
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             Url::getCommon(['db' => Current::$database], ''),
             $actual,
         );
 
-        $this->assertStringContainsString(Current::$database, $actual);
+        self::assertStringContainsString(Current::$database, $actual);
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             __('User'),
             $actual,
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             __('Host'),
             $actual,
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             __('Type'),
             $actual,
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             __('Privileges'),
             $actual,
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             __('Grant'),
             $actual,
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             __('Action'),
             $actual,
         );
@@ -109,19 +109,19 @@ class PrivilegesControllerTest extends AbstractTestCase
 
     public function testWithInvalidDatabaseName(): void
     {
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('getParam')->willReturnMap([['db', null, '']]);
 
         $response = new ResponseRenderer();
         (new PrivilegesController(
             $response,
             new Template(),
-            $this->createStub(Privileges::class),
+            self::createStub(Privileges::class),
             $this->createDatabaseInterface(),
         ))($request);
         $actual = $response->getHTMLResult();
 
-        $this->assertStringContainsString('<div class="alert alert-danger" role="alert">', $actual);
-        $this->assertStringContainsString('The database name must be a non-empty string.', $actual);
+        self::assertStringContainsString('<div class="alert alert-danger" role="alert">', $actual);
+        self::assertStringContainsString('The database name must be a non-empty string.', $actual);
     }
 }
diff --git a/tests/classes/Controllers/Database/RoutinesControllerTest.php b/tests/classes/Controllers/Database/RoutinesControllerTest.php
index f06a6ce1b4..f69c1420ce 100644
--- a/tests/classes/Controllers/Database/RoutinesControllerTest.php
+++ b/tests/classes/Controllers/Database/RoutinesControllerTest.php
@@ -240,7 +240,7 @@ final class RoutinesControllerTest extends AbstractTestCase
 HTML;
         // phpcs:enable
 
-        $this->assertSame($expected, $actual);
+        self::assertSame($expected, $actual);
     }
 
     public function testWithoutRoutines(): void
@@ -333,6 +333,6 @@ HTML;
 HTML;
         // phpcs:enable
 
-        $this->assertSame($expected, $actual);
+        self::assertSame($expected, $actual);
     }
 }
diff --git a/tests/classes/Controllers/Database/Structure/RealRowCountControllerTest.php b/tests/classes/Controllers/Database/Structure/RealRowCountControllerTest.php
index 30e400e824..39e71d5d0f 100644
--- a/tests/classes/Controllers/Database/Structure/RealRowCountControllerTest.php
+++ b/tests/classes/Controllers/Database/Structure/RealRowCountControllerTest.php
@@ -38,7 +38,7 @@ class RealRowCountControllerTest extends AbstractTestCase
         (new RealRowCountController($response, new Template(), $dbi, new DbTableExists($dbi)))($request);
 
         $json = $response->getJSONResult();
-        $this->assertEquals('4,079', $json['real_row_count']);
+        self::assertEquals('4,079', $json['real_row_count']);
 
         $_REQUEST['real_row_count_all'] = 'on';
 
@@ -50,7 +50,7 @@ class RealRowCountControllerTest extends AbstractTestCase
             ['table' => 'Country', 'row_count' => '239'],
             ['table' => 'CountryLanguage', 'row_count' => '984'],
         ];
-        $this->assertEquals($expected, $json['real_row_count_all']);
+        self::assertEquals($expected, $json['real_row_count_all']);
 
         $dbiDummy->assertAllSelectsConsumed();
     }
diff --git a/tests/classes/Controllers/Database/StructureControllerTest.php b/tests/classes/Controllers/Database/StructureControllerTest.php
index 6f19e32795..5a089cac28 100644
--- a/tests/classes/Controllers/Database/StructureControllerTest.php
+++ b/tests/classes/Controllers/Database/StructureControllerTest.php
@@ -48,15 +48,15 @@ class StructureControllerTest extends AbstractTestCase
             ->disableOriginalConstructor()
             ->getMock();
         // Expect the table will have 6 rows
-        $table->expects($this->any())->method('getRealRowCountTable')
+        $table->expects(self::any())->method('getRealRowCountTable')
             ->willReturn(6);
-        $table->expects($this->any())->method('countRecords')
+        $table->expects(self::any())->method('countRecords')
             ->willReturn(6);
 
         $dbi = $this->getMockBuilder(DatabaseInterface::class)
             ->disableOriginalConstructor()
             ->getMock();
-        $dbi->expects($this->any())->method('getTable')
+        $dbi->expects(self::any())->method('getTable')
             ->willReturn($table);
 
         DatabaseInterface::$instance = $dbi;
@@ -81,8 +81,8 @@ class StructureControllerTest extends AbstractTestCase
             $this->relation,
             $this->replication,
             $dbi,
-            $this->createStub(TrackingChecker::class),
-            $this->createStub(PageSettings::class),
+            self::createStub(TrackingChecker::class),
+            self::createStub(PageSettings::class),
             new DbTableExists($dbi),
         );
         // Showing statistics
@@ -102,9 +102,9 @@ class StructureControllerTest extends AbstractTestCase
             [$currentTable, 10],
         );
 
-        $this->assertTrue($currentTable['COUNTED']);
-        $this->assertEquals(6, $currentTable['TABLE_ROWS']);
-        $this->assertEquals(16394, $sumSize);
+        self::assertTrue($currentTable['COUNTED']);
+        self::assertEquals(6, $currentTable['TABLE_ROWS']);
+        self::assertEquals(16394, $sumSize);
 
         $currentTable['ENGINE'] = 'MYISAM';
         [$currentTable, , , $sumSize] = $method->invokeArgs(
@@ -112,8 +112,8 @@ class StructureControllerTest extends AbstractTestCase
             [$currentTable, 10],
         );
 
-        $this->assertFalse($currentTable['COUNTED']);
-        $this->assertEquals(16394, $sumSize);
+        self::assertFalse($currentTable['COUNTED']);
+        self::assertEquals(16394, $sumSize);
 
         $controller = new StructureController(
             $this->response,
@@ -121,20 +121,20 @@ class StructureControllerTest extends AbstractTestCase
             $this->relation,
             $this->replication,
             $dbi,
-            $this->createStub(TrackingChecker::class),
-            $this->createStub(PageSettings::class),
+            self::createStub(TrackingChecker::class),
+            self::createStub(PageSettings::class),
             new DbTableExists($dbi),
         );
 
         $currentTable['ENGINE'] = 'InnoDB';
         [$currentTable, , , $sumSize] = $method->invokeArgs($controller, [$currentTable, 10]);
-        $this->assertTrue($currentTable['COUNTED']);
-        $this->assertEquals(10, $sumSize);
+        self::assertTrue($currentTable['COUNTED']);
+        self::assertEquals(10, $sumSize);
 
         $currentTable['ENGINE'] = 'MYISAM';
         [$currentTable, , , $sumSize] = $method->invokeArgs($controller, [$currentTable, 10]);
-        $this->assertFalse($currentTable['COUNTED']);
-        $this->assertEquals(10, $sumSize);
+        self::assertFalse($currentTable['COUNTED']);
+        self::assertEquals(10, $sumSize);
     }
 
     /**
@@ -152,8 +152,8 @@ class StructureControllerTest extends AbstractTestCase
             $this->relation,
             $this->replication,
             $dbi,
-            $this->createStub(TrackingChecker::class),
-            $this->createStub(PageSettings::class),
+            self::createStub(TrackingChecker::class),
+            self::createStub(PageSettings::class),
             new DbTableExists($dbi),
         );
         // Showing statistics
@@ -167,16 +167,16 @@ class StructureControllerTest extends AbstractTestCase
             $controller,
             [$currentTable, 0, 0, 0, 0, 0, 0],
         );
-        $this->assertEquals(6, $currentTable['Rows']);
-        $this->assertEquals(16384, $sumSize);
-        $this->assertEquals(300, $overheadSize);
+        self::assertEquals(6, $currentTable['Rows']);
+        self::assertEquals(16384, $sumSize);
+        self::assertEquals(300, $overheadSize);
 
         unset($currentTable['Data_free']);
         [$currentTable, , , , , $overheadSize] = $method->invokeArgs(
             $controller,
             [$currentTable, 0, 0, 0, 0, 0, 0],
         );
-        $this->assertEquals(0, $overheadSize);
+        self::assertEquals(0, $overheadSize);
 
         $controller = new StructureController(
             $this->response,
@@ -184,15 +184,15 @@ class StructureControllerTest extends AbstractTestCase
             $this->relation,
             $this->replication,
             $dbi,
-            $this->createStub(TrackingChecker::class),
-            $this->createStub(PageSettings::class),
+            self::createStub(TrackingChecker::class),
+            self::createStub(PageSettings::class),
             new DbTableExists($dbi),
         );
         [$currentTable, , , , , , $sumSize] = $method->invokeArgs(
             $controller,
             [$currentTable, 0, 0, 0, 0, 0, 0],
         );
-        $this->assertEquals(0, $sumSize);
+        self::assertEquals(0, $sumSize);
 
         $controller = new StructureController(
             $this->response,
@@ -200,15 +200,15 @@ class StructureControllerTest extends AbstractTestCase
             $this->relation,
             $this->replication,
             $dbi,
-            $this->createStub(TrackingChecker::class),
-            $this->createStub(PageSettings::class),
+            self::createStub(TrackingChecker::class),
+            self::createStub(PageSettings::class),
             new DbTableExists($dbi),
         );
         [$currentTable] = $method->invokeArgs(
             $controller,
             [$currentTable, 0, 0, 0, 0, 0, 0],
         );
-        $this->assertArrayNotHasKey('Row', $currentTable);
+        self::assertArrayNotHasKey('Row', $currentTable);
     }
 
     /**
@@ -226,25 +226,25 @@ class StructureControllerTest extends AbstractTestCase
             $this->relation,
             $this->replication,
             $dbi,
-            $this->createStub(TrackingChecker::class),
-            $this->createStub(PageSettings::class),
+            self::createStub(TrackingChecker::class),
+            self::createStub(PageSettings::class),
             new DbTableExists($dbi),
         );
 
         // When parameter $db is empty
-        $this->assertFalse(
+        self::assertFalse(
             $method->invokeArgs($controller, [[], 'table']),
         );
 
         // Correct parameter
         $tables = ['db.table'];
-        $this->assertTrue(
+        self::assertTrue(
             $method->invokeArgs($controller, [$tables, 'table']),
         );
 
         // Table not in database
         $tables = ['db.tab1e'];
-        $this->assertFalse(
+        self::assertFalse(
             $method->invokeArgs($controller, [$tables, 'table']),
         );
     }
@@ -262,8 +262,8 @@ class StructureControllerTest extends AbstractTestCase
             $this->relation,
             $this->replication,
             $dbi,
-            $this->createStub(TrackingChecker::class),
-            $this->createStub(PageSettings::class),
+            self::createStub(TrackingChecker::class),
+            self::createStub(PageSettings::class),
             new DbTableExists($dbi),
         );
         // Showing statistics
@@ -280,8 +280,8 @@ class StructureControllerTest extends AbstractTestCase
         $_REQUEST['db'] = 'my_unique_test_db';
         $tablesProperty->setValue($controller, []);
         $result = $method->invoke($controller, ['status' => false]);
-        $this->assertStringContainsString($_REQUEST['db'], $result);
-        $this->assertStringNotContainsString('id="overhead"', $result);
+        self::assertStringContainsString($_REQUEST['db'], $result);
+        self::assertStringNotContainsString('id="overhead"', $result);
 
         //with table
         $_REQUEST['db'] = 'my_unique_test_db';
@@ -299,9 +299,9 @@ class StructureControllerTest extends AbstractTestCase
         ]);
         $result = $method->invoke($controller, ['status' => false]);
 
-        $this->assertStringContainsString($_REQUEST['db'], $result);
-        $this->assertStringContainsString('id="overhead"', $result);
-        $this->assertStringContainsString('9.8', $result);
+        self::assertStringContainsString($_REQUEST['db'], $result);
+        self::assertStringContainsString('id="overhead"', $result);
+        self::assertStringContainsString('9.8', $result);
     }
 
     /**
@@ -319,12 +319,12 @@ class StructureControllerTest extends AbstractTestCase
             $this->relation,
             $this->replication,
             $dbi,
-            $this->createStub(TrackingChecker::class),
-            $this->createStub(PageSettings::class),
+            self::createStub(TrackingChecker::class),
+            self::createStub(PageSettings::class),
             new DbTableExists($dbi),
         );
 
-        $this->assertSame(
+        self::assertSame(
             [[], '', '', 0],
             $this->callFunction(
                 $structureController,
@@ -340,10 +340,10 @@ class StructureControllerTest extends AbstractTestCase
             $structureController,
             StructureController::class,
             'getDatabaseInfo',
-            [$this->createStub(ServerRequest::class)],
+            [self::createStub(ServerRequest::class)],
         );
 
-        $this->assertSame(
+        self::assertSame(
             [['Data_length' => 45, 'Index_length' => 60], '105', 'B', 105],
             $this->callFunction(
                 $structureController,
@@ -353,7 +353,7 @@ class StructureControllerTest extends AbstractTestCase
             ),
         );
 
-        $this->assertSame(
+        self::assertSame(
             [
                 ['Data_length' => 45, 'Index_length' => 60],
                 '105',
diff --git a/tests/classes/Controllers/Export/ExportControllerTest.php b/tests/classes/Controllers/Export/ExportControllerTest.php
index c8feef6645..bd87ed8fcf 100644
--- a/tests/classes/Controllers/Export/ExportControllerTest.php
+++ b/tests/classes/Controllers/Export/ExportControllerTest.php
@@ -199,8 +199,8 @@ SQL;
         $exportController($request);
         $output = $this->getActualOutputForAssertion();
 
-        $this->assertStringNotContainsString('Missing parameter: what', $output);
-        $this->assertStringNotContainsString('Missing parameter: export_type', $output);
-        $this->assertStringContainsString(htmlspecialchars($expectedOutput, ENT_COMPAT), $output);
+        self::assertStringNotContainsString('Missing parameter: what', $output);
+        self::assertStringNotContainsString('Missing parameter: export_type', $output);
+        self::assertStringContainsString(htmlspecialchars($expectedOutput, ENT_COMPAT), $output);
     }
 }
diff --git a/tests/classes/Controllers/Export/Template/CreateControllerTest.php b/tests/classes/Controllers/Export/Template/CreateControllerTest.php
index 97dcd9cbfd..f9d4252a0c 100644
--- a/tests/classes/Controllers/Export/Template/CreateControllerTest.php
+++ b/tests/classes/Controllers/Export/Template/CreateControllerTest.php
@@ -48,7 +48,7 @@ class CreateControllerTest extends AbstractTestCase
 
         $response = new ResponseRenderer();
         $template = new Template();
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('getParsedBodyParam')->willReturnMap([
             ['exportType', '', 'type'],
             ['templateName', '', 'name'],
@@ -85,7 +85,7 @@ class CreateControllerTest extends AbstractTestCase
             'selected_template' => null,
         ]);
 
-        $this->assertTrue($response->hasSuccessState());
-        $this->assertEquals(['data' => $options], $response->getJSONResult());
+        self::assertTrue($response->hasSuccessState());
+        self::assertEquals(['data' => $options], $response->getJSONResult());
     }
 }
diff --git a/tests/classes/Controllers/Export/Template/DeleteControllerTest.php b/tests/classes/Controllers/Export/Template/DeleteControllerTest.php
index ed288028bf..bfd009a6d9 100644
--- a/tests/classes/Controllers/Export/Template/DeleteControllerTest.php
+++ b/tests/classes/Controllers/Export/Template/DeleteControllerTest.php
@@ -37,7 +37,7 @@ class DeleteControllerTest extends AbstractTestCase
         Config::getInstance()->selectedServer['user'] = 'user';
 
         $response = new ResponseRenderer();
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('getParsedBodyParam')->willReturn('1');
 
         (new DeleteController(
@@ -47,6 +47,6 @@ class DeleteControllerTest extends AbstractTestCase
             new Relation($this->dbi),
         ))($request);
 
-        $this->assertTrue($response->hasSuccessState());
+        self::assertTrue($response->hasSuccessState());
     }
 }
diff --git a/tests/classes/Controllers/Export/Template/LoadControllerTest.php b/tests/classes/Controllers/Export/Template/LoadControllerTest.php
index 214828a6f0..2918ab0aaa 100644
--- a/tests/classes/Controllers/Export/Template/LoadControllerTest.php
+++ b/tests/classes/Controllers/Export/Template/LoadControllerTest.php
@@ -46,7 +46,7 @@ class LoadControllerTest extends AbstractTestCase
         Config::getInstance()->selectedServer['user'] = 'user';
 
         $response = new ResponseRenderer();
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('getParsedBodyParam')->willReturn('1');
 
         (new LoadController(
@@ -56,7 +56,7 @@ class LoadControllerTest extends AbstractTestCase
             new Relation($this->dbi),
         ))($request);
 
-        $this->assertTrue($response->hasSuccessState());
-        $this->assertEquals(['data' => 'data1'], $response->getJSONResult());
+        self::assertTrue($response->hasSuccessState());
+        self::assertEquals(['data' => 'data1'], $response->getJSONResult());
     }
 }
diff --git a/tests/classes/Controllers/Export/Template/UpdateControllerTest.php b/tests/classes/Controllers/Export/Template/UpdateControllerTest.php
index bd897d8519..0c9625ef7a 100644
--- a/tests/classes/Controllers/Export/Template/UpdateControllerTest.php
+++ b/tests/classes/Controllers/Export/Template/UpdateControllerTest.php
@@ -37,7 +37,7 @@ class UpdateControllerTest extends AbstractTestCase
         Config::getInstance()->selectedServer['user'] = 'user';
 
         $response = new ResponseRenderer();
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('getParsedBodyParam')->willReturnMap([
             ['templateId', null, '1'],
             ['templateData', '', 'data'],
@@ -50,6 +50,6 @@ class UpdateControllerTest extends AbstractTestCase
             new Relation($this->dbi),
         ))($request);
 
-        $this->assertTrue($response->hasSuccessState());
+        self::assertTrue($response->hasSuccessState());
     }
 }
diff --git a/tests/classes/Controllers/GisDataEditorControllerTest.php b/tests/classes/Controllers/GisDataEditorControllerTest.php
index fbc363dd0f..fd73f73049 100644
--- a/tests/classes/Controllers/GisDataEditorControllerTest.php
+++ b/tests/classes/Controllers/GisDataEditorControllerTest.php
@@ -47,7 +47,7 @@ class GisDataEditorControllerTest extends AbstractTestCase
                 $value,
             ],
         );
-        $this->assertEquals($expected, $gisData);
+        self::assertEquals($expected, $gisData);
     }
 
     /** @return iterable<array{0:mixed,1:string,2:string|null,3:string}> */
diff --git a/tests/classes/Controllers/HomeControllerTest.php b/tests/classes/Controllers/HomeControllerTest.php
index b0bd9d6575..abfd1be8c7 100644
--- a/tests/classes/Controllers/HomeControllerTest.php
+++ b/tests/classes/Controllers/HomeControllerTest.php
@@ -24,18 +24,18 @@ final class HomeControllerTest extends AbstractTestCase
         $request = ServerRequestFactory::create()->createServerRequest('GET', 'http://example.com/')
             ->withQueryParams(['db' => 'test_db']);
         $controller = new HomeController(
-            $this->createStub(ResponseRenderer::class),
-            $this->createStub(Template::class),
-            $this->createStub(Config::class),
-            $this->createStub(ThemeManager::class),
-            $this->createStub(DatabaseInterface::class),
+            self::createStub(ResponseRenderer::class),
+            self::createStub(Template::class),
+            self::createStub(Config::class),
+            self::createStub(ThemeManager::class),
+            self::createStub(DatabaseInterface::class),
             ResponseFactory::create(),
         );
         $response = $controller($request);
-        $this->assertNotNull($response);
-        $this->assertSame(StatusCodeInterface::STATUS_FOUND, $response->getStatusCode());
-        $this->assertSame('./index.php?route=/database/structure&db=test_db', $response->getHeaderLine('Location'));
-        $this->assertSame('', (string) $response->getBody());
+        self::assertNotNull($response);
+        self::assertSame(StatusCodeInterface::STATUS_FOUND, $response->getStatusCode());
+        self::assertSame('./index.php?route=/database/structure&db=test_db', $response->getHeaderLine('Location'));
+        self::assertSame('', (string) $response->getBody());
     }
 
     public function testRedirectToTablePage(): void
@@ -43,17 +43,17 @@ final class HomeControllerTest extends AbstractTestCase
         $request = ServerRequestFactory::create()->createServerRequest('GET', 'http://example.com/')
             ->withQueryParams(['db' => 'test_db', 'table' => 'test_table']);
         $controller = new HomeController(
-            $this->createStub(ResponseRenderer::class),
-            $this->createStub(Template::class),
-            $this->createStub(Config::class),
-            $this->createStub(ThemeManager::class),
-            $this->createStub(DatabaseInterface::class),
+            self::createStub(ResponseRenderer::class),
+            self::createStub(Template::class),
+            self::createStub(Config::class),
+            self::createStub(ThemeManager::class),
+            self::createStub(DatabaseInterface::class),
             ResponseFactory::create(),
         );
         $response = $controller($request);
-        $this->assertNotNull($response);
-        $this->assertSame(StatusCodeInterface::STATUS_FOUND, $response->getStatusCode());
-        $this->assertSame('./index.php?route=/sql&db=test_db&table=test_table', $response->getHeaderLine('Location'));
-        $this->assertSame('', (string) $response->getBody());
+        self::assertNotNull($response);
+        self::assertSame(StatusCodeInterface::STATUS_FOUND, $response->getStatusCode());
+        self::assertSame('./index.php?route=/sql&db=test_db&table=test_table', $response->getHeaderLine('Location'));
+        self::assertSame('', (string) $response->getBody());
     }
 }
diff --git a/tests/classes/Controllers/Import/ImportControllerTest.php b/tests/classes/Controllers/Import/ImportControllerTest.php
index fa82db7d28..0eddcb09b8 100644
--- a/tests/classes/Controllers/Import/ImportControllerTest.php
+++ b/tests/classes/Controllers/Import/ImportControllerTest.php
@@ -51,7 +51,7 @@ class ImportControllerTest extends AbstractTestCase
             . 'FROM table1 A' . "\n"
             . 'WHERE A.nomEtablissement = :nomEta AND foo = :1 AND `:a` IS NULL';
 
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('getParsedBodyParam')->willReturnMap([
             ['db', null, Current::$database],
             ['table', null, Current::$table],
@@ -113,9 +113,9 @@ class ImportControllerTest extends AbstractTestCase
 
         $output = $responseRenderer->getHTMLResult();
 
-        $this->assertStringContainsString('MySQL returned an empty result set (i.e. zero rows).', $output);
+        self::assertStringContainsString('MySQL returned an empty result set (i.e. zero rows).', $output);
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             'SELECT A.*' . "\n" . 'FROM table1 A' . "\n"
                 . 'WHERE A.nomEtablissement = \'Saint-Louis - Châteaulin\' AND foo = 4 AND `:a` IS NULL',
             $output,
diff --git a/tests/classes/Controllers/JavaScriptMessagesControllerTest.php b/tests/classes/Controllers/JavaScriptMessagesControllerTest.php
index fc23ec8f4b..35415ab4ab 100644
--- a/tests/classes/Controllers/JavaScriptMessagesControllerTest.php
+++ b/tests/classes/Controllers/JavaScriptMessagesControllerTest.php
@@ -23,16 +23,16 @@ class JavaScriptMessagesControllerTest extends TestCase
     {
         $response = (new JavaScriptMessagesController(ResponseFactory::create()))();
         $actual = (string) $response->getBody();
-        $this->assertSame(StatusCodeInterface::STATUS_OK, $response->getStatusCode());
+        self::assertSame(StatusCodeInterface::STATUS_OK, $response->getStatusCode());
 
-        $this->assertStringStartsWith('window.Messages = {', $actual);
-        $this->assertStringEndsWith('};', $actual);
+        self::assertStringStartsWith('window.Messages = {', $actual);
+        self::assertStringEndsWith('};', $actual);
 
         $json = substr($actual, strlen('window.Messages = '), -1);
         $array = json_decode($json, true);
 
-        $this->assertIsArray($array);
-        $this->assertArrayHasKey('strDoYouReally', $array);
-        $this->assertEquals('Do you really want to execute "%s"?', $array['strDoYouReally']);
+        self::assertIsArray($array);
+        self::assertArrayHasKey('strDoYouReally', $array);
+        self::assertEquals('Do you really want to execute "%s"?', $array['strDoYouReally']);
     }
 }
diff --git a/tests/classes/Controllers/LintControllerTest.php b/tests/classes/Controllers/LintControllerTest.php
index 78f1c92027..60d9f40535 100644
--- a/tests/classes/Controllers/LintControllerTest.php
+++ b/tests/classes/Controllers/LintControllerTest.php
@@ -28,20 +28,20 @@ class LintControllerTest extends AbstractTestCase
 
     public function testWithoutParams(): void
     {
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('isAjax')->willReturn(true);
         $request->method('getParsedBodyParam')->willReturnMap([['sql_query', '', ''], ['options', null, null]]);
 
         $this->getLintController()($request);
 
         $output = $this->getActualOutputForAssertion();
-        $this->assertJson($output);
-        $this->assertJsonStringEqualsJsonString('[]', $output);
+        self::assertJson($output);
+        self::assertJsonStringEqualsJsonString('[]', $output);
     }
 
     public function testWithoutSqlErrors(): void
     {
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('isAjax')->willReturn(true);
         $request->method('getParsedBodyParam')->willReturnMap([
             ['sql_query', '', 'SELECT * FROM `actor` WHERE `actor_id` = 1;'],
@@ -51,8 +51,8 @@ class LintControllerTest extends AbstractTestCase
         $this->getLintController()($request);
 
         $output = $this->getActualOutputForAssertion();
-        $this->assertJson($output);
-        $this->assertJsonStringEqualsJsonString('[]', $output);
+        self::assertJson($output);
+        self::assertJsonStringEqualsJsonString('[]', $output);
     }
 
     public function testWithSqlErrors(): void
@@ -91,9 +91,9 @@ class LintControllerTest extends AbstractTestCase
                 'severity' => 'error',
             ],
         ]);
-        $this->assertNotFalse($expectedJson);
+        self::assertNotFalse($expectedJson);
 
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('isAjax')->willReturn(true);
         $request->method('getParsedBodyParam')->willReturnMap([
             ['sql_query', '', 'SELECT * FROM `actor` WHEREE `actor_id` = 1'],
@@ -103,8 +103,8 @@ class LintControllerTest extends AbstractTestCase
         $this->getLintController()($request);
 
         $output = $this->getActualOutputForAssertion();
-        $this->assertJson($output);
-        $this->assertJsonStringEqualsJsonString($expectedJson, $output);
+        self::assertJson($output);
+        self::assertJsonStringEqualsJsonString($expectedJson, $output);
     }
 
     private function getLintController(): LintController
diff --git a/tests/classes/Controllers/LogoutControllerTest.php b/tests/classes/Controllers/LogoutControllerTest.php
index ad016c7694..4fd1fb2c19 100644
--- a/tests/classes/Controllers/LogoutControllerTest.php
+++ b/tests/classes/Controllers/LogoutControllerTest.php
@@ -18,13 +18,13 @@ class LogoutControllerTest extends AbstractTestCase
     {
         $GLOBALS['token_mismatch'] = false;
 
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('isPost')->willReturn(true);
 
-        $authPlugin = $this->createMock(AuthenticationPlugin::class);
-        $authPlugin->expects($this->once())->method('logOut');
+        $authPlugin = self::createMock(AuthenticationPlugin::class);
+        $authPlugin->expects(self::once())->method('logOut');
 
-        $factory = $this->createStub(AuthenticationPluginFactory::class);
+        $factory = self::createStub(AuthenticationPluginFactory::class);
         $factory->method('create')->willReturn($authPlugin);
 
         (new LogoutController($factory))($request);
diff --git a/tests/classes/Controllers/NavigationControllerTest.php b/tests/classes/Controllers/NavigationControllerTest.php
index 8b641f0f85..7429d9b9bf 100644
--- a/tests/classes/Controllers/NavigationControllerTest.php
+++ b/tests/classes/Controllers/NavigationControllerTest.php
@@ -135,19 +135,19 @@ class NavigationControllerTest extends AbstractTestCase
 
         $_POST['full'] = '1';
 
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('isAjax')->willReturn(true);
 
         $navigationController($request);
-        $this->assertTrue($responseRenderer->hasSuccessState(), 'expected the request not to fail');
+        self::assertTrue($responseRenderer->hasSuccessState(), 'expected the request not to fail');
 
         $responseMessage = $responseRenderer->getJSONResult()['message'];
 
-        $this->assertStringContainsString('<div id=\'pma_navigation_tree_content\'>', $responseMessage);
+        self::assertStringContainsString('<div id=\'pma_navigation_tree_content\'>', $responseMessage);
 
         // root.air-balloon_burner_dev2
         // cm9vdA==.YWlyLWJhbGxvb25fYnVybmVyX2RldjI=
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             '<div id=\'pma_navigation_tree_content\'>' . "\n"
             . '  <ul>' . "\n"
             . '      <li class="first database">' . "\n"
@@ -289,15 +289,15 @@ class NavigationControllerTest extends AbstractTestCase
 
         $_POST['full'] = '1';
 
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('isAjax')->willReturn(true);
 
         $navigationController($request);
-        $this->assertTrue($responseRenderer->hasSuccessState(), 'expected the request not to fail');
+        self::assertTrue($responseRenderer->hasSuccessState(), 'expected the request not to fail');
 
         $responseMessage = $responseRenderer->getJSONResult()['message'];
 
-        $this->assertStringContainsString('<div id=\'pma_navigation_tree_content\'>', $responseMessage);
+        self::assertStringContainsString('<div id=\'pma_navigation_tree_content\'>', $responseMessage);
 
         $dbTemplate = '  <li class="database database">' . "\n"
             . '    <div class="block">' . "\n"
@@ -387,7 +387,7 @@ class NavigationControllerTest extends AbstractTestCase
 
         // root.air-balloon_burner_dev2
         // cm9vdA==.YWlyLWJhbGxvb25fYnVybmVyX2RldjI=
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             '<div id=\'pma_navigation_tree_content\'>' . "\n"
             . '  <ul>' . "\n"
             . '      <li class="first navGroup">' . "\n"
diff --git a/tests/classes/Controllers/Normalization/AddNewPrimaryControllerTest.php b/tests/classes/Controllers/Normalization/AddNewPrimaryControllerTest.php
index 3e19fcfe99..6ed9a2d6a7 100644
--- a/tests/classes/Controllers/Normalization/AddNewPrimaryControllerTest.php
+++ b/tests/classes/Controllers/Normalization/AddNewPrimaryControllerTest.php
@@ -40,8 +40,8 @@ class AddNewPrimaryControllerTest extends AbstractTestCase
             $template,
             new Normalization($dbi, new Relation($dbi), new Transformations(), $template),
         );
-        $controller($this->createStub(ServerRequest::class));
+        $controller(self::createStub(ServerRequest::class));
 
-        $this->assertStringContainsString('<table id="table_columns"', $response->getHTMLResult());
+        self::assertStringContainsString('<table id="table_columns"', $response->getHTMLResult());
     }
 }
diff --git a/tests/classes/Controllers/Normalization/CreateNewColumnControllerTest.php b/tests/classes/Controllers/Normalization/CreateNewColumnControllerTest.php
index 993d1d1a67..9c4296cd4f 100644
--- a/tests/classes/Controllers/Normalization/CreateNewColumnControllerTest.php
+++ b/tests/classes/Controllers/Normalization/CreateNewColumnControllerTest.php
@@ -34,7 +34,7 @@ class CreateNewColumnControllerTest extends AbstractTestCase
         DatabaseInterface::$instance = $dbi;
         $response = new ResponseRenderer();
         $template = new Template();
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('getParsedBodyParam')->willReturnMap([['numFields', null, '1']]);
 
         $controller = new CreateNewColumnController(
@@ -44,6 +44,6 @@ class CreateNewColumnControllerTest extends AbstractTestCase
         );
         $controller($request);
 
-        $this->assertStringContainsString('<table id="table_columns"', $response->getHTMLResult());
+        self::assertStringContainsString('<table id="table_columns"', $response->getHTMLResult());
     }
 }
diff --git a/tests/classes/Controllers/Normalization/FirstNormalForm/FirstStepControllerTest.php b/tests/classes/Controllers/Normalization/FirstNormalForm/FirstStepControllerTest.php
index 6733d21d65..11fb2aa67f 100644
--- a/tests/classes/Controllers/Normalization/FirstNormalForm/FirstStepControllerTest.php
+++ b/tests/classes/Controllers/Normalization/FirstNormalForm/FirstStepControllerTest.php
@@ -36,7 +36,7 @@ class FirstStepControllerTest extends AbstractTestCase
         DatabaseInterface::$instance = $dbi;
         $response = new ResponseRenderer();
         $template = new Template();
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('getParsedBodyParam')->willReturnMap([['normalizeTo', null, $normalizeTo]]);
 
         $controller = new FirstStepController(
@@ -47,22 +47,22 @@ class FirstStepControllerTest extends AbstractTestCase
         $controller($request);
 
         $files = $response->getHeader()->getScripts()->getFiles();
-        $this->assertTrue(
+        self::assertTrue(
             in_array(['name' => 'normalization.js', 'fire' => 1], $files, true),
             'normalization.js script was not included in the response.',
         );
-        $this->assertTrue(
+        self::assertTrue(
             in_array(['name' => 'vendor/jquery/jquery.uitablefilter.js', 'fire' => 0], $files, true),
             'vendor/jquery/jquery.uitablefilter.js script was not included in the response.',
         );
 
         $output = $response->getHTMLResult();
-        $this->assertStringContainsString('First step of normalization (1NF)', $output);
-        $this->assertStringContainsString(
+        self::assertStringContainsString('First step of normalization (1NF)', $output);
+        self::assertStringContainsString(
             '<div class="card" id="mainContent" data-normalizeto="' . $expectedNormalizeTo . '">',
             $output,
         );
-        $this->assertStringContainsString('<option value=\'no_such_col\'>No such column</option>', $output);
+        self::assertStringContainsString('<option value=\'no_such_col\'>No such column</option>', $output);
     }
 
     /** @return array<int, array{string|null, '1nf'|'2nf'|'3nf'}> */
diff --git a/tests/classes/Controllers/Normalization/FirstNormalForm/FourthStepControllerTest.php b/tests/classes/Controllers/Normalization/FirstNormalForm/FourthStepControllerTest.php
index b9fc686dbb..b01f14ae7f 100644
--- a/tests/classes/Controllers/Normalization/FirstNormalForm/FourthStepControllerTest.php
+++ b/tests/classes/Controllers/Normalization/FirstNormalForm/FourthStepControllerTest.php
@@ -37,10 +37,10 @@ class FourthStepControllerTest extends AbstractTestCase
             $template,
             new Normalization($dbi, new Relation($dbi), new Transformations(), $template),
         );
-        $controller($this->createStub(ServerRequest::class));
+        $controller(self::createStub(ServerRequest::class));
 
         // phpcs:disable Generic.Files.LineLength.TooLong
-        $this->assertSame([
+        self::assertSame([
             'legendText' => 'Step 1.4 Remove redundant columns',
             'headText' => 'Do you have a group of columns which on combining gives an existing column? For example, if you have first_name, last_name and full_name then combining first_name and last_name gives full_name which is redundant.',
             'subText' => 'Check the columns which are redundant and click on remove. If no redundant column, click on \'No redundant column\'',
diff --git a/tests/classes/Controllers/Normalization/FirstNormalForm/SecondStepControllerTest.php b/tests/classes/Controllers/Normalization/FirstNormalForm/SecondStepControllerTest.php
index d84c94a7de..d4dc3b0005 100644
--- a/tests/classes/Controllers/Normalization/FirstNormalForm/SecondStepControllerTest.php
+++ b/tests/classes/Controllers/Normalization/FirstNormalForm/SecondStepControllerTest.php
@@ -34,9 +34,9 @@ class SecondStepControllerTest extends AbstractTestCase
             $template,
             new Normalization($dbi, new Relation($dbi), new Transformations(), $template),
         );
-        $controller($this->createStub(ServerRequest::class));
+        $controller(self::createStub(ServerRequest::class));
 
-        $this->assertSame([
+        self::assertSame([
             'legendText' => 'Step 1.2 Have a primary key',
             'headText' => 'Primary key already exists.',
             'subText' => 'Taking you to next step…',
diff --git a/tests/classes/Controllers/Normalization/FirstNormalForm/ThirdStepControllerTest.php b/tests/classes/Controllers/Normalization/FirstNormalForm/ThirdStepControllerTest.php
index 1970d1bb12..0c774de6f0 100644
--- a/tests/classes/Controllers/Normalization/FirstNormalForm/ThirdStepControllerTest.php
+++ b/tests/classes/Controllers/Normalization/FirstNormalForm/ThirdStepControllerTest.php
@@ -37,10 +37,10 @@ class ThirdStepControllerTest extends AbstractTestCase
             $template,
             new Normalization($dbi, new Relation($dbi), new Transformations(), $template),
         );
-        $controller($this->createStub(ServerRequest::class));
+        $controller(self::createStub(ServerRequest::class));
 
         // phpcs:disable Generic.Files.LineLength.TooLong
-        $this->assertSame([
+        self::assertSame([
             'legendText' => 'Step 1.3 Move repeating groups',
             'headText' => 'Do you have a group of two or more columns that are closely related and are all repeating the same attribute? For example, a table that holds data on books might have columns such as book_id, author1, author2, author3 and so on which form a repeating group. In this case a new table (book_id, author) should be created.',
             'subText' => 'Check the columns which form a repeating group. If no such group, click on \'No repeating group\'',
diff --git a/tests/classes/Controllers/Normalization/GetColumnsControllerTest.php b/tests/classes/Controllers/Normalization/GetColumnsControllerTest.php
index 78b0e9fa32..be04a37d4e 100644
--- a/tests/classes/Controllers/Normalization/GetColumnsControllerTest.php
+++ b/tests/classes/Controllers/Normalization/GetColumnsControllerTest.php
@@ -37,10 +37,10 @@ class GetColumnsControllerTest extends AbstractTestCase
             $template,
             new Normalization($dbi, new Relation($dbi), new Transformations(), $template),
         );
-        $controller($this->createStub(ServerRequest::class));
+        $controller(self::createStub(ServerRequest::class));
 
         // phpcs:disable Generic.Files.LineLength.TooLong
-        $this->assertSame(
+        self::assertSame(
             '<option selected disabled>Select one…</option><option value="no_such_col">No such column</option><option value="name">name [ varchar(20) ]</option>',
             $response->getHTMLResult(),
         );
diff --git a/tests/classes/Controllers/Normalization/MainControllerTest.php b/tests/classes/Controllers/Normalization/MainControllerTest.php
index b103e43cf3..4ee83c719e 100644
--- a/tests/classes/Controllers/Normalization/MainControllerTest.php
+++ b/tests/classes/Controllers/Normalization/MainControllerTest.php
@@ -44,29 +44,29 @@ class MainControllerTest extends AbstractTestCase
         $response = new ResponseRenderer();
 
         $controller = new MainController($response, new Template());
-        $controller($this->createStub(ServerRequest::class));
+        $controller(self::createStub(ServerRequest::class));
 
         $files = $response->getHeader()->getScripts()->getFiles();
-        $this->assertTrue(
+        self::assertTrue(
             in_array(['name' => 'normalization.js', 'fire' => 1], $files, true),
             'normalization.js script was not included in the response.',
         );
-        $this->assertTrue(
+        self::assertTrue(
             in_array(['name' => 'vendor/jquery/jquery.uitablefilter.js', 'fire' => 0], $files, true),
             'vendor/jquery/jquery.uitablefilter.js script was not included in the response.',
         );
 
         $output = $response->getHTMLResult();
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             '<form method="post" action="index.php?route=/normalization/1nf/step1&lang=en"'
             . ' name="normalize" id="normalizeTable"',
             $output,
         );
-        $this->assertStringContainsString('<input type="hidden" name="db" value="test_db">', $output);
-        $this->assertStringContainsString('<input type="hidden" name="table" value="test_table">', $output);
-        $this->assertStringContainsString('type="radio" name="normalizeTo"', $output);
-        $this->assertStringContainsString('id="normalizeToRadio1" value="1nf" checked>', $output);
-        $this->assertStringContainsString('id="normalizeToRadio2" value="2nf">', $output);
-        $this->assertStringContainsString('id="normalizeToRadio3" value="3nf">', $output);
+        self::assertStringContainsString('<input type="hidden" name="db" value="test_db">', $output);
+        self::assertStringContainsString('<input type="hidden" name="table" value="test_table">', $output);
+        self::assertStringContainsString('type="radio" name="normalizeTo"', $output);
+        self::assertStringContainsString('id="normalizeToRadio1" value="1nf" checked>', $output);
+        self::assertStringContainsString('id="normalizeToRadio2" value="2nf">', $output);
+        self::assertStringContainsString('id="normalizeToRadio3" value="3nf">', $output);
     }
 }
diff --git a/tests/classes/Controllers/Normalization/MoveRepeatingGroupTest.php b/tests/classes/Controllers/Normalization/MoveRepeatingGroupTest.php
index 9d4b30774e..fe22744abc 100644
--- a/tests/classes/Controllers/Normalization/MoveRepeatingGroupTest.php
+++ b/tests/classes/Controllers/Normalization/MoveRepeatingGroupTest.php
@@ -39,7 +39,7 @@ class MoveRepeatingGroupTest extends AbstractTestCase
         DatabaseInterface::$instance = $dbi;
         $response = new ResponseRenderer();
         $template = new Template();
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('getParsedBodyParam')->willReturnMap([
             ['repeatingColumns', null, 'col1, col2'],
             ['newTable', null, 'new_table'],
@@ -55,6 +55,6 @@ class MoveRepeatingGroupTest extends AbstractTestCase
         $controller($request);
 
         $message = Message::success('Selected repeating group has been moved to the table \'test_table\'');
-        $this->assertSame(['queryError' => false, 'message' => $message->getDisplay()], $response->getJSONResult());
+        self::assertSame(['queryError' => false, 'message' => $message->getDisplay()], $response->getJSONResult());
     }
 }
diff --git a/tests/classes/Controllers/Normalization/PartialDependenciesControllerTest.php b/tests/classes/Controllers/Normalization/PartialDependenciesControllerTest.php
index e0c16946ed..f5ddbbaa90 100644
--- a/tests/classes/Controllers/Normalization/PartialDependenciesControllerTest.php
+++ b/tests/classes/Controllers/Normalization/PartialDependenciesControllerTest.php
@@ -45,10 +45,10 @@ class PartialDependenciesControllerTest extends AbstractTestCase
             $template,
             new Normalization($dbi, new Relation($dbi), new Transformations(), $template),
         );
-        $controller($this->createStub(ServerRequest::class));
+        $controller(self::createStub(ServerRequest::class));
 
         // phpcs:disable Generic.Files.LineLength.TooLong
-        $this->assertSame(
+        self::assertSame(
             'This list is based on a subset of the table\'s data and is not necessarily accurate. <div class="dependencies_box"><p class="d-block m-1">No partial dependencies found!</p></div>',
             $response->getHTMLResult(),
         );
diff --git a/tests/classes/Controllers/Normalization/SecondNormalForm/CreateNewTablesControllerTest.php b/tests/classes/Controllers/Normalization/SecondNormalForm/CreateNewTablesControllerTest.php
index 1a88aae0db..708276b25f 100644
--- a/tests/classes/Controllers/Normalization/SecondNormalForm/CreateNewTablesControllerTest.php
+++ b/tests/classes/Controllers/Normalization/SecondNormalForm/CreateNewTablesControllerTest.php
@@ -36,7 +36,7 @@ class CreateNewTablesControllerTest extends AbstractTestCase
         DatabaseInterface::$instance = $dbi;
         $response = new ResponseRenderer();
         $template = new Template();
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('getParsedBodyParam')->willReturnMap([
             ['pd', null, json_encode(['ID, task' => [], 'task' => ['timestamp']])],
             ['newTablesName', null, json_encode(['ID, task' => 'batch_log2', 'task' => 'table2'])],
@@ -49,7 +49,7 @@ class CreateNewTablesControllerTest extends AbstractTestCase
         );
         $controller($request);
 
-        $this->assertSame([
+        self::assertSame([
             'legendText' => 'End of step',
             'headText' => '<h3>The second step of normalization is complete for table \'test_table\'.</h3>',
             'queryError' => false,
diff --git a/tests/classes/Controllers/Normalization/SecondNormalForm/FirstStepControllerTest.php b/tests/classes/Controllers/Normalization/SecondNormalForm/FirstStepControllerTest.php
index aebf3c88a4..116d0b871c 100644
--- a/tests/classes/Controllers/Normalization/SecondNormalForm/FirstStepControllerTest.php
+++ b/tests/classes/Controllers/Normalization/SecondNormalForm/FirstStepControllerTest.php
@@ -34,9 +34,9 @@ class FirstStepControllerTest extends AbstractTestCase
             $template,
             new Normalization($dbi, new Relation($dbi), new Transformations(), $template),
         );
-        $controller($this->createStub(ServerRequest::class));
+        $controller(self::createStub(ServerRequest::class));
 
-        $this->assertSame([
+        self::assertSame([
             'legendText' => 'Step 2.1 Find partial dependencies',
             'headText' => 'No partial dependencies possible as the primary key ( id ) has just one column.<br>',
             'subText' => '',
diff --git a/tests/classes/Controllers/Normalization/SecondNormalForm/NewTablesControllerTest.php b/tests/classes/Controllers/Normalization/SecondNormalForm/NewTablesControllerTest.php
index b3655df84c..3bc2aa466f 100644
--- a/tests/classes/Controllers/Normalization/SecondNormalForm/NewTablesControllerTest.php
+++ b/tests/classes/Controllers/Normalization/SecondNormalForm/NewTablesControllerTest.php
@@ -30,7 +30,7 @@ class NewTablesControllerTest extends AbstractTestCase
         DatabaseInterface::$instance = $dbi;
         $response = new ResponseRenderer();
         $template = new Template();
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('getParsedBodyParam')->willReturnMap([
             ['pd', null, json_encode(['ID, task' => [], 'task' => ['timestamp']])],
         ]);
@@ -42,7 +42,7 @@ class NewTablesControllerTest extends AbstractTestCase
         $controller($request);
 
         // phpcs:disable Generic.Files.LineLength.TooLong
-        $this->assertSame(
+        self::assertSame(
             '<p><b>In order to put the original table \'test_table\' into Second normal form we need to create the following tables:</b></p><p><input type="text" name="ID, task" value="test_table">( <u>ID, task</u> )<p><input type="text" name="task" value="table2">( <u>task</u>, timestamp )',
             $response->getHTMLResult(),
         );
diff --git a/tests/classes/Controllers/Normalization/ThirdNormalForm/CreateNewTablesControllerTest.php b/tests/classes/Controllers/Normalization/ThirdNormalForm/CreateNewTablesControllerTest.php
index 68c8d100ee..904afa9dae 100644
--- a/tests/classes/Controllers/Normalization/ThirdNormalForm/CreateNewTablesControllerTest.php
+++ b/tests/classes/Controllers/Normalization/ThirdNormalForm/CreateNewTablesControllerTest.php
@@ -53,7 +53,7 @@ class CreateNewTablesControllerTest extends AbstractTestCase
         DatabaseInterface::$instance = $dbi;
         $response = new ResponseRenderer();
         $template = new Template();
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('getParsedBodyParam')->willReturnMap([['newTables', null, $newTables]]);
 
         $controller = new CreateNewTablesController(
@@ -63,7 +63,7 @@ class CreateNewTablesControllerTest extends AbstractTestCase
         );
         $controller($request);
 
-        $this->assertSame([
+        self::assertSame([
             'legendText' => 'End of step',
             'headText' => '<h3>The third step of normalization is complete.</h3>',
             'queryError' => false,
diff --git a/tests/classes/Controllers/Normalization/ThirdNormalForm/FirstStepControllerTest.php b/tests/classes/Controllers/Normalization/ThirdNormalForm/FirstStepControllerTest.php
index 7979c935f5..f1157c42a0 100644
--- a/tests/classes/Controllers/Normalization/ThirdNormalForm/FirstStepControllerTest.php
+++ b/tests/classes/Controllers/Normalization/ThirdNormalForm/FirstStepControllerTest.php
@@ -31,7 +31,7 @@ class FirstStepControllerTest extends AbstractTestCase
         DatabaseInterface::$instance = $dbi;
         $response = new ResponseRenderer();
         $template = new Template();
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('getParsedBodyParam')->willReturnMap([['tables', null, ['test_table']]]);
 
         $controller = new FirstStepController(
@@ -42,7 +42,7 @@ class FirstStepControllerTest extends AbstractTestCase
         $controller($request);
 
         // phpcs:disable Generic.Files.LineLength.TooLong
-        $this->assertSame([
+        self::assertSame([
             'legendText' => 'Step 3.1 Find transitive dependencies',
             'headText' => 'Please answer the following question(s) carefully to obtain a correct normalization.',
             'subText' => 'For each column below, please select the <b>minimal set</b> of columns among given set whose values combined together are sufficient to determine the value of the column.<br>Note: A column may have no transitive dependency, in that case you don\'t have to select any.',
diff --git a/tests/classes/Controllers/Normalization/ThirdNormalForm/NewTablesControllerTest.php b/tests/classes/Controllers/Normalization/ThirdNormalForm/NewTablesControllerTest.php
index 8c6a2c2e6d..3bff5a2e8e 100644
--- a/tests/classes/Controllers/Normalization/ThirdNormalForm/NewTablesControllerTest.php
+++ b/tests/classes/Controllers/Normalization/ThirdNormalForm/NewTablesControllerTest.php
@@ -39,7 +39,7 @@ class NewTablesControllerTest extends AbstractTestCase
         DatabaseInterface::$instance = $dbi;
         $response = new ResponseRenderer();
         $template = new Template();
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('getParsedBodyParam')->willReturnMap([['tables', null, $tables], ['pd', null, $pd]]);
 
         $controller = new NewTablesController(
@@ -50,7 +50,7 @@ class NewTablesControllerTest extends AbstractTestCase
         $controller($request);
 
         // phpcs:disable Generic.Files.LineLength.TooLong
-        $this->assertSame([
+        self::assertSame([
             'html' => '<p><b>In order to put the original table \'test_table\' into Third normal form we need to create the following tables:</b></p><p><input type="text" name="test_table" value="test_table">( <u>event</u>, TypeOfEvent, period, Start_time, NameOfVenue, LocationOfVenue )<p><input type="text" name="table2" value="table2">( <u>NameOfVenue</u>, DateOfEvent )<p><input type="text" name="table3" value="table3">( <u>period</u>, NumberOfGuests )',
             'newTables' => [
                 'test_table' => [
diff --git a/tests/classes/Controllers/Operations/TableControllerTest.php b/tests/classes/Controllers/Operations/TableControllerTest.php
index 673b9c878f..6c4ed94a8a 100644
--- a/tests/classes/Controllers/Operations/TableControllerTest.php
+++ b/tests/classes/Controllers/Operations/TableControllerTest.php
@@ -133,6 +133,6 @@ class TableControllerTest extends AbstractTestCase
         );
         $controller($request);
 
-        $this->assertEquals($expectedOutput, $responseRenderer->getHTMLResult());
+        self::assertEquals($expectedOutput, $responseRenderer->getHTMLResult());
     }
 }
diff --git a/tests/classes/Controllers/SchemaExportControllerTest.php b/tests/classes/Controllers/SchemaExportControllerTest.php
index d93740251f..2a89650982 100644
--- a/tests/classes/Controllers/SchemaExportControllerTest.php
+++ b/tests/classes/Controllers/SchemaExportControllerTest.php
@@ -21,9 +21,9 @@ class SchemaExportControllerTest extends AbstractTestCase
     {
         DatabaseInterface::$instance = $this->createDatabaseInterface();
 
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('getParsedBodyParam')->willReturnMap([['db', null, 'test_db'], ['export_type', null, 'svg']]);
-        $export = $this->createStub(Export::class);
+        $export = self::createStub(Export::class);
         $export->method('getExportSchemaInfo')->willReturn([
             'fileName' => 'file.svg',
             'mediaType' => 'image/svg+xml',
@@ -34,9 +34,9 @@ class SchemaExportControllerTest extends AbstractTestCase
         $controller = new SchemaExportController($export, $response);
         $controller($request);
         $output = $this->getActualOutputForAssertion();
-        $this->assertSame('file data', $output);
-        $this->assertTrue($response->isDisabled());
-        $this->assertSame('', $response->getHTMLResult());
-        $this->assertSame([], $response->getJSONResult());
+        self::assertSame('file data', $output);
+        self::assertTrue($response->isDisabled());
+        self::assertSame('', $response->getHTMLResult());
+        self::assertSame([], $response->getJSONResult());
     }
 }
diff --git a/tests/classes/Controllers/Server/BinlogControllerTest.php b/tests/classes/Controllers/Server/BinlogControllerTest.php
index 2dd126f4f1..e3b139492c 100644
--- a/tests/classes/Controllers/Server/BinlogControllerTest.php
+++ b/tests/classes/Controllers/Server/BinlogControllerTest.php
@@ -51,42 +51,42 @@ class BinlogControllerTest extends AbstractTestCase
 
         $controller = new BinlogController($response, new Template(), DatabaseInterface::getInstance());
 
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('getParsedBodyParam')->willReturnMap([['log', null, 'index1'], ['pos', 0, '3']]);
         $this->dummyDbi->addSelectDb('mysql');
         $controller($request);
         $this->dummyDbi->assertAllSelectsConsumed();
         $actual = $response->getHTMLResult();
 
-        $this->assertStringContainsString('Select binary log to view', $actual);
-        $this->assertStringContainsString('<option value="index1" selected>', $actual);
-        $this->assertStringContainsString('<option value="index2">', $actual);
+        self::assertStringContainsString('Select binary log to view', $actual);
+        self::assertStringContainsString('<option value="index1" selected>', $actual);
+        self::assertStringContainsString('<option value="index2">', $actual);
 
-        $this->assertStringContainsString('Your SQL query has been executed successfully', $actual);
+        self::assertStringContainsString('Your SQL query has been executed successfully', $actual);
 
-        $this->assertStringContainsString("SHOW BINLOG EVENTS IN 'index1' LIMIT 3, 10", $actual);
+        self::assertStringContainsString("SHOW BINLOG EVENTS IN 'index1' LIMIT 3, 10", $actual);
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             '<table class="table table-striped table-hover align-middle" id="binlogTable">',
             $actual,
         );
 
         $urlNavigation = Url::getFromRoute('/server/binlog') . '" data-post="log=index1&pos=3&'
             . 'is_full_query=1&server=1&';
-        $this->assertStringContainsString($urlNavigation, $actual);
-        $this->assertStringContainsString('title="Previous"', $actual);
+        self::assertStringContainsString($urlNavigation, $actual);
+        self::assertStringContainsString('title="Previous"', $actual);
 
-        $this->assertStringContainsString('Log name', $actual);
-        $this->assertStringContainsString('Position', $actual);
-        $this->assertStringContainsString('Event type', $actual);
-        $this->assertStringContainsString('Server ID', $actual);
-        $this->assertStringContainsString('Original position', $actual);
+        self::assertStringContainsString('Log name', $actual);
+        self::assertStringContainsString('Position', $actual);
+        self::assertStringContainsString('Event type', $actual);
+        self::assertStringContainsString('Server ID', $actual);
+        self::assertStringContainsString('Original position', $actual);
 
-        $this->assertStringContainsString('index1_Log_name', $actual);
-        $this->assertStringContainsString('index1_Pos', $actual);
-        $this->assertStringContainsString('index1_Event_type', $actual);
-        $this->assertStringContainsString('index1_Server_id', $actual);
-        $this->assertStringContainsString('index1_Orig_log_pos', $actual);
-        $this->assertStringContainsString('index1_Info', $actual);
+        self::assertStringContainsString('index1_Log_name', $actual);
+        self::assertStringContainsString('index1_Pos', $actual);
+        self::assertStringContainsString('index1_Event_type', $actual);
+        self::assertStringContainsString('index1_Server_id', $actual);
+        self::assertStringContainsString('index1_Orig_log_pos', $actual);
+        self::assertStringContainsString('index1_Info', $actual);
     }
 }
diff --git a/tests/classes/Controllers/Server/CollationsControllerTest.php b/tests/classes/Controllers/Server/CollationsControllerTest.php
index b9bea819e0..d8184db478 100644
--- a/tests/classes/Controllers/Server/CollationsControllerTest.php
+++ b/tests/classes/Controllers/Server/CollationsControllerTest.php
@@ -47,20 +47,20 @@ class CollationsControllerTest extends AbstractTestCase
         $controller = new CollationsController($response, new Template(), DatabaseInterface::getInstance());
 
         $this->dummyDbi->addSelectDb('mysql');
-        $controller($this->createStub(ServerRequest::class));
+        $controller(self::createStub(ServerRequest::class));
         $this->dummyDbi->assertAllSelectsConsumed();
         $actual = $response->getHTMLResult();
 
-        $this->assertStringContainsString('<div><strong>latin1</strong></div>', $actual);
-        $this->assertStringContainsString('<div>cp1252 West European</div>', $actual);
-        $this->assertStringContainsString('<div><strong>latin1_swedish_ci</strong></div>', $actual);
-        $this->assertStringContainsString('<div>Swedish, case-insensitive</div>', $actual);
-        $this->assertStringContainsString('<span class="badge bg-secondary text-dark">default</span>', $actual);
-        $this->assertStringContainsString('<div><strong>utf8</strong></div>', $actual);
-        $this->assertStringContainsString('<div>UTF-8 Unicode</div>', $actual);
-        $this->assertStringContainsString('<div><strong>utf8_bin</strong></div>', $actual);
-        $this->assertStringContainsString('<div>Unicode, binary</div>', $actual);
-        $this->assertStringContainsString('<div><strong>utf8_general_ci</strong></div>', $actual);
-        $this->assertStringContainsString('<div>Unicode, case-insensitive</div>', $actual);
+        self::assertStringContainsString('<div><strong>latin1</strong></div>', $actual);
+        self::assertStringContainsString('<div>cp1252 West European</div>', $actual);
+        self::assertStringContainsString('<div><strong>latin1_swedish_ci</strong></div>', $actual);
+        self::assertStringContainsString('<div>Swedish, case-insensitive</div>', $actual);
+        self::assertStringContainsString('<span class="badge bg-secondary text-dark">default</span>', $actual);
+        self::assertStringContainsString('<div><strong>utf8</strong></div>', $actual);
+        self::assertStringContainsString('<div>UTF-8 Unicode</div>', $actual);
+        self::assertStringContainsString('<div><strong>utf8_bin</strong></div>', $actual);
+        self::assertStringContainsString('<div>Unicode, binary</div>', $actual);
+        self::assertStringContainsString('<div><strong>utf8_general_ci</strong></div>', $actual);
+        self::assertStringContainsString('<div>Unicode, case-insensitive</div>', $actual);
     }
 }
diff --git a/tests/classes/Controllers/Server/Databases/CreateControllerTest.php b/tests/classes/Controllers/Server/Databases/CreateControllerTest.php
index 8893312b3c..48cbf40297 100644
--- a/tests/classes/Controllers/Server/Databases/CreateControllerTest.php
+++ b/tests/classes/Controllers/Server/Databases/CreateControllerTest.php
@@ -45,7 +45,7 @@ final class CreateControllerTest extends AbstractTestCase
         $template = new Template();
         $controller = new CreateController($response, $template, $this->dbi);
 
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('getParsedBodyParam')->willReturnMap([
             ['new_db', null, 'test_db_error'],
             ['db_collation', null, null],
@@ -54,14 +54,14 @@ final class CreateControllerTest extends AbstractTestCase
         $controller($request);
         $actual = $response->getJSONResult();
 
-        $this->assertArrayHasKey('message', $actual);
-        $this->assertStringContainsString('<div class="alert alert-danger" role="alert">', $actual['message']);
+        self::assertArrayHasKey('message', $actual);
+        self::assertStringContainsString('<div class="alert alert-danger" role="alert">', $actual['message']);
 
         $response = new ResponseRenderer();
 
         $controller = new CreateController($response, $template, $this->dbi);
 
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('isAjax')->willReturn(true);
         $request->method('getParsedBodyParam')->willReturnMap([
             ['new_db', null, 'test_db'],
@@ -71,9 +71,9 @@ final class CreateControllerTest extends AbstractTestCase
         $controller($request);
         $actual = $response->getJSONResult();
 
-        $this->assertArrayHasKey('message', $actual);
-        $this->assertStringContainsString('<div class="alert alert-success" role="alert">', $actual['message']);
-        $this->assertStringContainsString(
+        self::assertArrayHasKey('message', $actual);
+        self::assertStringContainsString('<div class="alert alert-success" role="alert">', $actual['message']);
+        self::assertStringContainsString(
             sprintf(__('Database %1$s has been created.'), 'test_db'),
             $actual['message'],
         );
diff --git a/tests/classes/Controllers/Server/Databases/DestroyControllerTest.php b/tests/classes/Controllers/Server/Databases/DestroyControllerTest.php
index e7b13408fa..2b2573acb2 100644
--- a/tests/classes/Controllers/Server/Databases/DestroyControllerTest.php
+++ b/tests/classes/Controllers/Server/Databases/DestroyControllerTest.php
@@ -46,14 +46,14 @@ class DestroyControllerTest extends AbstractTestCase
             new RelationCleanup($dbi, new Relation($dbi)),
         );
 
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('isAjax')->willReturn(true);
 
         $controller($request);
         $actual = $response->getJSONResult();
 
-        $this->assertArrayHasKey('message', $actual);
-        $this->assertStringContainsString('<div class="alert alert-danger" role="alert">', $actual['message']);
-        $this->assertStringContainsString(__('No databases selected.'), $actual['message']);
+        self::assertArrayHasKey('message', $actual);
+        self::assertStringContainsString('<div class="alert alert-danger" role="alert">', $actual['message']);
+        self::assertStringContainsString(__('No databases selected.'), $actual['message']);
     }
 }
diff --git a/tests/classes/Controllers/Server/DatabasesControllerTest.php b/tests/classes/Controllers/Server/DatabasesControllerTest.php
index 31177f9f2d..16c1dc577f 100644
--- a/tests/classes/Controllers/Server/DatabasesControllerTest.php
+++ b/tests/classes/Controllers/Server/DatabasesControllerTest.php
@@ -56,25 +56,25 @@ class DatabasesControllerTest extends AbstractTestCase
             ['SCHEMA_NAME'],
         );
         $this->dummyDbi->addSelectDb('mysql');
-        $controller($this->createStub(ServerRequest::class));
+        $controller(self::createStub(ServerRequest::class));
         $this->dummyDbi->assertAllSelectsConsumed();
         $actual = $response->getHTMLResult();
 
-        $this->assertStringContainsString('data-filter-row="SAKILA"', $actual);
-        $this->assertStringContainsString('sakila', $actual);
-        $this->assertStringContainsString('utf8_general_ci', $actual);
-        $this->assertStringContainsString('title="Unicode, case-insensitive"', $actual);
-        $this->assertStringContainsString('data-filter-row="SAKILA"', $actual);
-        $this->assertStringContainsString('employees', $actual);
-        $this->assertStringContainsString('latin1_swedish_ci', $actual);
-        $this->assertStringContainsString('title="Swedish, case-insensitive"', $actual);
-        $this->assertStringContainsString('<span id="filter-rows-count">2</span>', $actual);
-        $this->assertStringContainsString('name="pos" value="0"', $actual);
-        $this->assertStringContainsString('name="sort_by" value="SCHEMA_NAME"', $actual);
-        $this->assertStringContainsString('name="sort_order" value="asc"', $actual);
-        $this->assertStringContainsString(__('Enable statistics'), $actual);
-        $this->assertStringContainsString(__('No privileges to create databases'), $actual);
-        $this->assertStringNotContainsString(__('Indexes'), $actual);
+        self::assertStringContainsString('data-filter-row="SAKILA"', $actual);
+        self::assertStringContainsString('sakila', $actual);
+        self::assertStringContainsString('utf8_general_ci', $actual);
+        self::assertStringContainsString('title="Unicode, case-insensitive"', $actual);
+        self::assertStringContainsString('data-filter-row="SAKILA"', $actual);
+        self::assertStringContainsString('employees', $actual);
+        self::assertStringContainsString('latin1_swedish_ci', $actual);
+        self::assertStringContainsString('title="Swedish, case-insensitive"', $actual);
+        self::assertStringContainsString('<span id="filter-rows-count">2</span>', $actual);
+        self::assertStringContainsString('name="pos" value="0"', $actual);
+        self::assertStringContainsString('name="sort_by" value="SCHEMA_NAME"', $actual);
+        self::assertStringContainsString('name="sort_order" value="asc"', $actual);
+        self::assertStringContainsString(__('Enable statistics'), $actual);
+        self::assertStringContainsString(__('No privileges to create databases'), $actual);
+        self::assertStringNotContainsString(__('Indexes'), $actual);
 
         $response = new ResponseRenderer();
 
@@ -87,20 +87,20 @@ class DatabasesControllerTest extends AbstractTestCase
         $_REQUEST['sort_order'] = 'desc';
 
         $this->dummyDbi->addSelectDb('mysql');
-        $controller($this->createStub(ServerRequest::class));
+        $controller(self::createStub(ServerRequest::class));
         $this->dummyDbi->assertAllSelectsConsumed();
         $actual = $response->getHTMLResult();
 
-        $this->assertStringNotContainsString(__('Enable statistics'), $actual);
-        $this->assertStringContainsString(__('Indexes'), $actual);
-        $this->assertStringContainsString('name="sort_by" value="SCHEMA_TABLES"', $actual);
-        $this->assertStringContainsString('name="sort_order" value="desc"', $actual);
-        $this->assertStringContainsString('name="statistics" value="1"', $actual);
-        $this->assertStringContainsString('title="3912174"', $actual);
-        $this->assertStringContainsString('3,912,174', $actual);
-        $this->assertStringContainsString('title="4358144"', $actual);
-        $this->assertStringContainsString('4.2', $actual);
-        $this->assertStringContainsString('MiB', $actual);
-        $this->assertStringContainsString('name="db_collation"', $actual);
+        self::assertStringNotContainsString(__('Enable statistics'), $actual);
+        self::assertStringContainsString(__('Indexes'), $actual);
+        self::assertStringContainsString('name="sort_by" value="SCHEMA_TABLES"', $actual);
+        self::assertStringContainsString('name="sort_order" value="desc"', $actual);
+        self::assertStringContainsString('name="statistics" value="1"', $actual);
+        self::assertStringContainsString('title="3912174"', $actual);
+        self::assertStringContainsString('3,912,174', $actual);
+        self::assertStringContainsString('title="4358144"', $actual);
+        self::assertStringContainsString('4.2', $actual);
+        self::assertStringContainsString('MiB', $actual);
+        self::assertStringContainsString('name="db_collation"', $actual);
     }
 }
diff --git a/tests/classes/Controllers/Server/EnginesControllerTest.php b/tests/classes/Controllers/Server/EnginesControllerTest.php
index ced92aac0f..4b5efbf3a7 100644
--- a/tests/classes/Controllers/Server/EnginesControllerTest.php
+++ b/tests/classes/Controllers/Server/EnginesControllerTest.php
@@ -47,20 +47,20 @@ class EnginesControllerTest extends AbstractTestCase
         $controller = new EnginesController($response, new Template(), DatabaseInterface::getInstance());
 
         $this->dummyDbi->addSelectDb('mysql');
-        $controller->__invoke($this->createStub(ServerRequest::class));
+        $controller->__invoke(self::createStub(ServerRequest::class));
         $this->dummyDbi->assertAllSelectsConsumed();
 
         $actual = $response->getHTMLResult();
 
-        $this->assertStringContainsString('<th scope="col">Storage Engine</th>', $actual);
-        $this->assertStringContainsString('<th scope="col">Description</th>', $actual);
+        self::assertStringContainsString('<th scope="col">Storage Engine</th>', $actual);
+        self::assertStringContainsString('<th scope="col">Description</th>', $actual);
 
-        $this->assertStringContainsString('<td>Federated MySQL storage engine</td>', $actual);
-        $this->assertStringContainsString('FEDERATED', $actual);
-        $this->assertStringContainsString('index.php?route=/server/engines/FEDERATED', $actual);
+        self::assertStringContainsString('<td>Federated MySQL storage engine</td>', $actual);
+        self::assertStringContainsString('FEDERATED', $actual);
+        self::assertStringContainsString('index.php?route=/server/engines/FEDERATED', $actual);
 
-        $this->assertStringContainsString('<td>dummy comment</td>', $actual);
-        $this->assertStringContainsString('dummy', $actual);
-        $this->assertStringContainsString('index.php?route=/server/engines/dummy', $actual);
+        self::assertStringContainsString('<td>dummy comment</td>', $actual);
+        self::assertStringContainsString('dummy', $actual);
+        self::assertStringContainsString('index.php?route=/server/engines/dummy', $actual);
     }
 }
diff --git a/tests/classes/Controllers/Server/PluginsControllerTest.php b/tests/classes/Controllers/Server/PluginsControllerTest.php
index e9929adf18..d9104efd08 100644
--- a/tests/classes/Controllers/Server/PluginsControllerTest.php
+++ b/tests/classes/Controllers/Server/PluginsControllerTest.php
@@ -60,15 +60,15 @@ class PluginsControllerTest extends AbstractTestCase
             'PLUGIN_STATUS' => 'ACTIVE',
         ];
 
-        $resultStub = $this->createMock(DummyResult::class);
+        $resultStub = self::createMock(DummyResult::class);
 
         $dbi = $this->getMockBuilder(DatabaseInterface::class)
             ->disableOriginalConstructor()
             ->getMock();
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('query')
             ->willReturn($resultStub);
-        $resultStub->expects($this->exactly(1))
+        $resultStub->expects(self::exactly(1))
             ->method('fetchAllAssoc')
             ->willReturn([$row]);
 
@@ -76,22 +76,22 @@ class PluginsControllerTest extends AbstractTestCase
 
         $controller = new PluginsController($response, new Template(), new Plugins($dbi), $this->dbi);
         $this->dummyDbi->addSelectDb('mysql');
-        $controller($this->createStub(ServerRequest::class));
+        $controller(self::createStub(ServerRequest::class));
         $this->dummyDbi->assertAllSelectsConsumed();
         $actual = $response->getHTMLResult();
 
         //validate 1:Items
-        $this->assertStringContainsString('<th scope="col">Plugin</th>', $actual);
-        $this->assertStringContainsString('<th scope="col">Description</th>', $actual);
-        $this->assertStringContainsString('<th scope="col">Version</th>', $actual);
-        $this->assertStringContainsString('<th scope="col">Author</th>', $actual);
-        $this->assertStringContainsString('<th scope="col">License</th>', $actual);
+        self::assertStringContainsString('<th scope="col">Plugin</th>', $actual);
+        self::assertStringContainsString('<th scope="col">Description</th>', $actual);
+        self::assertStringContainsString('<th scope="col">Version</th>', $actual);
+        self::assertStringContainsString('<th scope="col">Author</th>', $actual);
+        self::assertStringContainsString('<th scope="col">License</th>', $actual);
 
         //validate 2: one Item HTML
-        $this->assertStringContainsString('plugin_name1', $actual);
-        $this->assertStringContainsString('<td>plugin_description1</td>', $actual);
-        $this->assertStringContainsString('<td>plugin_version1</td>', $actual);
-        $this->assertStringContainsString('<td>plugin_author1</td>', $actual);
-        $this->assertStringContainsString('<td>plugin_license1</td>', $actual);
+        self::assertStringContainsString('plugin_name1', $actual);
+        self::assertStringContainsString('<td>plugin_description1</td>', $actual);
+        self::assertStringContainsString('<td>plugin_version1</td>', $actual);
+        self::assertStringContainsString('<td>plugin_author1</td>', $actual);
+        self::assertStringContainsString('<td>plugin_license1</td>', $actual);
     }
 }
diff --git a/tests/classes/Controllers/Server/Privileges/AccountLockControllerTest.php b/tests/classes/Controllers/Server/Privileges/AccountLockControllerTest.php
index da05204834..f73a5c77e7 100644
--- a/tests/classes/Controllers/Server/Privileges/AccountLockControllerTest.php
+++ b/tests/classes/Controllers/Server/Privileges/AccountLockControllerTest.php
@@ -33,10 +33,10 @@ class AccountLockControllerTest extends AbstractTestCase
 
         DatabaseInterface::$instance = $this->createDatabaseInterface();
 
-        $this->dbiStub = $this->createStub(DatabaseInterface::class);
+        $this->dbiStub = self::createStub(DatabaseInterface::class);
         $this->dbiStub->method('isMariaDB')->willReturn(true);
 
-        $this->requestStub = $this->createStub(ServerRequest::class);
+        $this->requestStub = self::createStub(ServerRequest::class);
         $this->requestStub->method('isAjax')->willReturn(true);
         $this->requestStub->method('getParsedBodyParam')->willReturn('test.user', 'test.host');
 
@@ -52,14 +52,14 @@ class AccountLockControllerTest extends AbstractTestCase
     public function testWithValidAccount(): void
     {
         $this->dbiStub->method('getVersion')->willReturn(100402);
-        $this->dbiStub->method('tryQuery')->willReturn($this->createStub(DummyResult::class));
+        $this->dbiStub->method('tryQuery')->willReturn(self::createStub(DummyResult::class));
 
         ($this->controller)($this->requestStub);
 
         $message = Message::success('The account test.user@test.host has been successfully locked.');
-        $this->assertEquals(200, $this->responseRendererStub->getResponse()->getStatusCode());
-        $this->assertTrue($this->responseRendererStub->hasSuccessState());
-        $this->assertEquals(['message' => $message->getDisplay()], $this->responseRendererStub->getJSONResult());
+        self::assertEquals(200, $this->responseRendererStub->getResponse()->getStatusCode());
+        self::assertTrue($this->responseRendererStub->hasSuccessState());
+        self::assertEquals(['message' => $message->getDisplay()], $this->responseRendererStub->getJSONResult());
     }
 
     public function testWithInvalidAccount(): void
@@ -71,9 +71,9 @@ class AccountLockControllerTest extends AbstractTestCase
         ($this->controller)($this->requestStub);
 
         $message = Message::error('Invalid account.');
-        $this->assertEquals(400, $this->responseRendererStub->getResponse()->getStatusCode());
-        $this->assertFalse($this->responseRendererStub->hasSuccessState());
-        $this->assertEquals(['message' => $message->getDisplay()], $this->responseRendererStub->getJSONResult());
+        self::assertEquals(400, $this->responseRendererStub->getResponse()->getStatusCode());
+        self::assertFalse($this->responseRendererStub->hasSuccessState());
+        self::assertEquals(['message' => $message->getDisplay()], $this->responseRendererStub->getJSONResult());
     }
 
     public function testWithUnsupportedServer(): void
@@ -83,8 +83,8 @@ class AccountLockControllerTest extends AbstractTestCase
         ($this->controller)($this->requestStub);
 
         $message = Message::error('Account locking is not supported.');
-        $this->assertEquals(400, $this->responseRendererStub->getResponse()->getStatusCode());
-        $this->assertFalse($this->responseRendererStub->hasSuccessState());
-        $this->assertEquals(['message' => $message->getDisplay()], $this->responseRendererStub->getJSONResult());
+        self::assertEquals(400, $this->responseRendererStub->getResponse()->getStatusCode());
+        self::assertFalse($this->responseRendererStub->hasSuccessState());
+        self::assertEquals(['message' => $message->getDisplay()], $this->responseRendererStub->getJSONResult());
     }
 }
diff --git a/tests/classes/Controllers/Server/Privileges/AccountUnlockControllerTest.php b/tests/classes/Controllers/Server/Privileges/AccountUnlockControllerTest.php
index b3c1ca989d..ac335cb2a8 100644
--- a/tests/classes/Controllers/Server/Privileges/AccountUnlockControllerTest.php
+++ b/tests/classes/Controllers/Server/Privileges/AccountUnlockControllerTest.php
@@ -33,10 +33,10 @@ class AccountUnlockControllerTest extends AbstractTestCase
 
         DatabaseInterface::$instance = $this->createDatabaseInterface();
 
-        $this->dbiStub = $this->createStub(DatabaseInterface::class);
+        $this->dbiStub = self::createStub(DatabaseInterface::class);
         $this->dbiStub->method('isMariaDB')->willReturn(true);
 
-        $this->requestStub = $this->createStub(ServerRequest::class);
+        $this->requestStub = self::createStub(ServerRequest::class);
         $this->requestStub->method('isAjax')->willReturn(true);
         $this->requestStub->method('getParsedBodyParam')->willReturn('test.user', 'test.host');
 
@@ -52,14 +52,14 @@ class AccountUnlockControllerTest extends AbstractTestCase
     public function testWithValidAccount(): void
     {
         $this->dbiStub->method('getVersion')->willReturn(100402);
-        $this->dbiStub->method('tryQuery')->willReturn($this->createStub(DummyResult::class));
+        $this->dbiStub->method('tryQuery')->willReturn(self::createStub(DummyResult::class));
 
         ($this->controller)($this->requestStub);
 
         $message = Message::success('The account test.user@test.host has been successfully unlocked.');
-        $this->assertEquals(200, $this->responseRendererStub->getResponse()->getStatusCode());
-        $this->assertTrue($this->responseRendererStub->hasSuccessState());
-        $this->assertEquals(['message' => $message->getDisplay()], $this->responseRendererStub->getJSONResult());
+        self::assertEquals(200, $this->responseRendererStub->getResponse()->getStatusCode());
+        self::assertTrue($this->responseRendererStub->hasSuccessState());
+        self::assertEquals(['message' => $message->getDisplay()], $this->responseRendererStub->getJSONResult());
     }
 
     public function testWithInvalidAccount(): void
@@ -71,9 +71,9 @@ class AccountUnlockControllerTest extends AbstractTestCase
         ($this->controller)($this->requestStub);
 
         $message = Message::error('Invalid account.');
-        $this->assertEquals(400, $this->responseRendererStub->getResponse()->getStatusCode());
-        $this->assertFalse($this->responseRendererStub->hasSuccessState());
-        $this->assertEquals(['message' => $message->getDisplay()], $this->responseRendererStub->getJSONResult());
+        self::assertEquals(400, $this->responseRendererStub->getResponse()->getStatusCode());
+        self::assertFalse($this->responseRendererStub->hasSuccessState());
+        self::assertEquals(['message' => $message->getDisplay()], $this->responseRendererStub->getJSONResult());
     }
 
     public function testWithUnsupportedServer(): void
@@ -83,8 +83,8 @@ class AccountUnlockControllerTest extends AbstractTestCase
         ($this->controller)($this->requestStub);
 
         $message = Message::error('Account locking is not supported.');
-        $this->assertEquals(400, $this->responseRendererStub->getResponse()->getStatusCode());
-        $this->assertFalse($this->responseRendererStub->hasSuccessState());
-        $this->assertEquals(['message' => $message->getDisplay()], $this->responseRendererStub->getJSONResult());
+        self::assertEquals(400, $this->responseRendererStub->getResponse()->getStatusCode());
+        self::assertFalse($this->responseRendererStub->hasSuccessState());
+        self::assertEquals(['message' => $message->getDisplay()], $this->responseRendererStub->getJSONResult());
     }
 }
diff --git a/tests/classes/Controllers/Server/PrivilegesControllerTest.php b/tests/classes/Controllers/Server/PrivilegesControllerTest.php
index 31aa7ea4c5..826ed3e74f 100644
--- a/tests/classes/Controllers/Server/PrivilegesControllerTest.php
+++ b/tests/classes/Controllers/Server/PrivilegesControllerTest.php
@@ -61,7 +61,7 @@ class PrivilegesControllerTest extends AbstractTestCase
         );
         // phpcs:enable
 
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
 
         $request->method('getParsedBodyParam')->willReturnMap([['old_username', '', ''], ['old_hostname', '', '']]);
 
@@ -71,17 +71,17 @@ class PrivilegesControllerTest extends AbstractTestCase
         (new PrivilegesController($response, new Template(), new Relation($this->dbi), $this->dbi))($request);
 
         $actual = $response->getHTMLResult();
-        $this->assertStringContainsString('User accounts overview', $actual);
-        $this->assertStringContainsString(
+        self::assertStringContainsString('User accounts overview', $actual);
+        self::assertStringContainsString(
             'id="checkbox_sel_users_1" value="pma&amp;amp;#27;localhost" name="selected_usr[]"',
             $actual,
         );
-        $this->assertStringContainsString('<code><dfn title="No privileges.">USAGE</dfn></code>', $actual);
-        $this->assertStringContainsString(
+        self::assertStringContainsString('<code><dfn title="No privileges.">USAGE</dfn></code>', $actual);
+        self::assertStringContainsString(
             'id="checkbox_sel_users_2" value="root&amp;amp;#27;localhost" name="selected_usr[]"',
             $actual,
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             '<code><dfn title="Includes all privileges except GRANT.">ALL PRIVILEGES</dfn></code>',
             $actual,
         );
diff --git a/tests/classes/Controllers/Server/ShowEngineControllerTest.php b/tests/classes/Controllers/Server/ShowEngineControllerTest.php
index 6b6d6cc614..7ec07d5964 100644
--- a/tests/classes/Controllers/Server/ShowEngineControllerTest.php
+++ b/tests/classes/Controllers/Server/ShowEngineControllerTest.php
@@ -56,31 +56,31 @@ class ShowEngineControllerTest extends AbstractTestCase
 
         $enginePlugin = StorageEngine::getEngine('Pbxt');
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             htmlspecialchars($enginePlugin->getTitle()),
             $actual,
         );
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             MySQLDocumentation::show($enginePlugin->getMysqlHelpPage()),
             $actual,
         );
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             htmlspecialchars($enginePlugin->getComment()),
             $actual,
         );
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             __('Variables'),
             $actual,
         );
-        $this->assertStringContainsString('index.php?route=/server/engines/Pbxt/Documentation', $actual);
-        $this->assertStringContainsString(
+        self::assertStringContainsString('index.php?route=/server/engines/Pbxt/Documentation', $actual);
+        self::assertStringContainsString(
             $enginePlugin->getSupportInformationMessage(),
             $actual,
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             'There is no detailed status information available for this storage engine.',
             $actual,
         );
diff --git a/tests/classes/Controllers/Server/Status/AdvisorControllerTest.php b/tests/classes/Controllers/Server/Status/AdvisorControllerTest.php
index 3a2897237e..c4a0100699 100644
--- a/tests/classes/Controllers/Server/Status/AdvisorControllerTest.php
+++ b/tests/classes/Controllers/Server/Status/AdvisorControllerTest.php
@@ -53,11 +53,11 @@ class AdvisorControllerTest extends AbstractTestCase
             new Advisor(DatabaseInterface::getInstance(), new ExpressionLanguage()),
         );
 
-        $controller($this->createStub(ServerRequest::class));
+        $controller(self::createStub(ServerRequest::class));
 
         $expected = $this->template->render('server/status/advisor/index', ['data' => []]);
 
-        $this->assertSame(
+        self::assertSame(
             $expected,
             $this->response->getHTMLResult(),
         );
@@ -88,18 +88,18 @@ class AdvisorControllerTest extends AbstractTestCase
             ],
         ];
 
-        $advisor = $this->createMock(Advisor::class);
+        $advisor = self::createMock(Advisor::class);
         $advisor->method('run')->willReturn($advisorData);
 
         $this->data->dataLoaded = true;
 
         $controller = new AdvisorController($this->response, $this->template, $this->data, $advisor);
 
-        $controller($this->createStub(ServerRequest::class));
+        $controller(self::createStub(ServerRequest::class));
 
         $expected = $this->template->render('server/status/advisor/index', ['data' => $advisorData]);
 
-        $this->assertSame(
+        self::assertSame(
             $expected,
             $this->response->getHTMLResult(),
         );
diff --git a/tests/classes/Controllers/Server/Status/Monitor/GeneralLogControllerTest.php b/tests/classes/Controllers/Server/Status/Monitor/GeneralLogControllerTest.php
index 502bbc2a4a..fad38de730 100644
--- a/tests/classes/Controllers/Server/Status/Monitor/GeneralLogControllerTest.php
+++ b/tests/classes/Controllers/Server/Status/Monitor/GeneralLogControllerTest.php
@@ -62,7 +62,7 @@ class GeneralLogControllerTest extends AbstractTestCase
             $dbi,
         );
 
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('isAjax')->willReturn(true);
         $request->method('getParsedBodyParam')->willReturnMap([
             ['time_start', null, '0'],
@@ -78,8 +78,8 @@ class GeneralLogControllerTest extends AbstractTestCase
         $resultRows = [$value, $value2];
         $resultSum = ['argument' => 10, 'TOTAL' => 21, 'argument3' => 11];
 
-        $this->assertEquals(2, $ret['message']['numRows']);
-        $this->assertEquals($resultRows, $ret['message']['rows']);
-        $this->assertEquals($resultSum, $ret['message']['sum']);
+        self::assertEquals(2, $ret['message']['numRows']);
+        self::assertEquals($resultRows, $ret['message']['rows']);
+        self::assertEquals($resultSum, $ret['message']['sum']);
     }
 }
diff --git a/tests/classes/Controllers/Server/Status/Monitor/LogVarsControllerTest.php b/tests/classes/Controllers/Server/Status/Monitor/LogVarsControllerTest.php
index 0e1c481600..35a02fb42f 100644
--- a/tests/classes/Controllers/Server/Status/Monitor/LogVarsControllerTest.php
+++ b/tests/classes/Controllers/Server/Status/Monitor/LogVarsControllerTest.php
@@ -65,7 +65,7 @@ class LogVarsControllerTest extends AbstractTestCase
             $dbi,
         );
 
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('isAjax')->willReturn(true);
         $request->method('getParsedBodyParam')->willReturnMap([['varName', null, 'varName']]);
 
@@ -74,6 +74,6 @@ class LogVarsControllerTest extends AbstractTestCase
         $this->dummyDbi->assertAllSelectsConsumed();
         $ret = $response->getJSONResult();
 
-        $this->assertEquals($value, $ret['message']);
+        self::assertEquals($value, $ret['message']);
     }
 }
diff --git a/tests/classes/Controllers/Server/Status/Monitor/QueryAnalyzerControllerTest.php b/tests/classes/Controllers/Server/Status/Monitor/QueryAnalyzerControllerTest.php
index 2035494337..91dab983ed 100644
--- a/tests/classes/Controllers/Server/Status/Monitor/QueryAnalyzerControllerTest.php
+++ b/tests/classes/Controllers/Server/Status/Monitor/QueryAnalyzerControllerTest.php
@@ -45,7 +45,7 @@ class QueryAnalyzerControllerTest extends AbstractTestCase
         $statusData = new Data($dbi, $config);
         $controller = new QueryAnalyzerController($response, new Template(), $statusData, new Monitor($dbi), $dbi);
 
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('isAjax')->willReturn(true);
         $request->method('getParsedBodyParam')->willReturnMap([['database', '', 'database'], ['query', '', 'query']]);
 
@@ -55,12 +55,12 @@ class QueryAnalyzerControllerTest extends AbstractTestCase
         $dummyDbi->assertAllSelectsConsumed();
         $ret = $response->getJSONResult();
 
-        $this->assertEquals('cached_affected_rows', $ret['message']['affectedRows']);
-        $this->assertEquals(
+        self::assertEquals('cached_affected_rows', $ret['message']['affectedRows']);
+        self::assertEquals(
             [],
             $ret['message']['profiling'],
         );
-        $this->assertEquals(
+        self::assertEquals(
             [$value],
             $ret['message']['explain'],
         );
diff --git a/tests/classes/Controllers/Server/Status/Monitor/SlowLogControllerTest.php b/tests/classes/Controllers/Server/Status/Monitor/SlowLogControllerTest.php
index 571a74eb13..cdd13a2c9c 100644
--- a/tests/classes/Controllers/Server/Status/Monitor/SlowLogControllerTest.php
+++ b/tests/classes/Controllers/Server/Status/Monitor/SlowLogControllerTest.php
@@ -58,7 +58,7 @@ class SlowLogControllerTest extends AbstractTestCase
             $dbi,
         );
 
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('isAjax')->willReturn(true);
         $request->method('getParsedBodyParam')->willReturnMap([['time_start', null, '0'], ['time_end', null, '10']]);
 
@@ -69,8 +69,8 @@ class SlowLogControllerTest extends AbstractTestCase
 
         $resultRows = [['sql_text' => 'insert sql_text', '#' => 11], ['sql_text' => 'update sql_text', '#' => 10]];
         $resultSum = ['insert' => 11, 'TOTAL' => 21, 'update' => 10];
-        $this->assertEquals(2, $ret['message']['numRows']);
-        $this->assertEquals($resultRows, $ret['message']['rows']);
-        $this->assertEquals($resultSum, $ret['message']['sum']);
+        self::assertEquals(2, $ret['message']['numRows']);
+        self::assertEquals($resultRows, $ret['message']['rows']);
+        self::assertEquals($resultSum, $ret['message']['sum']);
     }
 }
diff --git a/tests/classes/Controllers/Server/Status/MonitorControllerTest.php b/tests/classes/Controllers/Server/Status/MonitorControllerTest.php
index 905b49fd1f..07d3b5d753 100644
--- a/tests/classes/Controllers/Server/Status/MonitorControllerTest.php
+++ b/tests/classes/Controllers/Server/Status/MonitorControllerTest.php
@@ -58,43 +58,43 @@ class MonitorControllerTest extends AbstractTestCase
         );
 
         $this->dummyDbi->addSelectDb('mysql');
-        $controller($this->createStub(ServerRequest::class));
+        $controller(self::createStub(ServerRequest::class));
         $this->dummyDbi->assertAllSelectsConsumed();
         $html = $response->getHTMLResult();
 
-        $this->assertStringContainsString(__('Start monitor'), $html);
-        $this->assertStringContainsString(
+        self::assertStringContainsString(__('Start monitor'), $html);
+        self::assertStringContainsString(
             __('Settings'),
             $html,
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             __('Done dragging (rearranging) charts'),
             $html,
         );
 
-        $this->assertStringContainsString('<div class="collapse" id="monitorSettingsContent">', $html);
-        $this->assertStringContainsString(
+        self::assertStringContainsString('<div class="collapse" id="monitorSettingsContent">', $html);
+        self::assertStringContainsString(
             __('Enable charts dragging'),
             $html,
         );
-        $this->assertStringContainsString('<option>3</option>', $html);
+        self::assertStringContainsString('<option>3</option>', $html);
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             __('Monitor Instructions'),
             $html,
         );
-        $this->assertStringContainsString('monitorInstructionsDialog', $html);
+        self::assertStringContainsString('monitorInstructionsDialog', $html);
 
-        $this->assertStringContainsString('<div class="modal fade" id="addChartModal"', $html);
-        $this->assertStringContainsString('<div id="chartVariableSettings">', $html);
-        $this->assertStringContainsString('<option>Processes</option>', $html);
-        $this->assertStringContainsString('<option>Connections</option>', $html);
+        self::assertStringContainsString('<div class="modal fade" id="addChartModal"', $html);
+        self::assertStringContainsString('<div id="chartVariableSettings">', $html);
+        self::assertStringContainsString('<option>Processes</option>', $html);
+        self::assertStringContainsString('<option>Connections</option>', $html);
 
-        $this->assertStringContainsString('<form id="js_data" class="hide">', $html);
-        $this->assertStringContainsString('<input type="hidden" name="server_time"', $html);
+        self::assertStringContainsString('<form id="js_data" class="hide">', $html);
+        self::assertStringContainsString('<input type="hidden" name="server_time"', $html);
         //validate 2: inputs
-        $this->assertStringContainsString('<input type="hidden" name="is_superuser"', $html);
-        $this->assertStringContainsString('<input type="hidden" name="server_db_isLocal"', $html);
-        $this->assertStringContainsString('<div id="explain_docu" class="hide">', $html);
+        self::assertStringContainsString('<input type="hidden" name="is_superuser"', $html);
+        self::assertStringContainsString('<input type="hidden" name="server_db_isLocal"', $html);
+        self::assertStringContainsString('<div id="explain_docu" class="hide">', $html);
     }
 }
diff --git a/tests/classes/Controllers/Server/Status/Processes/RefreshControllerTest.php b/tests/classes/Controllers/Server/Status/Processes/RefreshControllerTest.php
index ee92e28b86..f0d463e22c 100644
--- a/tests/classes/Controllers/Server/Status/Processes/RefreshControllerTest.php
+++ b/tests/classes/Controllers/Server/Status/Processes/RefreshControllerTest.php
@@ -65,7 +65,7 @@ class RefreshControllerTest extends AbstractTestCase
             new Processes(DatabaseInterface::getInstance()),
         );
 
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('isAjax')->willReturn(true);
         $request->method('getParsedBodyParam')->willReturnMap([
             ['column_name', '', ''],
@@ -77,44 +77,44 @@ class RefreshControllerTest extends AbstractTestCase
         $controller($request);
         $html = $response->getHTMLResult();
 
-        $this->assertStringContainsString('index.php?route=/server/status/processes', $html);
+        self::assertStringContainsString('index.php?route=/server/status/processes', $html);
         $killProcess = 'data-post="'
             . Url::getCommon(['kill' => $process['Id']], '') . '"';
-        $this->assertStringContainsString($killProcess, $html);
-        $this->assertStringContainsString('ajax kill_process', $html);
-        $this->assertStringContainsString(
+        self::assertStringContainsString($killProcess, $html);
+        self::assertStringContainsString('ajax kill_process', $html);
+        self::assertStringContainsString(
             __('Kill'),
             $html,
         );
 
         //validate 2: $process['User']
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             htmlspecialchars($process['User']),
             $html,
         );
 
         //validate 3: $process['Host']
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             htmlspecialchars($process['Host']),
             $html,
         );
 
         //validate 4: $process['db']
-        $this->assertStringContainsString($process['Db'], $html);
+        self::assertStringContainsString($process['Db'], $html);
 
         //validate 5: $process['Command']
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             htmlspecialchars($process['Command']),
             $html,
         );
 
         //validate 6: $process['Time']
-        $this->assertStringContainsString($process['Time'], $html);
+        self::assertStringContainsString($process['Time'], $html);
 
         //validate 7: $process['state']
-        $this->assertStringContainsString($process['State'], $html);
+        self::assertStringContainsString($process['State'], $html);
 
         //validate 8: $process['info']
-        $this->assertStringContainsString($process['Info'], $html);
+        self::assertStringContainsString($process['Info'], $html);
     }
 }
diff --git a/tests/classes/Controllers/Server/Status/ProcessesControllerTest.php b/tests/classes/Controllers/Server/Status/ProcessesControllerTest.php
index 4aeb2336cb..32cd21296c 100644
--- a/tests/classes/Controllers/Server/Status/ProcessesControllerTest.php
+++ b/tests/classes/Controllers/Server/Status/ProcessesControllerTest.php
@@ -59,33 +59,33 @@ class ProcessesControllerTest extends AbstractTestCase
         );
 
         $this->dummyDbi->addSelectDb('mysql');
-        $controller($this->createStub(ServerRequest::class));
+        $controller(self::createStub(ServerRequest::class));
         $this->dummyDbi->assertAllSelectsConsumed();
         $html = $response->getHTMLResult();
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             'Note: Enabling the auto refresh here might cause '
             . 'heavy traffic between the web server and the MySQL server.',
             $html,
         );
         // Test tab links
-        $this->assertStringContainsString('<div class="tabLinks row">', $html);
-        $this->assertStringContainsString('<a id="toggleRefresh" href="#">', $html);
-        $this->assertStringContainsString('play', $html);
-        $this->assertStringContainsString('Start auto refresh', $html);
-        $this->assertStringContainsString('<select id="id_refreshRate"', $html);
-        $this->assertStringContainsString('<option value="5" selected>', $html);
-        $this->assertStringContainsString('5 seconds', $html);
+        self::assertStringContainsString('<div class="tabLinks row">', $html);
+        self::assertStringContainsString('<a id="toggleRefresh" href="#">', $html);
+        self::assertStringContainsString('play', $html);
+        self::assertStringContainsString('Start auto refresh', $html);
+        self::assertStringContainsString('<select id="id_refreshRate"', $html);
+        self::assertStringContainsString('<option value="5" selected>', $html);
+        self::assertStringContainsString('5 seconds', $html);
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             '<table id="tableprocesslist" class="table table-striped table-hover sortable w-auto">',
             $html,
         );
-        $this->assertStringContainsString('<th>Processes</th>', $html);
-        $this->assertStringContainsString('Show full queries', $html);
-        $this->assertStringContainsString('index.php?route=/server/status/processes', $html);
+        self::assertStringContainsString('<th>Processes</th>', $html);
+        self::assertStringContainsString('Show full queries', $html);
+        self::assertStringContainsString('index.php?route=/server/status/processes', $html);
 
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('getParsedBodyParam')->willReturnMap([
             ['column_name', '', 'Database'],
             ['order_by_field', '', 'Db'],
@@ -98,11 +98,11 @@ class ProcessesControllerTest extends AbstractTestCase
         $this->dummyDbi->assertAllSelectsConsumed();
         $html = $response->getHTMLResult();
 
-        $this->assertStringContainsString('Truncate shown queries', $html);
-        $this->assertStringContainsString('Database', $html);
-        $this->assertStringContainsString('DESC', $html);
+        self::assertStringContainsString('Truncate shown queries', $html);
+        self::assertStringContainsString('Database', $html);
+        self::assertStringContainsString('DESC', $html);
 
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('getParsedBodyParam')->willReturnMap([
             ['column_name', '', 'Host'],
             ['order_by_field', '', 'Host'],
@@ -115,7 +115,7 @@ class ProcessesControllerTest extends AbstractTestCase
         $this->dummyDbi->assertAllSelectsConsumed();
         $html = $response->getHTMLResult();
 
-        $this->assertStringContainsString('Host', $html);
-        $this->assertStringContainsString('ASC', $html);
+        self::assertStringContainsString('Host', $html);
+        self::assertStringContainsString('ASC', $html);
     }
 }
diff --git a/tests/classes/Controllers/Server/Status/QueriesControllerTest.php b/tests/classes/Controllers/Server/Status/QueriesControllerTest.php
index edbf0da808..98f9845379 100644
--- a/tests/classes/Controllers/Server/Status/QueriesControllerTest.php
+++ b/tests/classes/Controllers/Server/Status/QueriesControllerTest.php
@@ -65,7 +65,7 @@ class QueriesControllerTest extends AbstractTestCase
         $controller = new QueriesController($response, new Template(), $this->data, DatabaseInterface::getInstance());
 
         $this->dummyDbi->addSelectDb('mysql');
-        $controller($this->createStub(ServerRequest::class));
+        $controller(self::createStub(ServerRequest::class));
         $this->dummyDbi->assertAllSelectsConsumed();
         $html = $response->getHTMLResult();
 
@@ -75,26 +75,26 @@ class QueriesControllerTest extends AbstractTestCase
 
         $questionsFromStart = __('Questions since startup:') . ' ' . Util::formatNumber($totalQueries, 0);
 
-        $this->assertStringContainsString('<h3>', $html);
-        $this->assertStringContainsString($questionsFromStart, $html);
+        self::assertStringContainsString('<h3>', $html);
+        self::assertStringContainsString($questionsFromStart, $html);
 
-        $this->assertStringContainsString('per hour:', $html);
-        $this->assertStringContainsString(Util::formatNumber($totalQueries * $hourFactor, 0), $html);
+        self::assertStringContainsString('per hour:', $html);
+        self::assertStringContainsString(Util::formatNumber($totalQueries * $hourFactor, 0), $html);
 
         $valuePerMinute = Util::formatNumber($totalQueries * 60 / $this->data->status['Uptime'], 0);
-        $this->assertStringContainsString('per minute:', $html);
-        $this->assertStringContainsString(htmlspecialchars($valuePerMinute), $html);
+        self::assertStringContainsString('per minute:', $html);
+        self::assertStringContainsString(htmlspecialchars($valuePerMinute), $html);
 
-        $this->assertStringContainsString('Statements', $html);
+        self::assertStringContainsString('Statements', $html);
 
-        $this->assertStringContainsString('Change Db', $html);
-        $this->assertStringContainsString('54', $html);
-        $this->assertStringContainsString('Select', $html);
-        $this->assertStringContainsString('Set Option', $html);
-        $this->assertStringContainsString('Show Databases', $html);
-        $this->assertStringContainsString('Show Status', $html);
-        $this->assertStringContainsString('Show Tables', $html);
+        self::assertStringContainsString('Change Db', $html);
+        self::assertStringContainsString('54', $html);
+        self::assertStringContainsString('Select', $html);
+        self::assertStringContainsString('Set Option', $html);
+        self::assertStringContainsString('Show Databases', $html);
+        self::assertStringContainsString('Show Status', $html);
+        self::assertStringContainsString('Show Tables', $html);
 
-        $this->assertStringContainsString('<canvas id="query-statistics-chart" data-chart-data="', $html);
+        self::assertStringContainsString('<canvas id="query-statistics-chart" data-chart-data="', $html);
     }
 }
diff --git a/tests/classes/Controllers/Server/Status/StatusControllerTest.php b/tests/classes/Controllers/Server/Status/StatusControllerTest.php
index 2b189639ce..74062aebe8 100644
--- a/tests/classes/Controllers/Server/Status/StatusControllerTest.php
+++ b/tests/classes/Controllers/Server/Status/StatusControllerTest.php
@@ -74,44 +74,44 @@ class StatusControllerTest extends AbstractTestCase
         $replicationInfo->replicaVariables = [];
 
         $this->dummyDbi->addSelectDb('mysql');
-        $controller($this->createStub(ServerRequest::class));
+        $controller(self::createStub(ServerRequest::class));
         $this->dummyDbi->assertAllSelectsConsumed();
         $html = $response->getHTMLResult();
 
         $traffic = $bytesReceived + $bytesSent;
         $trafficHtml = 'Network traffic since startup: ' . $traffic . ' B';
-        $this->assertStringContainsString($trafficHtml, $html);
+        self::assertStringContainsString($trafficHtml, $html);
         //updatetime
         $upTimeHtml = 'This MySQL server has been running for 0 days, 10 hours, 0 minutes and 0 seconds';
-        $this->assertStringContainsString($upTimeHtml, $html);
+        self::assertStringContainsString($upTimeHtml, $html);
         //primary state
         $primaryHtml = 'This MySQL server works as <b>primary</b>';
-        $this->assertStringContainsString($primaryHtml, $html);
+        self::assertStringContainsString($primaryHtml, $html);
 
         //validate 2: Status::getHtmlForServerStateTraffic
         $trafficHtml = '<table class="table table-striped table-hover col-12 col-md-5 w-auto">';
-        $this->assertStringContainsString($trafficHtml, $html);
+        self::assertStringContainsString($trafficHtml, $html);
         //traffic hint
         $trafficHtml = 'On a busy server, the byte counters may overrun';
-        $this->assertStringContainsString($trafficHtml, $html);
+        self::assertStringContainsString($trafficHtml, $html);
         //$bytes_received
-        $this->assertStringContainsString('<td class="font-monospace text-end">' . $bytesReceived . ' B', $html);
+        self::assertStringContainsString('<td class="font-monospace text-end">' . $bytesReceived . ' B', $html);
         //$bytes_sent
-        $this->assertStringContainsString('<td class="font-monospace text-end">' . $bytesSent . ' B', $html);
+        self::assertStringContainsString('<td class="font-monospace text-end">' . $bytesSent . ' B', $html);
 
         //validate 3: Status::getHtmlForServerStateConnections
-        $this->assertStringContainsString('<th scope="col">Connections</th>', $html);
-        $this->assertStringContainsString('<th class="text-end" scope="col">ø per hour</th>', $html);
-        $this->assertStringContainsString(
+        self::assertStringContainsString('<th scope="col">Connections</th>', $html);
+        self::assertStringContainsString('<th class="text-end" scope="col">ø per hour</th>', $html);
+        self::assertStringContainsString(
             '<table class="table table-striped table-hover col-12 col-md-6 w-auto">',
             $html,
         );
-        $this->assertStringContainsString('<th>Max. concurrent connections</th>', $html);
+        self::assertStringContainsString('<th>Max. concurrent connections</th>', $html);
         //Max_used_connections
-        $this->assertStringContainsString('<td class="font-monospace text-end">' . $maxUsedConnections, $html);
-        $this->assertStringContainsString('<th>Failed attempts</th>', $html);
+        self::assertStringContainsString('<td class="font-monospace text-end">' . $maxUsedConnections, $html);
+        self::assertStringContainsString('<th>Failed attempts</th>', $html);
         //Aborted_connects
-        $this->assertStringContainsString('<td class="font-monospace text-end">' . $abortedConnections, $html);
-        $this->assertStringContainsString('<th>Aborted</th>', $html);
+        self::assertStringContainsString('<td class="font-monospace text-end">' . $abortedConnections, $html);
+        self::assertStringContainsString('<th>Aborted</th>', $html);
     }
 }
diff --git a/tests/classes/Controllers/Server/Status/VariablesControllerTest.php b/tests/classes/Controllers/Server/Status/VariablesControllerTest.php
index a5cc63e9aa..c9b4f9161a 100644
--- a/tests/classes/Controllers/Server/Status/VariablesControllerTest.php
+++ b/tests/classes/Controllers/Server/Status/VariablesControllerTest.php
@@ -51,42 +51,42 @@ class VariablesControllerTest extends AbstractTestCase
         $controller = new VariablesController($response, new Template(), $this->data, DatabaseInterface::getInstance());
 
         $this->dummyDbi->addSelectDb('mysql');
-        $controller($this->createStub(ServerRequest::class));
+        $controller(self::createStub(ServerRequest::class));
         $this->dummyDbi->assertAllSelectsConsumed();
         $html = $response->getHTMLResult();
 
-        $this->assertStringContainsString('<div class="card mb-3" id="tableFilter">', $html);
-        $this->assertStringContainsString('index.php?route=/server/status/variables', $html);
+        self::assertStringContainsString('<div class="card mb-3" id="tableFilter">', $html);
+        self::assertStringContainsString('index.php?route=/server/status/variables', $html);
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             '<label class="col-12 col-form-label" for="filterText">Containing the word:</label>',
             $html,
         );
 
-        $this->assertStringContainsString('<label class="form-check-label" for="filterAlert">', $html);
-        $this->assertStringContainsString('Show only alert values', $html);
-        $this->assertStringContainsString('Filter by category', $html);
-        $this->assertStringContainsString('Show unformatted values', $html);
+        self::assertStringContainsString('<label class="form-check-label" for="filterAlert">', $html);
+        self::assertStringContainsString('Show only alert values', $html);
+        self::assertStringContainsString('Filter by category', $html);
+        self::assertStringContainsString('Show unformatted values', $html);
 
-        $this->assertStringContainsString('<div id="linkSuggestions" class="defaultLinks hide"', $html);
+        self::assertStringContainsString('<div id="linkSuggestions" class="defaultLinks hide"', $html);
 
-        $this->assertStringContainsString('Related links:', $html);
-        $this->assertStringContainsString('Flush (close) all tables', $html);
-        $this->assertStringContainsString('<span class="status_binlog_cache">', $html);
+        self::assertStringContainsString('Related links:', $html);
+        self::assertStringContainsString('Flush (close) all tables', $html);
+        self::assertStringContainsString('<span class="status_binlog_cache">', $html);
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             '<table class="table table-striped table-hover table-sm" id="serverStatusVariables">',
             $html,
         );
-        $this->assertStringContainsString('<th scope="col">Variable</th>', $html);
-        $this->assertStringContainsString('<th scope="col">Value</th>', $html);
-        $this->assertStringContainsString('<th scope="col">Description</th>', $html);
+        self::assertStringContainsString('<th scope="col">Variable</th>', $html);
+        self::assertStringContainsString('<th scope="col">Value</th>', $html);
+        self::assertStringContainsString('<th scope="col">Description</th>', $html);
 
-        $this->assertStringContainsString('Aborted clients', $html);
-        $this->assertStringContainsString('<span class="text-success">', $html);
-        $this->assertStringContainsString('Aborted connects', $html);
-        $this->assertStringContainsString('Com delete multi', $html);
-        $this->assertStringContainsString('Com create function', $html);
-        $this->assertStringContainsString('Com empty query', $html);
+        self::assertStringContainsString('Aborted clients', $html);
+        self::assertStringContainsString('<span class="text-success">', $html);
+        self::assertStringContainsString('Aborted connects', $html);
+        self::assertStringContainsString('Com delete multi', $html);
+        self::assertStringContainsString('Com create function', $html);
+        self::assertStringContainsString('Com empty query', $html);
     }
 }
diff --git a/tests/classes/Controllers/Server/VariablesControllerTest.php b/tests/classes/Controllers/Server/VariablesControllerTest.php
index dadf769e31..32e4ed5073 100644
--- a/tests/classes/Controllers/Server/VariablesControllerTest.php
+++ b/tests/classes/Controllers/Server/VariablesControllerTest.php
@@ -63,7 +63,7 @@ class VariablesControllerTest extends AbstractTestCase
             ['SHOW GLOBAL VARIABLES;', 0, 1, ConnectionType::User, $serverGlobalVariables],
         ];
 
-        $this->mockedDbi->expects($this->any())->method('fetchResult')
+        $this->mockedDbi->expects(self::any())->method('fetchResult')
             ->willReturnMap($fetchResult);
     }
 
@@ -73,44 +73,44 @@ class VariablesControllerTest extends AbstractTestCase
 
         $resultStub = $this->createMock(DummyResult::class);
 
-        $this->mockedDbi->expects($this->once())
+        $this->mockedDbi->expects(self::once())
             ->method('tryQuery')
             ->with('SHOW SESSION VARIABLES;')
             ->willReturn($resultStub);
 
         $controller = new VariablesController($response, new Template(), $this->mockedDbi);
 
-        $controller($this->createStub(ServerRequest::class));
+        $controller(self::createStub(ServerRequest::class));
         $html = $response->getHTMLResult();
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             Generator::getIcon('b_save', __('Save')),
             $html,
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             Generator::getIcon('b_close', __('Cancel')),
             $html,
         );
-        $this->assertStringContainsString('<div class="card-header">' . __('Filters') . '</div>', $html);
-        $this->assertStringContainsString(
+        self::assertStringContainsString('<div class="card-header">' . __('Filters') . '</div>', $html);
+        self::assertStringContainsString(
             __('Containing the word:'),
             $html,
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             __('Variable'),
             $html,
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             __('Value'),
             $html,
         );
 
         $name = 'auto_increment_increment';
         $value = htmlspecialchars(str_replace('_', ' ', $name));
-        $this->assertStringContainsString($value, $html);
+        self::assertStringContainsString($value, $html);
         $name = 'auto_increment_offset';
         $value = htmlspecialchars(str_replace('_', ' ', $name));
-        $this->assertStringContainsString($value, $html);
+        self::assertStringContainsString($value, $html);
     }
 
     /**
@@ -132,7 +132,7 @@ class VariablesControllerTest extends AbstractTestCase
         $voidProviderMock = $this->getMockBuilder(ServerVariablesVoidProvider::class)->getMock();
 
         $voidProviderMock
-            ->expects($this->exactly(2))
+            ->expects(self::exactly(2))
             ->method('getVariableType')
             ->willReturn('byte', 'string');
 
@@ -146,8 +146,8 @@ class VariablesControllerTest extends AbstractTestCase
             $args,
         );
 
-        $this->assertEquals('<abbr title="3">3 B</abbr>', $formattedValue);
-        $this->assertTrue($isHtmlFormatted);
+        self::assertEquals('<abbr title="3">3 B</abbr>', $formattedValue);
+        self::assertTrue($isHtmlFormatted);
 
         //name is_numeric and the value type is not byte
         $args = [$nameForValueNotByte, '3'];
@@ -157,8 +157,8 @@ class VariablesControllerTest extends AbstractTestCase
             'formatVariable',
             $args,
         );
-        $this->assertEquals('3', $formattedValue);
-        $this->assertFalse($isHtmlFormatted);
+        self::assertEquals('3', $formattedValue);
+        self::assertFalse($isHtmlFormatted);
 
         //value is not a number
         $args = [$nameForValueNotByte, 'value'];
@@ -168,8 +168,8 @@ class VariablesControllerTest extends AbstractTestCase
             'formatVariable',
             $args,
         );
-        $this->assertEquals('value', $formattedValue);
-        $this->assertFalse($isHtmlFormatted);
+        self::assertEquals('value', $formattedValue);
+        self::assertFalse($isHtmlFormatted);
     }
 
     /**
@@ -178,7 +178,7 @@ class VariablesControllerTest extends AbstractTestCase
     public function testFormatVariableMariaDbMySqlKbs(): void
     {
         if (! ServerVariablesProvider::mariaDbMySqlKbsExists()) {
-            $this->markTestSkipped('MariaDbMySqlKbs is missing');
+            self::markTestSkipped('MariaDbMySqlKbs is missing');
         }
 
         $response = new ReflectionProperty(ServerVariablesProvider::class, 'instance');
@@ -203,8 +203,8 @@ class VariablesControllerTest extends AbstractTestCase
             $args,
         );
 
-        $this->assertEquals('<abbr title="3">3 B</abbr>', $formattedValue);
-        $this->assertTrue($isHtmlFormatted);
+        self::assertEquals('<abbr title="3">3 B</abbr>', $formattedValue);
+        self::assertTrue($isHtmlFormatted);
 
         //name is_numeric and the value type is not byte
         $args = [$nameForValueNotByte, '3'];
@@ -214,8 +214,8 @@ class VariablesControllerTest extends AbstractTestCase
             'formatVariable',
             $args,
         );
-        $this->assertEquals('3', $formattedValue);
-        $this->assertFalse($isHtmlFormatted);
+        self::assertEquals('3', $formattedValue);
+        self::assertFalse($isHtmlFormatted);
 
         //value is not a number
         $args = [$nameForValueNotByte, 'value'];
@@ -225,8 +225,8 @@ class VariablesControllerTest extends AbstractTestCase
             'formatVariable',
             $args,
         );
-        $this->assertEquals('value', $formattedValue);
-        $this->assertFalse($isHtmlFormatted);
+        self::assertEquals('value', $formattedValue);
+        self::assertFalse($isHtmlFormatted);
     }
 
     /**
@@ -255,7 +255,7 @@ class VariablesControllerTest extends AbstractTestCase
             $args,
         );
 
-        $this->assertEquals('3', $formattedValue);
-        $this->assertFalse($isHtmlFormatted);
+        self::assertEquals('3', $formattedValue);
+        self::assertFalse($isHtmlFormatted);
     }
 }
diff --git a/tests/classes/Controllers/Sql/EnumValuesControllerTest.php b/tests/classes/Controllers/Sql/EnumValuesControllerTest.php
index 6c2b470283..924cfd55ac 100644
--- a/tests/classes/Controllers/Sql/EnumValuesControllerTest.php
+++ b/tests/classes/Controllers/Sql/EnumValuesControllerTest.php
@@ -45,7 +45,7 @@ class EnumValuesControllerTest extends AbstractTestCase
         Current::$database = 'cvv';
         Current::$table = 'enums';
 
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('getParsedBodyParam')->willReturnMap([
             ['db', null, 'cvv'],
             ['table', null, 'enums'],
@@ -75,9 +75,9 @@ class EnumValuesControllerTest extends AbstractTestCase
         );
         $sqlController($request);
 
-        $this->assertFalse($responseRenderer->hasSuccessState(), 'expected the request to fail');
+        self::assertFalse($responseRenderer->hasSuccessState(), 'expected the request to fail');
 
-        $this->assertSame(['message' => 'Error in processing request'], $responseRenderer->getJSONResult());
+        self::assertSame(['message' => 'Error in processing request'], $responseRenderer->getJSONResult());
     }
 
     public function testGetEnumValuesSuccess(): void
@@ -101,7 +101,7 @@ class EnumValuesControllerTest extends AbstractTestCase
         Current::$database = 'cvv';
         Current::$table = 'enums';
 
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('getParsedBodyParam')->willReturnMap([
             ['db', null, 'cvv'],
             ['table', null, 'enums'],
@@ -131,9 +131,9 @@ class EnumValuesControllerTest extends AbstractTestCase
         );
         $sqlController($request);
 
-        $this->assertTrue($responseRenderer->hasSuccessState(), 'expected the request not to fail');
+        self::assertTrue($responseRenderer->hasSuccessState(), 'expected the request not to fail');
 
-        $this->assertSame(
+        self::assertSame(
             [
                 'dropdown' => '<select>' . "\n"
                     . '      <option value="&lt;script&gt;alert(&quot;ok&quot;)&lt;/script&gt;">'
diff --git a/tests/classes/Controllers/Sql/SetValuesControllerTest.php b/tests/classes/Controllers/Sql/SetValuesControllerTest.php
index 921eaa29c4..1218d15475 100644
--- a/tests/classes/Controllers/Sql/SetValuesControllerTest.php
+++ b/tests/classes/Controllers/Sql/SetValuesControllerTest.php
@@ -42,7 +42,7 @@ class SetValuesControllerTest extends AbstractTestCase
         $this->dummyDbi->addResult('SHOW COLUMNS FROM `cvv`.`enums` LIKE \'set\'', false);
         $this->dummyDbi->addResult('SHOW INDEXES FROM `cvv`.`enums`', false);
 
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('getParsedBodyParam')->willReturnMap([
             ['ajax_request', null, true],
             ['db', null, 'cvv'],
@@ -76,9 +76,9 @@ class SetValuesControllerTest extends AbstractTestCase
         );
         $sqlController($request);
 
-        $this->assertFalse($responseRenderer->hasSuccessState(), 'expected the request to fail');
+        self::assertFalse($responseRenderer->hasSuccessState(), 'expected the request to fail');
 
-        $this->assertSame(['message' => 'Error in processing request'], $responseRenderer->getJSONResult());
+        self::assertSame(['message' => 'Error in processing request'], $responseRenderer->getJSONResult());
     }
 
     public function testSuccess(): void
@@ -99,7 +99,7 @@ class SetValuesControllerTest extends AbstractTestCase
         );
         $this->dummyDbi->addResult('SHOW INDEXES FROM `cvv`.`enums`', []);
 
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('getParsedBodyParam')->willReturnMap([
             ['ajax_request', null, true],
             ['db', null, 'cvv'],
@@ -133,9 +133,9 @@ class SetValuesControllerTest extends AbstractTestCase
         );
         $sqlController($request);
 
-        $this->assertTrue($responseRenderer->hasSuccessState(), 'expected the request not to fail');
+        self::assertTrue($responseRenderer->hasSuccessState(), 'expected the request not to fail');
 
-        $this->assertSame(
+        self::assertSame(
             [
                 'select' => '<select class="resize-vertical" size="5" multiple>' . "\n"
                     . '      <option value="&lt;script&gt;alert(&quot;ok&quot;)&lt;/script&gt;">'
diff --git a/tests/classes/Controllers/Table/AddFieldControllerTest.php b/tests/classes/Controllers/Table/AddFieldControllerTest.php
index c59b742b47..dcd5337c7d 100644
--- a/tests/classes/Controllers/Table/AddFieldControllerTest.php
+++ b/tests/classes/Controllers/Table/AddFieldControllerTest.php
@@ -267,6 +267,6 @@ class AddFieldControllerTest extends AbstractTestCase
             new DbTableExists($dbi),
         ))($request);
 
-        $this->assertSame($expected, $response->getHTMLResult());
+        self::assertSame($expected, $response->getHTMLResult());
     }
 }
diff --git a/tests/classes/Controllers/Table/ChangeRowsControllerTest.php b/tests/classes/Controllers/Table/ChangeRowsControllerTest.php
index 2a10abad7e..67487f0d87 100644
--- a/tests/classes/Controllers/Table/ChangeRowsControllerTest.php
+++ b/tests/classes/Controllers/Table/ChangeRowsControllerTest.php
@@ -32,13 +32,13 @@ class ChangeRowsControllerTest extends AbstractTestCase
         $request = ServerRequestFactory::create()->createServerRequest('POST', 'http://example.com/')
             ->withParsedBody(['rows_to_delete' => 'row']);
 
-        $mock = $this->createMock(ChangeController::class);
-        $mock->expects($this->once())->method('__invoke')->with($request);
+        $mock = self::createMock(ChangeController::class);
+        $mock->expects(self::once())->method('__invoke')->with($request);
 
         (new ChangeRowsController(new ResponseRenderer(), new Template(), $mock))($request);
 
         /** @psalm-suppress InvalidArrayOffset */
-        $this->assertSame([], $GLOBALS['where_clause']);
+        self::assertSame([], $GLOBALS['where_clause']);
     }
 
     public function testWithoutRowsToDelete(): void
@@ -46,16 +46,16 @@ class ChangeRowsControllerTest extends AbstractTestCase
         $request = ServerRequestFactory::create()->createServerRequest('POST', 'http://example.com/')
             ->withParsedBody(['goto' => 'goto']);
 
-        $mock = $this->createMock(ChangeController::class);
-        $mock->expects($this->never())->method('__invoke')->with($request);
+        $mock = self::createMock(ChangeController::class);
+        $mock->expects(self::never())->method('__invoke')->with($request);
 
         $response = new ResponseRenderer();
         (new ChangeRowsController($response, new Template(), $mock))($request);
 
-        $this->assertSame(['message' => 'No row selected.'], $response->getJSONResult());
-        $this->assertFalse($response->hasSuccessState());
+        self::assertSame(['message' => 'No row selected.'], $response->getJSONResult());
+        self::assertFalse($response->hasSuccessState());
         /** @psalm-suppress InvalidArrayOffset */
-        $this->assertNull($GLOBALS['where_clause']);
+        self::assertNull($GLOBALS['where_clause']);
     }
 
     public function testWithRowsToDelete(): void
@@ -63,12 +63,12 @@ class ChangeRowsControllerTest extends AbstractTestCase
         $request = ServerRequestFactory::create()->createServerRequest('POST', 'http://example.com/')
             ->withParsedBody(['goto' => 'goto', 'rows_to_delete' => ['key1' => 'row1', 'key2' => 'row2']]);
 
-        $mock = $this->createMock(ChangeController::class);
-        $mock->expects($this->once())->method('__invoke')->with($request);
+        $mock = self::createMock(ChangeController::class);
+        $mock->expects(self::once())->method('__invoke')->with($request);
 
         (new ChangeRowsController(new ResponseRenderer(), new Template(), $mock))($request);
 
         /** @psalm-suppress InvalidArrayOffset */
-        $this->assertSame(['row1', 'row2'], $GLOBALS['where_clause']);
+        self::assertSame(['row1', 'row2'], $GLOBALS['where_clause']);
     }
 }
diff --git a/tests/classes/Controllers/Table/ChartControllerTest.php b/tests/classes/Controllers/Table/ChartControllerTest.php
index 06d7fc84ab..94df09575d 100644
--- a/tests/classes/Controllers/Table/ChartControllerTest.php
+++ b/tests/classes/Controllers/Table/ChartControllerTest.php
@@ -105,6 +105,6 @@ class ChartControllerTest extends AbstractTestCase
             ]);
 
         (new ChartController($response, $template, $dbi, new DbTableExists($dbi)))($request);
-        $this->assertSame($expected, $response->getHTMLResult());
+        self::assertSame($expected, $response->getHTMLResult());
     }
 }
diff --git a/tests/classes/Controllers/Table/CreateControllerTest.php b/tests/classes/Controllers/Table/CreateControllerTest.php
index 343e31038f..fbc19d6724 100644
--- a/tests/classes/Controllers/Table/CreateControllerTest.php
+++ b/tests/classes/Controllers/Table/CreateControllerTest.php
@@ -261,6 +261,6 @@ class CreateControllerTest extends AbstractTestCase
             new ColumnsDefinition($dbi, $relation, $transformations),
         ))($request);
 
-        $this->assertSame($expected, $response->getHTMLResult());
+        self::assertSame($expected, $response->getHTMLResult());
     }
 }
diff --git a/tests/classes/Controllers/Table/DeleteConfirmControllerTest.php b/tests/classes/Controllers/Table/DeleteConfirmControllerTest.php
index 3660200eeb..802c65b4d2 100644
--- a/tests/classes/Controllers/Table/DeleteConfirmControllerTest.php
+++ b/tests/classes/Controllers/Table/DeleteConfirmControllerTest.php
@@ -53,6 +53,6 @@ class DeleteConfirmControllerTest extends AbstractTestCase
             ]);
 
         (new DeleteConfirmController($response, $template, new DbTableExists($dbi)))($request);
-        $this->assertSame($expected, $response->getHTMLResult());
+        self::assertSame($expected, $response->getHTMLResult());
     }
 }
diff --git a/tests/classes/Controllers/Table/DeleteRowsControllerTest.php b/tests/classes/Controllers/Table/DeleteRowsControllerTest.php
index bd238ca694..0842468eb7 100644
--- a/tests/classes/Controllers/Table/DeleteRowsControllerTest.php
+++ b/tests/classes/Controllers/Table/DeleteRowsControllerTest.php
@@ -52,7 +52,7 @@ class DeleteRowsControllerTest extends AbstractTestCase
         $dbi = $this->createDatabaseInterface($dummyDbi);
         DatabaseInterface::$instance = $dbi;
 
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('hasBodyParam')->willReturnMap([['original_sql_query', true]]);
         $request->method('getParsedBodyParam')->willReturnMap([
             ['original_sql_query', '', 'SELECT * FROM `test_db`.`test_table`'],
@@ -61,7 +61,7 @@ class DeleteRowsControllerTest extends AbstractTestCase
         $response = new ResponseRenderer();
         (new DeleteRowsController($response, new Template(), $dbi))($request);
         $actual = $response->getHTMLResult();
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             '<div class="alert alert-success border-top-0 border-start-0 border-end-0 rounded-bottom-0 mb-0"'
             . ' role="alert">' . "\n"
             . '  <img src="themes/dot.gif" title="" alt="" class="icon ic_s_success">'
@@ -69,10 +69,10 @@ class DeleteRowsControllerTest extends AbstractTestCase
             . '</div>',
             $actual,
         );
-        $this->assertStringContainsString('DELETE FROM `test_table` WHERE `test_table`.`id` = 3 LIMIT 1;', $actual);
-        $this->assertStringContainsString('Showing rows 0 -  1 (2 total, Query took', $actual);
-        $this->assertStringContainsString('SELECT * FROM `test_db`.`test_table`', $actual);
-        $this->assertStringContainsString(
+        self::assertStringContainsString('DELETE FROM `test_table` WHERE `test_table`.`id` = 3 LIMIT 1;', $actual);
+        self::assertStringContainsString('Showing rows 0 -  1 (2 total, Query took', $actual);
+        self::assertStringContainsString('SELECT * FROM `test_db`.`test_table`', $actual);
+        self::assertStringContainsString(
             '<td data-decimals="0" data-type="string" data-originallength="4" class="data text pre_wrap">abcd</td>',
             $actual,
         );
diff --git a/tests/classes/Controllers/Table/DropColumnConfirmationControllerTest.php b/tests/classes/Controllers/Table/DropColumnConfirmationControllerTest.php
index f533ec0bb7..089bb716a9 100644
--- a/tests/classes/Controllers/Table/DropColumnConfirmationControllerTest.php
+++ b/tests/classes/Controllers/Table/DropColumnConfirmationControllerTest.php
@@ -25,7 +25,7 @@ class DropColumnConfirmationControllerTest extends AbstractTestCase
 
     public function testWithValidParameters(): void
     {
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('getParsedBodyParam')->willReturnMap([
             ['db', null, 'test_db'],
             ['table', null, 'test_table'],
@@ -50,15 +50,15 @@ class DropColumnConfirmationControllerTest extends AbstractTestCase
 
         (new DropColumnConfirmationController($response, $template, new DbTableExists($dbi)))($request);
 
-        $this->assertSame(200, $response->getResponse()->getStatusCode());
-        $this->assertTrue($response->hasSuccessState());
-        $this->assertSame([], $response->getJSONResult());
-        $this->assertSame($expected, $response->getHTMLResult());
+        self::assertSame(200, $response->getResponse()->getStatusCode());
+        self::assertTrue($response->hasSuccessState());
+        self::assertSame([], $response->getJSONResult());
+        self::assertSame($expected, $response->getHTMLResult());
     }
 
     public function testWithoutFields(): void
     {
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('getParsedBodyParam')->willReturnMap([
             ['db', null, 'test_db'],
             ['table', null, 'test_table'],
@@ -74,15 +74,15 @@ class DropColumnConfirmationControllerTest extends AbstractTestCase
             new DbTableExists(DatabaseInterface::getInstance()),
         ))($request);
 
-        $this->assertSame(400, $response->getResponse()->getStatusCode());
-        $this->assertFalse($response->hasSuccessState());
-        $this->assertSame(['isErrorResponse' => true, 'message' => 'No column selected.'], $response->getJSONResult());
-        $this->assertSame('', $response->getHTMLResult());
+        self::assertSame(400, $response->getResponse()->getStatusCode());
+        self::assertFalse($response->hasSuccessState());
+        self::assertSame(['isErrorResponse' => true, 'message' => 'No column selected.'], $response->getJSONResult());
+        self::assertSame('', $response->getHTMLResult());
     }
 
     public function testWithoutDatabaseAndTable(): void
     {
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('getParsedBodyParam')->willReturnMap([
             ['db', null, null],
             ['table', null, null],
@@ -98,12 +98,12 @@ class DropColumnConfirmationControllerTest extends AbstractTestCase
             new DbTableExists(DatabaseInterface::getInstance()),
         ))($request);
 
-        $this->assertSame(400, $response->getResponse()->getStatusCode());
-        $this->assertFalse($response->hasSuccessState());
-        $this->assertSame([
+        self::assertSame(400, $response->getResponse()->getStatusCode());
+        self::assertFalse($response->hasSuccessState());
+        self::assertSame([
             'isErrorResponse' => true,
             'message' => 'The database name must be a non-empty string.',
         ], $response->getJSONResult());
-        $this->assertSame('', $response->getHTMLResult());
+        self::assertSame('', $response->getHTMLResult());
     }
 }
diff --git a/tests/classes/Controllers/Table/DropColumnControllerTest.php b/tests/classes/Controllers/Table/DropColumnControllerTest.php
index 8ea39412e3..be2b6091de 100644
--- a/tests/classes/Controllers/Table/DropColumnControllerTest.php
+++ b/tests/classes/Controllers/Table/DropColumnControllerTest.php
@@ -43,7 +43,7 @@ class DropColumnControllerTest extends AbstractTestCase
         $dummyDbi->addResult('ALTER TABLE `test_table` DROP `name`, DROP `datetimefield`;', true);
         $dbi = $this->createDatabaseInterface($dummyDbi);
 
-        $this->assertArrayNotHasKey('flashMessages', $_SESSION);
+        self::assertArrayNotHasKey('flashMessages', $_SESSION);
 
         (new DropColumnController(
             new ResponseRenderer(),
@@ -51,10 +51,10 @@ class DropColumnControllerTest extends AbstractTestCase
             $dbi,
             new FlashMessages(),
             new RelationCleanup($dbi, new Relation($dbi)),
-        ))($this->createStub(ServerRequest::class));
+        ))(self::createStub(ServerRequest::class));
 
-        $this->assertArrayHasKey('flashMessages', $_SESSION);
+        self::assertArrayHasKey('flashMessages', $_SESSION);
         /** @psalm-suppress InvalidArrayOffset */
-        $this->assertSame(['success' => ['2 columns have been dropped successfully.']], $_SESSION['flashMessages']);
+        self::assertSame(['success' => ['2 columns have been dropped successfully.']], $_SESSION['flashMessages']);
     }
 }
diff --git a/tests/classes/Controllers/Table/ExportControllerTest.php b/tests/classes/Controllers/Table/ExportControllerTest.php
index 8daf38db1b..e177332046 100644
--- a/tests/classes/Controllers/Table/ExportControllerTest.php
+++ b/tests/classes/Controllers/Table/ExportControllerTest.php
@@ -117,7 +117,7 @@ class ExportControllerTest extends AbstractTestCase
             $template,
             new Options(new Relation($dbi), new TemplateModel($dbi)),
             $pageSettings,
-        ))($this->createStub(ServerRequest::class));
-        $this->assertSame($expected, $response->getHTMLResult());
+        ))(self::createStub(ServerRequest::class));
+        self::assertSame($expected, $response->getHTMLResult());
     }
 }
diff --git a/tests/classes/Controllers/Table/ExportRowsControllerTest.php b/tests/classes/Controllers/Table/ExportRowsControllerTest.php
index fd7e6e84ba..c8d89dba7d 100644
--- a/tests/classes/Controllers/Table/ExportRowsControllerTest.php
+++ b/tests/classes/Controllers/Table/ExportRowsControllerTest.php
@@ -33,18 +33,18 @@ class ExportRowsControllerTest extends AbstractTestCase
         $_POST['rows_to_delete'] = 'row';
 
         $controller = $this->createMock(ExportController::class);
-        $controller->expects($this->once())->method('__invoke');
+        $controller->expects(self::once())->method('__invoke');
 
         (new ExportRowsController(
             new ResponseRenderer(),
             new Template(),
             $controller,
-        ))($this->createStub(ServerRequest::class));
+        ))(self::createStub(ServerRequest::class));
 
         /** @psalm-suppress InvalidArrayOffset */
-        $this->assertTrue($GLOBALS['single_table']);
+        self::assertTrue($GLOBALS['single_table']);
         /** @psalm-suppress InvalidArrayOffset */
-        $this->assertSame([], $GLOBALS['where_clause']);
+        self::assertSame([], $GLOBALS['where_clause']);
     }
 
     public function testWithoutRowsToDelete(): void
@@ -52,21 +52,21 @@ class ExportRowsControllerTest extends AbstractTestCase
         $_POST['goto'] = 'goto';
 
         $controller = $this->createMock(ExportController::class);
-        $controller->expects($this->never())->method('__invoke');
+        $controller->expects(self::never())->method('__invoke');
 
         $response = new ResponseRenderer();
         (new ExportRowsController(
             $response,
             new Template(),
             $controller,
-        ))($this->createStub(ServerRequest::class));
+        ))(self::createStub(ServerRequest::class));
 
-        $this->assertSame(['message' => 'No row selected.'], $response->getJSONResult());
-        $this->assertFalse($response->hasSuccessState());
+        self::assertSame(['message' => 'No row selected.'], $response->getJSONResult());
+        self::assertFalse($response->hasSuccessState());
         /** @psalm-suppress InvalidArrayOffset */
-        $this->assertNull($GLOBALS['single_table']);
+        self::assertNull($GLOBALS['single_table']);
         /** @psalm-suppress InvalidArrayOffset */
-        $this->assertNull($GLOBALS['where_clause']);
+        self::assertNull($GLOBALS['where_clause']);
     }
 
     public function testWithRowsToDelete(): void
@@ -75,17 +75,17 @@ class ExportRowsControllerTest extends AbstractTestCase
         $_POST['rows_to_delete'] = ['key1' => 'row1', 'key2' => 'row2'];
 
         $controller = $this->createMock(ExportController::class);
-        $controller->expects($this->once())->method('__invoke');
+        $controller->expects(self::once())->method('__invoke');
 
         (new ExportRowsController(
             new ResponseRenderer(),
             new Template(),
             $controller,
-        ))($this->createStub(ServerRequest::class));
+        ))(self::createStub(ServerRequest::class));
 
         /** @psalm-suppress InvalidArrayOffset */
-        $this->assertTrue($GLOBALS['single_table']);
+        self::assertTrue($GLOBALS['single_table']);
         /** @psalm-suppress InvalidArrayOffset */
-        $this->assertSame(['row1', 'row2'], $GLOBALS['where_clause']);
+        self::assertSame(['row1', 'row2'], $GLOBALS['where_clause']);
     }
 }
diff --git a/tests/classes/Controllers/Table/FindReplaceControllerTest.php b/tests/classes/Controllers/Table/FindReplaceControllerTest.php
index c83a79fee3..50d4f47753 100644
--- a/tests/classes/Controllers/Table/FindReplaceControllerTest.php
+++ b/tests/classes/Controllers/Table/FindReplaceControllerTest.php
@@ -40,7 +40,7 @@ class FindReplaceControllerTest extends AbstractTestCase
             new ColumnFull('Field1', 'Type1', 'Collation1', false, '', null, '', '', ''),
             new ColumnFull('Field2', 'Type2', 'Collation2', false, '', null, '', '', ''),
         ];
-        $dbi->expects($this->any())->method('getColumns')
+        $dbi->expects(self::any())->method('getColumns')
             ->willReturn($columns);
 
         $showCreateTable = "CREATE TABLE `table` (
@@ -54,9 +54,9 @@ class FindReplaceControllerTest extends AbstractTestCase
         ) ENGINE=MyISAM AUTO_INCREMENT=2 DEFAULT CHARSET=utf8 COLLATE=utf8_bin "
             . "COMMENT='table'";
 
-        $dbi->expects($this->any())->method('fetchValue')
+        $dbi->expects(self::any())->method('fetchValue')
             ->willReturn($showCreateTable);
-        $dbi->expects($this->any())->method('quoteString')
+        $dbi->expects(self::any())->method('quoteString')
             ->willReturnCallback(static fn (string $string): string => "'" . $string . "'");
 
         DatabaseInterface::$instance = $dbi;
@@ -82,7 +82,7 @@ class FindReplaceControllerTest extends AbstractTestCase
         $result = 'UPDATE `table` SET `Field1` = '
             . "REPLACE(`Field1`, 'Field', 'Column') "
             . "WHERE `Field1` LIKE '%Field%' COLLATE UTF-8_bin";
-        $this->assertEquals($result, $sqlQuery);
+        self::assertEquals($result, $sqlQuery);
     }
 
     public function testReplaceWithRegex(): void
@@ -108,6 +108,6 @@ class FindReplaceControllerTest extends AbstractTestCase
         $result = 'UPDATE `table` SET `Field1` = `Field1`'
             . " WHERE `Field1` RLIKE 'Field' COLLATE UTF-8_bin";
 
-        $this->assertEquals($result, $sqlQuery);
+        self::assertEquals($result, $sqlQuery);
     }
 }
diff --git a/tests/classes/Controllers/Table/GetFieldControllerTest.php b/tests/classes/Controllers/Table/GetFieldControllerTest.php
index d4489328b5..d82918dfc2 100644
--- a/tests/classes/Controllers/Table/GetFieldControllerTest.php
+++ b/tests/classes/Controllers/Table/GetFieldControllerTest.php
@@ -28,7 +28,7 @@ class GetFieldControllerTest extends AbstractTestCase
         Current::$database = 'test_db';
         Current::$table = 'table_with_blob';
 
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('getQueryParam')->willReturnMap([
             ['transform_key', '', 'file' ],
             ['sql_query', '', 'SELECT * FROM `test_db`.`table_with_blob`'],
diff --git a/tests/classes/Controllers/Table/GisVisualizationControllerTest.php b/tests/classes/Controllers/Table/GisVisualizationControllerTest.php
index 0287be531a..20feac71c4 100644
--- a/tests/classes/Controllers/Table/GisVisualizationControllerTest.php
+++ b/tests/classes/Controllers/Table/GisVisualizationControllerTest.php
@@ -113,6 +113,6 @@ class GisVisualizationControllerTest extends AbstractTestCase
 
         $response = new ResponseRenderer();
         (new GisVisualizationController($response, $template, $dbi, new DbTableExists($dbi)))($request);
-        $this->assertSame($expected, $response->getHTMLResult());
+        self::assertSame($expected, $response->getHTMLResult());
     }
 }
diff --git a/tests/classes/Controllers/Table/ImportControllerTest.php b/tests/classes/Controllers/Table/ImportControllerTest.php
index 241c092fdc..02fae7de7a 100644
--- a/tests/classes/Controllers/Table/ImportControllerTest.php
+++ b/tests/classes/Controllers/Table/ImportControllerTest.php
@@ -94,6 +94,6 @@ class ImportControllerTest extends AbstractTestCase
 
         $response = new ResponseRenderer();
         (new ImportController($response, $template, $dbi, $pageSettings, new DbTableExists($dbi)))($request);
-        $this->assertSame($expected, $response->getHTMLResult());
+        self::assertSame($expected, $response->getHTMLResult());
     }
 }
diff --git a/tests/classes/Controllers/Table/IndexRenameControllerTest.php b/tests/classes/Controllers/Table/IndexRenameControllerTest.php
index d536c23623..bb8f5fdd67 100644
--- a/tests/classes/Controllers/Table/IndexRenameControllerTest.php
+++ b/tests/classes/Controllers/Table/IndexRenameControllerTest.php
@@ -52,7 +52,7 @@ class IndexRenameControllerTest extends AbstractTestCase
             new Indexes($dbi),
             new DbTableExists($dbi),
         ))($request);
-        $this->assertSame($expected, $response->getHTMLResult());
+        self::assertSame($expected, $response->getHTMLResult());
     }
 
     public function testPreviewSqlWithOldStatement(): void
diff --git a/tests/classes/Controllers/Table/IndexesControllerTest.php b/tests/classes/Controllers/Table/IndexesControllerTest.php
index 4c946d904f..db38f037d9 100644
--- a/tests/classes/Controllers/Table/IndexesControllerTest.php
+++ b/tests/classes/Controllers/Table/IndexesControllerTest.php
@@ -68,7 +68,7 @@ class IndexesControllerTest extends AbstractTestCase
             ['Schema' => 'Schema3', 'Key_name' => 'Key_name3', 'Column_name' => 'Column_name3'],
         ];
 
-        $dbi->expects($this->any())->method('getTableIndexes')
+        $dbi->expects(self::any())->method('getTableIndexes')
             ->willReturn($indexs);
 
         DatabaseInterface::$instance = $dbi;
@@ -76,14 +76,14 @@ class IndexesControllerTest extends AbstractTestCase
         $table = $this->getMockBuilder(Table::class)
             ->disableOriginalConstructor()
             ->getMock();
-        $table->expects($this->any())->method('getStatusInfo')
+        $table->expects(self::any())->method('getStatusInfo')
             ->willReturn('');
-        $table->expects($this->any())->method('isView')
+        $table->expects(self::any())->method('isView')
             ->willReturn(false);
-        $table->expects($this->any())->method('getNameAndTypeOfTheColumns')
+        $table->expects(self::any())->method('getNameAndTypeOfTheColumns')
             ->willReturn(['field_name' => 'field_type']);
 
-        $dbi->expects($this->any())->method('getTable')
+        $dbi->expects(self::any())->method('getTable')
             ->willReturn($table);
 
         $response = new ResponseStub();
@@ -106,7 +106,7 @@ class IndexesControllerTest extends AbstractTestCase
         $html = $response->getHTMLResult();
 
         //Url::getHiddenInputs
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             Url::getHiddenInputs(
                 ['db' => 'db', 'table' => 'table', 'create_index' => 1],
             ),
@@ -120,20 +120,20 @@ class IndexesControllerTest extends AbstractTestCase
                 ),
             )->getMessage(),
         );
-        $this->assertStringContainsString($docHtml, $html);
+        self::assertStringContainsString($docHtml, $html);
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             MySQLDocumentation::show('ALTER_TABLE'),
             $html,
         );
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             sprintf(__('Add %s column(s) to index'), 1),
             $html,
         );
 
         //$field_name & $field_type
-        $this->assertStringContainsString('field_name', $html);
-        $this->assertStringContainsString('field_type', $html);
+        self::assertStringContainsString('field_name', $html);
+        self::assertStringContainsString('field_type', $html);
     }
 }
diff --git a/tests/classes/Controllers/Table/Maintenance/AnalyzeControllerTest.php b/tests/classes/Controllers/Table/Maintenance/AnalyzeControllerTest.php
index da80e17c60..5579c65625 100644
--- a/tests/classes/Controllers/Table/Maintenance/AnalyzeControllerTest.php
+++ b/tests/classes/Controllers/Table/Maintenance/AnalyzeControllerTest.php
@@ -21,16 +21,16 @@ class AnalyzeControllerTest extends AbstractTestCase
     #[DataProvider('providerForTestNoTableSelected')]
     public function testNoTableSelected(array|string|null $tables): void
     {
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('getParsedBodyParam')->willReturnMap([['selected_tbl', null, $tables]]);
         $dbi = $this->createDatabaseInterface();
         DatabaseInterface::$instance = $dbi;
         $response = new ResponseRenderer();
         $controller = new AnalyzeController($response, new Template(), new Maintenance($dbi), $this->createConfig());
         $controller($request);
-        $this->assertFalse($response->hasSuccessState());
-        $this->assertSame(['message' => 'No table selected.'], $response->getJSONResult());
-        $this->assertSame('', $response->getHTMLResult());
+        self::assertFalse($response->hasSuccessState());
+        self::assertSame(['message' => 'No table selected.'], $response->getJSONResult());
+        self::assertSame('', $response->getHTMLResult());
     }
 
     /** @return array<int, array{string[][]|string[]|string|null}> */
diff --git a/tests/classes/Controllers/Table/Maintenance/CheckControllerTest.php b/tests/classes/Controllers/Table/Maintenance/CheckControllerTest.php
index 0753f6a308..60e5803b5a 100644
--- a/tests/classes/Controllers/Table/Maintenance/CheckControllerTest.php
+++ b/tests/classes/Controllers/Table/Maintenance/CheckControllerTest.php
@@ -21,16 +21,16 @@ class CheckControllerTest extends AbstractTestCase
     #[DataProvider('providerForTestNoTableSelected')]
     public function testNoTableSelected(array|string|null $tables): void
     {
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('getParsedBodyParam')->willReturnMap([['selected_tbl', null, $tables]]);
         $dbi = $this->createDatabaseInterface();
         DatabaseInterface::$instance = $dbi;
         $response = new ResponseRenderer();
         $controller = new CheckController($response, new Template(), new Maintenance($dbi), $this->createConfig());
         $controller($request);
-        $this->assertFalse($response->hasSuccessState());
-        $this->assertSame(['message' => 'No table selected.'], $response->getJSONResult());
-        $this->assertSame('', $response->getHTMLResult());
+        self::assertFalse($response->hasSuccessState());
+        self::assertSame(['message' => 'No table selected.'], $response->getJSONResult());
+        self::assertSame('', $response->getHTMLResult());
     }
 
     /** @return array<int, array{string[][]|string[]|string|null}> */
diff --git a/tests/classes/Controllers/Table/Maintenance/ChecksumControllerTest.php b/tests/classes/Controllers/Table/Maintenance/ChecksumControllerTest.php
index f2e4757185..0e481e5a60 100644
--- a/tests/classes/Controllers/Table/Maintenance/ChecksumControllerTest.php
+++ b/tests/classes/Controllers/Table/Maintenance/ChecksumControllerTest.php
@@ -21,16 +21,16 @@ class ChecksumControllerTest extends AbstractTestCase
     #[DataProvider('providerForTestNoTableSelected')]
     public function testNoTableSelected(array|string|null $tables): void
     {
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('getParsedBodyParam')->willReturnMap([['selected_tbl', null, $tables]]);
         $dbi = $this->createDatabaseInterface();
         DatabaseInterface::$instance = $dbi;
         $response = new ResponseRenderer();
         $controller = new ChecksumController($response, new Template(), new Maintenance($dbi), $this->createConfig());
         $controller($request);
-        $this->assertFalse($response->hasSuccessState());
-        $this->assertSame(['message' => 'No table selected.'], $response->getJSONResult());
-        $this->assertSame('', $response->getHTMLResult());
+        self::assertFalse($response->hasSuccessState());
+        self::assertSame(['message' => 'No table selected.'], $response->getJSONResult());
+        self::assertSame('', $response->getHTMLResult());
     }
 
     /** @return array<int, array{string[][]|string[]|string|null}> */
diff --git a/tests/classes/Controllers/Table/Maintenance/OptimizeControllerTest.php b/tests/classes/Controllers/Table/Maintenance/OptimizeControllerTest.php
index b0e439735a..19a51d34fc 100644
--- a/tests/classes/Controllers/Table/Maintenance/OptimizeControllerTest.php
+++ b/tests/classes/Controllers/Table/Maintenance/OptimizeControllerTest.php
@@ -21,16 +21,16 @@ class OptimizeControllerTest extends AbstractTestCase
     #[DataProvider('providerForTestNoTableSelected')]
     public function testNoTableSelected(array|string|null $tables): void
     {
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('getParsedBodyParam')->willReturnMap([['selected_tbl', null, $tables]]);
         $dbi = $this->createDatabaseInterface();
         DatabaseInterface::$instance = $dbi;
         $response = new ResponseRenderer();
         $controller = new OptimizeController($response, new Template(), new Maintenance($dbi), $this->createConfig());
         $controller($request);
-        $this->assertFalse($response->hasSuccessState());
-        $this->assertSame(['message' => 'No table selected.'], $response->getJSONResult());
-        $this->assertSame('', $response->getHTMLResult());
+        self::assertFalse($response->hasSuccessState());
+        self::assertSame(['message' => 'No table selected.'], $response->getJSONResult());
+        self::assertSame('', $response->getHTMLResult());
     }
 
     /** @return array<int, array{string[][]|string[]|string|null}> */
diff --git a/tests/classes/Controllers/Table/Maintenance/RepairControllerTest.php b/tests/classes/Controllers/Table/Maintenance/RepairControllerTest.php
index cd1cd62958..a085db5e43 100644
--- a/tests/classes/Controllers/Table/Maintenance/RepairControllerTest.php
+++ b/tests/classes/Controllers/Table/Maintenance/RepairControllerTest.php
@@ -21,16 +21,16 @@ class RepairControllerTest extends AbstractTestCase
     #[DataProvider('providerForTestNoTableSelected')]
     public function testNoTableSelected(array|string|null $tables): void
     {
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('getParsedBodyParam')->willReturnMap([['selected_tbl', null, $tables]]);
         $dbi = $this->createDatabaseInterface();
         DatabaseInterface::$instance = $dbi;
         $response = new ResponseRenderer();
         $controller = new RepairController($response, new Template(), new Maintenance($dbi), $this->createConfig());
         $controller($request);
-        $this->assertFalse($response->hasSuccessState());
-        $this->assertSame(['message' => 'No table selected.'], $response->getJSONResult());
-        $this->assertSame('', $response->getHTMLResult());
+        self::assertFalse($response->hasSuccessState());
+        self::assertSame(['message' => 'No table selected.'], $response->getJSONResult());
+        self::assertSame('', $response->getHTMLResult());
     }
 
     /** @return array<int, array{string[][]|string[]|string|null}> */
diff --git a/tests/classes/Controllers/Table/Partition/AnalyzeControllerTest.php b/tests/classes/Controllers/Table/Partition/AnalyzeControllerTest.php
index ceabf06aef..4ef8ad7eda 100644
--- a/tests/classes/Controllers/Table/Partition/AnalyzeControllerTest.php
+++ b/tests/classes/Controllers/Table/Partition/AnalyzeControllerTest.php
@@ -25,7 +25,7 @@ class AnalyzeControllerTest extends AbstractTestCase
         string|null $table,
         string $message,
     ): void {
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('getParsedBodyParam')->willReturnMap([['partition_name', null, $partition]]);
         $request->method('getParam')->willReturnMap([['db', null, $db], ['table', null, $table]]);
         $dbi = $this->createDatabaseInterface();
@@ -35,7 +35,7 @@ class AnalyzeControllerTest extends AbstractTestCase
         $controller = new AnalyzeController($response, new Template(), new Maintenance($dbi));
         $controller($request);
 
-        $this->assertSame(Message::error($message)->getDisplay(), $response->getHTMLResult());
+        self::assertSame(Message::error($message)->getDisplay(), $response->getHTMLResult());
     }
 
     /** @return array<int, array{string|null, string|null, string|null, non-empty-string}> */
diff --git a/tests/classes/Controllers/Table/Partition/CheckControllerTest.php b/tests/classes/Controllers/Table/Partition/CheckControllerTest.php
index 10a5cf4e67..d51e72b368 100644
--- a/tests/classes/Controllers/Table/Partition/CheckControllerTest.php
+++ b/tests/classes/Controllers/Table/Partition/CheckControllerTest.php
@@ -25,7 +25,7 @@ class CheckControllerTest extends AbstractTestCase
         string|null $table,
         string $message,
     ): void {
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('getParsedBodyParam')->willReturnMap([['partition_name', null, $partition]]);
         $request->method('getParam')->willReturnMap([['db', null, $db], ['table', null, $table]]);
         $dbi = $this->createDatabaseInterface();
@@ -35,7 +35,7 @@ class CheckControllerTest extends AbstractTestCase
         $controller = new CheckController($response, new Template(), new Maintenance($dbi));
         $controller($request);
 
-        $this->assertSame(Message::error($message)->getDisplay(), $response->getHTMLResult());
+        self::assertSame(Message::error($message)->getDisplay(), $response->getHTMLResult());
     }
 
     /** @return array<int, array{string|null, string|null, string|null, non-empty-string}> */
diff --git a/tests/classes/Controllers/Table/Partition/DropControllerTest.php b/tests/classes/Controllers/Table/Partition/DropControllerTest.php
index 02187af869..77d53986f4 100644
--- a/tests/classes/Controllers/Table/Partition/DropControllerTest.php
+++ b/tests/classes/Controllers/Table/Partition/DropControllerTest.php
@@ -25,7 +25,7 @@ class DropControllerTest extends AbstractTestCase
         string|null $table,
         string $message,
     ): void {
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('getParsedBodyParam')->willReturnMap([['partition_name', null, $partition]]);
         $request->method('getParam')->willReturnMap([['db', null, $db], ['table', null, $table]]);
         $dbi = $this->createDatabaseInterface();
@@ -35,7 +35,7 @@ class DropControllerTest extends AbstractTestCase
         $controller = new DropController($response, new Template(), new Maintenance($dbi));
         $controller($request);
 
-        $this->assertSame(Message::error($message)->getDisplay(), $response->getHTMLResult());
+        self::assertSame(Message::error($message)->getDisplay(), $response->getHTMLResult());
     }
 
     /** @return array<int, array{string|null, string|null, string|null, non-empty-string}> */
diff --git a/tests/classes/Controllers/Table/Partition/OptimizeControllerTest.php b/tests/classes/Controllers/Table/Partition/OptimizeControllerTest.php
index bf226d8685..4ee6da1693 100644
--- a/tests/classes/Controllers/Table/Partition/OptimizeControllerTest.php
+++ b/tests/classes/Controllers/Table/Partition/OptimizeControllerTest.php
@@ -25,7 +25,7 @@ class OptimizeControllerTest extends AbstractTestCase
         string|null $table,
         string $message,
     ): void {
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('getParsedBodyParam')->willReturnMap([['partition_name', null, $partition]]);
         $request->method('getParam')->willReturnMap([['db', null, $db], ['table', null, $table]]);
         $dbi = $this->createDatabaseInterface();
@@ -35,7 +35,7 @@ class OptimizeControllerTest extends AbstractTestCase
         $controller = new OptimizeController($response, new Template(), new Maintenance($dbi));
         $controller($request);
 
-        $this->assertSame(Message::error($message)->getDisplay(), $response->getHTMLResult());
+        self::assertSame(Message::error($message)->getDisplay(), $response->getHTMLResult());
     }
 
     /** @return array<int, array{string|null, string|null, string|null, non-empty-string}> */
diff --git a/tests/classes/Controllers/Table/Partition/RebuildControllerTest.php b/tests/classes/Controllers/Table/Partition/RebuildControllerTest.php
index a259c686cd..2e1477c9a5 100644
--- a/tests/classes/Controllers/Table/Partition/RebuildControllerTest.php
+++ b/tests/classes/Controllers/Table/Partition/RebuildControllerTest.php
@@ -25,7 +25,7 @@ class RebuildControllerTest extends AbstractTestCase
         string|null $table,
         string $message,
     ): void {
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('getParsedBodyParam')->willReturnMap([['partition_name', null, $partition]]);
         $request->method('getParam')->willReturnMap([['db', null, $db], ['table', null, $table]]);
         $dbi = $this->createDatabaseInterface();
@@ -35,7 +35,7 @@ class RebuildControllerTest extends AbstractTestCase
         $controller = new RebuildController($response, new Template(), new Maintenance($dbi));
         $controller($request);
 
-        $this->assertSame(Message::error($message)->getDisplay(), $response->getHTMLResult());
+        self::assertSame(Message::error($message)->getDisplay(), $response->getHTMLResult());
     }
 
     /** @return array<int, array{string|null, string|null, string|null, non-empty-string}> */
diff --git a/tests/classes/Controllers/Table/Partition/RepairControllerTest.php b/tests/classes/Controllers/Table/Partition/RepairControllerTest.php
index 6171fbf93f..4c0e45b3fd 100644
--- a/tests/classes/Controllers/Table/Partition/RepairControllerTest.php
+++ b/tests/classes/Controllers/Table/Partition/RepairControllerTest.php
@@ -25,7 +25,7 @@ class RepairControllerTest extends AbstractTestCase
         string|null $table,
         string $message,
     ): void {
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('getParsedBodyParam')->willReturnMap([['partition_name', null, $partition]]);
         $request->method('getParam')->willReturnMap([['db', null, $db], ['table', null, $table]]);
         $dbi = $this->createDatabaseInterface();
@@ -35,7 +35,7 @@ class RepairControllerTest extends AbstractTestCase
         $controller = new RepairController($response, new Template(), new Maintenance($dbi));
         $controller($request);
 
-        $this->assertSame(Message::error($message)->getDisplay(), $response->getHTMLResult());
+        self::assertSame(Message::error($message)->getDisplay(), $response->getHTMLResult());
     }
 
     /** @return array<int, array{string|null, string|null, string|null, non-empty-string}> */
diff --git a/tests/classes/Controllers/Table/Partition/TruncateControllerTest.php b/tests/classes/Controllers/Table/Partition/TruncateControllerTest.php
index 4db730c076..7a820805ea 100644
--- a/tests/classes/Controllers/Table/Partition/TruncateControllerTest.php
+++ b/tests/classes/Controllers/Table/Partition/TruncateControllerTest.php
@@ -25,7 +25,7 @@ class TruncateControllerTest extends AbstractTestCase
         string|null $table,
         string $message,
     ): void {
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('getParsedBodyParam')->willReturnMap([['partition_name', null, $partition]]);
         $request->method('getParam')->willReturnMap([['db', null, $db], ['table', null, $table]]);
         $dbi = $this->createDatabaseInterface();
@@ -35,7 +35,7 @@ class TruncateControllerTest extends AbstractTestCase
         $controller = new TruncateController($response, new Template(), new Maintenance($dbi));
         $controller($request);
 
-        $this->assertSame(Message::error($message)->getDisplay(), $response->getHTMLResult());
+        self::assertSame(Message::error($message)->getDisplay(), $response->getHTMLResult());
     }
 
     /** @return array<int, array{string|null, string|null, string|null, non-empty-string}> */
diff --git a/tests/classes/Controllers/Table/PrivilegesControllerTest.php b/tests/classes/Controllers/Table/PrivilegesControllerTest.php
index dc945255c4..650fadc487 100644
--- a/tests/classes/Controllers/Table/PrivilegesControllerTest.php
+++ b/tests/classes/Controllers/Table/PrivilegesControllerTest.php
@@ -41,11 +41,11 @@ class PrivilegesControllerTest extends AbstractTestCase
 
         $privileges = [];
 
-        $serverPrivileges = $this->createMock(Privileges::class);
+        $serverPrivileges = self::createMock(Privileges::class);
         $serverPrivileges->method('getAllPrivileges')
             ->willReturn($privileges);
 
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('getParam')->willReturnMap([['db', null, 'db'], ['table', null, 'table']]);
 
         $response = new ResponseRenderer();
@@ -57,38 +57,38 @@ class PrivilegesControllerTest extends AbstractTestCase
         ))($request);
         $actual = $response->getHTMLResult();
 
-        $this->assertStringContainsString(Current::$database . '.' . Current::$table, $actual);
+        self::assertStringContainsString(Current::$database . '.' . Current::$table, $actual);
 
         //validate 2: Url::getCommon
         $item = Url::getCommon(['db' => Current::$database, 'table' => Current::$table], '');
-        $this->assertStringContainsString($item, $actual);
+        self::assertStringContainsString($item, $actual);
 
         //validate 3: items
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             __('User'),
             $actual,
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             __('Host'),
             $actual,
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             __('Type'),
             $actual,
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             __('Privileges'),
             $actual,
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             __('Grant'),
             $actual,
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             __('Action'),
             $actual,
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             __('No user found'),
             $actual,
         );
@@ -96,37 +96,37 @@ class PrivilegesControllerTest extends AbstractTestCase
 
     public function testWithInvalidDatabaseName(): void
     {
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('getParam')->willReturnMap([['db', null, ''], ['table', null, 'table']]);
 
         $response = new ResponseRenderer();
         (new PrivilegesController(
             $response,
             new Template(),
-            $this->createStub(Privileges::class),
+            self::createStub(Privileges::class),
             $this->createDatabaseInterface(),
         ))($request);
         $actual = $response->getHTMLResult();
 
-        $this->assertStringContainsString('<div class="alert alert-danger" role="alert">', $actual);
-        $this->assertStringContainsString('The database name must be a non-empty string.', $actual);
+        self::assertStringContainsString('<div class="alert alert-danger" role="alert">', $actual);
+        self::assertStringContainsString('The database name must be a non-empty string.', $actual);
     }
 
     public function testWithInvalidTableName(): void
     {
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('getParam')->willReturnMap([['db', null, 'db'], ['table', null, '']]);
 
         $response = new ResponseRenderer();
         (new PrivilegesController(
             $response,
             new Template(),
-            $this->createStub(Privileges::class),
+            self::createStub(Privileges::class),
             $this->createDatabaseInterface(),
         ))($request);
         $actual = $response->getHTMLResult();
 
-        $this->assertStringContainsString('<div class="alert alert-danger" role="alert">', $actual);
-        $this->assertStringContainsString('The table name must be a non-empty string.', $actual);
+        self::assertStringContainsString('<div class="alert alert-danger" role="alert">', $actual);
+        self::assertStringContainsString('The table name must be a non-empty string.', $actual);
     }
 }
diff --git a/tests/classes/Controllers/Table/RelationControllerTest.php b/tests/classes/Controllers/Table/RelationControllerTest.php
index c61b8c5299..ab57d426d2 100644
--- a/tests/classes/Controllers/Table/RelationControllerTest.php
+++ b/tests/classes/Controllers/Table/RelationControllerTest.php
@@ -63,12 +63,12 @@ class RelationControllerTest extends AbstractTestCase
             ->disableOriginalConstructor()
             ->getMock();
         // Test the situation when the table is a view
-        $tableMock->expects($this->any())->method('isView')
+        $tableMock->expects(self::any())->method('isView')
             ->willReturn(true);
-        $tableMock->expects($this->any())->method('getColumns')
+        $tableMock->expects(self::any())->method('getColumns')
             ->willReturn($viewColumns);
 
-        $this->dbi->expects($this->any())->method('getTable')
+        $this->dbi->expects(self::any())->method('getTable')
             ->willReturn($tableMock);
 
         $ctrl = new RelationController(
@@ -80,7 +80,7 @@ class RelationControllerTest extends AbstractTestCase
 
         $ctrl->getDropdownValueForTable();
         $json = $this->response->getJSONResult();
-        $this->assertEquals($viewColumns, $json['columns']);
+        self::assertEquals($viewColumns, $json['columns']);
     }
 
     /**
@@ -96,12 +96,12 @@ class RelationControllerTest extends AbstractTestCase
             ->disableOriginalConstructor()
             ->getMock();
         // Test the situation when the table is a view
-        $tableMock->expects($this->any())->method('isView')
+        $tableMock->expects(self::any())->method('isView')
             ->willReturn(false);
-        $tableMock->expects($this->any())->method('getIndexedColumns')
+        $tableMock->expects(self::any())->method('getIndexedColumns')
             ->willReturn($indexedColumns);
 
-        $this->dbi->expects($this->any())->method('getTable')
+        $this->dbi->expects(self::any())->method('getTable')
             ->willReturn($tableMock);
 
         $ctrl = new RelationController(
@@ -113,7 +113,7 @@ class RelationControllerTest extends AbstractTestCase
 
         $ctrl->getDropdownValueForTable();
         $json = $this->response->getJSONResult();
-        $this->assertEquals($indexedColumns, $json['columns']);
+        self::assertEquals($indexedColumns, $json['columns']);
     }
 
     /**
@@ -125,11 +125,11 @@ class RelationControllerTest extends AbstractTestCase
     {
         $resultStub = $this->createMock(DummyResult::class);
 
-        $this->dbi->expects($this->exactly(1))
+        $this->dbi->expects(self::exactly(1))
             ->method('query')
             ->willReturn($resultStub);
 
-        $resultStub->expects($this->any())
+        $resultStub->expects(self::any())
             ->method('getIterator')
             ->willReturnCallback(static function (): Generator {
                 yield from [['Engine' => 'InnoDB', 'Name' => 'table']];
@@ -145,7 +145,7 @@ class RelationControllerTest extends AbstractTestCase
         $_POST['foreign'] = 'true';
         $ctrl->getDropdownValueForDatabase('INNODB');
         $json = $this->response->getJSONResult();
-        $this->assertEquals(
+        self::assertEquals(
             ['table'],
             $json['tables'],
         );
@@ -160,11 +160,11 @@ class RelationControllerTest extends AbstractTestCase
     {
         $resultStub = $this->createMock(DummyResult::class);
 
-        $this->dbi->expects($this->exactly(1))
+        $this->dbi->expects(self::exactly(1))
             ->method('query')
             ->willReturn($resultStub);
 
-        $resultStub->expects($this->any())
+        $resultStub->expects(self::any())
             ->method('fetchAllColumn')
             ->willReturn(['table']);
 
@@ -178,7 +178,7 @@ class RelationControllerTest extends AbstractTestCase
         $_POST['foreign'] = 'false';
         $ctrl->getDropdownValueForDatabase('INNODB');
         $json = $this->response->getJSONResult();
-        $this->assertEquals(
+        self::assertEquals(
             ['table'],
             $json['tables'],
         );
diff --git a/tests/classes/Controllers/Table/ReplaceControllerTest.php b/tests/classes/Controllers/Table/ReplaceControllerTest.php
index c7d169cf88..79b5a5143a 100644
--- a/tests/classes/Controllers/Table/ReplaceControllerTest.php
+++ b/tests/classes/Controllers/Table/ReplaceControllerTest.php
@@ -80,7 +80,7 @@ class ReplaceControllerTest extends AbstractTestCase
         $_POST['relational_display'] = 'K';
         $_POST['goto'] = 'index.php?route=/sql';
 
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('getParsedBodyParam')->willReturnMap([
             ['sql_query', null, ''],
             ['clause_is_unique', null, 1],
@@ -101,7 +101,7 @@ class ReplaceControllerTest extends AbstractTestCase
         $template = new Template();
         $response = new ResponseRenderer();
 
-        $pageSettings = $this->createStub(PageSettings::class);
+        $pageSettings = self::createStub(PageSettings::class);
         $bookmarkRepository = new BookmarkRepository($dbi, $relation);
         $sqlController = new SqlController(
             $response,
@@ -140,11 +140,11 @@ class ReplaceControllerTest extends AbstractTestCase
         $replaceController($request);
         $output = $response->getHTMLResult();
         $this->dummyDbi->assertAllSelectsConsumed();
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             'class="icon ic_s_success"> Showing rows 0 -  1 (2 total, Query took',
             $output,
         );
-        $this->assertStringContainsString('SELECT * FROM `test_tbl`', $output);
+        self::assertStringContainsString('SELECT * FROM `test_tbl`', $output);
     }
 
     /**
@@ -152,7 +152,7 @@ class ReplaceControllerTest extends AbstractTestCase
      */
     public function testGetParamsForUpdateOrInsert(): void
     {
-        $request1 = $this->createStub(ServerRequest::class);
+        $request1 = self::createStub(ServerRequest::class);
         $request1->method('getParsedBodyParam')->willReturnMap([
             ['where_clause', null, 'LIMIT 1'],
             ['submit_type', null, 'showinsert'],
@@ -179,13 +179,13 @@ class ReplaceControllerTest extends AbstractTestCase
             [$request1],
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             [['LIMIT 1'], true, true],
             $result,
         );
 
         // case 2 (else)
-        $request2 = $this->createStub(ServerRequest::class);
+        $request2 = self::createStub(ServerRequest::class);
         $request2->method('getParsedBodyParam')->willReturnMap([
             ['fields', null, ['multi_edit' => ['a' => 'b', 'c' => 'd']]],
         ]);
@@ -198,7 +198,7 @@ class ReplaceControllerTest extends AbstractTestCase
             [$request2],
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             [['a', 'c'], false, true],
             $result,
         );
diff --git a/tests/classes/Controllers/Table/SearchControllerTest.php b/tests/classes/Controllers/Table/SearchControllerTest.php
index 7e366dcad0..c28d5bbea2 100644
--- a/tests/classes/Controllers/Table/SearchControllerTest.php
+++ b/tests/classes/Controllers/Table/SearchControllerTest.php
@@ -59,7 +59,7 @@ class SearchControllerTest extends AbstractTestCase
             new ColumnFull('Field1', 'Type1', 'Collation1', false, '', null, '', '', ''),
             new ColumnFull('Field2', 'Type2', 'Collation2', false, '', null, '', '', ''),
         ];
-        $this->mockedDbi->expects($this->any())->method('getColumns')
+        $this->mockedDbi->expects(self::any())->method('getColumns')
             ->willReturn($columns);
 
         $showCreateTable = "CREATE TABLE `pma_bookmark` (
@@ -73,7 +73,7 @@ class SearchControllerTest extends AbstractTestCase
         ) ENGINE=MyISAM AUTO_INCREMENT=2 DEFAULT CHARSET=utf8 COLLATE=utf8_bin "
         . "COMMENT='Bookmarks'";
 
-        $this->mockedDbi->expects($this->any())->method('fetchValue')
+        $this->mockedDbi->expects(self::any())->method('fetchValue')
             ->willReturn($showCreateTable);
 
         DatabaseInterface::$instance = $this->mockedDbi;
@@ -89,7 +89,7 @@ class SearchControllerTest extends AbstractTestCase
     {
         $expected = 'SELECT MIN(`column`) AS `min`, MAX(`column`) AS `max` FROM `PMA`.`PMA_BookMark`';
 
-        $this->mockedDbi->expects($this->any())
+        $this->mockedDbi->expects(self::any())
             ->method('fetchSingleRow')
             ->with($expected)
             ->willReturn([$expected]);
@@ -104,7 +104,7 @@ class SearchControllerTest extends AbstractTestCase
         );
 
         $result = $ctrl->getColumnMinMax('column');
-        $this->assertEquals([$expected], $result);
+        self::assertEquals([$expected], $result);
     }
 
     /**
@@ -155,6 +155,6 @@ class SearchControllerTest extends AbstractTestCase
         $ctrl->getDataRowAction();
 
         $json = $this->response->getJSONResult();
-        $this->assertEquals($expected, $json['row_info']);
+        self::assertEquals($expected, $json['row_info']);
     }
 }
diff --git a/tests/classes/Controllers/Table/SqlControllerTest.php b/tests/classes/Controllers/Table/SqlControllerTest.php
index 3fdf412b21..bda2c0bc87 100644
--- a/tests/classes/Controllers/Table/SqlControllerTest.php
+++ b/tests/classes/Controllers/Table/SqlControllerTest.php
@@ -99,6 +99,6 @@ class SqlControllerTest extends AbstractTestCase
             $pageSettings,
             new DbTableExists($this->dbi),
         ))($request);
-        $this->assertSame($expected, $response->getHTMLResult());
+        self::assertSame($expected, $response->getHTMLResult());
     }
 }
diff --git a/tests/classes/Controllers/Table/Structure/ChangeControllerTest.php b/tests/classes/Controllers/Table/Structure/ChangeControllerTest.php
index 40a2667916..493607488e 100644
--- a/tests/classes/Controllers/Table/Structure/ChangeControllerTest.php
+++ b/tests/classes/Controllers/Table/Structure/ChangeControllerTest.php
@@ -55,7 +55,7 @@ class ChangeControllerTest extends AbstractTestCase
 
         $method->invokeArgs($ctrl, [[$_REQUEST['field']]]);
         $actual = $response->getHTMLResult();
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             '<input id="field_0_1"' . "\n"
             . '        type="text"' . "\n"
             . '    name="field_name[0]"' . "\n"
@@ -66,6 +66,6 @@ class ChangeControllerTest extends AbstractTestCase
             . '    value="_id">' . "\n",
             $actual,
         );
-        $this->assertStringContainsString('id="enumEditorModal"', $actual);
+        self::assertStringContainsString('id="enumEditorModal"', $actual);
     }
 }
diff --git a/tests/classes/Controllers/Table/Structure/SaveControllerTest.php b/tests/classes/Controllers/Table/Structure/SaveControllerTest.php
index 77c7e89fcb..ed1e7c6e24 100644
--- a/tests/classes/Controllers/Table/Structure/SaveControllerTest.php
+++ b/tests/classes/Controllers/Table/Structure/SaveControllerTest.php
@@ -85,10 +85,10 @@ class SaveControllerTest extends AbstractTestCase
         );
         $dbi = $this->createDatabaseInterface($dummyDbi);
 
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
 
-        $mock = $this->createMock(StructureController::class);
-        $mock->expects($this->once())->method('__invoke')->with($request);
+        $mock = self::createMock(StructureController::class);
+        $mock->expects(self::once())->method('__invoke')->with($request);
 
         (new SaveController(
             new ResponseRenderer(),
@@ -99,7 +99,7 @@ class SaveControllerTest extends AbstractTestCase
             $mock,
         ))($request);
 
-        $this->assertArrayNotHasKey('selected', $_POST);
+        self::assertArrayNotHasKey('selected', $_POST);
     }
 
     public function testAdjustColumnPrivileges(): void
@@ -118,10 +118,10 @@ class SaveControllerTest extends AbstractTestCase
             new Relation($dbi),
             new Transformations(),
             $dbi,
-            $this->createStub(StructureController::class),
+            self::createStub(StructureController::class),
         );
 
-        $this->assertFalse(
+        self::assertFalse(
             $method->invokeArgs($ctrl, [[]]),
         );
     }
diff --git a/tests/classes/Controllers/Table/Structure/SpatialControllerTest.php b/tests/classes/Controllers/Table/Structure/SpatialControllerTest.php
index 224ad8ac4f..1930e2f58c 100644
--- a/tests/classes/Controllers/Table/Structure/SpatialControllerTest.php
+++ b/tests/classes/Controllers/Table/Structure/SpatialControllerTest.php
@@ -31,18 +31,18 @@ class SpatialControllerTest extends AbstractTestCase
         $dbiDummy->addResult('ALTER TABLE `test_table` ADD SPATIAL(`test_field`);', true);
         $dbi = $this->createDatabaseInterface($dbiDummy);
         DatabaseInterface::$instance = $dbi;
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('getParsedBodyParam')->willReturnMap([['selected_fld', [], ['test_field']]]);
-        $controllerStub = $this->createMock(StructureController::class);
-        $controllerStub->expects($this->once())->method('__invoke')->with($request);
+        $controllerStub = self::createMock(StructureController::class);
+        $controllerStub->expects(self::once())->method('__invoke')->with($request);
 
         $indexes = new Indexes(DatabaseInterface::getInstance());
         $controller = new SpatialController(new ResponseRenderer(), new Template(), $controllerStub, $indexes);
         $controller($request);
 
-        $this->assertEquals(Message::success(), $GLOBALS['message']);
+        self::assertEquals(Message::success(), $GLOBALS['message']);
         /** @psalm-suppress TypeDoesNotContainType */
-        $this->assertSame('ALTER TABLE `test_table` ADD SPATIAL(`test_field`);', $GLOBALS['sql_query']);
+        self::assertSame('ALTER TABLE `test_table` ADD SPATIAL(`test_field`);', $GLOBALS['sql_query']);
         $dbiDummy->assertAllSelectsConsumed();
         $dbiDummy->assertAllQueriesConsumed();
     }
@@ -59,18 +59,18 @@ class SpatialControllerTest extends AbstractTestCase
         $dbiDummy->addResult('ALTER TABLE `test_table` ADD SPATIAL(`test_field1`, `test_field2`);', true);
         $dbi = $this->createDatabaseInterface($dbiDummy);
         DatabaseInterface::$instance = $dbi;
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('getParsedBodyParam')->willReturnMap([['selected_fld', [], ['test_field1', 'test_field2']]]);
-        $controllerStub = $this->createMock(StructureController::class);
-        $controllerStub->expects($this->once())->method('__invoke')->with($request);
+        $controllerStub = self::createMock(StructureController::class);
+        $controllerStub->expects(self::once())->method('__invoke')->with($request);
 
         $indexes = new Indexes(DatabaseInterface::getInstance());
         $controller = new SpatialController(new ResponseRenderer(), new Template(), $controllerStub, $indexes);
         $controller($request);
 
-        $this->assertEquals(Message::success(), $GLOBALS['message']);
+        self::assertEquals(Message::success(), $GLOBALS['message']);
         /** @psalm-suppress TypeDoesNotContainType */
-        $this->assertSame('ALTER TABLE `test_table` ADD SPATIAL(`test_field1`, `test_field2`);', $GLOBALS['sql_query']);
+        self::assertSame('ALTER TABLE `test_table` ADD SPATIAL(`test_field1`, `test_field2`);', $GLOBALS['sql_query']);
         $dbiDummy->assertAllSelectsConsumed();
         $dbiDummy->assertAllQueriesConsumed();
     }
@@ -84,22 +84,22 @@ class SpatialControllerTest extends AbstractTestCase
 
         $dbi = $this->createDatabaseInterface();
         DatabaseInterface::$instance = $dbi;
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('getParsedBodyParam')->willReturnMap([['selected_fld', [], null]]);
-        $controllerStub = $this->createMock(StructureController::class);
-        $controllerStub->expects($this->never())->method('__invoke');
+        $controllerStub = self::createMock(StructureController::class);
+        $controllerStub->expects(self::never())->method('__invoke');
         $response = new ResponseRenderer();
 
         $indexes = new Indexes(DatabaseInterface::getInstance());
         $controller = new SpatialController($response, new Template(), $controllerStub, $indexes);
         $controller($request);
 
-        $this->assertFalse($response->hasSuccessState());
-        $this->assertSame(['message' => 'No column selected.'], $response->getJSONResult());
+        self::assertFalse($response->hasSuccessState());
+        self::assertSame(['message' => 'No column selected.'], $response->getJSONResult());
         /** @psalm-suppress RedundantCondition */
-        $this->assertNull($GLOBALS['message']);
+        self::assertNull($GLOBALS['message']);
         /** @psalm-suppress RedundantCondition */
-        $this->assertNull($GLOBALS['sql_query']);
+        self::assertNull($GLOBALS['sql_query']);
     }
 
     public function testAddSpatialKeyWithError(): void
@@ -115,21 +115,21 @@ class SpatialControllerTest extends AbstractTestCase
         $dbiDummy->addErrorCode('#1210 - Incorrect arguments to SPATIAL INDEX');
         $dbi = $this->createDatabaseInterface($dbiDummy);
         DatabaseInterface::$instance = $dbi;
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('getParsedBodyParam')->willReturnMap([['selected_fld', [], ['test_field']]]);
-        $controllerStub = $this->createMock(StructureController::class);
-        $controllerStub->expects($this->once())->method('__invoke')->with($request);
+        $controllerStub = self::createMock(StructureController::class);
+        $controllerStub->expects(self::once())->method('__invoke')->with($request);
 
         $indexes = new Indexes(DatabaseInterface::getInstance());
         $controller = new SpatialController(new ResponseRenderer(), new Template(), $controllerStub, $indexes);
         $controller($request);
 
-        $this->assertEquals(
+        self::assertEquals(
             Message::error('#1210 - Incorrect arguments to SPATIAL INDEX'),
             $GLOBALS['message'],
         );
         /** @psalm-suppress TypeDoesNotContainType */
-        $this->assertSame('ALTER TABLE `test_table` ADD SPATIAL(`test_field`);', $GLOBALS['sql_query']);
+        self::assertSame('ALTER TABLE `test_table` ADD SPATIAL(`test_field`);', $GLOBALS['sql_query']);
         $dbiDummy->assertAllSelectsConsumed();
         $dbiDummy->assertAllQueriesConsumed();
         $dbiDummy->assertAllErrorCodesConsumed();
diff --git a/tests/classes/Controllers/Table/Structure/UniqueControllerTest.php b/tests/classes/Controllers/Table/Structure/UniqueControllerTest.php
index 5ec1e554ec..131255d5ad 100644
--- a/tests/classes/Controllers/Table/Structure/UniqueControllerTest.php
+++ b/tests/classes/Controllers/Table/Structure/UniqueControllerTest.php
@@ -31,18 +31,18 @@ class UniqueControllerTest extends AbstractTestCase
         $dbiDummy->addResult('ALTER TABLE `test_table` ADD UNIQUE(`test_field`);', true);
         $dbi = $this->createDatabaseInterface($dbiDummy);
         DatabaseInterface::$instance = $dbi;
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('getParsedBodyParam')->willReturnMap([['selected_fld', [], ['test_field']]]);
-        $controllerStub = $this->createMock(StructureController::class);
-        $controllerStub->expects($this->once())->method('__invoke')->with($request);
+        $controllerStub = self::createMock(StructureController::class);
+        $controllerStub->expects(self::once())->method('__invoke')->with($request);
 
         $indexes = new Indexes(DatabaseInterface::getInstance());
         $controller = new UniqueController(new ResponseRenderer(), new Template(), $controllerStub, $indexes);
         $controller($request);
 
-        $this->assertEquals(Message::success(), $GLOBALS['message']);
+        self::assertEquals(Message::success(), $GLOBALS['message']);
         /** @psalm-suppress TypeDoesNotContainType */
-        $this->assertSame('ALTER TABLE `test_table` ADD UNIQUE(`test_field`);', $GLOBALS['sql_query']);
+        self::assertSame('ALTER TABLE `test_table` ADD UNIQUE(`test_field`);', $GLOBALS['sql_query']);
         $dbiDummy->assertAllSelectsConsumed();
         $dbiDummy->assertAllQueriesConsumed();
     }
@@ -59,18 +59,18 @@ class UniqueControllerTest extends AbstractTestCase
         $dbiDummy->addResult('ALTER TABLE `test_table` ADD UNIQUE(`test_field1`, `test_field2`);', true);
         $dbi = $this->createDatabaseInterface($dbiDummy);
         DatabaseInterface::$instance = $dbi;
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('getParsedBodyParam')->willReturnMap([['selected_fld', [], ['test_field1', 'test_field2']]]);
-        $controllerStub = $this->createMock(StructureController::class);
-        $controllerStub->expects($this->once())->method('__invoke')->with($request);
+        $controllerStub = self::createMock(StructureController::class);
+        $controllerStub->expects(self::once())->method('__invoke')->with($request);
 
         $indexes = new Indexes(DatabaseInterface::getInstance());
         $controller = new UniqueController(new ResponseRenderer(), new Template(), $controllerStub, $indexes);
         $controller($request);
 
-        $this->assertEquals(Message::success(), $GLOBALS['message']);
+        self::assertEquals(Message::success(), $GLOBALS['message']);
         /** @psalm-suppress TypeDoesNotContainType */
-        $this->assertSame('ALTER TABLE `test_table` ADD UNIQUE(`test_field1`, `test_field2`);', $GLOBALS['sql_query']);
+        self::assertSame('ALTER TABLE `test_table` ADD UNIQUE(`test_field1`, `test_field2`);', $GLOBALS['sql_query']);
         $dbiDummy->assertAllSelectsConsumed();
         $dbiDummy->assertAllQueriesConsumed();
     }
@@ -84,22 +84,22 @@ class UniqueControllerTest extends AbstractTestCase
 
         $dbi = $this->createDatabaseInterface();
         DatabaseInterface::$instance = $dbi;
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('getParsedBodyParam')->willReturnMap([['selected_fld', [], null]]);
-        $controllerStub = $this->createMock(StructureController::class);
-        $controllerStub->expects($this->never())->method('__invoke');
+        $controllerStub = self::createMock(StructureController::class);
+        $controllerStub->expects(self::never())->method('__invoke');
         $response = new ResponseRenderer();
 
         $indexes = new Indexes(DatabaseInterface::getInstance());
         $controller = new UniqueController($response, new Template(), $controllerStub, $indexes);
         $controller($request);
 
-        $this->assertFalse($response->hasSuccessState());
-        $this->assertSame(['message' => 'No column selected.'], $response->getJSONResult());
+        self::assertFalse($response->hasSuccessState());
+        self::assertSame(['message' => 'No column selected.'], $response->getJSONResult());
         /** @psalm-suppress RedundantCondition */
-        $this->assertNull($GLOBALS['message']);
+        self::assertNull($GLOBALS['message']);
         /** @psalm-suppress RedundantCondition */
-        $this->assertNull($GLOBALS['sql_query']);
+        self::assertNull($GLOBALS['sql_query']);
     }
 
     public function testAddUniqueKeyWithError(): void
@@ -115,21 +115,21 @@ class UniqueControllerTest extends AbstractTestCase
         $dbiDummy->addErrorCode('#1062 - Duplicate entry &#039;2&#039; for key &#039;test_field&#039;');
         $dbi = $this->createDatabaseInterface($dbiDummy);
         DatabaseInterface::$instance = $dbi;
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('getParsedBodyParam')->willReturnMap([['selected_fld', [], ['test_field']]]);
-        $controllerStub = $this->createMock(StructureController::class);
-        $controllerStub->expects($this->once())->method('__invoke')->with($request);
+        $controllerStub = self::createMock(StructureController::class);
+        $controllerStub->expects(self::once())->method('__invoke')->with($request);
 
         $indexes = new Indexes(DatabaseInterface::getInstance());
         $controller = new UniqueController(new ResponseRenderer(), new Template(), $controllerStub, $indexes);
         $controller($request);
 
-        $this->assertEquals(
+        self::assertEquals(
             Message::error('#1062 - Duplicate entry &#039;2&#039; for key &#039;test_field&#039;'),
             $GLOBALS['message'],
         );
         /** @psalm-suppress TypeDoesNotContainType */
-        $this->assertSame('ALTER TABLE `test_table` ADD UNIQUE(`test_field`);', $GLOBALS['sql_query']);
+        self::assertSame('ALTER TABLE `test_table` ADD UNIQUE(`test_field`);', $GLOBALS['sql_query']);
         $dbiDummy->assertAllSelectsConsumed();
         $dbiDummy->assertAllQueriesConsumed();
         $dbiDummy->assertAllErrorCodesConsumed();
diff --git a/tests/classes/Controllers/Table/StructureControllerTest.php b/tests/classes/Controllers/Table/StructureControllerTest.php
index 1ff9bf4051..21b8fd7f09 100644
--- a/tests/classes/Controllers/Table/StructureControllerTest.php
+++ b/tests/classes/Controllers/Table/StructureControllerTest.php
@@ -161,7 +161,7 @@ class StructureControllerTest extends AbstractTestCase
             'route' => '/table/structure',
         ]);
 
-        $this->assertSame($expected, $response->getHTMLResult());
+        self::assertSame($expected, $response->getHTMLResult());
 
         $this->dummyDbi->assertAllSelectsConsumed();
         $this->dummyDbi->assertAllQueriesConsumed();
diff --git a/tests/classes/Controllers/Table/TrackingControllerTest.php b/tests/classes/Controllers/Table/TrackingControllerTest.php
index 884790dd01..54fd392f94 100644
--- a/tests/classes/Controllers/Table/TrackingControllerTest.php
+++ b/tests/classes/Controllers/Table/TrackingControllerTest.php
@@ -53,7 +53,7 @@ class TrackingControllerTest extends AbstractTestCase
 
         $response = new ResponseRenderer();
         $template = new Template();
-        $trackingChecker = $this->createStub(TrackingChecker::class);
+        $trackingChecker = self::createStub(TrackingChecker::class);
         $relation = new Relation($this->dbi);
         $bookmarkRepository = new BookmarkRepository($this->dbi, $relation);
         (new TrackingController(
@@ -102,6 +102,6 @@ class TrackingControllerTest extends AbstractTestCase
             'main' => $main,
         ]);
 
-        $this->assertSame($expected, $response->getHTMLResult());
+        self::assertSame($expected, $response->getHTMLResult());
     }
 }
diff --git a/tests/classes/Controllers/Table/ZoomSearchControllerTest.php b/tests/classes/Controllers/Table/ZoomSearchControllerTest.php
index ac1bc09975..fb2ed2efa9 100644
--- a/tests/classes/Controllers/Table/ZoomSearchControllerTest.php
+++ b/tests/classes/Controllers/Table/ZoomSearchControllerTest.php
@@ -61,7 +61,7 @@ final class ZoomSearchControllerTest extends AbstractTestCase
             'max_plot_limit' => 500,
         ]);
 
-        $this->assertSame($expected, $response->getHTMLResult());
+        self::assertSame($expected, $response->getHTMLResult());
     }
 
     public function testChangeTableInfoAction(): void
@@ -123,6 +123,6 @@ HTML;
             'field_value' => $value,
         ];
 
-        $this->assertSame($expected, $response->getJSONResult());
+        self::assertSame($expected, $response->getJSONResult());
     }
 }
diff --git a/tests/classes/Controllers/ThemeSetControllerTest.php b/tests/classes/Controllers/ThemeSetControllerTest.php
index b5ff332403..5837f31910 100644
--- a/tests/classes/Controllers/ThemeSetControllerTest.php
+++ b/tests/classes/Controllers/ThemeSetControllerTest.php
@@ -34,18 +34,18 @@ class ThemeSetControllerTest extends AbstractTestCase
     {
         Config::getInstance()->settings['ThemeManager'] = true;
 
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('getParsedBodyParam')->willReturnMap([['set_theme', null, 'theme_name']]);
 
-        $themeManager = $this->createMock(ThemeManager::class);
-        $themeManager->expects($this->once())->method('setActiveTheme')->with($this->equalTo('theme_name'));
-        $themeManager->expects($this->once())->method('setThemeCookie');
+        $themeManager = self::createMock(ThemeManager::class);
+        $themeManager->expects(self::once())->method('setActiveTheme')->with(self::equalTo('theme_name'));
+        $themeManager->expects(self::once())->method('setThemeCookie');
 
-        $userPreferences = $this->createMock(UserPreferences::class);
-        $userPreferences->expects($this->once())->method('load')
+        $userPreferences = self::createMock(UserPreferences::class);
+        $userPreferences->expects(self::once())->method('load')
             ->willReturn(['config_data' => ['ThemeDefault' => 'pmahomme']]);
-        $userPreferences->expects($this->once())->method('save')
-            ->with($this->equalTo(['ThemeDefault' => 'theme_name']));
+        $userPreferences->expects(self::once())->method('save')
+            ->with(self::equalTo(['ThemeDefault' => 'theme_name']));
 
         (new ThemeSetController(new ResponseRenderer(), new Template(), $themeManager, $userPreferences))($request);
     }
@@ -58,16 +58,16 @@ class ThemeSetControllerTest extends AbstractTestCase
     {
         Config::getInstance()->settings['ThemeManager'] = $hasThemes;
 
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('getParsedBodyParam')->willReturnMap([['set_theme', null, $themeName]]);
 
-        $themeManager = $this->createMock(ThemeManager::class);
-        $themeManager->expects($this->never())->method('setActiveTheme');
-        $themeManager->expects($this->never())->method('setThemeCookie');
+        $themeManager = self::createMock(ThemeManager::class);
+        $themeManager->expects(self::never())->method('setActiveTheme');
+        $themeManager->expects(self::never())->method('setThemeCookie');
 
-        $userPreferences = $this->createMock(UserPreferences::class);
-        $userPreferences->expects($this->never())->method('load');
-        $userPreferences->expects($this->never())->method('save');
+        $userPreferences = self::createMock(UserPreferences::class);
+        $userPreferences->expects(self::never())->method('load');
+        $userPreferences->expects(self::never())->method('save');
 
         (new ThemeSetController(new ResponseRenderer(), new Template(), $themeManager, $userPreferences))($request);
     }
diff --git a/tests/classes/Controllers/Transformation/OverviewControllerTest.php b/tests/classes/Controllers/Transformation/OverviewControllerTest.php
index d8af7b13ee..32bb4f944c 100644
--- a/tests/classes/Controllers/Transformation/OverviewControllerTest.php
+++ b/tests/classes/Controllers/Transformation/OverviewControllerTest.php
@@ -40,25 +40,25 @@ class OverviewControllerTest extends AbstractTestCase
 
         $controller = new OverviewController($response, new Template(), new Transformations());
 
-        $controller($this->createStub(ServerRequest::class));
+        $controller(self::createStub(ServerRequest::class));
         $actual = $response->getHTMLResult();
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             __('Available media types'),
             $actual,
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             'id="transformation">' . __('Available browser display transformations'),
             $actual,
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             'id="input_transformation">' . __('Available input transformations'),
             $actual,
         );
-        $this->assertStringContainsString('Text/Plain', $actual);
-        $this->assertStringContainsString('Image/JPEG: Inline', $actual);
-        $this->assertStringContainsString('Displays a clickable thumbnail.', $actual);
-        $this->assertStringContainsString('Image/JPEG: Upload', $actual);
-        $this->assertStringContainsString('Image upload functionality which also displays a thumbnail.', $actual);
+        self::assertStringContainsString('Text/Plain', $actual);
+        self::assertStringContainsString('Image/JPEG: Inline', $actual);
+        self::assertStringContainsString('Displays a clickable thumbnail.', $actual);
+        self::assertStringContainsString('Image/JPEG: Upload', $actual);
+        self::assertStringContainsString('Image upload functionality which also displays a thumbnail.', $actual);
     }
 }
diff --git a/tests/classes/Controllers/Triggers/IndexControllerTest.php b/tests/classes/Controllers/Triggers/IndexControllerTest.php
index a1b4f37960..c8895bd9d7 100644
--- a/tests/classes/Controllers/Triggers/IndexControllerTest.php
+++ b/tests/classes/Controllers/Triggers/IndexControllerTest.php
@@ -155,7 +155,7 @@ final class IndexControllerTest extends AbstractTestCase
 HTML;
         // phpcs:enable
 
-        $this->assertSame($expected, $actual);
+        self::assertSame($expected, $actual);
     }
 
     public function testWithoutTriggers(): void
@@ -244,7 +244,7 @@ HTML;
 HTML;
         // phpcs:enable
 
-        $this->assertSame($expected, $actual);
+        self::assertSame($expected, $actual);
     }
 
     /**
@@ -267,7 +267,7 @@ HTML;
 
         $method = (new ReflectionClass(IndexController::class))->getMethod('getDataFromRequest');
 
-        $dbi = $this->createStub(DatabaseInterface::class);
+        $dbi = self::createStub(DatabaseInterface::class);
         DatabaseInterface::$instance = $dbi;
         $template = new Template();
         $response = new ResponseRenderer();
@@ -280,12 +280,12 @@ HTML;
         );
 
         $request = $this->createMock(ServerRequest::class);
-        $request->expects($this->any())
+        $request->expects(self::any())
             ->method('getParsedBodyParam')
             ->willReturn('foo');
 
         $output = $method->invoke($indexController, $request);
-        $this->assertEquals($out, $output);
+        self::assertEquals($out, $output);
     }
 
     /**
diff --git a/tests/classes/Controllers/VersionCheckControllerTest.php b/tests/classes/Controllers/VersionCheckControllerTest.php
index b230453760..da1cf8b1e3 100644
--- a/tests/classes/Controllers/VersionCheckControllerTest.php
+++ b/tests/classes/Controllers/VersionCheckControllerTest.php
@@ -35,20 +35,20 @@ class VersionCheckControllerTest extends AbstractTestCase
         ];
 
         $versionInformation = $this->createMock(VersionInformation::class);
-        $versionInformation->expects($this->once())->method('getLatestVersions')->willReturn($versionInfo);
-        $versionInformation->expects($this->once())->method('getLatestCompatibleVersion')
-            ->with($this->equalTo($versionInfo))
+        $versionInformation->expects(self::once())->method('getLatestVersions')->willReturn($versionInfo);
+        $versionInformation->expects(self::once())->method('getLatestCompatibleVersion')
+            ->with(self::equalTo($versionInfo))
             ->willReturn($versionInfo[0]);
 
         (new VersionCheckController(
             new ResponseRenderer(),
             new Template(),
             $versionInformation,
-        ))($this->createStub(ServerRequest::class));
+        ))(self::createStub(ServerRequest::class));
 
         $output = $this->getActualOutputForAssertion();
-        $this->assertTrue(isset($_GET['ajax_request']));
-        $this->assertSame('{"version":"5.1.3","date":"2022-02-11"}', $output);
+        self::assertTrue(isset($_GET['ajax_request']));
+        self::assertSame('{"version":"5.1.3","date":"2022-02-11"}', $output);
     }
 
     public function testWithoutLatestCompatibleVersion(): void
@@ -60,20 +60,20 @@ class VersionCheckControllerTest extends AbstractTestCase
         ];
 
         $versionInformation = $this->createMock(VersionInformation::class);
-        $versionInformation->expects($this->once())->method('getLatestVersions')->willReturn($versionInfo);
-        $versionInformation->expects($this->once())->method('getLatestCompatibleVersion')
-            ->with($this->equalTo($versionInfo))
+        $versionInformation->expects(self::once())->method('getLatestVersions')->willReturn($versionInfo);
+        $versionInformation->expects(self::once())->method('getLatestCompatibleVersion')
+            ->with(self::equalTo($versionInfo))
             ->willReturn(null);
 
         (new VersionCheckController(
             new ResponseRenderer(),
             new Template(),
             $versionInformation,
-        ))($this->createStub(ServerRequest::class));
+        ))(self::createStub(ServerRequest::class));
 
         $output = $this->getActualOutputForAssertion();
-        $this->assertTrue(isset($_GET['ajax_request']));
-        $this->assertSame('{"version":"","date":""}', $output);
+        self::assertTrue(isset($_GET['ajax_request']));
+        self::assertSame('{"version":"","date":""}', $output);
     }
 
     public function testWithoutLatestVersion(): void
@@ -81,17 +81,17 @@ class VersionCheckControllerTest extends AbstractTestCase
         $_GET = [];
 
         $versionInformation = $this->createMock(VersionInformation::class);
-        $versionInformation->expects($this->once())->method('getLatestVersions')->willReturn(null);
-        $versionInformation->expects($this->never())->method('getLatestCompatibleVersion');
+        $versionInformation->expects(self::once())->method('getLatestVersions')->willReturn(null);
+        $versionInformation->expects(self::never())->method('getLatestCompatibleVersion');
 
         (new VersionCheckController(
             new ResponseRenderer(),
             new Template(),
             $versionInformation,
-        ))($this->createStub(ServerRequest::class));
+        ))(self::createStub(ServerRequest::class));
 
         $output = $this->getActualOutputForAssertion();
-        $this->assertTrue(isset($_GET['ajax_request']));
-        $this->assertSame('[]', $output);
+        self::assertTrue(isset($_GET['ajax_request']));
+        self::assertSame('[]', $output);
     }
 }
diff --git a/tests/classes/CoreTest.php b/tests/classes/CoreTest.php
index 31cac65b63..8dbf84d0bb 100644
--- a/tests/classes/CoreTest.php
+++ b/tests/classes/CoreTest.php
@@ -56,72 +56,72 @@ class CoreTest extends AbstractTestCase
             'sarr' => ['arr1' => [1, 2, 3], [3, ['a', 'b', 'c'], 4]],
         ];
 
-        $this->assertEquals(
+        self::assertEquals(
             Core::arrayRead('int', $arr),
             $arr['int'],
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             Core::arrayRead('str', $arr),
             $arr['str'],
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             Core::arrayRead('arr/0', $arr),
             $arr['arr'][0],
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             Core::arrayRead('arr/1', $arr),
             $arr['arr'][1],
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             Core::arrayRead('arr/2', $arr),
             $arr['arr'][2],
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             Core::arrayRead('sarr/arr1/0', $arr),
             $arr['sarr']['arr1'][0],
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             Core::arrayRead('sarr/arr1/1', $arr),
             $arr['sarr']['arr1'][1],
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             Core::arrayRead('sarr/arr1/2', $arr),
             $arr['sarr']['arr1'][2],
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             Core::arrayRead('sarr/0/0', $arr),
             $arr['sarr'][0][0],
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             Core::arrayRead('sarr/0/1', $arr),
             $arr['sarr'][0][1],
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             Core::arrayRead('sarr/0/1/2', $arr),
             $arr['sarr'][0][1][2],
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             Core::arrayRead('sarr/not_exiting/1', $arr),
             null,
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             Core::arrayRead('sarr/not_exiting/1', $arr, 0),
             0,
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             Core::arrayRead('sarr/not_exiting/1', $arr, 'default_val'),
             'default_val',
         );
@@ -140,40 +140,40 @@ class CoreTest extends AbstractTestCase
         ];
 
         Core::arrayWrite('int', $arr, 5);
-        $this->assertEquals($arr['int'], 5);
+        self::assertEquals($arr['int'], 5);
 
         Core::arrayWrite('str', $arr, '_str');
-        $this->assertEquals($arr['str'], '_str');
+        self::assertEquals($arr['str'], '_str');
 
         Core::arrayWrite('arr/0', $arr, 'val_arr_0');
-        $this->assertEquals($arr['arr'][0], 'val_arr_0');
+        self::assertEquals($arr['arr'][0], 'val_arr_0');
 
         Core::arrayWrite('arr/1', $arr, 'val_arr_1');
-        $this->assertEquals($arr['arr'][1], 'val_arr_1');
+        self::assertEquals($arr['arr'][1], 'val_arr_1');
 
         Core::arrayWrite('arr/2', $arr, 'val_arr_2');
-        $this->assertEquals($arr['arr'][2], 'val_arr_2');
+        self::assertEquals($arr['arr'][2], 'val_arr_2');
 
         Core::arrayWrite('sarr/arr1/0', $arr, 'val_sarr_arr_0');
-        $this->assertEquals($arr['sarr']['arr1'][0], 'val_sarr_arr_0');
+        self::assertEquals($arr['sarr']['arr1'][0], 'val_sarr_arr_0');
 
         Core::arrayWrite('sarr/arr1/1', $arr, 'val_sarr_arr_1');
-        $this->assertEquals($arr['sarr']['arr1'][1], 'val_sarr_arr_1');
+        self::assertEquals($arr['sarr']['arr1'][1], 'val_sarr_arr_1');
 
         Core::arrayWrite('sarr/arr1/2', $arr, 'val_sarr_arr_2');
-        $this->assertEquals($arr['sarr']['arr1'][2], 'val_sarr_arr_2');
+        self::assertEquals($arr['sarr']['arr1'][2], 'val_sarr_arr_2');
 
         Core::arrayWrite('sarr/0/0', $arr, 5);
-        $this->assertEquals($arr['sarr'][0][0], 5);
+        self::assertEquals($arr['sarr'][0][0], 5);
 
         Core::arrayWrite('sarr/0/1/0', $arr, 'e');
-        $this->assertEquals($arr['sarr'][0][1][0], 'e');
+        self::assertEquals($arr['sarr'][0][1][0], 'e');
 
         Core::arrayWrite('sarr/not_existing/1', $arr, 'some_val');
-        $this->assertEquals($arr['sarr']['not_existing'][1], 'some_val');
+        self::assertEquals($arr['sarr']['not_existing'][1], 'some_val');
 
         Core::arrayWrite('sarr/0/2', $arr, null);
-        $this->assertNull($arr['sarr'][0][2]);
+        self::assertNull($arr['sarr'][0][2]);
     }
 
     /**
@@ -189,48 +189,48 @@ class CoreTest extends AbstractTestCase
         ];
 
         Core::arrayRemove('int', $arr);
-        $this->assertArrayNotHasKey('int', $arr);
+        self::assertArrayNotHasKey('int', $arr);
 
         Core::arrayRemove('str', $arr);
-        $this->assertArrayNotHasKey('str', $arr);
+        self::assertArrayNotHasKey('str', $arr);
 
         Core::arrayRemove('arr/0', $arr);
-        $this->assertArrayNotHasKey(0, $arr['arr']);
+        self::assertArrayNotHasKey(0, $arr['arr']);
 
         Core::arrayRemove('arr/1', $arr);
-        $this->assertArrayNotHasKey(1, $arr['arr']);
+        self::assertArrayNotHasKey(1, $arr['arr']);
 
         Core::arrayRemove('arr/2', $arr);
-        $this->assertArrayNotHasKey('arr', $arr);
+        self::assertArrayNotHasKey('arr', $arr);
 
         $tmpArr = $arr;
         Core::arrayRemove('sarr/not_existing/1', $arr);
-        $this->assertEquals($tmpArr, $arr);
+        self::assertEquals($tmpArr, $arr);
 
         Core::arrayRemove('sarr/arr1/0', $arr);
-        $this->assertArrayNotHasKey(0, $arr['sarr']['arr1']);
+        self::assertArrayNotHasKey(0, $arr['sarr']['arr1']);
 
         Core::arrayRemove('sarr/arr1/1', $arr);
-        $this->assertArrayNotHasKey(1, $arr['sarr']['arr1']);
+        self::assertArrayNotHasKey(1, $arr['sarr']['arr1']);
 
         Core::arrayRemove('sarr/arr1/2', $arr);
-        $this->assertArrayNotHasKey('arr1', $arr['sarr']);
+        self::assertArrayNotHasKey('arr1', $arr['sarr']);
 
         Core::arrayRemove('sarr/0/0', $arr);
-        $this->assertArrayNotHasKey(0, $arr['sarr'][0]);
+        self::assertArrayNotHasKey(0, $arr['sarr'][0]);
 
         Core::arrayRemove('sarr/0/1/0', $arr);
-        $this->assertArrayNotHasKey(0, $arr['sarr'][0][1]);
+        self::assertArrayNotHasKey(0, $arr['sarr'][0][1]);
 
         Core::arrayRemove('sarr/0/1/1', $arr);
-        $this->assertArrayNotHasKey(1, $arr['sarr'][0][1]);
+        self::assertArrayNotHasKey(1, $arr['sarr'][0][1]);
 
         Core::arrayRemove('sarr/0/1/2', $arr);
-        $this->assertArrayNotHasKey(1, $arr['sarr'][0]);
+        self::assertArrayNotHasKey(1, $arr['sarr'][0]);
 
         Core::arrayRemove('sarr/0/2', $arr);
 
-        $this->assertEmpty($arr);
+        self::assertEmpty($arr);
     }
 
     /**
@@ -242,7 +242,7 @@ class CoreTest extends AbstractTestCase
     #[DataProvider('providerTestGotoNowhere')]
     public function testGotoNowhere(string $page, bool $expected): void
     {
-        $this->assertSame($expected, Core::checkPageValidity($page));
+        self::assertSame($expected, Core::checkPageValidity($page));
     }
 
     /**
@@ -272,7 +272,7 @@ class CoreTest extends AbstractTestCase
     #[Group('32bit-incompatible')]
     public function testGetRealSize(string $size, int $expected): void
     {
-        $this->assertEquals($expected, Core::getRealSize($size));
+        self::assertEquals($expected, Core::getRealSize($size));
     }
 
     /**
@@ -304,7 +304,7 @@ class CoreTest extends AbstractTestCase
     public function testGetPHPDocLink(): void
     {
         $lang = _pgettext('PHP documentation language', 'en');
-        $this->assertEquals(
+        self::assertEquals(
             Core::getPHPDocLink('function'),
             'index.php?route=/url&url=https%3A%2F%2Fwww.php.net%2Fmanual%2F'
             . $lang . '%2Ffunction',
@@ -320,7 +320,7 @@ class CoreTest extends AbstractTestCase
     #[DataProvider('providerTestLinkURL')]
     public function testLinkURL(string $link, string $url): void
     {
-        $this->assertEquals(Core::linkURL($link), $url);
+        self::assertEquals(Core::linkURL($link), $url);
     }
 
     /**
@@ -342,7 +342,7 @@ class CoreTest extends AbstractTestCase
     public function testIsAllowedDomain(string $url, bool $expected): void
     {
         $_SERVER['SERVER_NAME'] = 'server.local';
-        $this->assertEquals(
+        self::assertEquals(
             $expected,
             Core::isAllowedDomain($url),
         );
@@ -391,7 +391,7 @@ class CoreTest extends AbstractTestCase
     #[DataProvider('provideTestSafeUnserialize')]
     public function testSafeUnserialize(string $data, mixed $expected): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             $expected,
             Core::safeUnserialize($data),
         );
@@ -431,7 +431,7 @@ class CoreTest extends AbstractTestCase
     #[DataProvider('provideTestSanitizeMySQLHost')]
     public function testSanitizeMySQLHost(string $host, string $expected): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             $expected,
             Core::sanitizeMySQLHost($host),
         );
@@ -457,15 +457,15 @@ class CoreTest extends AbstractTestCase
      */
     public function testReplaceDots(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             Core::securePath('../../../etc/passwd'),
             './././etc/passwd',
         );
-        $this->assertEquals(
+        self::assertEquals(
             Core::securePath('/var/www/../phpmyadmin'),
             '/var/www/./phpmyadmin',
         );
-        $this->assertEquals(
+        self::assertEquals(
             Core::securePath('./path/with..dots/../../file..php'),
             './path/with.dots/././file.php',
         );
@@ -519,7 +519,7 @@ class CoreTest extends AbstractTestCase
         $sqlQuery = 'SELECT * FROM `test`.`db` WHERE 1;';
         $signature = Core::signSqlQuery($sqlQuery);
         $hmac = '33371e8680a640dc05944a2a24e6e630d3e9e3dba24464135f2fb954c3a4ffe2';
-        $this->assertSame($hmac, $signature, 'The signature must match the computed one');
+        self::assertSame($hmac, $signature, 'The signature must match the computed one');
     }
 
     /**
@@ -530,7 +530,7 @@ class CoreTest extends AbstractTestCase
         $_SESSION[' HMAC_secret '] = hash('sha1', 'test');
         $sqlQuery = 'SELECT * FROM `test`.`db` WHERE 1;';
         $hmac = '33371e8680a640dc05944a2a24e6e630d3e9e3dba24464135f2fb954c3a4ffe2';
-        $this->assertTrue(Core::checkSqlQuerySignature($sqlQuery, $hmac));
+        self::assertTrue(Core::checkSqlQuerySignature($sqlQuery, $hmac));
     }
 
     /**
@@ -541,7 +541,7 @@ class CoreTest extends AbstractTestCase
         $_SESSION[' HMAC_secret '] = hash('sha1', '132654987gguieunofz');
         $sqlQuery = 'SELECT * FROM `test`.`db` WHERE 1;';
         $hmac = '33371e8680a640dc05944a2a24e6e630d3e9e3dba24464135f2fb954c3a4ffe2';
-        $this->assertFalse(Core::checkSqlQuerySignature($sqlQuery, $hmac));
+        self::assertFalse(Core::checkSqlQuerySignature($sqlQuery, $hmac));
     }
 
     /**
@@ -552,7 +552,7 @@ class CoreTest extends AbstractTestCase
         $_SESSION[' HMAC_secret '] = hash('sha1', 'test');
         $sqlQuery = 'SELECT * FROM `test`.`db` WHERE 1;';
         $hmac = '3333333380a640dc05944a2a24e6e630d3e9e3dba24464135f2fb954c3eeeeee';
-        $this->assertFalse(Core::checkSqlQuerySignature($sqlQuery, $hmac));
+        self::assertFalse(Core::checkSqlQuerySignature($sqlQuery, $hmac));
     }
 
     /**
@@ -563,7 +563,7 @@ class CoreTest extends AbstractTestCase
         $_SESSION[' HMAC_secret '] = 'empty';
         $sqlQuery = 'SELECT * FROM `test`.`db` WHERE 1;';
         $hmac = '3333333380a640dc05944a2a24e6e630d3e9e3dba24464135f2fb954c3eeeeee';
-        $this->assertFalse(Core::checkSqlQuerySignature($sqlQuery, $hmac));
+        self::assertFalse(Core::checkSqlQuerySignature($sqlQuery, $hmac));
     }
 
     /**
@@ -574,10 +574,10 @@ class CoreTest extends AbstractTestCase
         $_SESSION[' HMAC_secret '] = hash('sha1', 'firstSession');
         $sqlQuery = 'SELECT * FROM `test`.`db` WHERE 1;';
         $hmac = Core::signSqlQuery($sqlQuery);
-        $this->assertTrue(Core::checkSqlQuerySignature($sqlQuery, $hmac));
+        self::assertTrue(Core::checkSqlQuerySignature($sqlQuery, $hmac));
         $_SESSION[' HMAC_secret '] = hash('sha1', 'secondSession');
         // Try to use the token (hmac) from the previous session
-        $this->assertFalse(Core::checkSqlQuerySignature($sqlQuery, $hmac));
+        self::assertFalse(Core::checkSqlQuerySignature($sqlQuery, $hmac));
     }
 
     /**
@@ -590,16 +590,16 @@ class CoreTest extends AbstractTestCase
         $_SESSION[' HMAC_secret '] = hash('sha1', 'firstSession');
         $sqlQuery = 'SELECT * FROM `test`.`db` WHERE 1;';
         $hmac = Core::signSqlQuery($sqlQuery);
-        $this->assertTrue(Core::checkSqlQuerySignature($sqlQuery, $hmac));
+        self::assertTrue(Core::checkSqlQuerySignature($sqlQuery, $hmac));
         $config->settings['blowfish_secret'] = str_repeat('a', 32);
         // Try to use the previous HMAC signature
-        $this->assertFalse(Core::checkSqlQuerySignature($sqlQuery, $hmac));
+        self::assertFalse(Core::checkSqlQuerySignature($sqlQuery, $hmac));
 
         $config->settings['blowfish_secret'] = str_repeat('a', 32);
         // Generate the HMAC signature to check that it works
         $hmac = Core::signSqlQuery($sqlQuery);
         // Must work now, (good secret and blowfish_secret)
-        $this->assertTrue(Core::checkSqlQuerySignature($sqlQuery, $hmac));
+        self::assertTrue(Core::checkSqlQuerySignature($sqlQuery, $hmac));
     }
 
     public function testPopulateRequestWithEncryptedQueryParams(): void
@@ -612,7 +612,7 @@ class CoreTest extends AbstractTestCase
         $_GET = ['pos' => '0', 'eq' => Url::encryptQuery('{"db":"test_db","table":"test_table"}')];
         $_REQUEST = $_GET;
 
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('getQueryParams')->willReturn($_GET);
         $request->method('getParsedBody')->willReturn(null);
         $request->method('withQueryParams')->willReturnSelf();
@@ -622,8 +622,8 @@ class CoreTest extends AbstractTestCase
 
         $expected = ['pos' => '0', 'db' => 'test_db', 'table' => 'test_table'];
 
-        $this->assertEquals($expected, $_GET);
-        $this->assertEquals($expected, $_REQUEST);
+        self::assertEquals($expected, $_GET);
+        self::assertEquals($expected, $_REQUEST);
     }
 
     /**
@@ -643,7 +643,7 @@ class CoreTest extends AbstractTestCase
         $_GET = $encrypted;
         $_REQUEST = $encrypted;
 
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('getQueryParams')->willReturn($_GET);
         $request->method('getParsedBody')->willReturn(null);
         $request->method('withQueryParams')->willReturnSelf();
@@ -651,8 +651,8 @@ class CoreTest extends AbstractTestCase
 
         Core::populateRequestWithEncryptedQueryParams($request);
 
-        $this->assertEquals($decrypted, $_GET);
-        $this->assertEquals($decrypted, $_REQUEST);
+        self::assertEquals($decrypted, $_GET);
+        self::assertEquals($decrypted, $_REQUEST);
     }
 
     /** @return array<int, array<int, array<string, string|mixed[]>>> */
@@ -677,13 +677,13 @@ class CoreTest extends AbstractTestCase
         $headersList = \xdebug_get_headers();
         // phpcs:enable
 
-        $this->assertContains('Cache-Control: private, max-age=10800', $headersList);
-        $this->assertContains('Content-Description: File Transfer', $headersList);
-        $this->assertContains('Content-Disposition: attachment; filename="test.sql"', $headersList);
-        $this->assertContains('Content-type: text/x-sql;charset=UTF-8', $headersList);
-        $this->assertContains('Content-Transfer-Encoding: binary', $headersList);
-        $this->assertContains('Content-Length: 100', $headersList);
-        $this->assertNotContains('Content-Encoding: gzip', $headersList);
+        self::assertContains('Cache-Control: private, max-age=10800', $headersList);
+        self::assertContains('Content-Description: File Transfer', $headersList);
+        self::assertContains('Content-Disposition: attachment; filename="test.sql"', $headersList);
+        self::assertContains('Content-type: text/x-sql;charset=UTF-8', $headersList);
+        self::assertContains('Content-Transfer-Encoding: binary', $headersList);
+        self::assertContains('Content-Length: 100', $headersList);
+        self::assertNotContains('Content-Encoding: gzip', $headersList);
     }
 
     #[PreserveGlobalState(false)]
@@ -702,13 +702,13 @@ class CoreTest extends AbstractTestCase
         $headersList = \xdebug_get_headers();
         // phpcs:enable
 
-        $this->assertContains('Cache-Control: private, max-age=10800', $headersList);
-        $this->assertContains('Content-Description: File Transfer', $headersList);
-        $this->assertContains('Content-Disposition: attachment; filename="test.sql.gz"', $headersList);
-        $this->assertContains('Content-Type: application/x-gzip', $headersList);
-        $this->assertNotContains('Content-Encoding: gzip', $headersList);
-        $this->assertContains('Content-Transfer-Encoding: binary', $headersList);
-        $this->assertNotContains('Content-Length: 0', $headersList);
+        self::assertContains('Cache-Control: private, max-age=10800', $headersList);
+        self::assertContains('Content-Description: File Transfer', $headersList);
+        self::assertContains('Content-Disposition: attachment; filename="test.sql.gz"', $headersList);
+        self::assertContains('Content-Type: application/x-gzip', $headersList);
+        self::assertNotContains('Content-Encoding: gzip', $headersList);
+        self::assertContains('Content-Transfer-Encoding: binary', $headersList);
+        self::assertNotContains('Content-Length: 0', $headersList);
     }
 
     public function testGetEnv(): void
diff --git a/tests/classes/CreateAddFieldTest.php b/tests/classes/CreateAddFieldTest.php
index e74e3fceae..51eb975d66 100644
--- a/tests/classes/CreateAddFieldTest.php
+++ b/tests/classes/CreateAddFieldTest.php
@@ -38,7 +38,7 @@ class CreateAddFieldTest extends AbstractTestCase
     {
         $_POST = $request;
         $actual = $this->createAddField->getPartitionsDefinition();
-        $this->assertEquals($expected, $actual);
+        self::assertEquals($expected, $actual);
     }
 
     /**
@@ -231,7 +231,7 @@ class CreateAddFieldTest extends AbstractTestCase
     {
         $_POST = $request;
         $actual = $this->createAddField->getTableCreationQuery($db, $table);
-        $this->assertEquals($expected, $actual);
+        self::assertEquals($expected, $actual);
     }
 
     /**
@@ -463,6 +463,6 @@ class CreateAddFieldTest extends AbstractTestCase
     {
         $_POST = $request;
         $sqlQuery = $this->createAddField->getColumnCreationQuery('my_table');
-        $this->assertEquals($expected, $sqlQuery);
+        self::assertEquals($expected, $sqlQuery);
     }
 }
diff --git a/tests/classes/Crypto/CryptoTest.php b/tests/classes/Crypto/CryptoTest.php
index cf7c93a1d3..a1dade28f3 100644
--- a/tests/classes/Crypto/CryptoTest.php
+++ b/tests/classes/Crypto/CryptoTest.php
@@ -22,9 +22,9 @@ class CryptoTest extends AbstractTestCase
 
         $crypto = new Crypto();
         $encrypted = $crypto->encrypt('test');
-        $this->assertNotSame('test', $encrypted);
-        $this->assertSame('test', $crypto->decrypt($encrypted));
-        $this->assertArrayNotHasKey('URLQueryEncryptionSecretKey', $_SESSION);
+        self::assertNotSame('test', $encrypted);
+        self::assertSame('test', $crypto->decrypt($encrypted));
+        self::assertArrayNotHasKey('URLQueryEncryptionSecretKey', $_SESSION);
     }
 
     public function testWithValidKeyFromSession(): void
@@ -34,9 +34,9 @@ class CryptoTest extends AbstractTestCase
 
         $crypto = new Crypto();
         $encrypted = $crypto->encrypt('test');
-        $this->assertNotSame('test', $encrypted);
-        $this->assertSame('test', $crypto->decrypt($encrypted));
-        $this->assertArrayHasKey('URLQueryEncryptionSecretKey', $_SESSION);
+        self::assertNotSame('test', $encrypted);
+        self::assertSame('test', $crypto->decrypt($encrypted));
+        self::assertArrayHasKey('URLQueryEncryptionSecretKey', $_SESSION);
     }
 
     public function testWithNewSessionKey(): void
@@ -46,10 +46,10 @@ class CryptoTest extends AbstractTestCase
 
         $crypto = new Crypto();
         $encrypted = $crypto->encrypt('test');
-        $this->assertNotSame('test', $encrypted);
-        $this->assertSame('test', $crypto->decrypt($encrypted));
-        $this->assertArrayHasKey('URLQueryEncryptionSecretKey', $_SESSION);
-        $this->assertEquals(32, mb_strlen($_SESSION['URLQueryEncryptionSecretKey'], '8bit'));
+        self::assertNotSame('test', $encrypted);
+        self::assertSame('test', $crypto->decrypt($encrypted));
+        self::assertArrayHasKey('URLQueryEncryptionSecretKey', $_SESSION);
+        self::assertEquals(32, mb_strlen($_SESSION['URLQueryEncryptionSecretKey'], '8bit'));
     }
 
     public function testDecryptWithInvalidKey(): void
@@ -60,12 +60,12 @@ class CryptoTest extends AbstractTestCase
 
         $crypto = new Crypto();
         $encrypted = $crypto->encrypt('test');
-        $this->assertNotSame('test', $encrypted);
-        $this->assertSame('test', $crypto->decrypt($encrypted));
+        self::assertNotSame('test', $encrypted);
+        self::assertSame('test', $crypto->decrypt($encrypted));
 
         $config->set('URLQueryEncryptionSecretKey', str_repeat('b', 32));
 
         $crypto = new Crypto();
-        $this->assertNull($crypto->decrypt($encrypted));
+        self::assertNull($crypto->decrypt($encrypted));
     }
 }
diff --git a/tests/classes/Database/CentralColumnsTest.php b/tests/classes/Database/CentralColumnsTest.php
index 9caa195948..d63ed46fdb 100644
--- a/tests/classes/Database/CentralColumnsTest.php
+++ b/tests/classes/Database/CentralColumnsTest.php
@@ -134,26 +134,26 @@ class CentralColumnsTest extends AbstractTestCase
         DatabaseInterface::$instance = $this->dbi;
 
         // set some common expectations
-        $this->dbi->expects($this->any())
+        $this->dbi->expects(self::any())
             ->method('selectDb')
             ->willReturn(true);
-        $this->dbi->expects($this->any())
+        $this->dbi->expects(self::any())
             ->method('getColumns')
             ->willReturn([
                 'id' => new ColumnFull('id', 'integer', null, false, '', null, '', '', ''),
                 'col1' => new ColumnFull('col1', 'varchar(100)', null, true, '', null, '', '', ''),
                 'col2' => new ColumnFull('col2', 'DATETIME', null, false, '', null, '', '', ''),
             ]);
-        $this->dbi->expects($this->any())
+        $this->dbi->expects(self::any())
             ->method('getColumnNames')
             ->willReturn(['id', 'col1', 'col2']);
-        $this->dbi->expects($this->any())
+        $this->dbi->expects(self::any())
             ->method('tryQuery')
-            ->willReturn($this->createStub(DummyResult::class));
-        $this->dbi->expects($this->any())
+            ->willReturn(self::createStub(DummyResult::class));
+        $this->dbi->expects(self::any())
             ->method('getTables')
             ->willReturn(['PMA_table', 'PMA_table1', 'PMA_table2']);
-        $this->dbi->expects($this->any())->method('quoteString')
+        $this->dbi->expects(self::any())->method('quoteString')
         ->willReturnCallback(static fn (string $string): string => "'" . $string . "'");
 
         $this->centralColumns = new CentralColumns($this->dbi);
@@ -164,7 +164,7 @@ class CentralColumnsTest extends AbstractTestCase
      */
     public function testGetParams(): void
     {
-        $this->assertSame(
+        self::assertSame(
             ['user' => 'pma_user', 'db' => 'phpmyadmin', 'table' => 'pma_central_columns'],
             $this->centralColumns->getParams(),
         );
@@ -175,18 +175,18 @@ class CentralColumnsTest extends AbstractTestCase
      */
     public function testGetColumnsList(): void
     {
-        $this->dbi->expects($this->exactly(2))
+        $this->dbi->expects(self::exactly(2))
             ->method('fetchResult')
             ->willReturnOnConsecutiveCalls(
                 $this->columnData,
                 array_slice($this->columnData, 1, 2),
             );
 
-        $this->assertEquals(
+        self::assertEquals(
             $this->modifiedColumnData,
             $this->centralColumns->getColumnsList('phpmyadmin'),
         );
-        $this->assertEquals(
+        self::assertEquals(
             array_slice($this->modifiedColumnData, 1, 2),
             $this->centralColumns->getColumnsList('phpmyadmin', 1, 2),
         );
@@ -197,7 +197,7 @@ class CentralColumnsTest extends AbstractTestCase
      */
     public function testGetCount(): void
     {
-        $this->dbi->expects($this->once())
+        $this->dbi->expects(self::once())
             ->method('fetchResult')
             ->with(
                 'SELECT count(db_name) FROM `pma_central_columns` WHERE db_name = \'phpmyadmin\';',
@@ -207,7 +207,7 @@ class CentralColumnsTest extends AbstractTestCase
             )
             ->willReturn([3]);
 
-        $this->assertEquals(
+        self::assertEquals(
             3,
             $this->centralColumns->getCount('phpmyadmin'),
         );
@@ -221,7 +221,7 @@ class CentralColumnsTest extends AbstractTestCase
         $_POST['db'] = 'PMA_db';
         $_POST['table'] = 'PMA_table';
 
-        $this->assertTrue(
+        self::assertTrue(
             $this->centralColumns->syncUniqueColumns(
                 ['PMA_table'],
             ),
@@ -233,13 +233,13 @@ class CentralColumnsTest extends AbstractTestCase
      */
     public function testMakeConsistentWithList(): void
     {
-        $this->dbi->expects($this->any())
+        $this->dbi->expects(self::any())
             ->method('fetchResult')
             ->willReturn($this->columnData);
-        $this->dbi->expects($this->any())
+        $this->dbi->expects(self::any())
             ->method('fetchValue')
             ->willReturn('PMA_table=CREATE table `PMA_table` (id integer)');
-        $this->assertTrue(
+        self::assertTrue(
             $this->centralColumns->makeConsistentWithList(
                 'phpmyadmin',
                 ['PMA_table'],
@@ -255,7 +255,7 @@ class CentralColumnsTest extends AbstractTestCase
         $db = 'PMA_db';
         $table = 'PMA_table';
 
-        $this->dbi->expects($this->once())
+        $this->dbi->expects(self::once())
             ->method('fetchResult')
             ->with(
                 'SELECT col_name FROM `pma_central_columns` '
@@ -265,7 +265,7 @@ class CentralColumnsTest extends AbstractTestCase
                 ConnectionType::ControlUser,
             )
             ->willReturn(['id', 'col1']);
-        $this->assertEquals(
+        self::assertEquals(
             ['id', 'col1'],
             $this->centralColumns->getFromTable(
                 $db,
@@ -282,7 +282,7 @@ class CentralColumnsTest extends AbstractTestCase
         $db = 'PMA_db';
         $table = 'PMA_table';
 
-        $this->dbi->expects($this->once())
+        $this->dbi->expects(self::once())
             ->method('fetchResult')
             ->with(
                 'SELECT * FROM `pma_central_columns` '
@@ -292,7 +292,7 @@ class CentralColumnsTest extends AbstractTestCase
                 ConnectionType::ControlUser,
             )
             ->willReturn(array_slice($this->columnData, 0, 2));
-        $this->assertEquals(
+        self::assertEquals(
             array_slice($this->modifiedColumnData, 0, 2),
             $this->centralColumns->getFromTable(
                 $db,
@@ -307,7 +307,7 @@ class CentralColumnsTest extends AbstractTestCase
      */
     public function testUpdateOneColumn(): void
     {
-        $this->assertTrue(
+        self::assertTrue(
             $this->centralColumns->updateOneColumn(
                 'phpmyadmin',
                 '',
@@ -321,7 +321,7 @@ class CentralColumnsTest extends AbstractTestCase
                 '',
             ),
         );
-        $this->assertTrue(
+        self::assertTrue(
             $this->centralColumns->updateOneColumn(
                 'phpmyadmin',
                 'col1',
@@ -352,7 +352,7 @@ class CentralColumnsTest extends AbstractTestCase
         $params['field_attribute'] = ['', ''];
         $params['field_type'] = ['', ''];
         $params['field_collation'] = ['', ''];
-        $this->assertTrue(
+        self::assertTrue(
             $this->centralColumns->updateMultipleColumn($params),
         );
     }
@@ -362,7 +362,7 @@ class CentralColumnsTest extends AbstractTestCase
      */
     public function testGetHtmlForEditingPage(): void
     {
-        $this->dbi->expects($this->any())
+        $this->dbi->expects(self::any())
             ->method('fetchResult')
             ->with(
                 'SELECT * FROM `pma_central_columns` '
@@ -382,7 +382,7 @@ class CentralColumnsTest extends AbstractTestCase
             'findExistingColNames',
             ['phpmyadmin', ['col1', 'col2'], true],
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             $this->callFunction(
                 $this->centralColumns,
                 CentralColumns::class,
@@ -398,7 +398,7 @@ class CentralColumnsTest extends AbstractTestCase
      */
     public function testGetListRaw(): void
     {
-        $this->dbi->expects($this->once())
+        $this->dbi->expects(self::once())
             ->method('fetchResult')
             ->with(
                 'SELECT * FROM `pma_central_columns` WHERE db_name = \'phpmyadmin\';',
@@ -407,7 +407,7 @@ class CentralColumnsTest extends AbstractTestCase
                 ConnectionType::ControlUser,
             )
             ->willReturn($this->columnData);
-        $this->assertEquals(
+        self::assertEquals(
             $this->modifiedColumnData,
             $this->centralColumns->getListRaw(
                 'phpmyadmin',
@@ -421,7 +421,7 @@ class CentralColumnsTest extends AbstractTestCase
      */
     public function testGetListRawWithTable(): void
     {
-        $this->dbi->expects($this->once())
+        $this->dbi->expects(self::once())
             ->method('fetchResult')
             ->with(
                 'SELECT * FROM `pma_central_columns` '
@@ -432,7 +432,7 @@ class CentralColumnsTest extends AbstractTestCase
                 ConnectionType::ControlUser,
             )
             ->willReturn($this->columnData);
-        $this->assertEquals(
+        self::assertEquals(
             $this->modifiedColumnData,
             $this->centralColumns->getListRaw(
                 'phpmyadmin',
@@ -446,7 +446,7 @@ class CentralColumnsTest extends AbstractTestCase
      */
     public function testFindExistingColNames(): void
     {
-        $this->dbi->expects($this->once())
+        $this->dbi->expects(self::once())
             ->method('fetchResult')
             ->with(
                 'SELECT * FROM `pma_central_columns` WHERE db_name = \'phpmyadmin\' AND col_name IN (\'col1\');',
@@ -455,7 +455,7 @@ class CentralColumnsTest extends AbstractTestCase
                 ConnectionType::ControlUser,
             )
             ->willReturn(array_slice($this->columnData, 1, 1));
-        $this->assertEquals(
+        self::assertEquals(
             array_slice($this->modifiedColumnData, 1, 1),
             $this->callFunction(
                 $this->centralColumns,
@@ -469,7 +469,7 @@ class CentralColumnsTest extends AbstractTestCase
     public function testGetColumnsNotInCentralList(): void
     {
         $columns = $this->centralColumns->getColumnsNotInCentralList('PMA_db', 'PMA_table');
-        $this->assertIsArray($columns);
-        $this->assertEquals(['id', 'col1', 'col2'], $columns);
+        self::assertIsArray($columns);
+        self::assertEquals(['id', 'col1', 'col2'], $columns);
     }
 }
diff --git a/tests/classes/Database/Designer/CommonTest.php b/tests/classes/Database/Designer/CommonTest.php
index acb1abc921..c6ab5b59ed 100644
--- a/tests/classes/Database/Designer/CommonTest.php
+++ b/tests/classes/Database/Designer/CommonTest.php
@@ -58,7 +58,7 @@ class CommonTest extends AbstractTestCase
             ->disableOriginalConstructor()
             ->getMock();
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('fetchResult')
             ->with(
                 "
@@ -93,7 +93,7 @@ class CommonTest extends AbstractTestCase
             ->disableOriginalConstructor()
             ->getMock();
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('fetchValue')
             ->with(
                 'SELECT `page_descr` FROM `pmadb`.`pdf_pages`'
@@ -108,7 +108,7 @@ class CommonTest extends AbstractTestCase
 
         $result = $this->designerCommon->getPageName($pg);
 
-        $this->assertEquals($pageName, $result);
+        self::assertEquals($pageName, $result);
     }
 
     /**
@@ -118,13 +118,13 @@ class CommonTest extends AbstractTestCase
     {
         $pg = 1;
 
-        $resultStub = $this->createMock(DummyResult::class);
+        $resultStub = self::createMock(DummyResult::class);
 
         $dbi = $this->getMockBuilder(DatabaseInterface::class)
             ->disableOriginalConstructor()
             ->getMock();
 
-        $dbi->expects($this->exactly(2))
+        $dbi->expects(self::exactly(2))
             ->method('queryAsControlUser')
             ->willReturn($resultStub, $resultStub);
 
@@ -132,7 +132,7 @@ class CommonTest extends AbstractTestCase
         $this->designerCommon = new Common(DatabaseInterface::getInstance(), new Relation($dbi));
 
         $result = $this->designerCommon->deletePage($pg);
-        $this->assertTrue($result);
+        self::assertTrue($result);
     }
 
     /**
@@ -148,7 +148,7 @@ class CommonTest extends AbstractTestCase
             ->disableOriginalConstructor()
             ->getMock();
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('fetchValue')
             ->with(
                 'SELECT `page_nr` FROM `pmadb`.`pdf_pages`'
@@ -158,14 +158,14 @@ class CommonTest extends AbstractTestCase
                 ConnectionType::ControlUser,
             )
             ->willReturn($defaultPg);
-        $dbi->expects($this->any())->method('quoteString')
+        $dbi->expects(self::any())->method('quoteString')
             ->willReturnCallback(static fn (string $string): string => "'" . $string . "'");
 
         DatabaseInterface::$instance = $dbi;
         $this->designerCommon = new Common(DatabaseInterface::getInstance(), new Relation($dbi));
 
         $result = $this->designerCommon->getDefaultPage($db);
-        $this->assertEquals($defaultPg, $result);
+        self::assertEquals($defaultPg, $result);
     }
 
     /**
@@ -179,7 +179,7 @@ class CommonTest extends AbstractTestCase
             ->disableOriginalConstructor()
             ->getMock();
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('fetchValue')
             ->with(
                 'SELECT `page_nr` FROM `pmadb`.`pdf_pages`'
@@ -189,14 +189,14 @@ class CommonTest extends AbstractTestCase
                 ConnectionType::ControlUser,
             )
             ->willReturn(false);
-        $dbi->expects($this->any())->method('quoteString')
+        $dbi->expects(self::any())->method('quoteString')
             ->willReturnCallback(static fn (string $string): string => "'" . $string . "'");
 
         DatabaseInterface::$instance = $dbi;
         $this->designerCommon = new Common(DatabaseInterface::getInstance(), new Relation($dbi));
 
         $result = $this->designerCommon->getDefaultPage($db);
-        $this->assertEquals(-1, $result);
+        self::assertEquals(-1, $result);
     }
 
     /**
@@ -211,7 +211,7 @@ class CommonTest extends AbstractTestCase
             ->disableOriginalConstructor()
             ->getMock();
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('fetchValue')
             ->with(
                 'SELECT `page_nr` FROM `pmadb`.`pdf_pages`'
@@ -221,14 +221,14 @@ class CommonTest extends AbstractTestCase
                 ConnectionType::ControlUser,
             )
             ->willReturn($defaultPg);
-        $dbi->expects($this->any())->method('quoteString')
+        $dbi->expects(self::any())->method('quoteString')
             ->willReturnCallback(static fn (string $string): string => "'" . $string . "'");
 
         DatabaseInterface::$instance = $dbi;
         $this->designerCommon = new Common(DatabaseInterface::getInstance(), new Relation($dbi));
 
         $result = $this->designerCommon->getLoadingPage($db);
-        $this->assertEquals($defaultPg, $result);
+        self::assertEquals($defaultPg, $result);
     }
 
     /**
@@ -243,7 +243,7 @@ class CommonTest extends AbstractTestCase
             ->disableOriginalConstructor()
             ->getMock();
 
-        $dbi->expects($this->exactly(2))
+        $dbi->expects(self::exactly(2))
             ->method('fetchValue')
             ->willReturn(false, $firstPg);
 
@@ -251,7 +251,7 @@ class CommonTest extends AbstractTestCase
         $this->designerCommon = new Common(DatabaseInterface::getInstance(), new Relation($dbi));
 
         $result = $this->designerCommon->getLoadingPage($db);
-        $this->assertEquals($firstPg, $result);
+        self::assertEquals($firstPg, $result);
     }
 
     private function loadTestDataForRelationDeleteAddTests(string $createTableString): void
@@ -355,7 +355,7 @@ class CommonTest extends AbstractTestCase
 
         $result = $this->designerCommon->removeRelation('db\'1.table\'1', 'field\'1', 'db\'2.table\'2', 'field\'2');
 
-        $this->assertSame([false, 'Error: Relational features are disabled!'], $result);
+        self::assertSame([false, 'Error: Relational features are disabled!'], $result);
     }
 
     public function testRemoveRelationWorkingRelationDb(): void
@@ -398,7 +398,7 @@ class CommonTest extends AbstractTestCase
 
         $result = $this->designerCommon->removeRelation('db\'1.table\'1', 'field\'1', 'db\'2.table\'2', 'field\'2');
 
-        $this->assertSame([true, 'Internal relationship has been removed.'], $result);
+        self::assertSame([true, 'Internal relationship has been removed.'], $result);
     }
 
     public function testRemoveRelationWorkingRelationDbFoundFk(): void
@@ -461,7 +461,7 @@ class CommonTest extends AbstractTestCase
 
         $result = $this->designerCommon->removeRelation('db\'1.table\'1', 'field\'1', 'db\'2.table\'2', 'field\'2');
 
-        $this->assertSame([true, 'FOREIGN KEY relationship has been removed.'], $result);
+        self::assertSame([true, 'FOREIGN KEY relationship has been removed.'], $result);
     }
 
     public function testRemoveRelationWorkingRelationDbDeleteFails(): void
@@ -504,6 +504,6 @@ class CommonTest extends AbstractTestCase
 
         $result = $this->designerCommon->removeRelation('db\'1.table\'1', 'field\'1', 'db\'2.table\'2', 'field\'2');
 
-        $this->assertSame([false, 'Error: Internal relationship could not be removed!<br>'], $result);
+        self::assertSame([false, 'Error: Internal relationship could not be removed!<br>'], $result);
     }
 }
diff --git a/tests/classes/Database/DesignerTest.php b/tests/classes/Database/DesignerTest.php
index 61cc3c26af..d909392c86 100644
--- a/tests/classes/Database/DesignerTest.php
+++ b/tests/classes/Database/DesignerTest.php
@@ -60,7 +60,7 @@ class DesignerTest extends AbstractTestCase
             ->disableOriginalConstructor()
             ->getMock();
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('tryQueryAsControlUser')
             ->with(
                 'SELECT `page_nr`, `page_descr` FROM `pmadb`.`pdf_pages`'
@@ -68,14 +68,14 @@ class DesignerTest extends AbstractTestCase
             )
             ->willReturn($resultStub);
 
-        $resultStub->expects($this->exactly(1))
+        $resultStub->expects(self::exactly(1))
             ->method('fetchAllKeyPair')
             ->willReturn([
                 '1' => 'page1',
                 '2' => 'page2',
             ]);
 
-        $dbi->expects($this->any())->method('quoteString')
+        $dbi->expects(self::any())->method('quoteString')
             ->willReturnCallback(static fn (string $string): string => "'" . $string . "'");
 
         DatabaseInterface::$instance = $dbi;
@@ -95,7 +95,7 @@ class DesignerTest extends AbstractTestCase
         $method = new ReflectionMethod(Designer::class, 'getPageIdsAndNames');
         $result = $method->invokeArgs($this->designer, [$db]);
 
-        $this->assertEquals(
+        self::assertEquals(
             ['1' => 'page1', '2' => 'page2'],
             $result,
         );
@@ -114,13 +114,13 @@ class DesignerTest extends AbstractTestCase
         $this->designer = new Designer($dbi, new Relation($dbi), new Template());
 
         $result = $this->designer->getHtmlForEditOrDeletePages($db, $operation);
-        $this->assertStringContainsString('<input type="hidden" name="operation" value="' . $operation . '">', $result);
-        $this->assertStringContainsString('<select name="selected_page" id="selected_page">', $result);
-        $this->assertStringContainsString('<option value="0">', $result);
-        $this->assertStringContainsString('<option value="1">', $result);
-        $this->assertStringContainsString('page1', $result);
-        $this->assertStringContainsString('<option value="2">', $result);
-        $this->assertStringContainsString('page2', $result);
+        self::assertStringContainsString('<input type="hidden" name="operation" value="' . $operation . '">', $result);
+        self::assertStringContainsString('<select name="selected_page" id="selected_page">', $result);
+        self::assertStringContainsString('<option value="0">', $result);
+        self::assertStringContainsString('<option value="1">', $result);
+        self::assertStringContainsString('page1', $result);
+        self::assertStringContainsString('<option value="2">', $result);
+        self::assertStringContainsString('page2', $result);
     }
 
     /**
@@ -135,23 +135,23 @@ class DesignerTest extends AbstractTestCase
         $this->designer = new Designer($dbi, new Relation($dbi), new Template());
 
         $result = $this->designer->getHtmlForPageSaveAs($db);
-        $this->assertStringContainsString('<input type="hidden" name="operation" value="savePage">', $result);
-        $this->assertStringContainsString('<select name="selected_page" id="selected_page">', $result);
-        $this->assertStringContainsString('<option value="0">', $result);
-        $this->assertStringContainsString('<option value="1">', $result);
-        $this->assertStringContainsString('page1', $result);
-        $this->assertStringContainsString('<option value="2">', $result);
-        $this->assertStringContainsString('page2', $result);
+        self::assertStringContainsString('<input type="hidden" name="operation" value="savePage">', $result);
+        self::assertStringContainsString('<select name="selected_page" id="selected_page">', $result);
+        self::assertStringContainsString('<option value="0">', $result);
+        self::assertStringContainsString('<option value="1">', $result);
+        self::assertStringContainsString('page1', $result);
+        self::assertStringContainsString('<option value="2">', $result);
+        self::assertStringContainsString('page2', $result);
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             '<input type="radio" name="save_page" id="savePageSameRadio" value="same" checked>',
             $result,
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             '<input type="radio" name="save_page" id="savePageNewRadio" value="new">',
             $result,
         );
-        $this->assertStringContainsString('<input type="text" name="selected_value" id="selected_value">', $result);
+        self::assertStringContainsString('<input type="text" name="selected_value" id="selected_value">', $result);
     }
 
     /**
@@ -167,25 +167,25 @@ class DesignerTest extends AbstractTestCase
 
         $result = $this->designer->getHtmlForSchemaExport($db, $page);
         // export type
-        $this->assertStringContainsString('<select class="form-select" id="plugins" name="export_type">', $result);
+        self::assertStringContainsString('<select class="form-select" id="plugins" name="export_type">', $result);
 
         // hidden field
-        $this->assertStringContainsString('<input type="hidden" name="page_number" value="' . $page . '">', $result);
+        self::assertStringContainsString('<input type="hidden" name="page_number" value="' . $page . '">', $result);
 
         // orientation
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             '<select class="form-select" name="pdf_orientation" id="select_pdf_orientation">',
             $result,
         );
-        $this->assertStringContainsString('<option value="L" selected>Landscape</option>', $result);
-        $this->assertStringContainsString('<option value="P">Portrait</option>', $result);
+        self::assertStringContainsString('<option value="L" selected>Landscape</option>', $result);
+        self::assertStringContainsString('<option value="P">Portrait</option>', $result);
 
         // paper size
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             '<select class="form-select" name="pdf_paper" id="select_pdf_paper">',
             $result,
         );
-        $this->assertStringContainsString('<option value="A3">A3</option>', $result);
-        $this->assertStringContainsString('<option value="A4" selected>A4</option>', $result);
+        self::assertStringContainsString('<option value="A3">A3</option>', $result);
+        self::assertStringContainsString('<option value="A4" selected>A4</option>', $result);
     }
 }
diff --git a/tests/classes/Database/EventsTest.php b/tests/classes/Database/EventsTest.php
index 7d5b75940a..b9fe136d62 100644
--- a/tests/classes/Database/EventsTest.php
+++ b/tests/classes/Database/EventsTest.php
@@ -54,7 +54,7 @@ class EventsTest extends AbstractTestCase
             $_POST[$key] = $value;
         }
 
-        $this->assertEquals($out, $this->events->getDataFromRequest());
+        self::assertEquals($out, $this->events->getDataFromRequest());
     }
 
     /**
@@ -154,8 +154,8 @@ class EventsTest extends AbstractTestCase
             ->getMock();
         DatabaseInterface::$instance = $dbi;
 
-        $this->assertEquals($query, $this->events->getQueryFromRequest());
-        $this->assertCount($numErr, $GLOBALS['errors']);
+        self::assertEquals($query, $this->events->getQueryFromRequest());
+        self::assertCount($numErr, $GLOBALS['errors']);
     }
 
     /**
diff --git a/tests/classes/Database/RoutinesTest.php b/tests/classes/Database/RoutinesTest.php
index 08ca7d5dda..dde8d8ced2 100644
--- a/tests/classes/Database/RoutinesTest.php
+++ b/tests/classes/Database/RoutinesTest.php
@@ -64,7 +64,7 @@ class RoutinesTest extends AbstractTestCase
             $_REQUEST[$key] = $value;
         }
 
-        $this->assertEquals($out, $this->routines->getDataFromRequest());
+        self::assertEquals($out, $this->routines->getDataFromRequest());
     }
 
     /**
@@ -247,7 +247,7 @@ class RoutinesTest extends AbstractTestCase
             ->disableOriginalConstructor()
             ->getMock();
         $dbi->types = new Types($dbi);
-        $dbi->expects($this->any())
+        $dbi->expects(self::any())
             ->method('quoteString')
             ->willReturnMap([
                 ['foo', ConnectionType::User, "'foo'"],
@@ -259,8 +259,8 @@ class RoutinesTest extends AbstractTestCase
 
         unset($_POST);
         $_POST = $request;
-        $this->assertEquals($query, $routines->getQueryFromRequest());
-        $this->assertCount($numErr, $GLOBALS['errors']);
+        self::assertEquals($query, $routines->getQueryFromRequest());
+        self::assertCount($numErr, $GLOBALS['errors']);
 
         // reset
         DatabaseInterface::$instance = $oldDbi;
@@ -494,7 +494,7 @@ class RoutinesTest extends AbstractTestCase
         );
 
         $names = Routines::getFunctionNames($this->createDatabaseInterface($dbiDummy), 'test_db');
-        $this->assertSame(['test_func1', 'test_func2'], $names);
+        self::assertSame(['test_func1', 'test_func2'], $names);
 
         $dbiDummy->assertAllQueriesConsumed();
     }
@@ -509,7 +509,7 @@ class RoutinesTest extends AbstractTestCase
         );
 
         $names = Routines::getFunctionNames($this->createDatabaseInterface($dbiDummy), 'test_db');
-        $this->assertSame([], $names);
+        self::assertSame([], $names);
 
         $dbiDummy->assertAllQueriesConsumed();
     }
@@ -530,7 +530,7 @@ class RoutinesTest extends AbstractTestCase
         );
 
         $names = Routines::getProcedureNames($this->createDatabaseInterface($dbiDummy), 'test_db');
-        $this->assertSame(['test_proc1', 'test_proc2'], $names);
+        self::assertSame(['test_proc1', 'test_proc2'], $names);
 
         $dbiDummy->assertAllQueriesConsumed();
     }
@@ -549,7 +549,7 @@ class RoutinesTest extends AbstractTestCase
         );
 
         $names = Routines::getProcedureNames($this->createDatabaseInterface($dbiDummy), 'test_db');
-        $this->assertSame([], $names);
+        self::assertSame([], $names);
 
         $dbiDummy->assertAllQueriesConsumed();
     }
diff --git a/tests/classes/Database/SearchTest.php b/tests/classes/Database/SearchTest.php
index 7741fbb53f..d4b85077bb 100644
--- a/tests/classes/Database/SearchTest.php
+++ b/tests/classes/Database/SearchTest.php
@@ -34,7 +34,7 @@ class SearchTest extends AbstractTestCase
             ->disableOriginalConstructor()
             ->getMock();
 
-        $dbi->expects($this->any())
+        $dbi->expects(self::any())
             ->method('getColumns')
             ->with('pma', 'table1')
             ->willReturn([
@@ -42,7 +42,7 @@ class SearchTest extends AbstractTestCase
                 new Column('column2', '', false, '', null, ''),
             ]);
 
-        $dbi->expects($this->any())
+        $dbi->expects(self::any())
             ->method('quoteString')
             ->willReturnCallback(static fn (string $string): string => "'" . $string . "'");
 
@@ -74,7 +74,7 @@ class SearchTest extends AbstractTestCase
         $_POST['criteriaSearchString'] = 'search string';
 
         $this->object = new Search(DatabaseInterface::getInstance(), 'pma_test', new Template());
-        $this->assertEquals(
+        self::assertEquals(
             $expected,
             $this->callFunction(
                 $this->object,
@@ -130,7 +130,7 @@ class SearchTest extends AbstractTestCase
      */
     public function testGetSearchSqls(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             [
                 'select_columns' => 'SELECT * FROM `pma`.`table1` WHERE FALSE',
                 'select_count' => 'SELECT COUNT(*) AS `count` FROM `pma`.`table1` WHERE FALSE',
@@ -150,7 +150,7 @@ class SearchTest extends AbstractTestCase
      */
     public function testGetSearchResults(): void
     {
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             'Search results for "<em></em>" :',
             $this->object->getSearchResults(),
         );
@@ -164,18 +164,18 @@ class SearchTest extends AbstractTestCase
         $main = $this->object->getMainHtml();
 
         // test selection form
-        $this->assertStringContainsString('<form', $main);
-        $this->assertStringContainsString(
+        self::assertStringContainsString('<form', $main);
+        self::assertStringContainsString(
             '<button id="togglesearchformlink" class="btn btn-primary my-1"></button>',
             $main,
         );
-        $this->assertStringContainsString('criteriaSearchType', $main);
+        self::assertStringContainsString('criteriaSearchType', $main);
 
         // test result divs
-        $this->assertStringContainsString('<div id="table-info"', $main);
-        $this->assertStringContainsString('<a id="table-link"', $main);
-        $this->assertStringContainsString('<div id="browse-results"', $main);
-        $this->assertStringContainsString('<div id="sqlqueryform"', $main);
-        $this->assertStringContainsString('<button class="btn btn-secondary" id="togglequerybox"', $main);
+        self::assertStringContainsString('<div id="table-info"', $main);
+        self::assertStringContainsString('<a id="table-link"', $main);
+        self::assertStringContainsString('<div id="browse-results"', $main);
+        self::assertStringContainsString('<div id="sqlqueryform"', $main);
+        self::assertStringContainsString('<button class="btn btn-secondary" id="togglequerybox"', $main);
     }
 }
diff --git a/tests/classes/DatabaseInterfaceTest.php b/tests/classes/DatabaseInterfaceTest.php
index 1be1d537bf..62bbcbc068 100644
--- a/tests/classes/DatabaseInterfaceTest.php
+++ b/tests/classes/DatabaseInterfaceTest.php
@@ -50,7 +50,7 @@ class DatabaseInterfaceTest extends AbstractTestCase
         DatabaseInterface::$instance = null;
         $instanceOne = DatabaseInterface::getInstance();
         $instanceTwo = DatabaseInterface::getInstance();
-        $this->assertSame($instanceOne, $instanceTwo);
+        self::assertSame($instanceOne, $instanceTwo);
     }
 
     /**
@@ -75,9 +75,9 @@ class DatabaseInterfaceTest extends AbstractTestCase
             $dummyDbi->addResult('SELECT CURRENT_USER();', $value);
         }
 
-        $this->assertEquals($expected, $dbi->getCurrentUserAndHost());
+        self::assertEquals($expected, $dbi->getCurrentUserAndHost());
 
-        $this->assertEquals($string, $dbi->getCurrentUser());
+        self::assertEquals($string, $dbi->getCurrentUser());
 
         $dummyDbi->assertAllQueriesConsumed();
     }
@@ -103,7 +103,7 @@ class DatabaseInterfaceTest extends AbstractTestCase
     {
         $dbi = $this->createDatabaseInterface();
         $sd = $dbi->getSystemDatabase();
-        $this->assertInstanceOf(SystemDatabase::class, $sd);
+        self::assertInstanceOf(SystemDatabase::class, $sd);
     }
 
     /**
@@ -120,11 +120,11 @@ class DatabaseInterfaceTest extends AbstractTestCase
             ->onlyMethods(['fetchSingleRow', 'query', 'setVersion'])
             ->getMock();
 
-        $mock->expects($this->once())
+        $mock->expects(self::once())
             ->method('fetchSingleRow')
             ->willReturn(null);
 
-        $mock->expects($this->never())->method('setVersion');
+        $mock->expects(self::never())->method('setVersion');
 
         $mock->postConnect(new Server(['SessionTimeZone' => '']));
     }
@@ -147,11 +147,11 @@ class DatabaseInterfaceTest extends AbstractTestCase
             ->onlyMethods(['fetchSingleRow', 'query', 'setVersion'])
             ->getMock();
 
-        $mock->expects($this->once())
+        $mock->expects(self::once())
             ->method('fetchSingleRow')
             ->willReturn($versionQueryResult);
 
-        $mock->expects($this->once())->method('setVersion')->with($versionQueryResult);
+        $mock->expects(self::once())->method('setVersion')->with($versionQueryResult);
 
         $mock->postConnect(new Server(['SessionTimeZone' => '']));
     }
@@ -181,15 +181,15 @@ class DatabaseInterfaceTest extends AbstractTestCase
             ->onlyMethods(['fetchSingleRow', 'query'])
             ->getMock();
 
-        $mock->expects($this->once())
+        $mock->expects(self::once())
             ->method('fetchSingleRow')
             ->willReturn($version);
 
         $mock->postConnect(new Server(['SessionTimeZone' => '']));
 
-        $this->assertEquals($mock->getVersion(), $versionInt);
-        $this->assertEquals($mock->isMariaDB(), $isMariaDb);
-        $this->assertEquals($mock->isPercona(), $isPercona);
+        self::assertEquals($mock->getVersion(), $versionInt);
+        self::assertEquals($mock->isMariaDB(), $isMariaDb);
+        self::assertEquals($mock->isPercona(), $isPercona);
     }
 
     /**
@@ -204,7 +204,7 @@ class DatabaseInterfaceTest extends AbstractTestCase
         $config->selectedServer['DisableIS'] = false;
         $config->settings['DBG']['sql'] = false;
 
-        $this->assertEquals(
+        self::assertEquals(
             'utf8_general_ci',
             $dbi->getDbCollation('pma_test'),
         );
@@ -217,7 +217,7 @@ class DatabaseInterfaceTest extends AbstractTestCase
         $dbiDummy->removeDefaultResults();
         $dbiDummy->addResult('SELECT @@collation_database', [['utf8mb3_general_ci']], ['@@collation_database']);
 
-        $this->assertEquals('utf8mb3_general_ci', $dbi->getDbCollation('information_schema'));
+        self::assertEquals('utf8mb3_general_ci', $dbi->getDbCollation('information_schema'));
     }
 
     /**
@@ -227,7 +227,7 @@ class DatabaseInterfaceTest extends AbstractTestCase
     {
         $dbi = $this->createDatabaseInterface();
         Config::getInstance()->settings['DBG']['sql'] = true;
-        $this->assertEquals('utf8_general_ci', $dbi->getServerCollation());
+        self::assertEquals('utf8_general_ci', $dbi->getServerCollation());
     }
 
     /**
@@ -240,7 +240,7 @@ class DatabaseInterfaceTest extends AbstractTestCase
     #[DataProvider('errorData')]
     public function testFormatError(int $errorNumber, string $errorMessage, string $match): void
     {
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             $match,
             Utilities::formatError($errorNumber, $errorMessage),
         );
@@ -276,7 +276,7 @@ class DatabaseInterfaceTest extends AbstractTestCase
 
         $dummyDbi->addResult('SELECT @@basedir', $value);
 
-        $this->assertEquals(
+        self::assertEquals(
             $expected,
             $dbi->isAmazonRds(),
         );
@@ -311,10 +311,10 @@ class DatabaseInterfaceTest extends AbstractTestCase
     public function testVersion(string $version, int $expected, int $major, bool $upgrade): void
     {
         $verInt = Utilities::versionToInt($version);
-        $this->assertEquals($expected, $verInt);
-        $this->assertEquals($major, (int) ($verInt / 10000));
+        self::assertEquals($expected, $verInt);
+        self::assertEquals($major, (int) ($verInt / 10000));
         $mysqlMinVersion = 50500;
-        $this->assertEquals($upgrade, $verInt < $mysqlMinVersion);
+        self::assertEquals($upgrade, $verInt < $mysqlMinVersion);
     }
 
     /** @return mixed[][] */
@@ -404,7 +404,7 @@ class DatabaseInterfaceTest extends AbstractTestCase
         ];
 
         $actual = $dbi->getTablesFull('test_db');
-        $this->assertEquals($expected, $actual);
+        self::assertEquals($expected, $actual);
     }
 
     public function testGetTablesFullWithInformationSchema(): void
@@ -462,7 +462,7 @@ class DatabaseInterfaceTest extends AbstractTestCase
         ];
 
         $actual = $dbi->getTablesFull('test_db');
-        $this->assertEquals($expected, $actual);
+        self::assertEquals($expected, $actual);
     }
 
     public function testGetTablesFullBug18913(): void
@@ -483,7 +483,7 @@ class DatabaseInterfaceTest extends AbstractTestCase
         ], ['Name', 'Engine']);
 
         $actual = $dbi->getTablesFull('test_db_bug_18913');
-        $this->assertEquals($expected, array_keys($actual));
+        self::assertEquals($expected, array_keys($actual));
     }
 
     /**
@@ -499,15 +499,15 @@ class DatabaseInterfaceTest extends AbstractTestCase
         $dummyDbi->addResult($sql, true);
         $dummyDbi->addResult('Invalid query', false);
 
-        $this->assertInstanceOf(
+        self::assertInstanceOf(
             ResultInterface::class,
             $dbi->queryAsControlUser($sql),
         );
-        $this->assertInstanceOf(
+        self::assertInstanceOf(
             ResultInterface::class,
             $dbi->tryQueryAsControlUser($sql),
         );
-        $this->assertFalse($dbi->tryQueryAsControlUser('Invalid query'));
+        self::assertFalse($dbi->tryQueryAsControlUser('Invalid query'));
     }
 
     public function testGetDatabasesFullDisabledISAndSortIntColumn(): void
@@ -669,7 +669,7 @@ class DatabaseInterfaceTest extends AbstractTestCase
 
         $databaseList = $dbi->getDatabasesFull(null, true, ConnectionType::User, 'SCHEMA_DATA_LENGTH', 'ASC', 0, 100);
 
-        $this->assertSame([
+        self::assertSame([
             [
                 'SCHEMA_NAME' => 'db2',
                 'DEFAULT_COLLATION_NAME' => 'utf8_general_ci',
@@ -700,14 +700,14 @@ class DatabaseInterfaceTest extends AbstractTestCase
     public function testPrepare(): void
     {
         $query = 'SELECT * FROM `mysql`.`user` WHERE `User` = ? AND `Host` = ?;';
-        $stmtStub = $this->createStub(Statement::class);
+        $stmtStub = self::createStub(Statement::class);
         $dummyDbi = $this->createMock(DbiExtension::class);
-        $dummyDbi->expects($this->once())->method('prepare')
-            ->with($this->isType('object'), $this->equalTo($query))
+        $dummyDbi->expects(self::once())->method('prepare')
+            ->with(self::isType('object'), self::equalTo($query))
             ->willReturn($stmtStub);
         $dbi = $this->createDatabaseInterface($dummyDbi);
         $stmt = $dbi->prepare($query, ConnectionType::ControlUser);
-        $this->assertSame($stmtStub, $stmt);
+        self::assertSame($stmtStub, $stmt);
     }
 
     /**
@@ -731,10 +731,10 @@ class DatabaseInterfaceTest extends AbstractTestCase
 
         $dbi->setVersion($version);
 
-        $this->assertEquals($versionInt, $dbi->getVersion());
-        $this->assertEquals($isMariaDb, $dbi->isMariaDB());
-        $this->assertEquals($isPercona, $dbi->isPercona());
-        $this->assertEquals($version['@@version'], $dbi->getVersionString());
+        self::assertEquals($versionInt, $dbi->getVersion());
+        self::assertEquals($isMariaDb, $dbi->isMariaDB());
+        self::assertEquals($isPercona, $dbi->isPercona());
+        self::assertEquals($version['@@version'], $dbi->getVersionString());
     }
 
     /**
@@ -776,7 +776,7 @@ class DatabaseInterfaceTest extends AbstractTestCase
         $expectedResult = $result !== false ? [[$result]] : [];
         $dbiDummy->addResult('SELECT @@lower_case_table_names', $expectedResult, ['@@lower_case_table_names']);
         $dbi = $this->createDatabaseInterface($dbiDummy);
-        $this->assertSame($expected, $dbi->getLowerCaseNames());
+        self::assertSame($expected, $dbi->getLowerCaseNames());
         $dbiDummy->assertAllQueriesConsumed();
     }
 
diff --git a/tests/classes/DbTableExistsTest.php b/tests/classes/DbTableExistsTest.php
index 09eceb4f6b..c30a1b8235 100644
--- a/tests/classes/DbTableExistsTest.php
+++ b/tests/classes/DbTableExistsTest.php
@@ -20,17 +20,17 @@ final class DbTableExistsTest extends AbstractTestCase
         $dbiDummy->addSelectDb('test_db');
         $dbi = $this->createDatabaseInterface($dbiDummy);
         $dbTableExists = new DbTableExists($dbi);
-        $this->assertTrue($dbTableExists->selectDatabase(DatabaseName::from('test_db')));
+        self::assertTrue($dbTableExists->selectDatabase(DatabaseName::from('test_db')));
         $dbiDummy->assertAllSelectsConsumed();
     }
 
     public function testHasDatabaseWithNoDatabase(): void
     {
         $db = DatabaseName::from('test_db');
-        $dbi = $this->createMock(DatabaseInterface::class);
-        $dbi->expects($this->once())->method('selectDb')->with($db)->willReturn(false);
+        $dbi = self::createMock(DatabaseInterface::class);
+        $dbi->expects(self::once())->method('selectDb')->with($db)->willReturn(false);
         $dbTableExists = new DbTableExists($dbi);
-        $this->assertFalse($dbTableExists->selectDatabase($db));
+        self::assertFalse($dbTableExists->selectDatabase($db));
     }
 
     public function testHasTable(): void
@@ -40,9 +40,9 @@ final class DbTableExistsTest extends AbstractTestCase
         $dbiDummy->addResult('SELECT 1 FROM `test_db`.`test_table` LIMIT 1;', [['1']], ['1']);
         $dbi = $this->createDatabaseInterface($dbiDummy);
         $dbTableExists = new DbTableExists($dbi);
-        $this->assertTrue($dbTableExists->hasTable(DatabaseName::from('test_db'), TableName::from('test_table')));
+        self::assertTrue($dbTableExists->hasTable(DatabaseName::from('test_db'), TableName::from('test_table')));
         // cached result
-        $this->assertTrue($dbTableExists->hasTable(DatabaseName::from('test_db'), TableName::from('test_table')));
+        self::assertTrue($dbTableExists->hasTable(DatabaseName::from('test_db'), TableName::from('test_table')));
         $dbiDummy->assertAllQueriesConsumed();
     }
 
@@ -53,9 +53,9 @@ final class DbTableExistsTest extends AbstractTestCase
         $dbiDummy->addResult('SELECT 1 FROM `test_db`.`test_table` LIMIT 1;', [['1']], ['1']);
         $dbi = $this->createDatabaseInterface($dbiDummy);
         $dbTableExists = new DbTableExists($dbi);
-        $this->assertTrue($dbTableExists->hasTable(DatabaseName::from('test_db'), TableName::from('test_table')));
+        self::assertTrue($dbTableExists->hasTable(DatabaseName::from('test_db'), TableName::from('test_table')));
         // cached result
-        $this->assertTrue($dbTableExists->hasTable(DatabaseName::from('test_db'), TableName::from('test_table')));
+        self::assertTrue($dbTableExists->hasTable(DatabaseName::from('test_db'), TableName::from('test_table')));
         $dbiDummy->assertAllQueriesConsumed();
     }
 
@@ -66,7 +66,7 @@ final class DbTableExistsTest extends AbstractTestCase
         $dbiDummy->addResult('SELECT 1 FROM `test_db`.`test_table` LIMIT 1;', false);
         $dbi = $this->createDatabaseInterface($dbiDummy);
         $dbTableExists = new DbTableExists($dbi);
-        $this->assertFalse($dbTableExists->hasTable(DatabaseName::from('test_db'), TableName::from('test_table')));
+        self::assertFalse($dbTableExists->hasTable(DatabaseName::from('test_db'), TableName::from('test_table')));
         $dbiDummy->assertAllQueriesConsumed();
     }
 }
diff --git a/tests/classes/Dbal/DbiDummyTest.php b/tests/classes/Dbal/DbiDummyTest.php
index 0cc488df90..63da35cfa1 100644
--- a/tests/classes/Dbal/DbiDummyTest.php
+++ b/tests/classes/Dbal/DbiDummyTest.php
@@ -37,9 +37,9 @@ class DbiDummyTest extends AbstractTestCase
 
     public function testGetClientInfo(): void
     {
-        $this->assertNotEmpty($this->dummyDbi->getClientInfo());
+        self::assertNotEmpty($this->dummyDbi->getClientInfo());
         // Call the DatabaseInterface
-        $this->assertSame($this->dbi->getClientInfo(), $this->dummyDbi->getClientInfo());
+        self::assertSame($this->dbi->getClientInfo(), $this->dummyDbi->getClientInfo());
     }
 
     /**
@@ -49,7 +49,7 @@ class DbiDummyTest extends AbstractTestCase
      */
     public function testQuery(): void
     {
-        $this->assertInstanceOf(DummyResult::class, $this->dbi->tryQuery('SELECT 1'));
+        self::assertInstanceOf(DummyResult::class, $this->dbi->tryQuery('SELECT 1'));
     }
 
     /**
@@ -60,8 +60,8 @@ class DbiDummyTest extends AbstractTestCase
     public function testFetch(): void
     {
         $result = $this->dbi->tryQuery('SELECT 1');
-        $this->assertNotFalse($result);
-        $this->assertSame(['1'], $result->fetchRow());
+        self::assertNotFalse($result);
+        self::assertSame(['1'], $result->fetchRow());
     }
 
     /**
@@ -73,7 +73,7 @@ class DbiDummyTest extends AbstractTestCase
     #[DataProvider('schemaData')]
     public function testSystemSchema(string $schema, bool $expected): void
     {
-        $this->assertEquals($expected, Utilities::isSystemSchema($schema));
+        self::assertEquals($expected, Utilities::isSystemSchema($schema));
     }
 
     /** @return array<array{string, bool}> */
@@ -92,7 +92,7 @@ class DbiDummyTest extends AbstractTestCase
     #[DataProvider('errorData')]
     public function testFormatError(int $number, string $message, string $expected): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             $expected,
             Utilities::formatError($number, $message),
         );
diff --git a/tests/classes/Dbal/DbiMysqliTest.php b/tests/classes/Dbal/DbiMysqliTest.php
index 5ece719054..edc2557b39 100644
--- a/tests/classes/Dbal/DbiMysqliTest.php
+++ b/tests/classes/Dbal/DbiMysqliTest.php
@@ -31,7 +31,7 @@ class DbiMysqliTest extends AbstractTestCase
 
     public function testGetClientInfo(): void
     {
-        $this->assertNotEmpty($this->object->getClientInfo());
+        self::assertNotEmpty($this->object->getClientInfo());
     }
 
     /**
@@ -40,13 +40,13 @@ class DbiMysqliTest extends AbstractTestCase
     public function testSelectDb(): void
     {
         $databaseName = 'test';
-        $mysqli = $this->createMock(mysqli::class);
-        $mysqli->expects($this->once())
+        $mysqli = self::createMock(mysqli::class);
+        $mysqli->expects(self::once())
             ->method('select_db')
-            ->with($this->equalTo($databaseName))
+            ->with(self::equalTo($databaseName))
             ->willReturn(true);
 
-        $this->assertTrue($this->object->selectDb($databaseName, new Connection($mysqli)));
+        self::assertTrue($this->object->selectDb($databaseName, new Connection($mysqli)));
     }
 
     /**
@@ -55,13 +55,13 @@ class DbiMysqliTest extends AbstractTestCase
     public function testRealMultiQuery(): void
     {
         $query = 'test';
-        $mysqli = $this->createMock(mysqli::class);
-        $mysqli->expects($this->once())
+        $mysqli = self::createMock(mysqli::class);
+        $mysqli->expects(self::once())
             ->method('multi_query')
-            ->with($this->equalTo($query))
+            ->with(self::equalTo($query))
             ->willReturn(true);
 
-        $this->assertTrue($this->object->realMultiQuery(new Connection($mysqli), $query));
+        self::assertTrue($this->object->realMultiQuery(new Connection($mysqli), $query));
     }
 
     /**
@@ -70,14 +70,14 @@ class DbiMysqliTest extends AbstractTestCase
     public function testrealQuery(): void
     {
         $query = 'test';
-        $mysqliResult = $this->createMock(mysqli_result::class);
-        $mysqli = $this->createMock(mysqli::class);
-        $mysqli->expects($this->once())
+        $mysqliResult = self::createMock(mysqli_result::class);
+        $mysqli = self::createMock(mysqli::class);
+        $mysqli->expects(self::once())
             ->method('query')
-            ->with($this->equalTo($query))
+            ->with(self::equalTo($query))
             ->willReturn($mysqliResult);
 
-        $this->assertInstanceOf(MysqliResult::class, $this->object->realQuery($query, new Connection($mysqli), 0));
+        self::assertInstanceOf(MysqliResult::class, $this->object->realQuery($query, new Connection($mysqli), 0));
     }
 
     /**
@@ -85,12 +85,12 @@ class DbiMysqliTest extends AbstractTestCase
      */
     public function testNextResult(): void
     {
-        $mysqli = $this->createMock(mysqli::class);
-        $mysqli->expects($this->once())
+        $mysqli = self::createMock(mysqli::class);
+        $mysqli->expects(self::once())
             ->method('next_result')
             ->willReturn(true);
 
-        $this->assertTrue($this->object->nextResult(new Connection($mysqli)));
+        self::assertTrue($this->object->nextResult(new Connection($mysqli)));
     }
 
     /**
@@ -98,13 +98,13 @@ class DbiMysqliTest extends AbstractTestCase
      */
     public function testStoreResult(): void
     {
-        $mysqli = $this->createMock(mysqli::class);
-        $mysqliResult = $this->createMock(mysqli_result::class);
-        $mysqli->expects($this->once())
+        $mysqli = self::createMock(mysqli::class);
+        $mysqliResult = self::createMock(mysqli_result::class);
+        $mysqli->expects(self::once())
             ->method('store_result')
             ->willReturn($mysqliResult);
 
-        $this->assertInstanceOf(MysqliResult::class, $this->object->storeResult(new Connection($mysqli)));
+        self::assertInstanceOf(MysqliResult::class, $this->object->storeResult(new Connection($mysqli)));
     }
 
     /**
@@ -113,17 +113,17 @@ class DbiMysqliTest extends AbstractTestCase
     public function testEscapeString(): void
     {
         $string = 'test';
-        $mysqli = $this->createMock(mysqli::class);
-        $mysqli->expects($this->once())
+        $mysqli = self::createMock(mysqli::class);
+        $mysqli->expects(self::once())
             ->method('real_escape_string')
             ->willReturn($string);
 
-        $this->assertEquals($string, $this->object->escapeString(new Connection($mysqli), $string));
+        self::assertEquals($string, $this->object->escapeString(new Connection($mysqli), $string));
     }
 
     public function testGetWarningCount(): void
     {
         $mysqli = (object) ['warning_count' => 30];
-        $this->assertSame(30, $this->object->getWarningCount(new Connection($mysqli)));
+        self::assertSame(30, $this->object->getWarningCount(new Connection($mysqli)));
     }
 }
diff --git a/tests/classes/Dbal/MysqliResultTest.php b/tests/classes/Dbal/MysqliResultTest.php
index 22777d05e8..54dbc84334 100644
--- a/tests/classes/Dbal/MysqliResultTest.php
+++ b/tests/classes/Dbal/MysqliResultTest.php
@@ -19,15 +19,15 @@ class MysqliResultTest extends AbstractTestCase
     public function testFetchAssoc(): void
     {
         $expected = [['foo' => 'bar'], null];
-        $mysqliResult = $this->createMock(mysqli_result::class);
-        $mysqliResult->expects($this->exactly(2))
+        $mysqliResult = self::createMock(mysqli_result::class);
+        $mysqliResult->expects(self::exactly(2))
             ->method('fetch_assoc')
             ->willReturn(...$expected);
 
         $result = new MysqliResult($mysqliResult);
 
-        $this->assertSame(['foo' => 'bar'], $result->fetchAssoc());
-        $this->assertSame([], $result->fetchAssoc());
+        self::assertSame(['foo' => 'bar'], $result->fetchAssoc());
+        self::assertSame([], $result->fetchAssoc());
     }
 
     /**
@@ -36,15 +36,15 @@ class MysqliResultTest extends AbstractTestCase
     public function testFetchRow(): void
     {
         $expected = [['bar'], null];
-        $mysqliResult = $this->createMock(mysqli_result::class);
-        $mysqliResult->expects($this->exactly(2))
+        $mysqliResult = self::createMock(mysqli_result::class);
+        $mysqliResult->expects(self::exactly(2))
             ->method('fetch_row')
             ->willReturn(...$expected);
 
         $result = new MysqliResult($mysqliResult);
 
-        $this->assertSame(['bar'], $result->fetchRow());
-        $this->assertSame([], $result->fetchRow());
+        self::assertSame(['bar'], $result->fetchRow());
+        self::assertSame([], $result->fetchRow());
     }
 
     /**
@@ -53,14 +53,14 @@ class MysqliResultTest extends AbstractTestCase
     public function testDataSeek(): void
     {
         $offset = 1;
-        $mysqliResult = $this->createMock(mysqli_result::class);
-        $mysqliResult->expects($this->once())
+        $mysqliResult = self::createMock(mysqli_result::class);
+        $mysqliResult->expects(self::once())
             ->method('data_seek')
-            ->with($this->equalTo($offset))
+            ->with(self::equalTo($offset))
             ->willReturn(true);
 
         $result = new MysqliResult($mysqliResult);
 
-        $this->assertTrue($result->seek($offset));
+        self::assertTrue($result->seek($offset));
     }
 }
diff --git a/tests/classes/Dbal/MysqliStatementTest.php b/tests/classes/Dbal/MysqliStatementTest.php
index b09f86629e..7cc19b689d 100644
--- a/tests/classes/Dbal/MysqliStatementTest.php
+++ b/tests/classes/Dbal/MysqliStatementTest.php
@@ -16,10 +16,10 @@ class MysqliStatementTest extends TestCase
 {
     public function testGetResult(): void
     {
-        $mysqliStmt = $this->createMock(mysqli_stmt::class);
-        $mysqliStmt->expects($this->once())->method('get_result')->willReturn(false);
+        $mysqliStmt = self::createMock(mysqli_stmt::class);
+        $mysqliStmt->expects(self::once())->method('get_result')->willReturn(false);
         $statement = new MysqliStatement($mysqliStmt);
         $result = $statement->getResult();
-        $this->assertInstanceOf(MysqliResult::class, $result);
+        self::assertInstanceOf(MysqliResult::class, $result);
     }
 }
diff --git a/tests/classes/Dbal/WarningTest.php b/tests/classes/Dbal/WarningTest.php
index 3917b720ad..51ee125b9f 100644
--- a/tests/classes/Dbal/WarningTest.php
+++ b/tests/classes/Dbal/WarningTest.php
@@ -17,10 +17,10 @@ class WarningTest extends TestCase
     public function testWarning(array $row, string $level, int $code, string $message, string $toString): void
     {
         $warning = Warning::fromArray($row);
-        $this->assertSame($level, $warning->level);
-        $this->assertSame($code, $warning->code);
-        $this->assertSame($message, $warning->message);
-        $this->assertSame($toString, (string) $warning);
+        self::assertSame($level, $warning->level);
+        self::assertSame($code, $warning->code);
+        self::assertSame($message, $warning->message);
+        self::assertSame($toString, (string) $warning);
     }
 
     /**
diff --git a/tests/classes/Display/DisplayPartsTest.php b/tests/classes/Display/DisplayPartsTest.php
index 2da8f6e6e5..ed33820710 100644
--- a/tests/classes/Display/DisplayPartsTest.php
+++ b/tests/classes/Display/DisplayPartsTest.php
@@ -23,25 +23,25 @@ class DisplayPartsTest extends TestCase
             'hasTextButton' => true,
             'hasPrintLink' => true,
         ]);
-        $this->assertTrue($displayParts->hasEditLink);
-        $this->assertSame(DeleteLinkEnum::DELETE_ROW, $displayParts->deleteLink);
-        $this->assertTrue($displayParts->hasSortLink);
-        $this->assertTrue($displayParts->hasNavigationBar);
-        $this->assertTrue($displayParts->hasBookmarkForm);
-        $this->assertTrue($displayParts->hasTextButton);
-        $this->assertTrue($displayParts->hasPrintLink);
+        self::assertTrue($displayParts->hasEditLink);
+        self::assertSame(DeleteLinkEnum::DELETE_ROW, $displayParts->deleteLink);
+        self::assertTrue($displayParts->hasSortLink);
+        self::assertTrue($displayParts->hasNavigationBar);
+        self::assertTrue($displayParts->hasBookmarkForm);
+        self::assertTrue($displayParts->hasTextButton);
+        self::assertTrue($displayParts->hasPrintLink);
     }
 
     public function testWith(): void
     {
         $displayParts = DisplayParts::fromArray([]);
-        $this->assertFalse($displayParts->hasEditLink);
-        $this->assertSame(DeleteLinkEnum::NO_DELETE, $displayParts->deleteLink);
-        $this->assertFalse($displayParts->hasSortLink);
-        $this->assertFalse($displayParts->hasNavigationBar);
-        $this->assertFalse($displayParts->hasBookmarkForm);
-        $this->assertFalse($displayParts->hasTextButton);
-        $this->assertFalse($displayParts->hasPrintLink);
+        self::assertFalse($displayParts->hasEditLink);
+        self::assertSame(DeleteLinkEnum::NO_DELETE, $displayParts->deleteLink);
+        self::assertFalse($displayParts->hasSortLink);
+        self::assertFalse($displayParts->hasNavigationBar);
+        self::assertFalse($displayParts->hasBookmarkForm);
+        self::assertFalse($displayParts->hasTextButton);
+        self::assertFalse($displayParts->hasPrintLink);
 
         $displayParts = $displayParts->with([
             'hasEditLink' => true,
@@ -52,21 +52,21 @@ class DisplayPartsTest extends TestCase
             'hasTextButton' => true,
             'hasPrintLink' => true,
         ]);
-        $this->assertTrue($displayParts->hasEditLink);
-        $this->assertSame(DeleteLinkEnum::KILL_PROCESS, $displayParts->deleteLink);
-        $this->assertTrue($displayParts->hasSortLink);
-        $this->assertTrue($displayParts->hasNavigationBar);
-        $this->assertTrue($displayParts->hasBookmarkForm);
-        $this->assertTrue($displayParts->hasTextButton);
-        $this->assertTrue($displayParts->hasPrintLink);
+        self::assertTrue($displayParts->hasEditLink);
+        self::assertSame(DeleteLinkEnum::KILL_PROCESS, $displayParts->deleteLink);
+        self::assertTrue($displayParts->hasSortLink);
+        self::assertTrue($displayParts->hasNavigationBar);
+        self::assertTrue($displayParts->hasBookmarkForm);
+        self::assertTrue($displayParts->hasTextButton);
+        self::assertTrue($displayParts->hasPrintLink);
 
         $displayParts = $displayParts->with([]);
-        $this->assertTrue($displayParts->hasEditLink);
-        $this->assertSame(DeleteLinkEnum::KILL_PROCESS, $displayParts->deleteLink);
-        $this->assertTrue($displayParts->hasSortLink);
-        $this->assertTrue($displayParts->hasNavigationBar);
-        $this->assertTrue($displayParts->hasBookmarkForm);
-        $this->assertTrue($displayParts->hasTextButton);
-        $this->assertTrue($displayParts->hasPrintLink);
+        self::assertTrue($displayParts->hasEditLink);
+        self::assertSame(DeleteLinkEnum::KILL_PROCESS, $displayParts->deleteLink);
+        self::assertTrue($displayParts->hasSortLink);
+        self::assertTrue($displayParts->hasNavigationBar);
+        self::assertTrue($displayParts->hasBookmarkForm);
+        self::assertTrue($displayParts->hasTextButton);
+        self::assertTrue($displayParts->hasPrintLink);
     }
 }
diff --git a/tests/classes/Display/ResultsTest.php b/tests/classes/Display/ResultsTest.php
index e820f2139e..852ffe4289 100644
--- a/tests/classes/Display/ResultsTest.php
+++ b/tests/classes/Display/ResultsTest.php
@@ -96,7 +96,7 @@ class ResultsTest extends AbstractTestCase
      */
     public function testisSelect(): void
     {
-        $this->assertTrue(
+        self::assertTrue(
             $this->callFunction(
                 $this->object,
                 DisplayResults::class,
@@ -108,7 +108,7 @@ class ResultsTest extends AbstractTestCase
 
     public function testGetClassForDateTimeRelatedFieldsCase1(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             'datetimefield',
             $this->callFunction(
                 $this->object,
@@ -121,7 +121,7 @@ class ResultsTest extends AbstractTestCase
 
     public function testGetClassForDateTimeRelatedFieldsCase2(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             'datefield',
             $this->callFunction(
                 $this->object,
@@ -134,7 +134,7 @@ class ResultsTest extends AbstractTestCase
 
     public function testGetClassForDateTimeRelatedFieldsCase3(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             'text',
             $this->callFunction(
                 $this->object,
@@ -151,7 +151,7 @@ class ResultsTest extends AbstractTestCase
     public function testGetOffsetsCase1(): void
     {
         $_SESSION['tmpval']['max_rows'] = DisplayResults::ALL_ROWS;
-        $this->assertEquals(
+        self::assertEquals(
             [0, 0],
             $this->callFunction(
                 $this->object,
@@ -169,7 +169,7 @@ class ResultsTest extends AbstractTestCase
     {
         $_SESSION['tmpval']['max_rows'] = 5;
         $_SESSION['tmpval']['pos'] = 4;
-        $this->assertEquals(
+        self::assertEquals(
             [9, 0],
             $this->callFunction(
                 $this->object,
@@ -252,7 +252,7 @@ class ResultsTest extends AbstractTestCase
             ],
         ];
 
-        $this->assertEquals(
+        self::assertEquals(
             $output,
             $this->callFunction(
                 $this->object,
@@ -303,7 +303,7 @@ class ResultsTest extends AbstractTestCase
     ): void {
         (new ReflectionProperty(DisplayResults::class, 'fieldsMeta'))->setValue($this->object, $fieldsMeta);
 
-        $this->assertEquals(
+        self::assertEquals(
             $output,
             $this->callFunction(
                 $this->object,
@@ -324,7 +324,7 @@ class ResultsTest extends AbstractTestCase
             [StatementInfo::fromArray(Query::getAll($query))],
         );
 
-        $this->assertEquals([
+        self::assertEquals([
             'db_name' => true,
             'tbl' => true,
             'id' => true,
@@ -359,7 +359,7 @@ class ResultsTest extends AbstractTestCase
     {
         $_SESSION['tmpval']['pftext'] = $pftext;
         Config::getInstance()->settings['LimitChars'] = $limitChars;
-        $this->assertEquals(
+        self::assertEquals(
             $output,
             $this->callFunction(
                 $this->object,
@@ -438,7 +438,7 @@ class ResultsTest extends AbstractTestCase
         $_SESSION['tmpval']['display_binary'] = $displayBinary;
         $_SESSION['tmpval']['display_blob'] = $displayBlob;
         Config::getInstance()->settings['LimitChars'] = 50;
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             $output,
             $this->callFunction(
                 $this->object,
@@ -613,8 +613,8 @@ class ResultsTest extends AbstractTestCase
         $config = Config::getInstance();
         $config->settings['LimitChars'] = 50;
         $config->settings['ProtectBinary'] = $protectBinary;
-        $statementInfo = $this->createStub(StatementInfo::class);
-        $this->assertStringContainsString(
+        $statementInfo = self::createStub(StatementInfo::class);
+        self::assertStringContainsString(
             $output,
             $this->callFunction(
                 $this->object,
@@ -682,7 +682,7 @@ class ResultsTest extends AbstractTestCase
             ->getMock();
 
         // MIME transformations
-        $dbi->expects($this->exactly(1))
+        $dbi->expects(self::exactly(1))
             ->method('fetchResult')
             ->willReturn(
                 [
@@ -717,9 +717,9 @@ class ResultsTest extends AbstractTestCase
         );
 
         // Dateformat
-        $this->assertStringContainsString('Jan 01, 1970 at 01:00 AM', $output);
+        self::assertStringContainsString('Jan 01, 1970 at 01:00 AM', $output);
         // Bool2Text
-        $this->assertStringContainsString('>T<', $output);
+        self::assertStringContainsString('>T<', $output);
     }
 
     /** @return mixed[][] */
@@ -802,31 +802,31 @@ class ResultsTest extends AbstractTestCase
             [$urlParams, $colName],
         );
         $out = urldecode(htmlspecialchars_decode($output));
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             'name="url-remove-order" value="index.php?route=/sql&sql_query=' . $sqlRemove,
             $out,
             'The remove query should be found',
         );
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             'name="url-add-order" value="index.php?route=/sql&sql_query=' . $sqlAdd,
             $out,
             'The add query should be found',
         );
 
         $firstLine = explode("\n", $out)[0] ?? '';
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             'url-remove-order',
             $firstLine,
             'The first line should contain url-remove-order input',
         );
-        $this->assertStringNotContainsString(
+        self::assertStringNotContainsString(
             'url-add-order',
             $firstLine,
             'The first line should contain NOT url-add-order input',
         );
 
-        $this->assertStringContainsString($urlParamsRemove, $firstLine, 'The first line should contain the URL params');
+        self::assertStringContainsString($urlParamsRemove, $firstLine, 'The first line should contain the URL params');
     }
 
     /** @see https://github.com/phpmyadmin/phpmyadmin/issues/16836 */
@@ -838,14 +838,14 @@ class ResultsTest extends AbstractTestCase
             'buildValueDisplay',
             ['my_class', false, '  special value  '],
         );
-        $this->assertSame('<td class="text-start my_class">  special value  </td>' . "\n", $output);
+        self::assertSame('<td class="text-start my_class">  special value  </td>' . "\n", $output);
         $output = $this->callFunction(
             $this->object,
             DisplayResults::class,
             'buildValueDisplay',
             ['my_class', false, '0x11e6ac0cfb1e8bf3bf48b827ebdafb0b'],
         );
-        $this->assertSame('<td class="text-start my_class">0x11e6ac0cfb1e8bf3bf48b827ebdafb0b</td>' . "\n", $output);
+        self::assertSame('<td class="text-start my_class">0x11e6ac0cfb1e8bf3bf48b827ebdafb0b</td>' . "\n", $output);
         $output = $this->callFunction(
             $this->object,
             DisplayResults::class,
@@ -856,7 +856,7 @@ class ResultsTest extends AbstractTestCase
                 '0x11e6ac0cfb1e8bf3bf48b827ebdafb0b',
             ],
         );
-        $this->assertSame(
+        self::assertSame(
             '<td class="text-start my_class condition">0x11e6ac0cfb1e8bf3bf48b827ebdafb0b</td>' . "\n",
             $output,
         );
@@ -873,7 +873,7 @@ class ResultsTest extends AbstractTestCase
         $object = new DisplayResults($this->dbi, $db, $table, 2, '', $query);
         $object->setConfigParamsForDisplayTable($analyzedSqlResults);
 
-        $this->assertSame('F', $_SESSION['tmpval']['pftext']);
+        self::assertSame('F', $_SESSION['tmpval']['pftext']);
 
         $query = 'ANALYZE NO_WRITE_TO_BINLOG TABLE test_table';
         [$analyzedSqlResults] = ParseAnalyze::sqlQuery($query, $db);
@@ -881,7 +881,7 @@ class ResultsTest extends AbstractTestCase
         $object = new DisplayResults($this->dbi, $db, $table, 2, '', $query);
         $object->setConfigParamsForDisplayTable($analyzedSqlResults);
 
-        $this->assertSame('P', $_SESSION['tmpval']['pftext']);
+        self::assertSame('P', $_SESSION['tmpval']['pftext']);
     }
 
     /**
@@ -912,9 +912,9 @@ class ResultsTest extends AbstractTestCase
         $object = new DisplayResults($this->dbi, $db, $table, 2, '', $query);
         $object->setConfigParamsForDisplayTable($analyzedSqlResults);
 
-        $this->assertArrayHasKey('tmpval', $_SESSION);
-        $this->assertIsArray($_SESSION['tmpval']);
-        $this->assertSame($expected, $_SESSION['tmpval']);
+        self::assertArrayHasKey('tmpval', $_SESSION);
+        self::assertIsArray($_SESSION['tmpval']);
+        self::assertSame($expected, $_SESSION['tmpval']);
     }
 
     /** @return mixed[][] */
@@ -1201,7 +1201,7 @@ class ResultsTest extends AbstractTestCase
             'hasPrintLink' => true,
         ]);
 
-        $this->assertNotFalse($dtResult);
+        self::assertNotFalse($dtResult);
         $actual = $object->getTable($dtResult, $displayParts, $statementInfo);
 
         $template = new Template();
@@ -1416,7 +1416,7 @@ class ResultsTest extends AbstractTestCase
             'text_dir' => 'ltr',
         ]);
 
-        $this->assertEquals($tableTemplate, $actual);
+        self::assertEquals($tableTemplate, $actual);
     }
 
     public function testGetTable2(): void
@@ -1494,7 +1494,7 @@ class ResultsTest extends AbstractTestCase
             'hasPrintLink' => true,
         ]);
 
-        $this->assertNotFalse($dtResult);
+        self::assertNotFalse($dtResult);
         $actual = $object->getTable($dtResult, $displayParts, $statementInfo);
 
         $template = new Template();
@@ -1651,7 +1651,7 @@ class ResultsTest extends AbstractTestCase
             'text_dir' => 'ltr',
         ]);
 
-        $this->assertEquals($tableTemplate, $actual);
+        self::assertEquals($tableTemplate, $actual);
     }
 
     /** @return array<string, array{string, string, int}> */
@@ -1758,7 +1758,7 @@ class ResultsTest extends AbstractTestCase
             ],
         );
 
-        $this->assertSame([
+        self::assertSame([
             "\n" . 'ORDER BY `Country`.`FoundedIn` ' . $querySortDirection, // singleSortOrder
             "\n" . 'ORDER BY `Country`.`Code` ASC, `Country`.`FoundedIn` ' . $querySortDirection, // sortOrderColumns
             '', // orderImg
@@ -1778,7 +1778,7 @@ class ResultsTest extends AbstractTestCase
             ],
         );
 
-        $this->assertSame([
+        self::assertSame([
             "\n" . 'ORDER BY `Country`.`Code2` ' . $querySortDirection, // singleSortOrder
             "\n" . 'ORDER BY `Country`.`Code` ASC, `Country`.`Code2` ' . $querySortDirection, // sortOrderColumns
             '', // orderImg
@@ -1805,7 +1805,7 @@ class ResultsTest extends AbstractTestCase
             ],
         );
 
-        $this->assertSame([
+        self::assertSame([
             "\n" . 'ORDER BY `Country`.`Code2` ' . $querySortDirection, // singleSortOrder
             "\n" . 'ORDER BY `Country`.`Continent` DESC, `Country`.`Region` ASC'
                 . ', `Country`.`Population` ASC, `Country`.`Code2` ' . $querySortDirection, // sortOrderColumns
diff --git a/tests/classes/EncodingTest.php b/tests/classes/EncodingTest.php
index 5e9136cfd9..e25d27860d 100644
--- a/tests/classes/EncodingTest.php
+++ b/tests/classes/EncodingTest.php
@@ -45,7 +45,7 @@ class EncodingTest extends AbstractTestCase
     #[Group('medium')]
     public function testNoConversion(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             'test',
             Encoding::convertString('UTF-8', 'UTF-8', 'test'),
         );
@@ -55,7 +55,7 @@ class EncodingTest extends AbstractTestCase
     {
         // Invalid value to use default case
         Encoding::setEngine(-1);
-        $this->assertEquals(
+        self::assertEquals(
             'test',
             Encoding::convertString('UTF-8', 'anything', 'test'),
         );
@@ -73,7 +73,7 @@ class EncodingTest extends AbstractTestCase
         // Set PHP native locale
         if (function_exists('setlocale')) {
             if (setlocale(0, 'POSIX') === false) {
-                $this->markTestSkipped('native setlocale failed');
+                self::markTestSkipped('native setlocale failed');
             }
         }
 
@@ -83,7 +83,7 @@ class EncodingTest extends AbstractTestCase
         if (PHP_INT_SIZE === 8) {
             $config->settings['IconvExtraParams'] = '//TRANSLIT';
             Encoding::setEngine(Encoding::ENGINE_ICONV);
-            $this->assertEquals(
+            self::assertEquals(
                 "This is the Euro symbol 'EUR'.",
                 Encoding::convertString(
                     'UTF-8',
@@ -96,7 +96,7 @@ class EncodingTest extends AbstractTestCase
             // NOTE: or it will throw "iconv(): Detected an illegal character in input string"
             $config->settings['IconvExtraParams'] = '//TRANSLIT//IGNORE';
             Encoding::setEngine(Encoding::ENGINE_ICONV);
-            $this->assertEquals(
+            self::assertEquals(
                 "This is the Euro symbol ''.",
                 Encoding::convertString(
                     'UTF-8',
@@ -110,7 +110,7 @@ class EncodingTest extends AbstractTestCase
     public function testMbstring(): void
     {
         Encoding::setEngine(Encoding::ENGINE_MB);
-        $this->assertEquals(
+        self::assertEquals(
             "This is the Euro symbol '?'.",
             Encoding::convertString(
                 'UTF-8',
@@ -125,11 +125,11 @@ class EncodingTest extends AbstractTestCase
      */
     public function testChangeOrder(): void
     {
-        $this->assertEquals('ASCII,SJIS,EUC-JP,JIS', Encoding::getKanjiEncodings());
+        self::assertEquals('ASCII,SJIS,EUC-JP,JIS', Encoding::getKanjiEncodings());
         Encoding::kanjiChangeOrder();
-        $this->assertEquals('ASCII,EUC-JP,SJIS,JIS', Encoding::getKanjiEncodings());
+        self::assertEquals('ASCII,EUC-JP,SJIS,JIS', Encoding::getKanjiEncodings());
         Encoding::kanjiChangeOrder();
-        $this->assertEquals('ASCII,SJIS,EUC-JP,JIS', Encoding::getKanjiEncodings());
+        self::assertEquals('ASCII,SJIS,EUC-JP,JIS', Encoding::getKanjiEncodings());
     }
 
     /**
@@ -137,24 +137,24 @@ class EncodingTest extends AbstractTestCase
      */
     public function testKanjiStrConv(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             'test',
             Encoding::kanjiStrConv('test', '', ''),
         );
 
         $GLOBALS['kanji_encoding_list'] = 'ASCII,SJIS,EUC-JP,JIS';
 
-        $this->assertEquals(
+        self::assertEquals(
             'test è',
             Encoding::kanjiStrConv('test è', '', ''),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             mb_convert_encoding('test è', 'ASCII', 'SJIS'),
             Encoding::kanjiStrConv('test è', 'ASCII', ''),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             mb_convert_kana('全角', 'KV', 'SJIS'),
             Encoding::kanjiStrConv('全角', '', 'kana'),
         );
@@ -167,7 +167,7 @@ class EncodingTest extends AbstractTestCase
     {
         $fileStr = '教育漢字常用漢字';
         $filename = 'test.kanji';
-        $this->assertNotFalse(file_put_contents($filename, $fileStr));
+        self::assertNotFalse(file_put_contents($filename, $fileStr));
         $GLOBALS['kanji_encoding_list'] = 'ASCII,EUC-JP,SJIS,JIS';
 
         $result = Encoding::kanjiFileConv($filename, 'JIS', 'kana');
@@ -176,7 +176,7 @@ class EncodingTest extends AbstractTestCase
         Encoding::kanjiChangeOrder();
         $expected = Encoding::kanjiStrConv($fileStr, 'JIS', 'kana');
         Encoding::kanjiChangeOrder();
-        $this->assertEquals($string, $expected);
+        self::assertEquals($string, $expected);
         unlink($result);
     }
 
@@ -186,17 +186,17 @@ class EncodingTest extends AbstractTestCase
     public function testEncodingForm(): void
     {
         $actual = Encoding::kanjiEncodingForm();
-        $this->assertStringContainsString('<input type="radio" name="knjenc"', $actual);
-        $this->assertStringContainsString('type="radio" name="knjenc"', $actual);
-        $this->assertStringContainsString('<input type="radio" name="knjenc" value="EUC-JP" id="kj-euc">', $actual);
-        $this->assertStringContainsString('<input type="radio" name="knjenc" value="SJIS" id="kj-sjis">', $actual);
-        $this->assertStringContainsString('<input type="checkbox" name="xkana" value="kana" id="kj-kana">', $actual);
+        self::assertStringContainsString('<input type="radio" name="knjenc"', $actual);
+        self::assertStringContainsString('type="radio" name="knjenc"', $actual);
+        self::assertStringContainsString('<input type="radio" name="knjenc" value="EUC-JP" id="kj-euc">', $actual);
+        self::assertStringContainsString('<input type="radio" name="knjenc" value="SJIS" id="kj-sjis">', $actual);
+        self::assertStringContainsString('<input type="checkbox" name="xkana" value="kana" id="kj-kana">', $actual);
     }
 
     public function testListEncodings(): void
     {
         Config::getInstance()->settings['AvailableCharsets'] = ['utf-8'];
         $result = Encoding::listEncodings();
-        $this->assertContains('utf-8', $result);
+        self::assertContains('utf-8', $result);
     }
 }
diff --git a/tests/classes/Engines/BdbTest.php b/tests/classes/Engines/BdbTest.php
index 61ee10a6de..38cbec0d03 100644
--- a/tests/classes/Engines/BdbTest.php
+++ b/tests/classes/Engines/BdbTest.php
@@ -44,7 +44,7 @@ class BdbTest extends AbstractTestCase
      */
     public function testGetVariables(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             $this->object->getVariables(),
             [
                 'version_bdb' => ['title' => __('Version information')],
@@ -71,7 +71,7 @@ class BdbTest extends AbstractTestCase
      */
     public function testGetVariablesLikePattern(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             $this->object->getVariablesLikePattern(),
             '%bdb%',
         );
@@ -82,7 +82,7 @@ class BdbTest extends AbstractTestCase
      */
     public function testGetMysqlHelpPage(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             $this->object->getMysqlHelpPage(),
             'bdb',
         );
diff --git a/tests/classes/Engines/BinlogTest.php b/tests/classes/Engines/BinlogTest.php
index 97951c4ebb..2ccfbe2c47 100644
--- a/tests/classes/Engines/BinlogTest.php
+++ b/tests/classes/Engines/BinlogTest.php
@@ -42,7 +42,7 @@ class BinlogTest extends AbstractTestCase
      */
     public function testGetMysqlHelpPage(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             $this->object->getMysqlHelpPage(),
             'binary-log',
         );
diff --git a/tests/classes/Engines/InnodbTest.php b/tests/classes/Engines/InnodbTest.php
index 703ef07e65..f0fb851da0 100644
--- a/tests/classes/Engines/InnodbTest.php
+++ b/tests/classes/Engines/InnodbTest.php
@@ -44,7 +44,7 @@ class InnodbTest extends AbstractTestCase
      */
     public function testGetVariables(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             [
                 'innodb_data_home_dir' => [
                     'title' => __('Data home directory'),
@@ -103,7 +103,7 @@ class InnodbTest extends AbstractTestCase
      */
     public function testGetVariablesLikePattern(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             'innodb\\_%',
             $this->object->getVariablesLikePattern(),
         );
@@ -114,12 +114,12 @@ class InnodbTest extends AbstractTestCase
      */
     public function testGetInfoPages(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             [],
             $this->object->getInfoPages(),
         );
         $this->object->support = 2;
-        $this->assertEquals(
+        self::assertEquals(
             ['Bufferpool' => 'Buffer Pool', 'Status' => 'InnoDB Status'],
             $this->object->getInfoPages(),
         );
@@ -130,7 +130,7 @@ class InnodbTest extends AbstractTestCase
      */
     public function testGetPageBufferpool(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             '<table class="table table-striped table-hover w-auto float-start caption-top">' . "\n" .
             '    <caption>' . "\n" .
             '        Buffer Pool Usage' . "\n" .
@@ -213,7 +213,7 @@ class InnodbTest extends AbstractTestCase
      */
     public function testGetPageStatus(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             '<pre id="pre_innodb_status">' . "\n\n" . '</pre>' . "\n",
             $this->object->getPageStatus(),
         );
@@ -224,12 +224,12 @@ class InnodbTest extends AbstractTestCase
      */
     public function testGetPage(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             '',
             $this->object->getPage('Status'),
         );
         $this->object->support = 2;
-        $this->assertEquals(
+        self::assertEquals(
             '<pre id="pre_innodb_status">' . "\n\n" . '</pre>' . "\n",
             $this->object->getPage('Status'),
         );
@@ -240,7 +240,7 @@ class InnodbTest extends AbstractTestCase
      */
     public function testGetMysqlHelpPage(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             'innodb-storage-engine',
             $this->object->getMysqlHelpPage(),
         );
@@ -251,7 +251,7 @@ class InnodbTest extends AbstractTestCase
      */
     public function testGetInnodbPluginVersion(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             '1.1.8',
             $this->object->getInnodbPluginVersion(),
         );
@@ -262,7 +262,7 @@ class InnodbTest extends AbstractTestCase
      */
     public function testSupportsFilePerTable(): void
     {
-        $this->assertFalse(
+        self::assertFalse(
             $this->object->supportsFilePerTable(),
         );
     }
@@ -272,7 +272,7 @@ class InnodbTest extends AbstractTestCase
      */
     public function testGetInnodbFileFormat(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             'Antelope',
             $this->object->getInnodbFileFormat(),
         );
diff --git a/tests/classes/Engines/MemoryTest.php b/tests/classes/Engines/MemoryTest.php
index 48352a6084..c8cba59987 100644
--- a/tests/classes/Engines/MemoryTest.php
+++ b/tests/classes/Engines/MemoryTest.php
@@ -42,7 +42,7 @@ class MemoryTest extends AbstractTestCase
      */
     public function testGetVariables(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             $this->object->getVariables(),
             ['max_heap_table_size' => ['type' => 1]],
         );
diff --git a/tests/classes/Engines/MrgMyisamTest.php b/tests/classes/Engines/MrgMyisamTest.php
index 4ab62b973b..09cce5588b 100644
--- a/tests/classes/Engines/MrgMyisamTest.php
+++ b/tests/classes/Engines/MrgMyisamTest.php
@@ -42,7 +42,7 @@ class MrgMyisamTest extends AbstractTestCase
      */
     public function testGetMysqlHelpPage(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             $this->object->getMysqlHelpPage(),
             'merge-storage-engine',
         );
diff --git a/tests/classes/Engines/MyisamTest.php b/tests/classes/Engines/MyisamTest.php
index 9453dcdc25..3298c30058 100644
--- a/tests/classes/Engines/MyisamTest.php
+++ b/tests/classes/Engines/MyisamTest.php
@@ -44,7 +44,7 @@ class MyisamTest extends AbstractTestCase
      */
     public function testGetVariables(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             $this->object->getVariables(),
             [
                 'myisam_data_pointer_size' => [
diff --git a/tests/classes/Engines/NdbclusterTest.php b/tests/classes/Engines/NdbclusterTest.php
index f942ffa724..2a50e9912d 100644
--- a/tests/classes/Engines/NdbclusterTest.php
+++ b/tests/classes/Engines/NdbclusterTest.php
@@ -42,7 +42,7 @@ class NdbclusterTest extends AbstractTestCase
      */
     public function testGetVariables(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             $this->object->getVariables(),
             ['ndb_connectstring' => []],
         );
@@ -53,7 +53,7 @@ class NdbclusterTest extends AbstractTestCase
      */
     public function testGetVariablesLikePattern(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             $this->object->getVariablesLikePattern(),
             'ndb\\_%',
         );
@@ -64,7 +64,7 @@ class NdbclusterTest extends AbstractTestCase
      */
     public function testGetMysqlHelpPage(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             $this->object->getMysqlHelpPage(),
             'ndbcluster',
         );
diff --git a/tests/classes/Engines/PbxtTest.php b/tests/classes/Engines/PbxtTest.php
index 09514f8884..a11db4a1ed 100644
--- a/tests/classes/Engines/PbxtTest.php
+++ b/tests/classes/Engines/PbxtTest.php
@@ -47,7 +47,7 @@ class PbxtTest extends AbstractTestCase
      */
     public function testGetVariables(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             $this->object->getVariables(),
             [
                 'pbxt_index_cache_size' => [
@@ -168,7 +168,7 @@ class PbxtTest extends AbstractTestCase
     #[DataProvider('providerFortTestResolveTypeSize')]
     public function testResolveTypeSize(string $formattedSize, array $output): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             $this->object->resolveTypeSize($formattedSize),
             $output,
         );
@@ -189,7 +189,7 @@ class PbxtTest extends AbstractTestCase
      */
     public function testGetInfoPages(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             $this->object->getInfoPages(),
             ['Documentation' => 'Documentation'],
         );
@@ -200,7 +200,7 @@ class PbxtTest extends AbstractTestCase
      */
     public function testGetPage(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             $this->object->getPage('Documentation'),
             '<p>'
             . sprintf(
@@ -214,7 +214,7 @@ class PbxtTest extends AbstractTestCase
             . '</p>' . "\n",
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             $this->object->getPage('NonExistMethod'),
             false,
         );
diff --git a/tests/classes/Engines/PerformanceSchemaTest.php b/tests/classes/Engines/PerformanceSchemaTest.php
index 6ff8628d4a..a54831ad5f 100644
--- a/tests/classes/Engines/PerformanceSchemaTest.php
+++ b/tests/classes/Engines/PerformanceSchemaTest.php
@@ -42,7 +42,7 @@ class PerformanceSchemaTest extends AbstractTestCase
      */
     public function testGetMysqlHelpPage(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             $this->object->getMysqlHelpPage(),
             'performance-schema',
         );
diff --git a/tests/classes/EnvironmentTest.php b/tests/classes/EnvironmentTest.php
index 18d51d82da..c03e72ca0c 100644
--- a/tests/classes/EnvironmentTest.php
+++ b/tests/classes/EnvironmentTest.php
@@ -18,7 +18,7 @@ class EnvironmentTest extends AbstractTestCase
      */
     public function testPhpVersion(): void
     {
-        $this->assertTrue(
+        self::assertTrue(
             version_compare('8.1.2', PHP_VERSION, '<='),
             'phpMyAdmin requires PHP 8.1.2 or above',
         );
diff --git a/tests/classes/Error/ErrorHandlerTest.php b/tests/classes/Error/ErrorHandlerTest.php
index 03d7078e92..57e6aa637a 100644
--- a/tests/classes/Error/ErrorHandlerTest.php
+++ b/tests/classes/Error/ErrorHandlerTest.php
@@ -64,7 +64,7 @@ class ErrorHandlerTest extends AbstractTestCase
         ErrorHandler::$instance = null;
         $instanceOne = ErrorHandler::getInstance();
         $instanceTwo = ErrorHandler::getInstance();
-        $this->assertSame($instanceOne, $instanceTwo);
+        self::assertSame($instanceOne, $instanceTwo);
     }
 
     /** @return array<array{int, string, string, int, string, string}> */
@@ -116,7 +116,7 @@ class ErrorHandlerTest extends AbstractTestCase
             'checkSavedErrors',
             [],
         );
-        $this->assertArrayNotHasKey('errors', $_SESSION);
+        self::assertArrayNotHasKey('errors', $_SESSION);
     }
 
     /**
@@ -126,7 +126,7 @@ class ErrorHandlerTest extends AbstractTestCase
     public function testCountErrors(): void
     {
         $this->object->addError('Compile Error', E_WARNING, 'error.txt', 15);
-        $this->assertEquals(
+        self::assertEquals(
             1,
             $this->object->countErrors(),
         );
@@ -140,23 +140,23 @@ class ErrorHandlerTest extends AbstractTestCase
     {
         $this->object->addError('Compile Error', E_WARNING, 'error.txt', 15);
         $this->object->addError('Compile Error', E_WARNING, 'error.txt', 16);
-        $this->assertEquals(
+        self::assertEquals(
             2,
             $this->object->countErrors(),
         );
-        $this->assertEquals(
+        self::assertEquals(
             [],
             $this->object->sliceErrors(2),
         );
-        $this->assertEquals(
+        self::assertEquals(
             2,
             $this->object->countErrors(),
         );
-        $this->assertCount(
+        self::assertCount(
             1,
             $this->object->sliceErrors(1),
         );
-        $this->assertEquals(
+        self::assertEquals(
             1,
             $this->object->countErrors(),
         );
@@ -173,32 +173,32 @@ class ErrorHandlerTest extends AbstractTestCase
         }
 
         // 10 initial items
-        $this->assertEquals(10, $this->object->countErrors());
-        $this->assertEquals(10, count($this->object->getCurrentErrors()));
+        self::assertEquals(10, $this->object->countErrors());
+        self::assertEquals(10, count($this->object->getCurrentErrors()));
 
         // slice 9 elements, returns one 10 - 9
         $elements = $this->object->sliceErrors(9);
         $firstKey = array_keys($elements)[0];
 
         // Gives the last element
-        $this->assertEquals(
+        self::assertEquals(
             [$firstKey => $elements[$firstKey]],
             $elements,
         );
-        $this->assertEquals(9, count($this->object->getCurrentErrors()));
-        $this->assertEquals(9, $this->object->countErrors());
+        self::assertEquals(9, count($this->object->getCurrentErrors()));
+        self::assertEquals(9, $this->object->countErrors());
 
         // Slice as much as there is (9), does nothing
         $elements = $this->object->sliceErrors(9);
-        $this->assertEquals([], $elements);
-        $this->assertEquals(9, count($this->object->getCurrentErrors()));
-        $this->assertEquals(9, $this->object->countErrors());
+        self::assertEquals([], $elements);
+        self::assertEquals(9, count($this->object->getCurrentErrors()));
+        self::assertEquals(9, $this->object->countErrors());
 
         // Slice 0, removes everything
         $elements = $this->object->sliceErrors(0);
-        $this->assertEquals(9, count($elements));
-        $this->assertEquals(0, count($this->object->getCurrentErrors()));
-        $this->assertEquals(0, $this->object->countErrors());
+        self::assertEquals(9, count($elements));
+        self::assertEquals(0, count($this->object->getCurrentErrors()));
+        self::assertEquals(0, $this->object->countErrors());
     }
 
     /**
@@ -207,12 +207,12 @@ class ErrorHandlerTest extends AbstractTestCase
     public function testCountUserErrors(): void
     {
         $this->object->addError('Compile Error', E_WARNING, 'error.txt', 15);
-        $this->assertEquals(
+        self::assertEquals(
             0,
             $this->object->countUserErrors(),
         );
         $this->object->addError('Compile Error', E_USER_WARNING, 'error.txt', 15);
-        $this->assertEquals(
+        self::assertEquals(
             1,
             $this->object->countUserErrors(),
         );
@@ -223,7 +223,7 @@ class ErrorHandlerTest extends AbstractTestCase
      */
     public function testHasUserErrors(): void
     {
-        $this->assertFalse($this->object->hasUserErrors());
+        self::assertFalse($this->object->hasUserErrors());
     }
 
     /**
@@ -231,7 +231,7 @@ class ErrorHandlerTest extends AbstractTestCase
      */
     public function testHasErrors(): void
     {
-        $this->assertFalse($this->object->hasErrors());
+        self::assertFalse($this->object->hasErrors());
     }
 
     /**
@@ -239,7 +239,7 @@ class ErrorHandlerTest extends AbstractTestCase
      */
     public function testCountDisplayErrorsForDisplayTrue(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             0,
             $this->object->countDisplayErrors(),
         );
@@ -250,7 +250,7 @@ class ErrorHandlerTest extends AbstractTestCase
      */
     public function testCountDisplayErrorsForDisplayFalse(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             0,
             $this->object->countDisplayErrors(),
         );
@@ -261,7 +261,7 @@ class ErrorHandlerTest extends AbstractTestCase
      */
     public function testHasDisplayErrors(): void
     {
-        $this->assertFalse($this->object->hasDisplayErrors());
+        self::assertFalse($this->object->hasDisplayErrors());
     }
 
     public function testHandleExceptionForDevEnv(): void
@@ -269,23 +269,23 @@ class ErrorHandlerTest extends AbstractTestCase
         $GLOBALS['lang'] = 'en';
         Config::getInstance()->set('environment', 'development');
         $errorHandler = new ErrorHandler();
-        $this->assertSame([], $errorHandler->getCurrentErrors());
+        self::assertSame([], $errorHandler->getCurrentErrors());
         try {
             $errorHandler->handleException(new Exception('Exception message.'));
         } catch (Throwable $throwable) {
         }
 
-        $this->assertInstanceOf(ExitException::class, $throwable ?? null);
+        self::assertInstanceOf(ExitException::class, $throwable ?? null);
         $output = $this->getActualOutputForAssertion();
         $errors = $errorHandler->getCurrentErrors();
-        $this->assertCount(1, $errors);
+        self::assertCount(1, $errors);
         $error = array_pop($errors);
-        $this->assertInstanceOf(Error::class, $error);
-        $this->assertSame('Exception: Exception message.', $error->getOnlyMessage());
-        $this->assertStringContainsString($error->getDisplay(), $output);
-        $this->assertStringContainsString('Internal error', $output);
-        $this->assertStringContainsString('ErrorHandlerTest.php#' . $error->getLine(), $output);
-        $this->assertStringContainsString('Exception: Exception message.', $output);
+        self::assertInstanceOf(Error::class, $error);
+        self::assertSame('Exception: Exception message.', $error->getOnlyMessage());
+        self::assertStringContainsString($error->getDisplay(), $output);
+        self::assertStringContainsString('Internal error', $output);
+        self::assertStringContainsString('ErrorHandlerTest.php#' . $error->getLine(), $output);
+        self::assertStringContainsString('Exception: Exception message.', $output);
     }
 
     public function testHandleExceptionForProdEnv(): void
@@ -293,22 +293,22 @@ class ErrorHandlerTest extends AbstractTestCase
         $GLOBALS['lang'] = 'en';
         Config::getInstance()->set('environment', 'production');
         $errorHandler = new ErrorHandler();
-        $this->assertSame([], $errorHandler->getCurrentErrors());
+        self::assertSame([], $errorHandler->getCurrentErrors());
         try {
             $errorHandler->handleException(new Exception('Exception message.'));
         } catch (Throwable $throwable) {
         }
 
-        $this->assertInstanceOf(ExitException::class, $throwable ?? null);
+        self::assertInstanceOf(ExitException::class, $throwable ?? null);
         $output = $this->getActualOutputForAssertion();
         $errors = $errorHandler->getCurrentErrors();
-        $this->assertCount(1, $errors);
+        self::assertCount(1, $errors);
         $error = array_pop($errors);
-        $this->assertInstanceOf(Error::class, $error);
-        $this->assertSame('Exception: Exception message.', $error->getOnlyMessage());
-        $this->assertStringContainsString($error->getDisplay(), $output);
-        $this->assertStringContainsString('Exception: Exception message.', $output);
-        $this->assertStringNotContainsString('ErrorHandlerTest.php#' . $error->getLine(), $output);
+        self::assertInstanceOf(Error::class, $error);
+        self::assertSame('Exception: Exception message.', $error->getOnlyMessage());
+        self::assertStringContainsString($error->getDisplay(), $output);
+        self::assertStringContainsString('Exception: Exception message.', $output);
+        self::assertStringNotContainsString('ErrorHandlerTest.php#' . $error->getLine(), $output);
     }
 
     public function testAddErrorWithFatalError(): void
@@ -321,7 +321,7 @@ class ErrorHandlerTest extends AbstractTestCase
         } catch (Throwable $exception) {
         }
 
-        $this->assertInstanceOf(ExitException::class, $exception ?? null);
+        self::assertInstanceOf(ExitException::class, $exception ?? null);
         // phpcs:disable Generic.Files.LineLength.TooLong
         $expectedStart = <<<'HTML'
 <!DOCTYPE html>
@@ -332,7 +332,7 @@ class ErrorHandlerTest extends AbstractTestCase
 HTML;
         // phpcs:enable
         $output = $this->getActualOutputForAssertion();
-        $this->assertStringStartsWith($expectedStart, $output);
-        $this->assertStringEndsWith('</li></ol></div>' . "\n\n" . '</body>' . "\n" . '</html>', $output);
+        self::assertStringStartsWith($expectedStart, $output);
+        self::assertStringEndsWith('</li></ol></div>' . "\n\n" . '</body>' . "\n" . '</html>', $output);
     }
 }
diff --git a/tests/classes/Error/ErrorReportTest.php b/tests/classes/Error/ErrorReportTest.php
index 28892fa149..75b1a6a763 100644
--- a/tests/classes/Error/ErrorReportTest.php
+++ b/tests/classes/Error/ErrorReportTest.php
@@ -63,15 +63,15 @@ class ErrorReportTest extends AbstractTestCase
     public function testGetData(): void
     {
         $actual = $this->errorReport->getData('unknown');
-        $this->assertEquals([], $actual);
+        self::assertEquals([], $actual);
 
         $actual = $this->errorReport->getData('php');
-        $this->assertEquals([], $actual);
+        self::assertEquals([], $actual);
 
         $_SESSION['prev_errors'] = [];
 
         $actual = $this->errorReport->getData('php');
-        $this->assertEquals([], $actual);
+        self::assertEquals([], $actual);
 
         $_SESSION['prev_errors'] = [new Error(0, 'error 0', 'file', 1), new Error(1, 'error 1', 'file', 2)];
 
@@ -108,7 +108,7 @@ class ErrorReportTest extends AbstractTestCase
         ];
 
         $actual = $this->errorReport->getData('php');
-        $this->assertEquals($report, $actual);
+        self::assertEquals($report, $actual);
     }
 
     public function testSend(): void
@@ -120,7 +120,7 @@ class ErrorReportTest extends AbstractTestCase
         $httpRequest = $this->getMockBuilder(HttpRequest::class)
             ->onlyMethods(['create'])
             ->getMock();
-        $httpRequest->expects($this->once())
+        $httpRequest->expects(self::once())
             ->method('create')
             ->with(
                 $submissionUrl,
@@ -139,7 +139,7 @@ class ErrorReportTest extends AbstractTestCase
         );
         $this->errorReport->setSubmissionUrl($submissionUrl);
 
-        $this->assertEquals($return, $this->errorReport->send($report));
+        self::assertEquals($return, $this->errorReport->send($report));
     }
 
     public function testGetForm(): void
@@ -147,7 +147,7 @@ class ErrorReportTest extends AbstractTestCase
         $_POST['exception'] = [];
 
         $form = $this->errorReport->getForm();
-        $this->assertStringContainsString('<pre class="pre-scrollable">[]</pre>', $form);
+        self::assertStringContainsString('<pre class="pre-scrollable">[]</pre>', $form);
 
         $context = [
             'Widget.prototype = {',
@@ -213,7 +213,7 @@ class ErrorReportTest extends AbstractTestCase
         $expectedData = json_encode($report, JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES);
 
         $form = $this->errorReport->getForm();
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             '<pre class="pre-scrollable">' . htmlspecialchars((string) $expectedData, ENT_QUOTES) . '</pre>',
             $form,
         );
@@ -278,7 +278,7 @@ class ErrorReportTest extends AbstractTestCase
         $data['stack'][1]['context'][1] = '!function(e,t){"use strict";"object"='
                                         . '=typeof module&&"object"==typeof modul//...';
 
-        $this->assertEquals($data, $actual['exception']);
+        self::assertEquals($data, $actual['exception']);
     }
 
     /**
@@ -322,7 +322,7 @@ class ErrorReportTest extends AbstractTestCase
     public function testSanitizeUrl(string $url, array $result): void
     {
         // $this->errorReport->sanitizeUrl
-        $this->assertSame(
+        self::assertSame(
             $result,
             $this->callFunction(
                 $this->errorReport,
diff --git a/tests/classes/Error/ErrorTest.php b/tests/classes/Error/ErrorTest.php
index 603389d8a2..76fa9c1e77 100644
--- a/tests/classes/Error/ErrorTest.php
+++ b/tests/classes/Error/ErrorTest.php
@@ -48,7 +48,7 @@ class ErrorTest extends AbstractTestCase
         $bt = [['file' => 'bt1', 'line' => 2, 'function' => 'bar', 'args' => ['foo' => $this]]];
         $this->object->setBacktrace($bt);
         $bt[0]['args']['foo'] = '<Class:PhpMyAdmin\Tests\Error\ErrorTest>';
-        $this->assertEquals($bt, $this->object->getBacktrace());
+        self::assertEquals($bt, $this->object->getBacktrace());
     }
 
     /**
@@ -57,7 +57,7 @@ class ErrorTest extends AbstractTestCase
     public function testSetLine(): void
     {
         $this->object->setLine(15);
-        $this->assertEquals(15, $this->object->getLine());
+        self::assertEquals(15, $this->object->getLine());
     }
 
     /**
@@ -70,7 +70,7 @@ class ErrorTest extends AbstractTestCase
     public function testSetFile(string $file, string $expected): void
     {
         $this->object->setFile($file);
-        $this->assertEquals($expected, $this->object->getFile());
+        self::assertEquals($expected, $this->object->getFile());
     }
 
     /**
@@ -96,7 +96,7 @@ class ErrorTest extends AbstractTestCase
      */
     public function testGetHash(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             1,
             preg_match('/^([a-z0-9]*)$/', $this->object->getHash()),
         );
@@ -107,7 +107,7 @@ class ErrorTest extends AbstractTestCase
      */
     public function testGetBacktraceDisplay(): void
     {
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             'PHPUnit\Framework\TestRunner->run(<Class:PhpMyAdmin\Tests\Error\ErrorTest>)',
             $this->object->getBacktraceDisplay(),
         );
@@ -119,18 +119,18 @@ class ErrorTest extends AbstractTestCase
     public function testGetDisplay(): void
     {
         $actual = $this->object->getDisplay();
-        $this->assertStringStartsWith(
+        self::assertStringStartsWith(
             '<div class="alert alert-danger" role="alert"><p><strong>Warning</strong> in error.txt#15</p>'
             . '<img src="themes/dot.gif" title="" alt="" class="icon ic_s_error"> Compile Error'
             . '<p class="mt-3"><strong>Backtrace</strong></p><ol class="list-group"><li class="list-group-item">',
             $actual,
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             'PHPUnit\Framework\TestRunner->run(<Class:PhpMyAdmin\Tests\Error\ErrorTest>)</li>'
             . '<li class="list-group-item">',
             $actual,
         );
-        $this->assertStringEndsWith('</li></ol></div>' . "\n", $actual);
+        self::assertStringEndsWith('</li></ol></div>' . "\n", $actual);
     }
 
     /**
@@ -138,7 +138,7 @@ class ErrorTest extends AbstractTestCase
      */
     public function testGetHtmlTitle(): void
     {
-        $this->assertEquals('Warning: Compile Error', $this->object->getHtmlTitle());
+        self::assertEquals('Warning: Compile Error', $this->object->getHtmlTitle());
     }
 
     /**
@@ -146,7 +146,7 @@ class ErrorTest extends AbstractTestCase
      */
     public function testGetTitle(): void
     {
-        $this->assertEquals('Warning: Compile Error', $this->object->getTitle());
+        self::assertEquals('Warning: Compile Error', $this->object->getTitle());
     }
 
     /**
@@ -164,9 +164,9 @@ class ErrorTest extends AbstractTestCase
         $this->object->setBacktrace($bt);
 
         // case: full backtrace
-        $this->assertCount(4, $this->object->getBacktrace());
+        self::assertCount(4, $this->object->getBacktrace());
 
         // case: first 2 frames
-        $this->assertCount(2, $this->object->getBacktrace(2));
+        self::assertCount(2, $this->object->getBacktrace(2));
     }
 }
diff --git a/tests/classes/Export/ExportTest.php b/tests/classes/Export/ExportTest.php
index 070e153bf1..5c3b76315a 100644
--- a/tests/classes/Export/ExportTest.php
+++ b/tests/classes/Export/ExportTest.php
@@ -57,7 +57,7 @@ class ExportTest extends AbstractTestCase
             ],
         ];
         $actual = $export->mergeAliases($aliases1, $aliases2);
-        $this->assertEquals($expected, $actual);
+        self::assertEquals($expected, $actual);
     }
 
     public function testGetFinalFilenameAndMimetypeForFilename(): void
@@ -71,15 +71,15 @@ class ExportTest extends AbstractTestCase
             new Transformations(),
         );
         $finalFileName = $export->getFinalFilenameAndMimetypeForFilename($exportPlugin, 'zip', 'myfilename');
-        $this->assertSame(['myfilename.php.zip', 'application/zip'], $finalFileName);
+        self::assertSame(['myfilename.php.zip', 'application/zip'], $finalFileName);
         $finalFileName = $export->getFinalFilenameAndMimetypeForFilename($exportPlugin, 'gzip', 'myfilename');
-        $this->assertSame(['myfilename.php.gz', 'application/x-gzip'], $finalFileName);
+        self::assertSame(['myfilename.php.gz', 'application/x-gzip'], $finalFileName);
         $finalFileName = $export->getFinalFilenameAndMimetypeForFilename(
             $exportPlugin,
             'gzip',
             'export.db1.table1.file',
         );
-        $this->assertSame(['export.db1.table1.file.php.gz', 'application/x-gzip'], $finalFileName);
+        self::assertSame(['export.db1.table1.file.php.gz', 'application/x-gzip'], $finalFileName);
     }
 
     public function testExportDatabase(): void
@@ -147,7 +147,7 @@ INSERT INTO test_table (id, name, datetimefield) VALUES
 
 SQL;
 
-        $this->assertSame(htmlspecialchars($expected, ENT_COMPAT), $this->getActualOutputForAssertion());
+        self::assertSame(htmlspecialchars($expected, ENT_COMPAT), $this->getActualOutputForAssertion());
     }
 
     public function testExportServer(): void
@@ -230,7 +230,7 @@ INSERT INTO test_table (id, name, datetimefield) VALUES
 
 SQL;
 
-        $this->assertSame(htmlspecialchars($expected, ENT_COMPAT), $this->getActualOutputForAssertion());
+        self::assertSame(htmlspecialchars($expected, ENT_COMPAT), $this->getActualOutputForAssertion());
     }
 
     public function testGetPageLocationAndSaveMessageForServerExportWithError(): void
@@ -241,8 +241,8 @@ SQL;
         $dbi = $this->createDatabaseInterface();
         $export = new Export($dbi);
         $location = $export->getPageLocationAndSaveMessage('server', Message::error('Error message!'));
-        $this->assertSame('index.php?route=/server/export&server=2&lang=en', $location);
-        $this->assertSame(['danger' => ['Error message!']], (new FlashMessages())->getMessages());
+        self::assertSame('index.php?route=/server/export&server=2&lang=en', $location);
+        self::assertSame(['danger' => ['Error message!']], (new FlashMessages())->getMessages());
     }
 
     public function testGetPageLocationAndSaveMessageForServerExportWithSuccess(): void
@@ -253,8 +253,8 @@ SQL;
         $dbi = $this->createDatabaseInterface();
         $export = new Export($dbi);
         $location = $export->getPageLocationAndSaveMessage('server', Message::success('Success message!'));
-        $this->assertSame('index.php?route=/server/export&server=2&lang=en', $location);
-        $this->assertSame(['success' => ['Success message!']], (new FlashMessages())->getMessages());
+        self::assertSame('index.php?route=/server/export&server=2&lang=en', $location);
+        self::assertSame(['success' => ['Success message!']], (new FlashMessages())->getMessages());
     }
 
     public function testGetPageLocationAndSaveMessageForDatabaseExportWithError(): void
@@ -266,8 +266,8 @@ SQL;
         $dbi = $this->createDatabaseInterface();
         $export = new Export($dbi);
         $location = $export->getPageLocationAndSaveMessage('database', Message::error('Error message!'));
-        $this->assertSame('index.php?route=/database/export&db=test_db&server=2&lang=en', $location);
-        $this->assertSame(['danger' => ['Error message!']], (new FlashMessages())->getMessages());
+        self::assertSame('index.php?route=/database/export&db=test_db&server=2&lang=en', $location);
+        self::assertSame(['danger' => ['Error message!']], (new FlashMessages())->getMessages());
     }
 
     public function testGetPageLocationAndSaveMessageForDatabaseExportWithSuccess(): void
@@ -279,8 +279,8 @@ SQL;
         $dbi = $this->createDatabaseInterface();
         $export = new Export($dbi);
         $location = $export->getPageLocationAndSaveMessage('database', Message::success('Success message!'));
-        $this->assertSame('index.php?route=/database/export&db=test_db&server=2&lang=en', $location);
-        $this->assertSame(['success' => ['Success message!']], (new FlashMessages())->getMessages());
+        self::assertSame('index.php?route=/database/export&db=test_db&server=2&lang=en', $location);
+        self::assertSame(['success' => ['Success message!']], (new FlashMessages())->getMessages());
     }
 
     public function testGetPageLocationAndSaveMessageForTableExportWithError(): void
@@ -293,11 +293,11 @@ SQL;
         $dbi = $this->createDatabaseInterface();
         $export = new Export($dbi);
         $location = $export->getPageLocationAndSaveMessage('table', Message::error('Error message!'));
-        $this->assertSame(
+        self::assertSame(
             'index.php?route=/table/export&db=test_db&table=test_table&single_table=true&server=2&lang=en',
             $location,
         );
-        $this->assertSame(['danger' => ['Error message!']], (new FlashMessages())->getMessages());
+        self::assertSame(['danger' => ['Error message!']], (new FlashMessages())->getMessages());
     }
 
     public function testGetPageLocationAndSaveMessageForTableExportWithSuccess(): void
@@ -310,10 +310,10 @@ SQL;
         $dbi = $this->createDatabaseInterface();
         $export = new Export($dbi);
         $location = $export->getPageLocationAndSaveMessage('table', Message::success('Success message!'));
-        $this->assertSame(
+        self::assertSame(
             'index.php?route=/table/export&db=test_db&table=test_table&single_table=true&server=2&lang=en',
             $location,
         );
-        $this->assertSame(['success' => ['Success message!']], (new FlashMessages())->getMessages());
+        self::assertSame(['success' => ['Success message!']], (new FlashMessages())->getMessages());
     }
 }
diff --git a/tests/classes/Export/OptionsTest.php b/tests/classes/Export/OptionsTest.php
index d9a321154f..582fb05ce7 100644
--- a/tests/classes/Export/OptionsTest.php
+++ b/tests/classes/Export/OptionsTest.php
@@ -70,9 +70,9 @@ class OptionsTest extends AbstractTestCase
             ->disableOriginalConstructor()
             ->getMock();
 
-        $dbi->expects($this->any())->method('getColumnsFull')
+        $dbi->expects(self::any())->method('getColumnsFull')
             ->willReturn($columnsInfo);
-        $dbi->expects($this->any())->method('getCompatibilities')
+        $dbi->expects(self::any())->method('getCompatibilities')
             ->willReturn([]);
 
         DatabaseInterface::$instance = $dbi;
@@ -129,6 +129,6 @@ class OptionsTest extends AbstractTestCase
             'filename_template' => 'user value for test',
         ];
 
-        $this->assertEquals($expected, $actual);
+        self::assertEquals($expected, $actual);
     }
 }
diff --git a/tests/classes/FieldMetadataTest.php b/tests/classes/FieldMetadataTest.php
index e1072a1299..a16e7037d2 100644
--- a/tests/classes/FieldMetadataTest.php
+++ b/tests/classes/FieldMetadataTest.php
@@ -19,81 +19,81 @@ class FieldMetadataTest extends AbstractTestCase
     public function testEmptyConstruct(): void
     {
         $fm = FieldHelper::fromArray(['type' => -1]);
-        $this->assertSame('', $fm->getMappedType());
-        $this->assertFalse($fm->isBinary());
-        $this->assertFalse($fm->isEnum());
-        $this->assertFalse($fm->isUniqueKey());
-        $this->assertFalse($fm->isUnsigned());
-        $this->assertFalse($fm->isZerofill());
-        $this->assertFalse($fm->isSet());
-        $this->assertFalse($fm->isNotNull());
-        $this->assertFalse($fm->isPrimaryKey());
-        $this->assertFalse($fm->isMultipleKey());
-        $this->assertFalse($fm->isBlob());
+        self::assertSame('', $fm->getMappedType());
+        self::assertFalse($fm->isBinary());
+        self::assertFalse($fm->isEnum());
+        self::assertFalse($fm->isUniqueKey());
+        self::assertFalse($fm->isUnsigned());
+        self::assertFalse($fm->isZerofill());
+        self::assertFalse($fm->isSet());
+        self::assertFalse($fm->isNotNull());
+        self::assertFalse($fm->isPrimaryKey());
+        self::assertFalse($fm->isMultipleKey());
+        self::assertFalse($fm->isBlob());
     }
 
     public function testIsBinary(): void
     {
         $fm = FieldHelper::fromArray(['type' => MYSQLI_TYPE_STRING, 'charsetnr' => 63]);
-        $this->assertTrue($fm->isBinary());
-        $this->assertFalse($fm->isEnum());
-        $this->assertFalse($fm->isUniqueKey());
-        $this->assertFalse($fm->isUnsigned());
-        $this->assertFalse($fm->isZerofill());
-        $this->assertFalse($fm->isSet());
-        $this->assertFalse($fm->isNotNull());
-        $this->assertFalse($fm->isPrimaryKey());
-        $this->assertFalse($fm->isMultipleKey());
-        $this->assertFalse($fm->isBlob());
+        self::assertTrue($fm->isBinary());
+        self::assertFalse($fm->isEnum());
+        self::assertFalse($fm->isUniqueKey());
+        self::assertFalse($fm->isUnsigned());
+        self::assertFalse($fm->isZerofill());
+        self::assertFalse($fm->isSet());
+        self::assertFalse($fm->isNotNull());
+        self::assertFalse($fm->isPrimaryKey());
+        self::assertFalse($fm->isMultipleKey());
+        self::assertFalse($fm->isBlob());
     }
 
     public function testIsNumeric(): void
     {
         $fm = FieldHelper::fromArray(['type' => MYSQLI_TYPE_INT24, 'flags' => MYSQLI_NUM_FLAG]);
-        $this->assertSame('int', $fm->getMappedType());
-        $this->assertFalse($fm->isBinary());
-        $this->assertFalse($fm->isEnum());
-        $this->assertFalse($fm->isUniqueKey());
-        $this->assertFalse($fm->isUnsigned());
-        $this->assertFalse($fm->isZerofill());
-        $this->assertFalse($fm->isSet());
-        $this->assertFalse($fm->isNotNull());
-        $this->assertFalse($fm->isPrimaryKey());
-        $this->assertFalse($fm->isMultipleKey());
-        $this->assertTrue($fm->isNumeric());
-        $this->assertFalse($fm->isBlob());
+        self::assertSame('int', $fm->getMappedType());
+        self::assertFalse($fm->isBinary());
+        self::assertFalse($fm->isEnum());
+        self::assertFalse($fm->isUniqueKey());
+        self::assertFalse($fm->isUnsigned());
+        self::assertFalse($fm->isZerofill());
+        self::assertFalse($fm->isSet());
+        self::assertFalse($fm->isNotNull());
+        self::assertFalse($fm->isPrimaryKey());
+        self::assertFalse($fm->isMultipleKey());
+        self::assertTrue($fm->isNumeric());
+        self::assertFalse($fm->isBlob());
     }
 
     public function testIsBlob(): void
     {
         $fm = FieldHelper::fromArray(['type' => -1, 'flags' => MYSQLI_BLOB_FLAG]);
-        $this->assertSame('', $fm->getMappedType());
-        $this->assertFalse($fm->isBinary());
-        $this->assertFalse($fm->isEnum());
-        $this->assertFalse($fm->isUniqueKey());
-        $this->assertFalse($fm->isUnsigned());
-        $this->assertFalse($fm->isZerofill());
-        $this->assertFalse($fm->isSet());
-        $this->assertFalse($fm->isNotNull());
-        $this->assertFalse($fm->isPrimaryKey());
-        $this->assertFalse($fm->isMultipleKey());
-        $this->assertTrue($fm->isBlob());
+        self::assertSame('', $fm->getMappedType());
+        self::assertFalse($fm->isBinary());
+        self::assertFalse($fm->isEnum());
+        self::assertFalse($fm->isUniqueKey());
+        self::assertFalse($fm->isUnsigned());
+        self::assertFalse($fm->isZerofill());
+        self::assertFalse($fm->isSet());
+        self::assertFalse($fm->isNotNull());
+        self::assertFalse($fm->isPrimaryKey());
+        self::assertFalse($fm->isMultipleKey());
+        self::assertTrue($fm->isBlob());
     }
 
     public function testIsNumericFloat(): void
     {
         $fm = FieldHelper::fromArray(['type' => MYSQLI_TYPE_FLOAT, 'flags' => MYSQLI_NUM_FLAG]);
-        $this->assertSame('real', $fm->getMappedType());
-        $this->assertFalse($fm->isBinary());
-        $this->assertFalse($fm->isEnum());
-        $this->assertFalse($fm->isUniqueKey());
-        $this->assertFalse($fm->isUnsigned());
-        $this->assertFalse($fm->isZerofill());
-        $this->assertFalse($fm->isSet());
-        $this->assertFalse($fm->isNotNull());
-        $this->assertFalse($fm->isPrimaryKey());
-        $this->assertFalse($fm->isMultipleKey());
-        $this->assertTrue($fm->isNumeric());
-        $this->assertFalse($fm->isBlob());
+        self::assertSame('real', $fm->getMappedType());
+        self::assertFalse($fm->isBinary());
+        self::assertFalse($fm->isEnum());
+        self::assertFalse($fm->isUniqueKey());
+        self::assertFalse($fm->isUnsigned());
+        self::assertFalse($fm->isZerofill());
+        self::assertFalse($fm->isSet());
+        self::assertFalse($fm->isNotNull());
+        self::assertFalse($fm->isPrimaryKey());
+        self::assertFalse($fm->isMultipleKey());
+        self::assertTrue($fm->isNumeric());
+        self::assertFalse($fm->isBlob());
     }
 }
diff --git a/tests/classes/FileListingTest.php b/tests/classes/FileListingTest.php
index bac5ddb42e..3ff501abce 100644
--- a/tests/classes/FileListingTest.php
+++ b/tests/classes/FileListingTest.php
@@ -29,7 +29,7 @@ class FileListingTest extends AbstractTestCase
 
     public function testGetDirContent(): void
     {
-        $this->assertFalse($this->fileListing->getDirContent('nonexistent directory'));
+        self::assertFalse($this->fileListing->getDirContent('nonexistent directory'));
 
         $fixturesDir = TEST_PATH . 'tests/classes/_data/file_listing';
 
@@ -38,7 +38,7 @@ class FileListingTest extends AbstractTestCase
             $dirContent = [];
         }
 
-        $this->assertSame(
+        self::assertSame(
             ['one.txt', 'two.md'],
             array_values($dirContent),
         );
@@ -48,7 +48,7 @@ class FileListingTest extends AbstractTestCase
     {
         $fixturesDir = TEST_PATH . 'tests/classes/_data/file_listing';
 
-        $this->assertFalse($this->fileListing->getFileSelectOptions('nonexistent directory'));
+        self::assertFalse($this->fileListing->getFileSelectOptions('nonexistent directory'));
 
         $expectedHtmlWithoutActive = '  <option value="one.txt">' . "\n"
             . '    one.txt' . "\n"
@@ -57,7 +57,7 @@ class FileListingTest extends AbstractTestCase
             . '    two.md' . "\n"
             . '  </option>' . "\n";
 
-        $this->assertSame(
+        self::assertSame(
             $expectedHtmlWithoutActive,
             $this->fileListing->getFileSelectOptions($fixturesDir),
         );
@@ -69,7 +69,7 @@ class FileListingTest extends AbstractTestCase
             . '    two.md' . "\n"
             . '  </option>' . "\n";
 
-        $this->assertSame(
+        self::assertSame(
             $expectedHtmlWithActive,
             $this->fileListing->getFileSelectOptions($fixturesDir, '', 'two.md'),
         );
@@ -78,7 +78,7 @@ class FileListingTest extends AbstractTestCase
             . '    one.txt' . "\n"
             . '  </option>' . "\n";
 
-        $this->assertSame(
+        self::assertSame(
             $expectedFilteredHtml,
             $this->fileListing->getFileSelectOptions($fixturesDir, '/.*\.txt/'),
         );
@@ -90,7 +90,7 @@ class FileListingTest extends AbstractTestCase
         $config->settings['ZipDump'] = false;
         $config->settings['GZipDump'] = false;
         $config->settings['BZipDump'] = false;
-        $this->assertEmpty($this->fileListing->supportedDecompressions());
+        self::assertEmpty($this->fileListing->supportedDecompressions());
     }
 
     #[RequiresPhpExtension('bz2')]
@@ -100,7 +100,7 @@ class FileListingTest extends AbstractTestCase
         $config->settings['ZipDump'] = true;
         $config->settings['GZipDump'] = true;
         $config->settings['BZipDump'] = true;
-        $this->assertEquals('gz|bz2|zip', $this->fileListing->supportedDecompressions());
+        self::assertEquals('gz|bz2|zip', $this->fileListing->supportedDecompressions());
     }
 
     public function testSupportedDecompressionsPartial(): void
@@ -115,6 +115,6 @@ class FileListingTest extends AbstractTestCase
         }
 
         $extensionString .= '|zip';
-        $this->assertEquals($extensionString, $this->fileListing->supportedDecompressions());
+        self::assertEquals($extensionString, $this->fileListing->supportedDecompressions());
     }
 }
diff --git a/tests/classes/FileTest.php b/tests/classes/FileTest.php
index a3bf206ba2..2513261e1d 100644
--- a/tests/classes/FileTest.php
+++ b/tests/classes/FileTest.php
@@ -35,7 +35,7 @@ class FileTest extends AbstractTestCase
     public function testMIME(string $file, string $mime): void
     {
         $arr = new File($file);
-        $this->assertEquals($mime, $arr->getCompression());
+        self::assertEquals($mime, $arr->getCompression());
     }
 
     /**
@@ -48,7 +48,7 @@ class FileTest extends AbstractTestCase
     {
         $data = '0x' . bin2hex((string) file_get_contents($file));
         $file = new File($file);
-        $this->assertEquals($data, $file->getContent());
+        self::assertEquals($data, $file->getContent());
     }
 
     /**
@@ -64,7 +64,7 @@ class FileTest extends AbstractTestCase
         $file = new File($file);
         $file->setDecompressContent(true);
         $file->open();
-        $this->assertEquals("TEST FILE\n", $file->read(100));
+        self::assertEquals("TEST FILE\n", $file->read(100));
         $file->close();
     }
 
diff --git a/tests/classes/FlashMessagesTest.php b/tests/classes/FlashMessagesTest.php
index f6f9668db9..ba45970c14 100644
--- a/tests/classes/FlashMessagesTest.php
+++ b/tests/classes/FlashMessagesTest.php
@@ -15,10 +15,10 @@ class FlashMessagesTest extends AbstractTestCase
 
     public function testConstructor(): void
     {
-        $this->assertArrayNotHasKey(self::STORAGE_KEY, $_SESSION);
+        self::assertArrayNotHasKey(self::STORAGE_KEY, $_SESSION);
         $flash = new FlashMessages();
-        $this->assertIsArray($_SESSION[self::STORAGE_KEY]);
-        $this->assertSame([], $flash->getMessages());
+        self::assertIsArray($_SESSION[self::STORAGE_KEY]);
+        self::assertSame([], $flash->getMessages());
     }
 
     public function testConstructorSessionNotFound(): void
@@ -32,11 +32,11 @@ class FlashMessagesTest extends AbstractTestCase
     public function testAddMessage(): void
     {
         $flash = new FlashMessages();
-        $this->assertArrayNotHasKey('error', $_SESSION[self::STORAGE_KEY]);
+        self::assertArrayNotHasKey('error', $_SESSION[self::STORAGE_KEY]);
         $flash->addMessage('error', 'Error');
-        $this->assertArrayHasKey('error', $_SESSION[self::STORAGE_KEY]);
-        $this->assertIsArray($_SESSION[self::STORAGE_KEY]['error']);
-        $this->assertEquals(['Error'], $_SESSION[self::STORAGE_KEY]['error']);
+        self::assertArrayHasKey('error', $_SESSION[self::STORAGE_KEY]);
+        self::assertIsArray($_SESSION[self::STORAGE_KEY]['error']);
+        self::assertEquals(['Error'], $_SESSION[self::STORAGE_KEY]['error']);
     }
 
     public function testGetMessage(): void
@@ -44,9 +44,9 @@ class FlashMessagesTest extends AbstractTestCase
         $_SESSION[self::STORAGE_KEY] = ['warning' => ['Warning']];
         $flash = new FlashMessages();
         $message = $flash->getMessage('error');
-        $this->assertNull($message);
+        self::assertNull($message);
         $message = $flash->getMessage('warning');
-        $this->assertEquals(['Warning'], $message);
+        self::assertEquals(['Warning'], $message);
     }
 
     public function testGetMessages(): void
@@ -55,7 +55,7 @@ class FlashMessagesTest extends AbstractTestCase
         $flash = new FlashMessages();
         $flash->addMessage('notice', 'Notice');
         $messages = $flash->getMessages();
-        $this->assertEquals(
+        self::assertEquals(
             ['error' => ['Error1', 'Error2'], 'warning' => ['Warning']],
             $messages,
         );
diff --git a/tests/classes/FontTest.php b/tests/classes/FontTest.php
index fb398203fd..b5d030b149 100644
--- a/tests/classes/FontTest.php
+++ b/tests/classes/FontTest.php
@@ -28,115 +28,115 @@ class FontTest extends AbstractTestCase
     public function testGetStringWidth(): void
     {
         // empty string
-        $this->assertEquals(
+        self::assertEquals(
             0,
             $this->font->getStringWidth('', 'arial', 10),
         );
 
         // empty string
-        $this->assertEquals(
+        self::assertEquals(
             3,
             $this->font->getStringWidth(' ', 'arial', 10),
         );
 
         // string "a"
-        $this->assertEquals(
+        self::assertEquals(
             6,
             $this->font->getStringWidth('a', 'arial', 10),
         );
 
         // string "aa"
-        $this->assertEquals(
+        self::assertEquals(
             12,
             $this->font->getStringWidth('aa', 'arial', 10),
         );
 
         // string "i"
-        $this->assertEquals(
+        self::assertEquals(
             3,
             $this->font->getStringWidth('i', 'arial', 10),
         );
 
         // string "f"
-        $this->assertEquals(
+        self::assertEquals(
             3,
             $this->font->getStringWidth('f', 'arial', 10),
         );
 
         // string "t"
-        $this->assertEquals(
+        self::assertEquals(
             3,
             $this->font->getStringWidth('t', 'arial', 10),
         );
 
         // string "if"
-        $this->assertEquals(
+        self::assertEquals(
             5,
             $this->font->getStringWidth('if', 'arial', 10),
         );
 
         // string "it"
-        $this->assertEquals(
+        self::assertEquals(
             6,
             $this->font->getStringWidth('it', 'arial', 10),
         );
 
         // string "r"
-        $this->assertEquals(
+        self::assertEquals(
             4,
             $this->font->getStringWidth('r', 'arial', 10),
         );
 
         // string "1"
-        $this->assertEquals(
+        self::assertEquals(
             5,
             $this->font->getStringWidth('1', 'arial', 10),
         );
 
         // string "c"
-        $this->assertEquals(
+        self::assertEquals(
             5,
             $this->font->getStringWidth('c', 'arial', 10),
         );
 
         // string "F"
-        $this->assertEquals(
+        self::assertEquals(
             7,
             $this->font->getStringWidth('F', 'arial', 10),
         );
 
         // string "A"
-        $this->assertEquals(
+        self::assertEquals(
             7,
             $this->font->getStringWidth('A', 'arial', 10),
         );
 
         // string "w"
-        $this->assertEquals(
+        self::assertEquals(
             8,
             $this->font->getStringWidth('w', 'arial', 10),
         );
 
         // string "G"
-        $this->assertEquals(
+        self::assertEquals(
             8,
             $this->font->getStringWidth('G', 'arial', 10),
         );
 
         // string "m"
-        $this->assertEquals(
+        self::assertEquals(
             9,
             $this->font->getStringWidth('m', 'arial', 10),
         );
 
         // string "W"
-        $this->assertEquals(
+        self::assertEquals(
             10,
             $this->font->getStringWidth('W', 'arial', 10),
         );
 
         // string "$"
-        $this->assertEquals(
+        self::assertEquals(
             3,
             $this->font->getStringWidth('$', 'arial', 10),
         );
@@ -148,25 +148,25 @@ class FontTest extends AbstractTestCase
     public function testGetStringWidthFont(): void
     {
         // string "phpMyAdmin", with Arial 10
-        $this->assertEquals(
+        self::assertEquals(
             59,
             $this->font->getStringWidth('phpMyAdmin', 'arial', 10),
         );
 
         // string "phpMyAdmin", with No font
-        $this->assertEquals(
+        self::assertEquals(
             59,
             $this->font->getStringWidth('phpMyAdmin', '', 10),
         );
 
         // string "phpMyAdmin", with Times 10
-        $this->assertEquals(
+        self::assertEquals(
             55,
             $this->font->getStringWidth('phpMyAdmin', 'times', 10),
         );
 
         // string "phpMyAdmin", with Broadway 10
-        $this->assertEquals(
+        self::assertEquals(
             73,
             $this->font->getStringWidth('phpMyAdmin', 'broadway', 10),
         );
@@ -178,25 +178,25 @@ class FontTest extends AbstractTestCase
     public function testGetStringWidthSize(): void
     {
         // string "phpMyAdmin", with font size 0
-        $this->assertEquals(
+        self::assertEquals(
             0,
             $this->font->getStringWidth('phpMyAdmin', 'arial', 0),
         );
 
         // string "phpMyAdmin", with Arial 10
-        $this->assertEquals(
+        self::assertEquals(
             59,
             $this->font->getStringWidth('phpMyAdmin', 'arial', 10),
         );
 
         // string "phpMyAdmin", with Arial 11
-        $this->assertEquals(
+        self::assertEquals(
             65,
             $this->font->getStringWidth('phpMyAdmin', 'arial', 11),
         );
 
         // string "phpMyAdmin", with Arial 20
-        $this->assertEquals(
+        self::assertEquals(
             118,
             $this->font->getStringWidth('phpMyAdmin', 'arial', 20),
         );
@@ -208,14 +208,14 @@ class FontTest extends AbstractTestCase
     public function testGetStringWidthCharLists(): void
     {
         // string "a", with invalid charlist (= array without proper structure)
-        $this->assertEquals(
+        self::assertEquals(
             6,
             $this->font->getStringWidth('a', 'arial', 10, ['list']),
         );
 
         // string "a", with invalid charlist (= array without proper structure :
         // modifier is missing
-        $this->assertEquals(
+        self::assertEquals(
             6,
             $this->font->getStringWidth(
                 'a',
@@ -227,7 +227,7 @@ class FontTest extends AbstractTestCase
 
         // string "a", with invalid charlist (= array without proper structure :
         // chars is missing
-        $this->assertEquals(
+        self::assertEquals(
             6,
             $this->font->getStringWidth(
                 'a',
@@ -239,7 +239,7 @@ class FontTest extends AbstractTestCase
 
         // string "a", with invalid charlist (= array without proper structure :
         // chars is not an array
-        $this->assertEquals(
+        self::assertEquals(
             6,
             $this->font->getStringWidth(
                 'a',
@@ -250,7 +250,7 @@ class FontTest extends AbstractTestCase
         );
 
         // string "a", with valid charlist
-        $this->assertEquals(
+        self::assertEquals(
             7,
             $this->font->getStringWidth(
                 'a',
diff --git a/tests/classes/FooterTest.php b/tests/classes/FooterTest.php
index 41c25cf640..dc8939aeb1 100644
--- a/tests/classes/FooterTest.php
+++ b/tests/classes/FooterTest.php
@@ -74,7 +74,7 @@ class FooterTest extends AbstractTestCase
             ['count' => 1, 'time' => 2.5, 'query' => 'SELECT * FROM `db` WHERE 1'],
         ];
 
-        $this->assertEquals(
+        self::assertEquals(
             '{"queries":[{"count":1,"time":0.2,"query":"SELECT * FROM `pma_bookmark` WHERE 1"},'
             . '{"count":1,"time":2.5,"query":"SELECT * FROM `db` WHERE 1"}]}',
             $this->object->getDebugMessage(),
@@ -92,7 +92,7 @@ class FooterTest extends AbstractTestCase
         $object->child->parent = $object;
 
         $this->callFunction($this->object, Footer::class, 'removeRecursion', [&$object]);
-        $this->assertEquals(
+        self::assertEquals(
             '{"child":{"parent":"***RECURSION***"},"childIterator":"***ITERATOR***"}',
             json_encode($object),
         );
@@ -105,7 +105,7 @@ class FooterTest extends AbstractTestCase
     {
         $footer = new Footer(new Template());
         $footer->disable();
-        $this->assertEquals(
+        self::assertEquals(
             '',
             $footer->getDisplay(),
         );
@@ -116,7 +116,7 @@ class FooterTest extends AbstractTestCase
         $template = new Template();
         $footer = new Footer($template);
         $footer->setAjax(true);
-        $this->assertEquals(
+        self::assertEquals(
             $template->render('modals/function_confirm') . "\n"
             . $template->render('modals/add_index') . "\n"
             . $template->render('modals/page_settings') . "\n",
@@ -130,7 +130,7 @@ class FooterTest extends AbstractTestCase
     public function testGetScripts(): void
     {
         $footer = new Footer(new Template());
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             '<script data-cfasync="false">',
             $footer->getScripts()->getDisplay(),
         );
@@ -143,7 +143,7 @@ class FooterTest extends AbstractTestCase
     public function testDisplay(): void
     {
         $footer = new Footer(new Template());
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             'Open new phpMyAdmin window',
             $footer->getDisplay(),
         );
@@ -157,7 +157,7 @@ class FooterTest extends AbstractTestCase
         $template = new Template();
         $footer = new Footer($template);
         $footer->setMinimal();
-        $this->assertEquals(
+        self::assertEquals(
             $template->render('modals/function_confirm') . "\n"
             . $template->render('modals/add_index') . "\n"
             . $template->render('modals/page_settings')
@@ -171,10 +171,10 @@ class FooterTest extends AbstractTestCase
         $isAjax = new ReflectionProperty(Footer::class, 'isAjax');
         $footer = new Footer(new Template());
 
-        $this->assertFalse($isAjax->getValue($footer));
+        self::assertFalse($isAjax->getValue($footer));
         $footer->setAjax(true);
-        $this->assertTrue($isAjax->getValue($footer));
+        self::assertTrue($isAjax->getValue($footer));
         $footer->setAjax(false);
-        $this->assertFalse($isAjax->getValue($footer));
+        self::assertFalse($isAjax->getValue($footer));
     }
 }
diff --git a/tests/classes/Gis/Ds/PolygonTest.php b/tests/classes/Gis/Ds/PolygonTest.php
index bc9b6478e8..4bb57b5113 100644
--- a/tests/classes/Gis/Ds/PolygonTest.php
+++ b/tests/classes/Gis/Ds/PolygonTest.php
@@ -48,7 +48,7 @@ class PolygonTest extends AbstractTestCase
     #[DataProvider('providerForTestArea')]
     public function testArea(Polygon $ring, float $area): void
     {
-        $this->assertEquals($area, $ring->area());
+        self::assertEquals($area, $ring->area());
     }
 
     /**
@@ -95,7 +95,7 @@ class PolygonTest extends AbstractTestCase
     #[DataProvider('providerForTestIsPointInsidePolygon')]
     public function testIsPointInsidePolygon(Point $point, Polygon $polygon, bool $isInside): void
     {
-        $this->assertEquals($isInside, $point->isInsidePolygon($polygon));
+        self::assertEquals($isInside, $point->isInsidePolygon($polygon));
     }
 
     /**
@@ -133,8 +133,8 @@ class PolygonTest extends AbstractTestCase
     public function testGetPointOnSurface(Polygon $ring): void
     {
         $point = $ring->getPointOnSurface();
-        $this->assertInstanceOf(Point::class, $point);
-        $this->assertTrue($point->isInsidePolygon($ring));
+        self::assertInstanceOf(Point::class, $point);
+        self::assertTrue($point->isInsidePolygon($ring));
     }
 
     /**
@@ -159,7 +159,7 @@ class PolygonTest extends AbstractTestCase
     #[DataProvider('providerForIsOuterRing')]
     public function testIsOuterRing(Polygon $ring): void
     {
-        $this->assertTrue($ring->isOuterRing());
+        self::assertTrue($ring->isOuterRing());
     }
 
     /**
diff --git a/tests/classes/Gis/GisFactoryTest.php b/tests/classes/Gis/GisFactoryTest.php
index 3d7108e367..55fc38af9c 100644
--- a/tests/classes/Gis/GisFactoryTest.php
+++ b/tests/classes/Gis/GisFactoryTest.php
@@ -30,9 +30,9 @@ class GisFactoryTest extends AbstractTestCase
     {
         $geometry = GisFactory::fromType($type);
         if ($classString === null) {
-            $this->assertNull($geometry);
+            self::assertNull($geometry);
         } else {
-            $this->assertInstanceOf($classString, $geometry);
+            self::assertInstanceOf($classString, $geometry);
         }
     }
 
@@ -66,9 +66,9 @@ class GisFactoryTest extends AbstractTestCase
     {
         $geometry = GisFactory::fromWkt($wkt);
         if ($classString === null) {
-            $this->assertNull($geometry);
+            self::assertNull($geometry);
         } else {
-            $this->assertInstanceOf($classString, $geometry);
+            self::assertInstanceOf($classString, $geometry);
         }
     }
 
diff --git a/tests/classes/Gis/GisGeometryCollectionTest.php b/tests/classes/Gis/GisGeometryCollectionTest.php
index be053051f7..e0a4e46375 100644
--- a/tests/classes/Gis/GisGeometryCollectionTest.php
+++ b/tests/classes/Gis/GisGeometryCollectionTest.php
@@ -45,7 +45,7 @@ class GisGeometryCollectionTest extends GisGeomTestCase
     public function testGetExtent(string $spatial, Extent $extent): void
     {
         $object = GisGeometryCollection::singleton();
-        $this->assertEquals($extent, $object->getExtent($spatial));
+        self::assertEquals($extent, $object->getExtent($spatial));
     }
 
     /**
@@ -60,7 +60,7 @@ class GisGeometryCollectionTest extends GisGeomTestCase
     public function testGenerateWkt(array $gisData, int $index, string $empty, string $output): void
     {
         $object = GisGeometryCollection::singleton();
-        $this->assertEquals($output, $object->generateWkt($gisData, $index, $empty));
+        self::assertEquals($output, $object->generateWkt($gisData, $index, $empty));
     }
 
     /**
@@ -158,7 +158,7 @@ class GisGeometryCollectionTest extends GisGeomTestCase
     public function testGenerateParams(string $wkt, array $params): void
     {
         $object = GisGeometryCollection::singleton();
-        $this->assertEquals($params, $object->generateParams($wkt));
+        self::assertEquals($params, $object->generateParams($wkt));
     }
 
     /**
@@ -282,7 +282,7 @@ class GisGeometryCollectionTest extends GisGeomTestCase
     {
         $object = GisGeometryCollection::singleton();
         $image = ImageWrapper::create(200, 124, ['red' => 229, 'green' => 229, 'blue' => 229]);
-        $this->assertNotNull($image);
+        self::assertNotNull($image);
         $object->prepareRowAsPng(
             'GEOMETRYCOLLECTION(POLYGON((35 10,10 20,15 40,45 45,35 10),(20 30,35 32,30 20,20 30)),'
             . 'LINESTRING(5 30,4 4))',
@@ -291,13 +291,13 @@ class GisGeometryCollectionTest extends GisGeomTestCase
             new ScaleData(offsetX: -19, offsetY: -3, scale: 2.29, height: 124),
             $image,
         );
-        $this->assertEquals(200, $image->width());
-        $this->assertEquals(124, $image->height());
+        self::assertEquals(200, $image->width());
+        self::assertEquals(124, $image->height());
 
         $fileExpected = $this->testDir . '/geometrycollection-expected.png';
         $fileActual = $this->testDir . '/geometrycollection-actual.png';
-        $this->assertTrue($image->png($fileActual));
-        $this->assertFileEquals($fileExpected, $fileActual);
+        self::assertTrue($image->png($fileActual));
+        self::assertFileEquals($fileExpected, $fileActual);
     }
 
     /**
@@ -321,7 +321,7 @@ class GisGeometryCollectionTest extends GisGeomTestCase
         $object->prepareRowAsPdf($spatial, $label, $color, $scaleData, $pdf);
 
         $fileExpected = $this->testDir . '/geometrycollection-expected.pdf';
-        $this->assertStringEqualsFile($fileExpected, $pdf->Output(dest: 'S'));
+        self::assertStringEqualsFile($fileExpected, $pdf->Output(dest: 'S'));
     }
 
     /**
@@ -363,7 +363,7 @@ class GisGeometryCollectionTest extends GisGeomTestCase
     ): void {
         $object = GisGeometryCollection::singleton();
         $svg = $object->prepareRowAsSvg($spatial, $label, $color, $scaleData);
-        $this->assertEquals($output, $svg);
+        self::assertEquals($output, $svg);
     }
 
     /**
@@ -405,7 +405,7 @@ class GisGeometryCollectionTest extends GisGeomTestCase
         string $output,
     ): void {
         $object = GisGeometryCollection::singleton();
-        $this->assertEquals(
+        self::assertEquals(
             $output,
             $object->prepareRowAsOl(
                 $spatial,
diff --git a/tests/classes/Gis/GisGeometryTest.php b/tests/classes/Gis/GisGeometryTest.php
index 370f725a5a..e206465784 100644
--- a/tests/classes/Gis/GisGeometryTest.php
+++ b/tests/classes/Gis/GisGeometryTest.php
@@ -54,7 +54,7 @@ class GisGeometryTest extends AbstractTestCase
             'getCoordinatesExtent',
             [$pointSet],
         );
-        $this->assertEquals($expected, $extent);
+        self::assertEquals($expected, $extent);
     }
 
     /**
@@ -85,7 +85,7 @@ class GisGeometryTest extends AbstractTestCase
     #[DataProvider('providerForTestParseWktAndSrid')]
     public function testParseWktAndSrid(string $value, array $output): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             $output,
             $this->callFunction(
                 $this->object,
@@ -137,7 +137,7 @@ class GisGeometryTest extends AbstractTestCase
             'extractPointsInternal',
             [$pointSet, $scaleData, $linear],
         );
-        $this->assertEquals($output, $points);
+        self::assertEquals($output, $points);
     }
 
     /**
diff --git a/tests/classes/Gis/GisLineStringTest.php b/tests/classes/Gis/GisLineStringTest.php
index c9a9bc01df..0fe5b950c0 100644
--- a/tests/classes/Gis/GisLineStringTest.php
+++ b/tests/classes/Gis/GisLineStringTest.php
@@ -71,7 +71,7 @@ class GisLineStringTest extends GisGeomTestCase
     public function testGenerateWkt(array $gisData, int $index, string $empty, string $output): void
     {
         $object = GisLineString::singleton();
-        $this->assertEquals($output, $object->generateWkt($gisData, $index, $empty));
+        self::assertEquals($output, $object->generateWkt($gisData, $index, $empty));
     }
 
     /**
@@ -84,7 +84,7 @@ class GisLineStringTest extends GisGeomTestCase
     public function testGenerateParams(string $wkt, array $params): void
     {
         $object = GisLineString::singleton();
-        $this->assertEquals($params, $object->generateParams($wkt));
+        self::assertEquals($params, $object->generateParams($wkt));
     }
 
     /**
@@ -136,7 +136,7 @@ class GisLineStringTest extends GisGeomTestCase
     public function testGetExtent(string $spatial, Extent $extent): void
     {
         $object = GisLineString::singleton();
-        $this->assertEquals($extent, $object->getExtent($spatial));
+        self::assertEquals($extent, $object->getExtent($spatial));
     }
 
     /**
@@ -156,7 +156,7 @@ class GisLineStringTest extends GisGeomTestCase
     {
         $object = GisLineString::singleton();
         $image = ImageWrapper::create(200, 124, ['red' => 229, 'green' => 229, 'blue' => 229]);
-        $this->assertNotNull($image);
+        self::assertNotNull($image);
         $object->prepareRowAsPng(
             'LINESTRING(12 35,48 75,69 23,25 45,14 53,35 78)',
             'image',
@@ -164,13 +164,13 @@ class GisLineStringTest extends GisGeomTestCase
             new ScaleData(offsetX: -18, offsetY: 14, scale: 1.71, height: 124),
             $image,
         );
-        $this->assertEquals(200, $image->width());
-        $this->assertEquals(124, $image->height());
+        self::assertEquals(200, $image->width());
+        self::assertEquals(124, $image->height());
 
         $fileExpected = $this->testDir . '/linestring-expected.png';
         $fileActual = $this->testDir . '/linestring-actual.png';
-        $this->assertTrue($image->png($fileActual));
-        $this->assertFileEquals($fileExpected, $fileActual);
+        self::assertTrue($image->png($fileActual));
+        self::assertFileEquals($fileExpected, $fileActual);
     }
 
     /**
@@ -193,7 +193,7 @@ class GisLineStringTest extends GisGeomTestCase
         $object->prepareRowAsPdf($spatial, $label, $color, $scaleData, $pdf);
 
         $fileExpected = $this->testDir . '/linestring-expected.pdf';
-        $this->assertStringEqualsFile($fileExpected, $pdf->Output(dest: 'S'));
+        self::assertStringEqualsFile($fileExpected, $pdf->Output(dest: 'S'));
     }
 
     /**
@@ -234,7 +234,7 @@ class GisLineStringTest extends GisGeomTestCase
     ): void {
         $object = GisLineString::singleton();
         $svg = $object->prepareRowAsSvg($spatial, $label, $color, $scaleData);
-        $this->assertEquals($output, $svg);
+        self::assertEquals($output, $svg);
     }
 
     /**
@@ -276,7 +276,7 @@ class GisLineStringTest extends GisGeomTestCase
     ): void {
         $object = GisLineString::singleton();
         $ol = $object->prepareRowAsOl($spatial, $srid, $label, $color);
-        $this->assertEquals($output, $ol);
+        self::assertEquals($output, $ol);
     }
 
     /**
diff --git a/tests/classes/Gis/GisMultiLineStringTest.php b/tests/classes/Gis/GisMultiLineStringTest.php
index 67a5635d51..6ab619184c 100644
--- a/tests/classes/Gis/GisMultiLineStringTest.php
+++ b/tests/classes/Gis/GisMultiLineStringTest.php
@@ -71,7 +71,7 @@ class GisMultiLineStringTest extends GisGeomTestCase
     public function testGenerateWkt(array $gisData, int $index, string $empty, string $output): void
     {
         $object = GisMultiLineString::singleton();
-        $this->assertEquals($output, $object->generateWkt($gisData, $index, $empty));
+        self::assertEquals($output, $object->generateWkt($gisData, $index, $empty));
     }
 
     /**
@@ -88,7 +88,7 @@ class GisMultiLineStringTest extends GisGeomTestCase
         ];
 
         $object = GisMultiLineString::singleton();
-        $this->assertEquals(
+        self::assertEquals(
             'MULTILINESTRING((5.02 8.45,6.14 0.15),(1.23 4.25,9.15 0.47))',
             $object->getShape($rowData),
         );
@@ -104,7 +104,7 @@ class GisMultiLineStringTest extends GisGeomTestCase
     public function testGenerateParams(string $wkt, array $params): void
     {
         $object = GisMultiLineString::singleton();
-        $this->assertEquals($params, $object->generateParams($wkt));
+        self::assertEquals($params, $object->generateParams($wkt));
     }
 
     /**
@@ -141,7 +141,7 @@ class GisMultiLineStringTest extends GisGeomTestCase
     public function testGetExtent(string $spatial, Extent $extent): void
     {
         $object = GisMultiLineString::singleton();
-        $this->assertEquals($extent, $object->getExtent($spatial));
+        self::assertEquals($extent, $object->getExtent($spatial));
     }
 
     /**
@@ -164,7 +164,7 @@ class GisMultiLineStringTest extends GisGeomTestCase
     {
         $object = GisMultiLineString::singleton();
         $image = ImageWrapper::create(200, 124, ['red' => 229, 'green' => 229, 'blue' => 229]);
-        $this->assertNotNull($image);
+        self::assertNotNull($image);
         $object->prepareRowAsPng(
             'MULTILINESTRING((36 14,47 23,62 75),(36 10,17 23,178 53))',
             'image',
@@ -172,13 +172,13 @@ class GisMultiLineStringTest extends GisGeomTestCase
             new ScaleData(offsetX: 3, offsetY: -16, scale: 1.06, height: 124),
             $image,
         );
-        $this->assertEquals(200, $image->width());
-        $this->assertEquals(124, $image->height());
+        self::assertEquals(200, $image->width());
+        self::assertEquals(124, $image->height());
 
         $fileExpected = $this->testDir . '/multilinestring-expected.png';
         $fileActual = $this->testDir . '/multilinestring-actual.png';
-        $this->assertTrue($image->png($fileActual));
-        $this->assertFileEquals($fileExpected, $fileActual);
+        self::assertTrue($image->png($fileActual));
+        self::assertFileEquals($fileExpected, $fileActual);
     }
 
     /**
@@ -201,7 +201,7 @@ class GisMultiLineStringTest extends GisGeomTestCase
         $object->prepareRowAsPdf($spatial, $label, $color, $scaleData, $pdf);
 
         $fileExpected = $this->testDir . '/multilinestring-expected.pdf';
-        $this->assertStringEqualsFile($fileExpected, $pdf->Output(dest: 'S'));
+        self::assertStringEqualsFile($fileExpected, $pdf->Output(dest: 'S'));
     }
 
     /**
@@ -242,7 +242,7 @@ class GisMultiLineStringTest extends GisGeomTestCase
     ): void {
         $object = GisMultiLineString::singleton();
         $svg = $object->prepareRowAsSvg($spatial, $label, $color, $scaleData);
-        $this->assertEquals($output, $svg);
+        self::assertEquals($output, $svg);
     }
 
     /**
@@ -286,7 +286,7 @@ class GisMultiLineStringTest extends GisGeomTestCase
     ): void {
         $object = GisMultiLineString::singleton();
         $ol = $object->prepareRowAsOl($spatial, $srid, $label, $color);
-        $this->assertEquals($output, $ol);
+        self::assertEquals($output, $ol);
     }
 
     /**
diff --git a/tests/classes/Gis/GisMultiPointTest.php b/tests/classes/Gis/GisMultiPointTest.php
index bb3fec65a4..1f0d6a2996 100644
--- a/tests/classes/Gis/GisMultiPointTest.php
+++ b/tests/classes/Gis/GisMultiPointTest.php
@@ -60,7 +60,7 @@ class GisMultiPointTest extends GisGeomTestCase
     public function testGenerateWkt(array $gisData, int $index, string $empty, string $output): void
     {
         $object = GisMultiPoint::singleton();
-        $this->assertEquals($output, $object->generateWkt($gisData, $index, $empty));
+        self::assertEquals($output, $object->generateWkt($gisData, $index, $empty));
     }
 
     /**
@@ -71,7 +71,7 @@ class GisMultiPointTest extends GisGeomTestCase
         $gisData = ['numpoints' => 2, 'points' => [0 => ['x' => 5.02, 'y' => 8.45], 1 => ['x' => 6.14, 'y' => 0.15]]];
 
         $object = GisMultiPoint::singleton();
-        $this->assertEquals('MULTIPOINT(5.02 8.45,6.14 0.15)', $object->getShape($gisData));
+        self::assertEquals('MULTIPOINT(5.02 8.45,6.14 0.15)', $object->getShape($gisData));
     }
 
     /**
@@ -84,7 +84,7 @@ class GisMultiPointTest extends GisGeomTestCase
     public function testGenerateParams(string $wkt, array $params): void
     {
         $object = GisMultiPoint::singleton();
-        $this->assertEquals($params, $object->generateParams($wkt));
+        self::assertEquals($params, $object->generateParams($wkt));
     }
 
     /**
@@ -121,7 +121,7 @@ class GisMultiPointTest extends GisGeomTestCase
     public function testGetExtent(string $spatial, Extent $extent): void
     {
         $object = GisMultiPoint::singleton();
-        $this->assertEquals($extent, $object->getExtent($spatial));
+        self::assertEquals($extent, $object->getExtent($spatial));
     }
 
     /**
@@ -141,7 +141,7 @@ class GisMultiPointTest extends GisGeomTestCase
     {
         $object = GisMultiPoint::singleton();
         $image = ImageWrapper::create(200, 124, ['red' => 229, 'green' => 229, 'blue' => 229]);
-        $this->assertNotNull($image);
+        self::assertNotNull($image);
         $object->prepareRowAsPng(
             'MULTIPOINT(12 35,48 75,69 23,25 45,14 53,35 78)',
             'image',
@@ -149,13 +149,13 @@ class GisMultiPointTest extends GisGeomTestCase
             new ScaleData(offsetX: -18, offsetY: 14, scale: 1.71, height: 124),
             $image,
         );
-        $this->assertEquals(200, $image->width());
-        $this->assertEquals(124, $image->height());
+        self::assertEquals(200, $image->width());
+        self::assertEquals(124, $image->height());
 
         $fileExpected = $this->testDir . '/multipoint-expected.png';
         $fileActual = $this->testDir . '/multipoint-actual.png';
-        $this->assertTrue($image->png($fileActual));
-        $this->assertFileEquals($fileExpected, $fileActual);
+        self::assertTrue($image->png($fileActual));
+        self::assertFileEquals($fileExpected, $fileActual);
     }
 
     /**
@@ -180,7 +180,7 @@ class GisMultiPointTest extends GisGeomTestCase
         $fileExpectedArch = $this->testDir . '/multipoint-expected-' . $this->getArch() . '.pdf';
         $fileExpectedGeneric = $this->testDir . '/multipoint-expected.pdf';
         $fileExpected = file_exists($fileExpectedArch) ? $fileExpectedArch : $fileExpectedGeneric;
-        $this->assertStringEqualsFile($fileExpected, $pdf->Output(dest: 'S'));
+        self::assertStringEqualsFile($fileExpected, $pdf->Output(dest: 'S'));
     }
 
     /**
@@ -221,7 +221,7 @@ class GisMultiPointTest extends GisGeomTestCase
     ): void {
         $object = GisMultiPoint::singleton();
         $svg = $object->prepareRowAsSvg($spatial, $label, $color, $scaleData);
-        $this->assertEquals($output, $svg);
+        self::assertEquals($output, $svg);
     }
 
     /**
@@ -271,7 +271,7 @@ class GisMultiPointTest extends GisGeomTestCase
     ): void {
         $object = GisMultiPoint::singleton();
         $ol = $object->prepareRowAsOl($spatial, $srid, $label, $color);
-        $this->assertEquals($output, $ol);
+        self::assertEquals($output, $ol);
     }
 
     /**
diff --git a/tests/classes/Gis/GisMultiPolygonTest.php b/tests/classes/Gis/GisMultiPolygonTest.php
index 8f848651a7..2902867fc9 100644
--- a/tests/classes/Gis/GisMultiPolygonTest.php
+++ b/tests/classes/Gis/GisMultiPolygonTest.php
@@ -74,7 +74,7 @@ class GisMultiPolygonTest extends GisGeomTestCase
     public function testGenerateWkt(array $gisData, int $index, string $empty, string $output): void
     {
         $object = GisMultiPolygon::singleton();
-        $this->assertEquals($output, $object->generateWkt($gisData, $index, $empty));
+        self::assertEquals($output, $object->generateWkt($gisData, $index, $empty));
     }
 
     /**
@@ -134,7 +134,7 @@ class GisMultiPolygonTest extends GisGeomTestCase
     public function testGenerateParams(string $wkt, array $params): void
     {
         $object = GisMultiPolygon::singleton();
-        $this->assertEquals($params, $object->generateParams($wkt));
+        self::assertEquals($params, $object->generateParams($wkt));
     }
 
     /**
@@ -163,7 +163,7 @@ class GisMultiPolygonTest extends GisGeomTestCase
     public function testGetShape(array $rowData, string $shape): void
     {
         $object = GisMultiPolygon::singleton();
-        $this->assertEquals($shape, $object->getShape($rowData));
+        self::assertEquals($shape, $object->getShape($rowData));
     }
 
     /**
@@ -220,7 +220,7 @@ class GisMultiPolygonTest extends GisGeomTestCase
     public function testGetExtent(string $spatial, Extent $extent): void
     {
         $object = GisMultiPolygon::singleton();
-        $this->assertEquals($extent, $object->getExtent($spatial));
+        self::assertEquals($extent, $object->getExtent($spatial));
     }
 
     /**
@@ -248,7 +248,7 @@ class GisMultiPolygonTest extends GisGeomTestCase
     {
         $object = GisMultiPolygon::singleton();
         $image = ImageWrapper::create(200, 124, ['red' => 229, 'green' => 229, 'blue' => 229]);
-        $this->assertNotNull($image);
+        self::assertNotNull($image);
         $object->prepareRowAsPng(
             'MULTIPOLYGON(((5 5,95 5,95 95,5 95,5 5),(10 10,10 40,40 40,40 10,10 10),(60 60,90 60,90 90,60 90,6'
             . '0 60)),((-5 -5,-95 -5,-95 -95,-5 -95,-5 -5),(-10 -10,-10 -40,-40 -40,-40 -10,-10 -10),(-60 -60,-90'
@@ -258,13 +258,13 @@ class GisMultiPolygonTest extends GisGeomTestCase
             new ScaleData(offsetX: -202, offsetY: -125, scale: 0.50, height: 124),
             $image,
         );
-        $this->assertEquals(200, $image->width());
-        $this->assertEquals(124, $image->height());
+        self::assertEquals(200, $image->width());
+        self::assertEquals(124, $image->height());
 
         $fileExpected = $this->testDir . '/multipolygon-expected.png';
         $fileActual = $this->testDir . '/multipolygon-actual.png';
-        $this->assertTrue($image->png($fileActual));
-        $this->assertFileEquals($fileExpected, $fileActual);
+        self::assertTrue($image->png($fileActual));
+        self::assertFileEquals($fileExpected, $fileActual);
     }
 
     /**
@@ -287,7 +287,7 @@ class GisMultiPolygonTest extends GisGeomTestCase
         $object->prepareRowAsPdf($spatial, $label, $color, $scaleData, $pdf);
 
         $fileExpected = $this->testDir . '/multipolygon-expected.pdf';
-        $this->assertStringEqualsFile($fileExpected, $pdf->Output(dest: 'S'));
+        self::assertStringEqualsFile($fileExpected, $pdf->Output(dest: 'S'));
     }
 
     /**
@@ -330,7 +330,7 @@ class GisMultiPolygonTest extends GisGeomTestCase
     ): void {
         $object = GisMultiPolygon::singleton();
         $svg = $object->prepareRowAsSvg($spatial, $label, $color, $scaleData);
-        $this->assertEquals($output, $svg);
+        self::assertEquals($output, $svg);
     }
 
     /**
@@ -377,7 +377,7 @@ class GisMultiPolygonTest extends GisGeomTestCase
     ): void {
         $object = GisMultiPolygon::singleton();
         $ol = $object->prepareRowAsOl($spatial, $srid, $label, $color);
-        $this->assertEquals($output, $ol);
+        self::assertEquals($output, $ol);
     }
 
     /**
diff --git a/tests/classes/Gis/GisPointTest.php b/tests/classes/Gis/GisPointTest.php
index 080557120f..883fcdae3e 100644
--- a/tests/classes/Gis/GisPointTest.php
+++ b/tests/classes/Gis/GisPointTest.php
@@ -50,7 +50,7 @@ class GisPointTest extends GisGeomTestCase
     public function testGenerateWkt(array $gisData, int $index, string $empty, string $output): void
     {
         $object = GisPoint::singleton();
-        $this->assertEquals($output, $object->generateWkt($gisData, $index, $empty));
+        self::assertEquals($output, $object->generateWkt($gisData, $index, $empty));
     }
 
     /**
@@ -63,7 +63,7 @@ class GisPointTest extends GisGeomTestCase
     public function testGetShape(array $rowData, string $shape): void
     {
         $object = GisPoint::singleton();
-        $this->assertEquals($shape, $object->getShape($rowData));
+        self::assertEquals($shape, $object->getShape($rowData));
     }
 
     /**
@@ -86,7 +86,7 @@ class GisPointTest extends GisGeomTestCase
     public function testGenerateParams(string $wkt, array $params): void
     {
         $object = GisPoint::singleton();
-        $this->assertEquals($params, $object->generateParams($wkt));
+        self::assertEquals($params, $object->generateParams($wkt));
     }
 
     /**
@@ -134,7 +134,7 @@ class GisPointTest extends GisGeomTestCase
     public function testGetExtent(string $spatial, Extent $extent): void
     {
         $object = GisPoint::singleton();
-        $this->assertEquals($extent, $object->getExtent($spatial));
+        self::assertEquals($extent, $object->getExtent($spatial));
     }
 
     /**
@@ -152,7 +152,7 @@ class GisPointTest extends GisGeomTestCase
     {
         $object = GisPoint::singleton();
         $image = ImageWrapper::create(200, 124, ['red' => 229, 'green' => 229, 'blue' => 229]);
-        $this->assertNotNull($image);
+        self::assertNotNull($image);
         $object->prepareRowAsPng(
             'POINT(12 35)',
             'image',
@@ -160,13 +160,13 @@ class GisPointTest extends GisGeomTestCase
             new ScaleData(offsetX: -88, offsetY: -27, scale: 1, height: 124),
             $image,
         );
-        $this->assertEquals(200, $image->width());
-        $this->assertEquals(124, $image->height());
+        self::assertEquals(200, $image->width());
+        self::assertEquals(124, $image->height());
 
         $fileExpected = $this->testDir . '/point-expected.png';
         $fileActual = $this->testDir . '/point-actual.png';
-        $this->assertTrue($image->png($fileActual));
-        $this->assertFileEquals($fileExpected, $fileActual);
+        self::assertTrue($image->png($fileActual));
+        self::assertFileEquals($fileExpected, $fileActual);
     }
 
     /**
@@ -191,7 +191,7 @@ class GisPointTest extends GisGeomTestCase
         $fileExpectedArch = $this->testDir . '/point-expected-' . $this->getArch() . '.pdf';
         $fileExpectedGeneric = $this->testDir . '/point-expected.pdf';
         $fileExpected = file_exists($fileExpectedArch) ? $fileExpectedArch : $fileExpectedGeneric;
-        $this->assertStringEqualsFile($fileExpected, $pdf->Output(dest: 'S'));
+        self::assertStringEqualsFile($fileExpected, $pdf->Output(dest: 'S'));
     }
 
     /**
@@ -232,7 +232,7 @@ class GisPointTest extends GisGeomTestCase
     ): void {
         $object = GisPoint::singleton();
         $svg = $object->prepareRowAsSvg($spatial, $label, $color, $scaleData);
-        $this->assertEquals($output, $svg);
+        self::assertEquals($output, $svg);
     }
 
     /**
@@ -272,7 +272,7 @@ class GisPointTest extends GisGeomTestCase
     ): void {
         $object = GisPoint::singleton();
         $ol = $object->prepareRowAsOl($spatial, $srid, $label, $color);
-        $this->assertEquals($output, $ol);
+        self::assertEquals($output, $ol);
     }
 
     /**
diff --git a/tests/classes/Gis/GisPolygonTest.php b/tests/classes/Gis/GisPolygonTest.php
index 48d322b368..236fb3ca58 100644
--- a/tests/classes/Gis/GisPolygonTest.php
+++ b/tests/classes/Gis/GisPolygonTest.php
@@ -61,7 +61,7 @@ class GisPolygonTest extends GisGeomTestCase
     public function testGenerateWkt(array $gisData, int $index, string $empty, string $output): void
     {
         $object = GisPolygon::singleton();
-        $this->assertEquals($output, $object->generateWkt($gisData, $index, $empty));
+        self::assertEquals($output, $object->generateWkt($gisData, $index, $empty));
     }
 
     /**
@@ -107,7 +107,7 @@ class GisPolygonTest extends GisGeomTestCase
     public function testGenerateParams(string $wkt, array $params): void
     {
         $object = GisPolygon::singleton();
-        $this->assertEquals($params, $object->generateParams($wkt));
+        self::assertEquals($params, $object->generateParams($wkt));
     }
 
     /**
@@ -135,7 +135,7 @@ class GisPolygonTest extends GisGeomTestCase
     public function testGetExtent(string $spatial, Extent $extent): void
     {
         $object = GisPolygon::singleton();
-        $this->assertEquals($extent, $object->getExtent($spatial));
+        self::assertEquals($extent, $object->getExtent($spatial));
     }
 
     /**
@@ -159,7 +159,7 @@ class GisPolygonTest extends GisGeomTestCase
     {
         $object = GisPolygon::singleton();
         $image = ImageWrapper::create(200, 124, ['red' => 229, 'green' => 229, 'blue' => 229]);
-        $this->assertNotNull($image);
+        self::assertNotNull($image);
         $object->prepareRowAsPng(
             'POLYGON((0 0,100 0,100 100,0 100,0 0),(10 10,10 40,40 40,40 10,10 10),(60 60,90 60,90 90,60 90,60 60))',
             'image',
@@ -167,13 +167,13 @@ class GisPolygonTest extends GisGeomTestCase
             new ScaleData(offsetX: -56, offsetY: -16, scale: 0.94, height: 124),
             $image,
         );
-        $this->assertEquals(200, $image->width());
-        $this->assertEquals(124, $image->height());
+        self::assertEquals(200, $image->width());
+        self::assertEquals(124, $image->height());
 
         $fileExpected = $this->testDir . '/polygon-expected.png';
         $fileActual = $this->testDir . '/polygon-actual.png';
-        $this->assertTrue($image->png($fileActual));
-        $this->assertFileEquals($fileExpected, $fileActual);
+        self::assertTrue($image->png($fileActual));
+        self::assertFileEquals($fileExpected, $fileActual);
     }
 
     /**
@@ -196,7 +196,7 @@ class GisPolygonTest extends GisGeomTestCase
         $object->prepareRowAsPdf($spatial, $label, $color, $scaleData, $pdf);
 
         $fileExpected = $this->testDir . '/polygon-expected.pdf';
-        $this->assertStringEqualsFile($fileExpected, $pdf->Output(dest: 'S'));
+        self::assertStringEqualsFile($fileExpected, $pdf->Output(dest: 'S'));
     }
 
     /**
@@ -238,7 +238,7 @@ class GisPolygonTest extends GisGeomTestCase
     ): void {
         $object = GisPolygon::singleton();
         $svg = $object->prepareRowAsSvg($spatial, $label, $color, $scaleData);
-        $this->assertEquals($output, $svg);
+        self::assertEquals($output, $svg);
     }
 
     /**
@@ -280,7 +280,7 @@ class GisPolygonTest extends GisGeomTestCase
     ): void {
         $object = GisPolygon::singleton();
         $ol = $object->prepareRowAsOl($spatial, $srid, $label, $color);
-        $this->assertEquals($output, $ol);
+        self::assertEquals($output, $ol);
     }
 
     /**
diff --git a/tests/classes/Gis/GisVisualizationTest.php b/tests/classes/Gis/GisVisualizationTest.php
index 4f200bd7f8..1d077f96a1 100644
--- a/tests/classes/Gis/GisVisualizationTest.php
+++ b/tests/classes/Gis/GisVisualizationTest.php
@@ -43,7 +43,7 @@ class GisVisualizationTest extends AbstractTestCase
                 ],
             ],
         );
-        $this->assertNull($dataSet);
+        self::assertNull($dataSet);
 
         $dataSet = $this->callFunction(
             $gis,
@@ -59,7 +59,7 @@ class GisVisualizationTest extends AbstractTestCase
                 ],
             ],
         );
-        $this->assertEquals(
+        self::assertEquals(
             new ScaleData(
                 offsetX: -45.35714285714286,
                 offsetY: 42.85714285714286,
@@ -81,7 +81,7 @@ class GisVisualizationTest extends AbstractTestCase
                 ],
             ],
         );
-        $this->assertEquals(
+        self::assertEquals(
             new ScaleData(
                 scale: 32.30769230769231,
                 offsetX: -2.7857142857142865,
@@ -105,7 +105,7 @@ class GisVisualizationTest extends AbstractTestCase
             [''],
         );
 
-        $this->assertEquals('SELECT ASTEXT(`abc`) AS `abc`, SRID(`abc`) AS `srid` FROM () AS `temp_gis`', $queryString);
+        self::assertEquals('SELECT ASTEXT(`abc`) AS `abc`, SRID(`abc`) AS `srid` FROM () AS `temp_gis`', $queryString);
     }
 
     /**
@@ -121,7 +121,7 @@ class GisVisualizationTest extends AbstractTestCase
             [''],
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'SELECT ST_ASTEXT(`abc`) AS `abc`, ST_SRID(`abc`) AS `srid` FROM () AS `temp_gis`',
             $queryString,
         );
@@ -140,7 +140,7 @@ class GisVisualizationTest extends AbstractTestCase
             ['SELECT 1 FROM foo;'],
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'SELECT ST_ASTEXT(`abc`) AS `abc`, ST_SRID(`abc`) AS `srid` FROM (SELECT 1 FROM foo) AS `temp_gis`',
             $queryString,
         );
@@ -164,7 +164,7 @@ class GisVisualizationTest extends AbstractTestCase
             [''],
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'SELECT `country name`, ST_ASTEXT(`country_geom`) AS `country_geom`,'
             . ' ST_SRID(`country_geom`) AS `srid` FROM () AS `temp_gis`',
             $queryString,
@@ -186,7 +186,7 @@ class GisVisualizationTest extends AbstractTestCase
             [''],
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'SELECT ST_ASTEXT(`abc`) AS `abc`, ST_SRID(`abc`) AS `srid` FROM () AS `temp_gis` LIMIT 10',
             $queryString,
         );
@@ -201,7 +201,7 @@ class GisVisualizationTest extends AbstractTestCase
             [''],
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'SELECT ST_ASTEXT(`abc`) AS `abc`, ST_SRID(`abc`) AS `srid` FROM () AS `temp_gis` LIMIT 10, 15',
             $queryString,
         );
@@ -220,7 +220,7 @@ class GisVisualizationTest extends AbstractTestCase
             [''],
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'SELECT ST_ASTEXT(`abc`, \'axis-order=long-lat\') AS `abc`, ST_SRID(`abc`) AS `srid` FROM () AS `temp_gis`',
             $queryString,
         );
@@ -239,7 +239,7 @@ class GisVisualizationTest extends AbstractTestCase
             [''],
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'SELECT ST_ASTEXT(`abc`) AS `abc`, ST_SRID(`abc`) AS `srid` FROM () AS `temp_gis`',
             $queryString,
         );
diff --git a/tests/classes/GitTest.php b/tests/classes/GitTest.php
index 0511be7aee..2e3c0d6f7e 100644
--- a/tests/classes/GitTest.php
+++ b/tests/classes/GitTest.php
@@ -70,11 +70,11 @@ class GitTest extends AbstractTestCase
 
         $gitLocation = '';
 
-        $this->assertTrue($this->object->isGitRevision($gitLocation));
+        self::assertTrue($this->object->isGitRevision($gitLocation));
 
-        $this->assertFalse($this->object->hasGitInformation());
+        self::assertFalse($this->object->hasGitInformation());
 
-        $this->assertEquals('.cachedgitlocation', $gitLocation);
+        self::assertEquals('.cachedgitlocation', $gitLocation);
     }
 
     /**
@@ -83,7 +83,7 @@ class GitTest extends AbstractTestCase
     public function testIsGitRevisionSkipped(): void
     {
         $this->object = new Git(false);
-        $this->assertFalse(
+        self::assertFalse(
             $this->object->isGitRevision($gitLocation),
         );
     }
@@ -94,31 +94,31 @@ class GitTest extends AbstractTestCase
     #[Group('git-revision')]
     public function testIsGitRevisionLocalGitDir(): void
     {
-        $this->assertFalse(
+        self::assertFalse(
             $this->object->isGitRevision(),
         );
 
-        $this->assertFalse($this->object->hasGitInformation());
+        self::assertFalse($this->object->hasGitInformation());
 
         unset($_SESSION['git_location']);
         unset($_SESSION['is_git_revision']);
 
         mkdir($this->testDir . '.git');
 
-        $this->assertFalse(
+        self::assertFalse(
             $this->object->isGitRevision(),
         );
 
-        $this->assertFalse($this->object->hasGitInformation());
+        self::assertFalse($this->object->hasGitInformation());
 
         unset($_SESSION['git_location']);
         unset($_SESSION['is_git_revision']);
 
         file_put_contents($this->testDir . '.git/config', '');
 
-        $this->assertTrue($this->object->isGitRevision());
+        self::assertTrue($this->object->isGitRevision());
 
-        $this->assertFalse($this->object->hasGitInformation());
+        self::assertFalse($this->object->hasGitInformation());
 
         unlink($this->testDir . '.git/config');
         rmdir($this->testDir . '.git');
@@ -131,31 +131,31 @@ class GitTest extends AbstractTestCase
     public function testIsGitRevisionExternalGitDir(): void
     {
         file_put_contents($this->testDir . '.git', 'gitdir: ' . $this->testDir . '.customgitdir');
-        $this->assertFalse(
+        self::assertFalse(
             $this->object->isGitRevision(),
         );
 
-        $this->assertFalse($this->object->hasGitInformation());
+        self::assertFalse($this->object->hasGitInformation());
 
         unset($_SESSION['git_location']);
         unset($_SESSION['is_git_revision']);
 
         mkdir($this->testDir . '.customgitdir');
 
-        $this->assertTrue($this->object->isGitRevision());
+        self::assertTrue($this->object->isGitRevision());
 
-        $this->assertFalse($this->object->hasGitInformation());
+        self::assertFalse($this->object->hasGitInformation());
 
         unset($_SESSION['git_location']);
         unset($_SESSION['is_git_revision']);
 
         file_put_contents($this->testDir . '.git', 'random data here');
 
-        $this->assertFalse(
+        self::assertFalse(
             $this->object->isGitRevision(),
         );
 
-        $this->assertFalse($this->object->hasGitInformation());
+        self::assertFalse($this->object->hasGitInformation());
 
         unlink($this->testDir . '.git');
         rmdir($this->testDir . '.customgitdir');
@@ -172,14 +172,14 @@ class GitTest extends AbstractTestCase
 
         $commit = $this->object->checkGitRevision();
 
-        $this->assertNull($commit);
-        $this->assertFalse($this->object->hasGitInformation());
+        self::assertNull($commit);
+        self::assertFalse($this->object->hasGitInformation());
 
         file_put_contents($this->testDir . '.git/HEAD', 'ref: refs/remotes/origin/master');
 
         $commit = $this->object->checkGitRevision();
 
-        $this->assertNull($commit);
+        self::assertNull($commit);
 
         file_put_contents(
             $this->testDir . '.git/packed-refs',
@@ -203,24 +203,24 @@ class GitTest extends AbstractTestCase
             $commit === null
             && ! isset($_SESSION['PMA_VERSION_REMOTECOMMIT_8d660283c5c88a04bac7a2b3aa9ad9eaff0fd05e'])
         ) {
-            $this->markTestSkipped('Unable to get remote commit information.');
+            self::markTestSkipped('Unable to get remote commit information.');
         }
 
-        $this->assertIsArray($commit);
-        $this->assertSame('8d660283c5c88a04bac7a2b3aa9ad9eaff0fd05e', $commit['hash']);
-        $this->assertSame('master', $commit['branch']);
-        $this->assertSame(
+        self::assertIsArray($commit);
+        self::assertSame('8d660283c5c88a04bac7a2b3aa9ad9eaff0fd05e', $commit['hash']);
+        self::assertSame('master', $commit['branch']);
+        self::assertSame(
             'Update po files' . "\n\n" . '[ci skip]' . "\n\n" . 'Signed-off-by: phpMyAdmin bot <bot@phpmyadmin.net>',
             $commit['message'],
         );
-        $this->assertTrue($commit['is_remote_commit']);
-        $this->assertTrue($commit['is_remote_branch']);
-        $this->assertSame('phpMyAdmin bot', $commit['author']['name']);
-        $this->assertSame('bot@phpmyadmin.net', $commit['author']['email']);
-        $this->assertSame('2023-05-14T00:19:49Z', $commit['author']['date']);
-        $this->assertSame('phpMyAdmin bot', $commit['committer']['name']);
-        $this->assertSame('bot@phpmyadmin.net', $commit['committer']['email']);
-        $this->assertSame('2023-05-14T00:19:49Z', $commit['committer']['date']);
+        self::assertTrue($commit['is_remote_commit']);
+        self::assertTrue($commit['is_remote_branch']);
+        self::assertSame('phpMyAdmin bot', $commit['author']['name']);
+        self::assertSame('bot@phpmyadmin.net', $commit['author']['email']);
+        self::assertSame('2023-05-14T00:19:49Z', $commit['author']['date']);
+        self::assertSame('phpMyAdmin bot', $commit['committer']['name']);
+        self::assertSame('bot@phpmyadmin.net', $commit['committer']['email']);
+        self::assertSame('2023-05-14T00:19:49Z', $commit['committer']['date']);
     }
 
     /**
@@ -234,8 +234,8 @@ class GitTest extends AbstractTestCase
 
         $commit = $this->object->checkGitRevision();
 
-        $this->assertNull($commit);
-        $this->assertFalse($this->object->hasGitInformation());
+        self::assertNull($commit);
+        self::assertFalse($this->object->hasGitInformation());
 
         file_put_contents($this->testDir . '.git/HEAD', 'ref: refs/remotes/origin/master');
         mkdir($this->testDir . '.git/refs/remotes/origin', 0777, true);
@@ -246,8 +246,8 @@ class GitTest extends AbstractTestCase
         mkdir($this->testDir . '.git/objects/pack', 0777, true);//default = 0777, recursive mode
         $commit = $this->object->checkGitRevision();
 
-        $this->assertNull($commit);
-        $this->assertFalse($this->object->hasGitInformation());
+        self::assertNull($commit);
+        self::assertFalse($this->object->hasGitInformation());
 
         unlink($this->testDir . '.git/refs/remotes/origin/master');
         rmdir($this->testDir . '.git/refs/remotes/origin');
@@ -271,14 +271,14 @@ class GitTest extends AbstractTestCase
 
         $commit = $this->object->checkGitRevision();
 
-        $this->assertNull($commit);
-        $this->assertFalse($this->object->hasGitInformation());
+        self::assertNull($commit);
+        self::assertFalse($this->object->hasGitInformation());
 
         file_put_contents($this->testDir . '.git/HEAD', 'ref: refs/remotes/origin/master');
 
         $commit = $this->object->checkGitRevision();
 
-        $this->assertNull($commit);
+        self::assertNull($commit);
 
         file_put_contents(
             $this->testDir . '.git/packed-refs',
@@ -311,24 +311,24 @@ class GitTest extends AbstractTestCase
             $commit === null
             && ! isset($_SESSION['PMA_VERSION_REMOTECOMMIT_8d660283c5c88a04bac7a2b3aa9ad9eaff0fd05e'])
         ) {
-            $this->markTestSkipped('Unable to get remote commit information.');
+            self::markTestSkipped('Unable to get remote commit information.');
         }
 
-        $this->assertIsArray($commit);
-        $this->assertSame('8d660283c5c88a04bac7a2b3aa9ad9eaff0fd05e', $commit['hash']);
-        $this->assertSame('master', $commit['branch']);
-        $this->assertSame(
+        self::assertIsArray($commit);
+        self::assertSame('8d660283c5c88a04bac7a2b3aa9ad9eaff0fd05e', $commit['hash']);
+        self::assertSame('master', $commit['branch']);
+        self::assertSame(
             'Update po files' . "\n\n" . '[ci skip]' . "\n\n" . 'Signed-off-by: phpMyAdmin bot <bot@phpmyadmin.net>',
             $commit['message'],
         );
-        $this->assertTrue($commit['is_remote_commit']);
-        $this->assertTrue($commit['is_remote_branch']);
-        $this->assertSame('phpMyAdmin bot', $commit['author']['name']);
-        $this->assertSame('bot@phpmyadmin.net', $commit['author']['email']);
-        $this->assertSame('2023-05-14T00:19:49Z', $commit['author']['date']);
-        $this->assertSame('phpMyAdmin bot', $commit['committer']['name']);
-        $this->assertSame('bot@phpmyadmin.net', $commit['committer']['email']);
-        $this->assertSame('2023-05-14T00:19:49Z', $commit['committer']['date']);
+        self::assertTrue($commit['is_remote_commit']);
+        self::assertTrue($commit['is_remote_branch']);
+        self::assertSame('phpMyAdmin bot', $commit['author']['name']);
+        self::assertSame('bot@phpmyadmin.net', $commit['author']['email']);
+        self::assertSame('2023-05-14T00:19:49Z', $commit['author']['date']);
+        self::assertSame('phpMyAdmin bot', $commit['committer']['name']);
+        self::assertSame('bot@phpmyadmin.net', $commit['committer']['email']);
+        self::assertSame('2023-05-14T00:19:49Z', $commit['committer']['date']);
     }
 
     /**
@@ -339,9 +339,9 @@ class GitTest extends AbstractTestCase
         $this->object = new Git(false);
         $commit = $this->object->checkGitRevision();
 
-        $this->assertNull($commit);
+        self::assertNull($commit);
 
-        $this->assertFalse($this->object->hasGitInformation());
+        self::assertFalse($this->object->hasGitInformation());
     }
 
     /**
@@ -352,9 +352,9 @@ class GitTest extends AbstractTestCase
         $_SESSION['git_location'] = 'customdir/.git';
         $_SESSION['is_git_revision'] = true;
         $gitFolder = '';
-        $this->assertTrue($this->object->isGitRevision($gitFolder));
+        self::assertTrue($this->object->isGitRevision($gitFolder));
 
-        $this->assertEquals($gitFolder, 'customdir/.git');
+        self::assertEquals($gitFolder, 'customdir/.git');
     }
 
     /**
@@ -365,10 +365,10 @@ class GitTest extends AbstractTestCase
         $_SESSION['is_git_revision'] = false;
         $_SESSION['git_location'] = null;
         $gitFolder = 'defaultvaluebyref';
-        $this->assertFalse($this->object->isGitRevision($gitFolder));
+        self::assertFalse($this->object->isGitRevision($gitFolder));
 
         // Assert that the value is replaced by cached one
-        $this->assertEquals($gitFolder, null);
+        self::assertEquals($gitFolder, null);
     }
 
     /**
@@ -379,10 +379,10 @@ class GitTest extends AbstractTestCase
         $_SESSION['is_git_revision'] = false;
         $_SESSION['git_location'] = 'randomdir/.git';
         $gitFolder = 'defaultvaluebyref';
-        $this->assertFalse($this->object->isGitRevision($gitFolder));
+        self::assertFalse($this->object->isGitRevision($gitFolder));
 
         // Assert that the value is replaced by cached one
-        $this->assertEquals($gitFolder, 'randomdir/.git');
+        self::assertEquals($gitFolder, 'randomdir/.git');
     }
 
     /**
@@ -425,7 +425,7 @@ class GitTest extends AbstractTestCase
             ],
         );
 
-        $this->assertSame([
+        self::assertSame([
             ['name' => 'William Desportes', 'email' => 'williamdes@wdes.fr', 'date' => '2022-07-13 14:56:40 +0200'],
             ['name' => 'William Desportes', 'email' => 'williamdes@wdes.fr', 'date' => '2022-07-13 14:56:40 +0200'],
             'Remove ignore config.inc.php for psalm because '
diff --git a/tests/classes/HeaderTest.php b/tests/classes/HeaderTest.php
index cbf1297649..6e4b1257b9 100644
--- a/tests/classes/HeaderTest.php
+++ b/tests/classes/HeaderTest.php
@@ -67,7 +67,7 @@ class HeaderTest extends AbstractTestCase
     {
         $header = $this->getNewHeaderInstance();
         $header->disable();
-        $this->assertEquals(
+        self::assertEquals(
             '',
             $header->getDisplay(),
         );
@@ -80,7 +80,7 @@ class HeaderTest extends AbstractTestCase
     {
         Current::$server = 0;
         $header = $this->getNewHeaderInstance();
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             '<title>phpMyAdmin</title>',
             $header->getDisplay(),
         );
@@ -93,7 +93,7 @@ class HeaderTest extends AbstractTestCase
     {
         $header = $this->getNewHeaderInstance();
         $header->setBodyId('PMA_header_id');
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             'PMA_header_id',
             $header->getDisplay(),
         );
@@ -105,7 +105,7 @@ class HeaderTest extends AbstractTestCase
     public function testGetJsParams(): void
     {
         $header = $this->getNewHeaderInstance();
-        $this->assertArrayHasKey(
+        self::assertArrayHasKey(
             'common_query',
             $header->getJsParams(),
         );
@@ -114,7 +114,7 @@ class HeaderTest extends AbstractTestCase
     public function testGetJsParamsCode(): void
     {
         $header = $this->getNewHeaderInstance();
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             'window.Navigation.update(window.CommonParams.setAll(',
             $header->getJsParamsCode(),
         );
@@ -126,7 +126,7 @@ class HeaderTest extends AbstractTestCase
     public function testGetMessage(): void
     {
         $header = $this->getNewHeaderInstance();
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             'phpmyadminmessage',
             $header->getMessage(),
         );
@@ -142,7 +142,7 @@ class HeaderTest extends AbstractTestCase
         $header = $this->getNewHeaderInstance();
         $header->disableWarnings();
 
-        $this->assertFalse($reflection->getValue($header));
+        self::assertFalse($reflection->getValue($header));
     }
 
     #[DataProvider('providerForTestGetHttpHeaders')]
@@ -189,7 +189,7 @@ class HeaderTest extends AbstractTestCase
         }
 
         $headers = $this->callFunction($header, Header::class, 'getHttpHeaders', []);
-        $this->assertSame($expected, $headers);
+        self::assertSame($expected, $headers);
     }
 
     /** @return mixed[][] */
@@ -276,24 +276,24 @@ class HeaderTest extends AbstractTestCase
             ['name' => 'menu_resizer.js', 'fire' => 1],
             ['name' => 'main.js', 'fire' => 1],
         ];
-        $this->assertSame($expected, $scripts->getFiles());
+        self::assertSame($expected, $scripts->getFiles());
     }
 
     public function testSetAjax(): void
     {
         $header = $this->getNewHeaderInstance();
         $console = (new ReflectionProperty(Header::class, 'console'))->getValue($header);
-        $this->assertInstanceOf(Console::class, $console);
+        self::assertInstanceOf(Console::class, $console);
         $isAjax = new ReflectionProperty(Header::class, 'isAjax');
         $consoleIsAjax = new ReflectionProperty(Console::class, 'isAjax');
 
-        $this->assertFalse($isAjax->getValue($header));
-        $this->assertFalse($consoleIsAjax->getValue($console));
+        self::assertFalse($isAjax->getValue($header));
+        self::assertFalse($consoleIsAjax->getValue($console));
         $header->setAjax(true);
-        $this->assertTrue($isAjax->getValue($header));
-        $this->assertTrue($consoleIsAjax->getValue($console));
+        self::assertTrue($isAjax->getValue($header));
+        self::assertTrue($consoleIsAjax->getValue($console));
         $header->setAjax(false);
-        $this->assertFalse($isAjax->getValue($header));
-        $this->assertFalse($consoleIsAjax->getValue($console));
+        self::assertFalse($isAjax->getValue($header));
+        self::assertFalse($consoleIsAjax->getValue($console));
     }
 }
diff --git a/tests/classes/Html/GeneratorTest.php b/tests/classes/Html/GeneratorTest.php
index 7b7eb3c291..1037c6ff1c 100644
--- a/tests/classes/Html/GeneratorTest.php
+++ b/tests/classes/Html/GeneratorTest.php
@@ -45,7 +45,7 @@ class GeneratorTest extends AbstractTestCase
         Current::$database = 'test_db';
         Current::$server = 99;
         $database = Current::$database;
-        $this->assertEquals(
+        self::assertEquals(
             '<a href="'
             . Util::getScriptNameForOption(
                 Config::getInstance()->settings['DefaultTabDatabase'],
@@ -67,7 +67,7 @@ class GeneratorTest extends AbstractTestCase
     {
         Current::$server = 99;
         $database = 'test_database';
-        $this->assertEquals(
+        self::assertEquals(
             '<a href="' . Util::getScriptNameForOption(
                 Config::getInstance()->settings['DefaultTabDatabase'],
                 'database',
@@ -87,7 +87,7 @@ class GeneratorTest extends AbstractTestCase
     {
         Current::$server = 99;
         $database = 'test&data\'base';
-        $this->assertEquals(
+        self::assertEquals(
             '<a href="'
             . Util::getScriptNameForOption(
                 Config::getInstance()->settings['DefaultTabDatabase'],
@@ -109,7 +109,7 @@ class GeneratorTest extends AbstractTestCase
     {
         Config::getInstance()->settings['ActionLinksMode'] = 'text';
 
-        $this->assertEquals(
+        self::assertEquals(
             '<span class="text-nowrap"></span>',
             Generator::getIcon('b_comment'),
         );
@@ -122,7 +122,7 @@ class GeneratorTest extends AbstractTestCase
     {
         Config::getInstance()->settings['ActionLinksMode'] = 'icons';
 
-        $this->assertEquals(
+        self::assertEquals(
             '<span class="text-nowrap"><img src="themes/dot.gif" title="" alt="" class="icon ic_b_comment"></span>',
             Generator::getIcon('b_comment'),
         );
@@ -136,7 +136,7 @@ class GeneratorTest extends AbstractTestCase
         Config::getInstance()->settings['ActionLinksMode'] = 'icons';
         $alternateText = 'alt_str';
 
-        $this->assertEquals(
+        self::assertEquals(
             '<span class="text-nowrap"><img src="themes/dot.gif" title="'
             . $alternateText . '" alt="' . $alternateText
             . '" class="icon ic_b_comment"></span>',
@@ -154,7 +154,7 @@ class GeneratorTest extends AbstractTestCase
 
         // Here we are checking for an icon embedded inside a span (i.e not a menu
         // bar icon
-        $this->assertEquals(
+        self::assertEquals(
             '<span class="text-nowrap"><img src="themes/dot.gif" title="'
             . $alternateText . '" alt="' . $alternateText
             . '" class="icon ic_b_comment">&nbsp;' . $alternateText . '</span>',
@@ -176,7 +176,7 @@ class GeneratorTest extends AbstractTestCase
             . '<img src="themes/dot.gif" title="' . __('Documentation') . '" alt="'
             . __('Documentation') . '" class="icon ic_b_help"></a>';
 
-        $this->assertEquals(
+        self::assertEquals(
             $expected,
             Generator::showPHPDocumentation($target),
         );
@@ -200,7 +200,7 @@ class GeneratorTest extends AbstractTestCase
                 [Generator::class, 'linkOrButton'],
                 $params,
             );
-            $this->assertEquals($match, $result);
+            self::assertEquals($match, $result);
         } finally {
             $config->settings['LinkLengthLimit'] = $restore;
         }
@@ -288,7 +288,7 @@ class GeneratorTest extends AbstractTestCase
 
     public function testFormatSql(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             '<code class="sql" dir="ltr"><pre>' . "\n"
             . 'SELECT 1 &lt; 2' . "\n"
             . '</pre></code>',
@@ -297,7 +297,7 @@ class GeneratorTest extends AbstractTestCase
 
         Config::getInstance()->settings['MaxCharactersInDisplayedSQL'] = 6;
 
-        $this->assertEquals(
+        self::assertEquals(
             '<code class="sql" dir="ltr"><pre>' . "\n"
             . 'SELECT[...]' . "\n"
             . '</pre></code>',
@@ -322,7 +322,7 @@ class GeneratorTest extends AbstractTestCase
 
         $config = Config::getInstance();
         $config->selectedServer = ['ssl' => false, 'host' => '127.0.0.1'];
-        $this->assertEquals(
+        self::assertEquals(
             $sslNotUsed,
             Generator::getServerSSL(),
         );
@@ -330,7 +330,7 @@ class GeneratorTest extends AbstractTestCase
         $config->selectedServer = ['ssl' => false, 'host' => 'custom.host'];
         $config->settings['MysqlSslWarningSafeHosts'] = ['localhost', '127.0.0.1'];
 
-        $this->assertEquals(
+        self::assertEquals(
             $sslNotUsedCaution,
             Generator::getServerSSL(),
         );
@@ -338,21 +338,21 @@ class GeneratorTest extends AbstractTestCase
         $config->selectedServer = ['ssl' => false, 'host' => 'custom.host'];
         $config->settings['MysqlSslWarningSafeHosts'] = ['localhost', '127.0.0.1', 'custom.host'];
 
-        $this->assertEquals(
+        self::assertEquals(
             $sslNotUsed,
             Generator::getServerSSL(),
         );
 
         $config->selectedServer = ['ssl' => false, 'ssl_verify' => true, 'host' => 'custom.host'];
 
-        $this->assertEquals(
+        self::assertEquals(
             $sslNotUsed,
             Generator::getServerSSL(),
         );
 
         $config->selectedServer = ['ssl' => true, 'ssl_verify' => false, 'host' => 'custom.host'];
 
-        $this->assertEquals(
+        self::assertEquals(
             '<span class="text-danger">SSL is used with disabled verification</span>'
             . ' <a href="index.php?route=/url&url=https%3A%2F%2Fdocs.phpmyadmin.net%2Fen%2Flatest%2Fsetup.html%23ssl"'
             . ' target="documentation"><img src="themes/dot.gif" title="Documentation" alt="Documentation"'
@@ -362,7 +362,7 @@ class GeneratorTest extends AbstractTestCase
 
         $config->selectedServer = ['ssl' => true, 'ssl_verify' => true, 'host' => 'custom.host'];
 
-        $this->assertEquals(
+        self::assertEquals(
             '<span class="text-danger">SSL is used without certification authority</span>'
             . ' <a href="index.php?route=/url&url=https%3A%2F%2Fdocs.phpmyadmin.net%2Fen%2Flatest%2Fsetup.html%23ssl"'
             . ' target="documentation"><img src="themes/dot.gif" title="Documentation" alt="Documentation"'
@@ -377,7 +377,7 @@ class GeneratorTest extends AbstractTestCase
             'host' => 'custom.host',
         ];
 
-        $this->assertEquals(
+        self::assertEquals(
             '<span class="">SSL is used</span>'
             . ' <a href="index.php?route=/url&url=https%3A%2F%2Fdocs.phpmyadmin.net%2Fen%2Flatest%2Fsetup.html%23ssl"'
             . ' target="documentation"><img src="themes/dot.gif" title="Documentation" alt="Documentation"'
@@ -401,7 +401,7 @@ class GeneratorTest extends AbstractTestCase
         bool $insertMode,
         string $expected,
     ): void {
-        $dbiStub = $this->createStub(DatabaseInterface::class);
+        $dbiStub = self::createStub(DatabaseInterface::class);
         $dbiStub->types = new Types($dbiStub);
         $dbiStub->method('getVersion')->willReturn(50700);
 
@@ -418,7 +418,7 @@ class GeneratorTest extends AbstractTestCase
             $insertMode,
         );
 
-        $this->assertEquals($expected, $result);
+        self::assertEquals($expected, $result);
     }
 
     /**
@@ -524,9 +524,9 @@ SELECT 1;
 HTML;
         // phpcs:enable
 
-        $this->assertSame($expected, Generator::getMessage('Message [em]one[/em].'));
-        $this->assertArrayNotHasKey('using_bookmark_message', $GLOBALS);
-        $this->assertArrayNotHasKey('special_message', $GLOBALS);
+        self::assertSame($expected, Generator::getMessage('Message [em]one[/em].'));
+        self::assertArrayNotHasKey('using_bookmark_message', $GLOBALS);
+        self::assertArrayNotHasKey('special_message', $GLOBALS);
         SessionCache::remove('profiling_supported');
     }
 
@@ -570,8 +570,8 @@ $sql = "EXPLAIN SELECT 1;";
 HTML;
         // phpcs:enable
 
-        $this->assertSame($expected, Generator::getMessage(Message::success('Message [em]one[/em].')));
-        $this->assertArrayNotHasKey('special_message', $GLOBALS);
+        self::assertSame($expected, Generator::getMessage(Message::success('Message [em]one[/em].')));
+        self::assertArrayNotHasKey('special_message', $GLOBALS);
         SessionCache::remove('profiling_supported');
     }
 }
diff --git a/tests/classes/Html/MySQLDocumentationTest.php b/tests/classes/Html/MySQLDocumentationTest.php
index 94e1986645..216ce50e93 100644
--- a/tests/classes/Html/MySQLDocumentationTest.php
+++ b/tests/classes/Html/MySQLDocumentationTest.php
@@ -16,7 +16,7 @@ class MySQLDocumentationTest extends AbstractTestCase
     {
         Config::getInstance()->settings['ServerDefault'] = 1;
 
-        $this->assertEquals(
+        self::assertEquals(
             '<a href="index.php?route=/url&url=https%3A%2F%2Fdocs.phpmyadmin.net%2Fen'
             . '%2Flatest%2Fpage.html%23anchor" target="documentation"><img src="themes/dot.gif"'
             . ' title="Documentation" alt="Documentation" class="icon ic_b_help"></a>',
diff --git a/tests/classes/Html/SecurityTest.php b/tests/classes/Html/SecurityTest.php
index 7f5b51b1b6..b6aa832264 100644
--- a/tests/classes/Html/SecurityTest.php
+++ b/tests/classes/Html/SecurityTest.php
@@ -30,7 +30,7 @@ class SecurityTest extends AbstractTestCase
 
     public function testInjectCodeUsingTemplate(): void
     {
-        $this->assertSame(
+        self::assertSame(
             '?db=%3Cscript%3Ealert%28%27%26%3D%21%3A%3B%27%29%3B%3C%2Fscr'
             . 'ipt%3E&amp;table=%26mytable%3E1%3F&amp;server=12'
             . "\n"
@@ -56,12 +56,12 @@ class SecurityTest extends AbstractTestCase
             'table' => '&mytable>1?',
             'server' => 12,
         ]);
-        $this->assertSame(
+        self::assertSame(
             '?db=%3Cscript%3Ealert%28%27%26%3D%21%3A%3B%27%29%3B%3C%2Fscr'
             . 'ipt%3E&table=%26mytable%3E1%3F&server=12',
             $url1,
         );
-        $this->assertSame(
+        self::assertSame(
             $url1
             . "\n"
             . '?db=%22%27%22%3E%3Ciframe+onload%3Dalert%281%29%3E%D1%88%D0%B5%D0%BB%D0%BB%D1%8B'
diff --git a/tests/classes/Http/Factory/ResponseFactoryTest.php b/tests/classes/Http/Factory/ResponseFactoryTest.php
index 909909958f..4f9dcfe2f9 100644
--- a/tests/classes/Http/Factory/ResponseFactoryTest.php
+++ b/tests/classes/Http/Factory/ResponseFactoryTest.php
@@ -36,10 +36,10 @@ final class ResponseFactoryTest extends TestCase
         $this->skipIfNotAvailable($provider);
         $responseFactory = new ResponseFactory(new $provider());
         $response = $responseFactory->createResponse(StatusCodeInterface::STATUS_NOT_FOUND, 'Not Found');
-        $this->assertSame(StatusCodeInterface::STATUS_NOT_FOUND, $response->getStatusCode());
-        $this->assertSame('Not Found', $response->getReasonPhrase());
+        self::assertSame(StatusCodeInterface::STATUS_NOT_FOUND, $response->getStatusCode());
+        self::assertSame('Not Found', $response->getReasonPhrase());
         $actual = (new ReflectionProperty(Response::class, 'response'))->getValue($response);
-        $this->assertInstanceOf($expectedResponse, $actual);
+        self::assertInstanceOf($expectedResponse, $actual);
     }
 
     /** @psalm-return iterable<string, array{class-string<ResponseFactoryInterface>, class-string<ResponseInterface>}> */
@@ -61,7 +61,7 @@ final class ResponseFactoryTest extends TestCase
         (new ReflectionProperty(ResponseFactory::class, 'providers'))->setValue(null, [$provider]);
         $responseFactory = ResponseFactory::create();
         $actual = (new ReflectionProperty(ResponseFactory::class, 'responseFactory'))->getValue($responseFactory);
-        $this->assertInstanceOf($provider, $actual);
+        self::assertInstanceOf($provider, $actual);
     }
 
     /** @psalm-return iterable<string, array{class-string<ResponseFactoryInterface>}> */
@@ -91,6 +91,6 @@ final class ResponseFactoryTest extends TestCase
         }
 
         // This can happen when testing without the development packages.
-        $this->markTestSkipped($provider . ' is not available.');
+        self::markTestSkipped($provider . ' is not available.');
     }
 }
diff --git a/tests/classes/Http/Factory/ServerRequestFactoryTest.php b/tests/classes/Http/Factory/ServerRequestFactoryTest.php
index 442e5ab605..0cde1d87fe 100644
--- a/tests/classes/Http/Factory/ServerRequestFactoryTest.php
+++ b/tests/classes/Http/Factory/ServerRequestFactoryTest.php
@@ -51,7 +51,7 @@ final class ServerRequestFactoryTest extends TestCase
         $serverRequestFactory = new ServerRequestFactory(new $provider());
         $serverRequest = $serverRequestFactory->createServerRequest('GET', 'http://example.com/');
         $actual = (new ReflectionProperty(ServerRequest::class, 'serverRequest'))->getValue($serverRequest);
-        $this->assertInstanceOf($expectedServerRequest, $actual);
+        self::assertInstanceOf($expectedServerRequest, $actual);
     }
 
     /**
@@ -80,7 +80,7 @@ final class ServerRequestFactoryTest extends TestCase
         $serverRequestFactory = ServerRequestFactory::create();
         $actual = (new ReflectionProperty(ServerRequestFactory::class, 'serverRequestFactory'))
             ->getValue($serverRequestFactory);
-        $this->assertInstanceOf($provider, $actual);
+        self::assertInstanceOf($provider, $actual);
     }
 
     /** @psalm-return iterable<string, array{class-string<ServerRequestFactoryInterface>}> */
@@ -130,17 +130,17 @@ final class ServerRequestFactoryTest extends TestCase
 
         $serverRequest = $serverRequestFactory->fromGlobals();
 
-        $this->assertInstanceOf($expectedUri, $serverRequest->getUri());
-        $this->assertSame('GET', $serverRequest->getMethod());
-        $this->assertSame(
+        self::assertInstanceOf($expectedUri, $serverRequest->getUri());
+        self::assertSame('GET', $serverRequest->getMethod());
+        self::assertSame(
             'http://phpmyadmin.local/test-page.php?foo=bar&blob=baz',
             $serverRequest->getUri()->__toString(),
         );
-        $this->assertFalse($serverRequest->isPost());
-        $this->assertSame('default', $serverRequest->getParam('not-exists', 'default'));
-        $this->assertSame('bar', $serverRequest->getParam('foo'));
-        $this->assertSame('baz', $serverRequest->getParam('blob'));
-        $this->assertSame(['foo' => 'bar', 'blob' => 'baz'], $serverRequest->getQueryParams());
+        self::assertFalse($serverRequest->isPost());
+        self::assertSame('default', $serverRequest->getParam('not-exists', 'default'));
+        self::assertSame('bar', $serverRequest->getParam('foo'));
+        self::assertSame('baz', $serverRequest->getParam('blob'));
+        self::assertSame(['foo' => 'bar', 'blob' => 'baz'], $serverRequest->getQueryParams());
     }
 
     /**
@@ -175,26 +175,26 @@ final class ServerRequestFactoryTest extends TestCase
 
         $serverRequest = $serverRequestFactory->fromGlobals();
 
-        $this->assertInstanceOf($expectedUri, $serverRequest->getUri());
-        $this->assertSame(['application/x-www-form-urlencoded'], $serverRequest->getHeader('Content-Type'));
-        $this->assertSame('POST', $serverRequest->getMethod());
-        $this->assertSame(
+        self::assertInstanceOf($expectedUri, $serverRequest->getUri());
+        self::assertSame(['application/x-www-form-urlencoded'], $serverRequest->getHeader('Content-Type'));
+        self::assertSame('POST', $serverRequest->getMethod());
+        self::assertSame(
             'http://phpmyadmin.local/test-page.php?foo=bar&blob=baz',
             $serverRequest->getUri()->__toString(),
         );
-        $this->assertTrue($serverRequest->isPost());
-        $this->assertSame('default', $serverRequest->getParam('not-exists', 'default'));
-        $this->assertSame('bar', $serverRequest->getParam('foo'));
-        $this->assertSame('baz', $serverRequest->getParam('blob'));
-        $this->assertSame(['foo' => 'bar', 'blob' => 'baz'], $serverRequest->getQueryParams());
-        $this->assertSame(
+        self::assertTrue($serverRequest->isPost());
+        self::assertSame('default', $serverRequest->getParam('not-exists', 'default'));
+        self::assertSame('bar', $serverRequest->getParam('foo'));
+        self::assertSame('baz', $serverRequest->getParam('blob'));
+        self::assertSame(['foo' => 'bar', 'blob' => 'baz'], $serverRequest->getQueryParams());
+        self::assertSame(
             ['input1' => 'value1', 'input2' => 'value2', 'input3' => ''],
             $serverRequest->getParsedBody(),
         );
-        $this->assertNull($serverRequest->getParsedBodyParam('foo'));
-        $this->assertSame('value1', $serverRequest->getParsedBodyParam('input1'));
-        $this->assertSame('value2', $serverRequest->getParsedBodyParam('input2'));
-        $this->assertSame('', $serverRequest->getParsedBodyParam('input3', 'default'));
+        self::assertNull($serverRequest->getParsedBodyParam('foo'));
+        self::assertSame('value1', $serverRequest->getParsedBodyParam('input1'));
+        self::assertSame('value2', $serverRequest->getParsedBodyParam('input2'));
+        self::assertSame('', $serverRequest->getParsedBodyParam('input3', 'default'));
     }
 
     /**
@@ -222,10 +222,10 @@ final class ServerRequestFactoryTest extends TestCase
 
         $serverRequest = $serverRequestFactory->fromGlobals();
 
-        $this->assertInstanceOf($expectedUri, $serverRequest->getUri());
-        $this->assertSame('POST', $serverRequest->getMethod());
-        $this->assertNull($serverRequest->getParsedBody());
-        $this->assertSame(
+        self::assertInstanceOf($expectedUri, $serverRequest->getUri());
+        self::assertSame('POST', $serverRequest->getMethod());
+        self::assertNull($serverRequest->getParsedBody());
+        self::assertSame(
             ['Host' => ['example.com'], 'Content-Type' => ['application/json'], 'Content-Length' => ['123']],
             $serverRequest->getHeaders(),
         );
@@ -279,6 +279,6 @@ final class ServerRequestFactoryTest extends TestCase
         }
 
         // This can happen when testing without the development packages.
-        $this->markTestSkipped($provider . ' is not available.');
+        self::markTestSkipped($provider . ' is not available.');
     }
 }
diff --git a/tests/classes/Http/Factory/UriFactoryTest.php b/tests/classes/Http/Factory/UriFactoryTest.php
index f6a5052815..9a5c161874 100644
--- a/tests/classes/Http/Factory/UriFactoryTest.php
+++ b/tests/classes/Http/Factory/UriFactoryTest.php
@@ -37,7 +37,7 @@ final class UriFactoryTest extends TestCase
         $this->skipIfNotAvailable($provider);
         $uriFactory = new UriFactory(new $provider());
         $uri = $uriFactory->createUri('https://www.phpmyadmin.net/');
-        $this->assertInstanceOf($expectedUri, $uri);
+        self::assertInstanceOf($expectedUri, $uri);
     }
 
     /** @psalm-return iterable<string, array{class-string<UriFactoryInterface>, class-string<UriInterface>}> */
@@ -59,7 +59,7 @@ final class UriFactoryTest extends TestCase
         (new ReflectionProperty(UriFactory::class, 'providers'))->setValue(null, [$provider]);
         $uriFactory = UriFactory::create();
         $actual = (new ReflectionProperty(UriFactory::class, 'uriFactory'))->getValue($uriFactory);
-        $this->assertInstanceOf($provider, $actual);
+        self::assertInstanceOf($provider, $actual);
     }
 
     /** @psalm-return iterable<string, array{class-string<UriFactoryInterface>}> */
@@ -96,7 +96,7 @@ final class UriFactoryTest extends TestCase
             'QUERY_STRING' => 'route=/server/plugins',
             'HTTP_HOST' => 'example.com:8080',
         ]);
-        $this->assertSame('http://username:password@example.com:8080/index.php?route=/server/plugins', (string) $uri);
+        self::assertSame('http://username:password@example.com:8080/index.php?route=/server/plugins', (string) $uri);
     }
 
     /** @psalm-param class-string<UriFactoryInterface> $provider */
@@ -111,7 +111,7 @@ final class UriFactoryTest extends TestCase
             'SERVER_NAME' => 'example.com',
             'HTTPS' => 'on',
         ]);
-        $this->assertSame('https://username@example.com', (string) $uri);
+        self::assertSame('https://username@example.com', (string) $uri);
     }
 
     /** @psalm-param class-string<UriFactoryInterface> $provider */
@@ -125,7 +125,7 @@ final class UriFactoryTest extends TestCase
             'HTTPS' => 'off',
             'REQUEST_URI' => '/index.php?route=/server/plugins',
         ]);
-        $this->assertSame('http://[2001:db8::1]/index.php?route=/server/plugins', (string) $uri);
+        self::assertSame('http://[2001:db8::1]/index.php?route=/server/plugins', (string) $uri);
     }
 
     /** @psalm-param class-string<UriFactoryInterface> $provider */
@@ -136,6 +136,6 @@ final class UriFactoryTest extends TestCase
         }
 
         // This can happen when testing without the development packages.
-        $this->markTestSkipped($provider . ' is not available.');
+        self::markTestSkipped($provider . ' is not available.');
     }
 }
diff --git a/tests/classes/Http/Handler/ApplicationHandlerTest.php b/tests/classes/Http/Handler/ApplicationHandlerTest.php
index 71c62e3ccd..51e2d60799 100644
--- a/tests/classes/Http/Handler/ApplicationHandlerTest.php
+++ b/tests/classes/Http/Handler/ApplicationHandlerTest.php
@@ -22,45 +22,45 @@ final class ApplicationHandlerTest extends TestCase
     #[BackupStaticProperties(true)]
     public function testHandleReturnsResponse(): void
     {
-        $responseRendererMock = $this->createMock(ResponseRenderer::class);
-        $responseRendererMock->expects($this->never())->method('response');
+        $responseRendererMock = self::createMock(ResponseRenderer::class);
+        $responseRendererMock->expects(self::never())->method('response');
         (new ReflectionProperty(ResponseRenderer::class, 'instance'))->setValue(null, $responseRendererMock);
-        $request = $this->createStub(ServerRequest::class);
-        $responseStub = new Response($this->createStub(ResponseInterface::class));
-        $appMock = $this->createMock(Application::class);
-        $appMock->expects($this->once())->method('handle')->with($request)->willReturn($responseStub);
+        $request = self::createStub(ServerRequest::class);
+        $responseStub = new Response(self::createStub(ResponseInterface::class));
+        $appMock = self::createMock(Application::class);
+        $appMock->expects(self::once())->method('handle')->with($request)->willReturn($responseStub);
         $handler = new ApplicationHandler($appMock);
         $response = $handler->handle($request);
-        $this->assertSame($response, $responseStub);
+        self::assertSame($response, $responseStub);
     }
 
     #[BackupStaticProperties(true)]
     public function testHandleThrowsExit(): void
     {
-        $responseStub = new Response($this->createStub(ResponseInterface::class));
-        $responseRendererMock = $this->createMock(ResponseRenderer::class);
-        $responseRendererMock->expects($this->once())->method('response')->willReturn($responseStub);
+        $responseStub = new Response(self::createStub(ResponseInterface::class));
+        $responseRendererMock = self::createMock(ResponseRenderer::class);
+        $responseRendererMock->expects(self::once())->method('response')->willReturn($responseStub);
         (new ReflectionProperty(ResponseRenderer::class, 'instance'))->setValue(null, $responseRendererMock);
-        $request = $this->createStub(ServerRequest::class);
-        $appMock = $this->createMock(Application::class);
-        $appMock->expects($this->once())->method('handle')->with($request)->willThrowException(new ExitException());
+        $request = self::createStub(ServerRequest::class);
+        $appMock = self::createMock(Application::class);
+        $appMock->expects(self::once())->method('handle')->with($request)->willThrowException(new ExitException());
         $handler = new ApplicationHandler($appMock);
         $response = $handler->handle($request);
-        $this->assertSame($response, $responseStub);
+        self::assertSame($response, $responseStub);
     }
 
     #[BackupStaticProperties(true)]
     public function testHandleReturnsNull(): void
     {
-        $responseStub = new Response($this->createStub(ResponseInterface::class));
-        $responseRendererMock = $this->createMock(ResponseRenderer::class);
-        $responseRendererMock->expects($this->once())->method('response')->willReturn($responseStub);
+        $responseStub = new Response(self::createStub(ResponseInterface::class));
+        $responseRendererMock = self::createMock(ResponseRenderer::class);
+        $responseRendererMock->expects(self::once())->method('response')->willReturn($responseStub);
         (new ReflectionProperty(ResponseRenderer::class, 'instance'))->setValue(null, $responseRendererMock);
-        $request = $this->createStub(ServerRequest::class);
-        $appMock = $this->createMock(Application::class);
-        $appMock->expects($this->once())->method('handle')->with($request)->willReturn(null);
+        $request = self::createStub(ServerRequest::class);
+        $appMock = self::createMock(Application::class);
+        $appMock->expects(self::once())->method('handle')->with($request)->willReturn(null);
         $handler = new ApplicationHandler($appMock);
         $response = $handler->handle($request);
-        $this->assertSame($response, $responseStub);
+        self::assertSame($response, $responseStub);
     }
 }
diff --git a/tests/classes/Http/Handler/QueueRequestHandlerTest.php b/tests/classes/Http/Handler/QueueRequestHandlerTest.php
index f84da298df..7a15f7940f 100644
--- a/tests/classes/Http/Handler/QueueRequestHandlerTest.php
+++ b/tests/classes/Http/Handler/QueueRequestHandlerTest.php
@@ -29,7 +29,7 @@ final class QueueRequestHandlerTest extends TestCase
             ->withAttribute('attribute', ['Initial']);
         $response = $handler->handle($request);
         $response->getBody()->write('Last');
-        $this->assertSame(
+        self::assertSame(
             'Initial, First before, Second before, Fallback, Second after, First after, Last',
             (string) $response->getBody(),
         );
@@ -46,7 +46,7 @@ final class QueueRequestHandlerTest extends TestCase
             ->withAttribute('early', true);
         $response = $handler->handle($request);
         $response->getBody()->write('Last');
-        $this->assertSame('Initial, First before, Early, First after, Last', (string) $response->getBody());
+        self::assertSame('Initial, First before, Early, First after, Last', (string) $response->getBody());
     }
 
     private function getFallbackHandler(): RequestHandler
diff --git a/tests/classes/Http/Middleware/TokenRequestParamCheckingTest.php b/tests/classes/Http/Middleware/TokenRequestParamCheckingTest.php
index a8103a1a69..eacd143d60 100644
--- a/tests/classes/Http/Middleware/TokenRequestParamCheckingTest.php
+++ b/tests/classes/Http/Middleware/TokenRequestParamCheckingTest.php
@@ -25,10 +25,10 @@ final class TokenRequestParamCheckingTest extends TestCase
         $_POST['test'] = 'test';
         $_SESSION[' PMA_token '] = 'token';
         $middleware->checkTokenRequestParam();
-        $this->assertFalse($GLOBALS['token_mismatch']);
-        $this->assertTrue($GLOBALS['token_provided']);
-        $this->assertArrayHasKey('test', $_POST);
-        $this->assertEquals('test', $_POST['test']);
+        self::assertFalse($GLOBALS['token_mismatch']);
+        self::assertTrue($GLOBALS['token_provided']);
+        self::assertArrayHasKey('test', $_POST);
+        self::assertEquals('test', $_POST['test']);
     }
 
     public function testCheckTokenRequestParamWithGetMethod(): void
@@ -42,8 +42,8 @@ final class TokenRequestParamCheckingTest extends TestCase
 
         $_SERVER['REQUEST_METHOD'] = 'GET';
         $middleware->checkTokenRequestParam();
-        $this->assertTrue($GLOBALS['token_mismatch']);
-        $this->assertFalse($GLOBALS['token_provided']);
+        self::assertTrue($GLOBALS['token_mismatch']);
+        self::assertFalse($GLOBALS['token_provided']);
     }
 
     public function testCheckTokenRequestParamWithoutToken(): void
@@ -58,9 +58,9 @@ final class TokenRequestParamCheckingTest extends TestCase
         $_SERVER['REQUEST_METHOD'] = 'POST';
         $_POST['test'] = 'test';
         $middleware->checkTokenRequestParam();
-        $this->assertTrue($GLOBALS['token_mismatch']);
-        $this->assertFalse($GLOBALS['token_provided']);
-        $this->assertArrayNotHasKey('test', $_POST);
+        self::assertTrue($GLOBALS['token_mismatch']);
+        self::assertFalse($GLOBALS['token_provided']);
+        self::assertArrayNotHasKey('test', $_POST);
     }
 
     public function testCheckTokenRequestParamWithTokenMismatch(): void
@@ -77,8 +77,8 @@ final class TokenRequestParamCheckingTest extends TestCase
         $_POST['test'] = 'test';
         $_SESSION[' PMA_token '] = 'mismatch';
         $middleware->checkTokenRequestParam();
-        $this->assertTrue($GLOBALS['token_mismatch']);
-        $this->assertTrue($GLOBALS['token_provided']);
-        $this->assertArrayNotHasKey('test', $_POST);
+        self::assertTrue($GLOBALS['token_mismatch']);
+        self::assertTrue($GLOBALS['token_provided']);
+        self::assertArrayNotHasKey('test', $_POST);
     }
 }
diff --git a/tests/classes/Http/ResponseTest.php b/tests/classes/Http/ResponseTest.php
index b74251bfe6..242b2d11a9 100644
--- a/tests/classes/Http/ResponseTest.php
+++ b/tests/classes/Http/ResponseTest.php
@@ -26,7 +26,7 @@ final class ResponseTest extends TestCase
     private function getResponse(string $provider): Response
     {
         if (! class_exists($provider)) {
-            $this->markTestSkipped($provider . ' is not available.');
+            self::markTestSkipped($provider . ' is not available.');
         }
 
         return (new ResponseFactory(new $provider()))->createResponse();
@@ -48,8 +48,8 @@ final class ResponseTest extends TestCase
     {
         $response = $this->getResponse($provider)->withProtocolVersion('1.0');
         $newResponse = $response->withProtocolVersion('1.1');
-        $this->assertSame('1.0', $response->getProtocolVersion());
-        $this->assertSame('1.1', $newResponse->getProtocolVersion());
+        self::assertSame('1.0', $response->getProtocolVersion());
+        self::assertSame('1.1', $newResponse->getProtocolVersion());
     }
 
     /** @psalm-param class-string<ResponseFactoryInterface> $provider */
@@ -57,20 +57,20 @@ final class ResponseTest extends TestCase
     public function testHeaders(string $provider): void
     {
         $response = $this->getResponse($provider);
-        $this->assertSame([], $response->getHeaders());
+        self::assertSame([], $response->getHeaders());
         $response = $response->withHeader('Content-Type', 'application/json');
-        $this->assertTrue($response->hasHeader('Content-Type'));
-        $this->assertSame(['application/json'], $response->getHeader('Content-Type'));
-        $this->assertSame('application/json', $response->getHeaderLine('Content-Type'));
+        self::assertTrue($response->hasHeader('Content-Type'));
+        self::assertSame(['application/json'], $response->getHeader('Content-Type'));
+        self::assertSame('application/json', $response->getHeaderLine('Content-Type'));
         $response = $response->withAddedHeader('Content-Type', 'text/html');
         $newResponse = $response->withHeader('Content-Length', '123');
-        $this->assertSame(['Content-Type' => ['application/json', 'text/html']], $response->getHeaders());
-        $this->assertSame(
+        self::assertSame(['Content-Type' => ['application/json', 'text/html']], $response->getHeaders());
+        self::assertSame(
             ['Content-Type' => ['application/json', 'text/html'], 'Content-Length' => ['123']],
             $newResponse->getHeaders(),
         );
         $newResponse = $newResponse->withoutHeader('Content-Type');
-        $this->assertSame(['Content-Length' => ['123']], $newResponse->getHeaders());
+        self::assertSame(['Content-Length' => ['123']], $newResponse->getHeaders());
     }
 
     /** @psalm-param class-string<ResponseFactoryInterface> $provider */
@@ -82,8 +82,8 @@ final class ResponseTest extends TestCase
         $newBody = $this->getResponse($provider)->getBody();
         $newBody->write('bar');
         $newResponse = $response->withBody($newBody);
-        $this->assertSame('foo', (string) $response->getBody());
-        $this->assertSame('bar', (string) $newResponse->getBody());
+        self::assertSame('foo', (string) $response->getBody());
+        self::assertSame('bar', (string) $newResponse->getBody());
     }
 
     /** @psalm-param class-string<ResponseFactoryInterface> $provider */
@@ -92,10 +92,10 @@ final class ResponseTest extends TestCase
     {
         $response = $this->getResponse($provider)->withStatus(StatusCodeInterface::STATUS_OK, 'OK');
         $newResponse = $response->withStatus(StatusCodeInterface::STATUS_NOT_FOUND, 'Not Found');
-        $this->assertSame(StatusCodeInterface::STATUS_OK, $response->getStatusCode());
-        $this->assertSame('OK', $response->getReasonPhrase());
-        $this->assertSame(StatusCodeInterface::STATUS_NOT_FOUND, $newResponse->getStatusCode());
-        $this->assertSame('Not Found', $newResponse->getReasonPhrase());
+        self::assertSame(StatusCodeInterface::STATUS_OK, $response->getStatusCode());
+        self::assertSame('OK', $response->getReasonPhrase());
+        self::assertSame(StatusCodeInterface::STATUS_NOT_FOUND, $newResponse->getStatusCode());
+        self::assertSame('Not Found', $newResponse->getReasonPhrase());
     }
 
     /** @psalm-param class-string<ResponseFactoryInterface> $provider */
@@ -105,8 +105,8 @@ final class ResponseTest extends TestCase
         $response = $this->getResponse($provider);
         $response->getBody()->write('foo');
         $sameResponse = $response->write('bar');
-        $this->assertSame('foobar', (string) $response->getBody());
-        $this->assertSame('foobar', (string) $sameResponse->getBody());
-        $this->assertSame($response, $sameResponse);
+        self::assertSame('foobar', (string) $response->getBody());
+        self::assertSame('foobar', (string) $sameResponse->getBody());
+        self::assertSame($response, $sameResponse);
     }
 }
diff --git a/tests/classes/Http/ServerRequestTest.php b/tests/classes/Http/ServerRequestTest.php
index 982d712383..8165846395 100644
--- a/tests/classes/Http/ServerRequestTest.php
+++ b/tests/classes/Http/ServerRequestTest.php
@@ -21,11 +21,11 @@ class ServerRequestTest extends TestCase
     #[DataProvider('providerForTestGetRoute')]
     public function testGetRoute(string $expected, array $get, array $post): void
     {
-        $requestStub = $this->createStub(ServerRequestInterface::class);
+        $requestStub = self::createStub(ServerRequestInterface::class);
         $requestStub->method('getQueryParams')->willReturn($get);
         $requestStub->method('getParsedBody')->willReturn($post);
         $request = new ServerRequest($requestStub);
-        $this->assertSame($expected, $request->getRoute());
+        self::assertSame($expected, $request->getRoute());
     }
 
     /**
@@ -51,45 +51,45 @@ class ServerRequestTest extends TestCase
     public function testGetQueryParam(): void
     {
         $queryParams = ['key1' => 'value1', 'key2' => ['value2'], 'key4' => ''];
-        $requestStub = $this->createStub(ServerRequestInterface::class);
+        $requestStub = self::createStub(ServerRequestInterface::class);
         $requestStub->method('getQueryParams')->willReturn($queryParams);
         $request = new ServerRequest($requestStub);
-        $this->assertSame('value1', $request->getQueryParam('key1'));
-        $this->assertSame('value1', $request->getQueryParam('key1', 'default'));
-        $this->assertSame(['value2'], $request->getQueryParam('key2'));
-        $this->assertSame(['value2'], $request->getQueryParam('key2', 'default'));
-        $this->assertNull($request->getQueryParam('key3'));
-        $this->assertSame('default', $request->getQueryParam('key3', 'default'));
-        $this->assertSame('', $request->getQueryParam('key4'));
-        $this->assertSame('', $request->getQueryParam('key4', 'default'));
+        self::assertSame('value1', $request->getQueryParam('key1'));
+        self::assertSame('value1', $request->getQueryParam('key1', 'default'));
+        self::assertSame(['value2'], $request->getQueryParam('key2'));
+        self::assertSame(['value2'], $request->getQueryParam('key2', 'default'));
+        self::assertNull($request->getQueryParam('key3'));
+        self::assertSame('default', $request->getQueryParam('key3', 'default'));
+        self::assertSame('', $request->getQueryParam('key4'));
+        self::assertSame('', $request->getQueryParam('key4', 'default'));
     }
 
     public function testHasBodyParam(): void
     {
         $queryParams = ['key1' => 'value1', 'key2' => ['value2'], 'key4' => ''];
-        $requestStub = $this->createStub(ServerRequestInterface::class);
+        $requestStub = self::createStub(ServerRequestInterface::class);
         $requestStub->method('getParsedBody')->willReturn($queryParams);
         $request = new ServerRequest($requestStub);
-        $this->assertTrue($request->hasBodyParam('key1'));
-        $this->assertTrue($request->hasBodyParam('key2'));
-        $this->assertFalse($request->hasBodyParam('key3'));
-        $this->assertTrue($request->hasBodyParam('key4'));
+        self::assertTrue($request->hasBodyParam('key1'));
+        self::assertTrue($request->hasBodyParam('key2'));
+        self::assertFalse($request->hasBodyParam('key3'));
+        self::assertTrue($request->hasBodyParam('key4'));
     }
 
     public function testHasQueryParam(): void
     {
         $queryParams = ['key1' => 'value1', 'key2' => ['value2'], 'key4' => ''];
-        $requestStub = $this->createStub(ServerRequestInterface::class);
+        $requestStub = self::createStub(ServerRequestInterface::class);
         $requestStub->method('getQueryParams')->willReturn($queryParams);
         $request = new ServerRequest($requestStub);
-        $this->assertTrue($request->hasQueryParam('key1'));
-        $this->assertTrue($request->has('key1'));
-        $this->assertTrue($request->hasQueryParam('key2'));
-        $this->assertTrue($request->has('key2'));
-        $this->assertFalse($request->hasQueryParam('key3'));
-        $this->assertFalse($request->has('key3'));
-        $this->assertTrue($request->hasQueryParam('key4'));
-        $this->assertTrue($request->has('key4'));
+        self::assertTrue($request->hasQueryParam('key1'));
+        self::assertTrue($request->has('key1'));
+        self::assertTrue($request->hasQueryParam('key2'));
+        self::assertTrue($request->has('key2'));
+        self::assertFalse($request->hasQueryParam('key3'));
+        self::assertFalse($request->has('key3'));
+        self::assertTrue($request->hasQueryParam('key4'));
+        self::assertTrue($request->has('key4'));
     }
 
     /**
@@ -104,7 +104,7 @@ class ServerRequestTest extends TestCase
             $request = $request->withAddedHeader($name, $value);
         }
 
-        $this->assertSame($expected, $request->isAjax());
+        self::assertSame($expected, $request->isAjax());
     }
 
     /** @return iterable<int, array{bool, string, string, array<string, string>, array<string, string>|null}> */
diff --git a/tests/classes/Identifiers/DatabaseNameTest.php b/tests/classes/Identifiers/DatabaseNameTest.php
index 52b6ee0221..e66007f638 100644
--- a/tests/classes/Identifiers/DatabaseNameTest.php
+++ b/tests/classes/Identifiers/DatabaseNameTest.php
@@ -20,17 +20,17 @@ class DatabaseNameTest extends TestCase
     public function testValidName(string $validName): void
     {
         $name = DatabaseName::from($validName);
-        $this->assertEquals($validName, $name->getName());
-        $this->assertEquals($validName, (string) $name);
+        self::assertEquals($validName, $name->getName());
+        self::assertEquals($validName, (string) $name);
     }
 
     #[DataProvider('providerForTestValidNames')]
     public function testTryFromValueWithValidName(string $validName): void
     {
         $name = DatabaseName::tryFrom($validName);
-        $this->assertNotNull($name);
-        $this->assertEquals($validName, $name->getName());
-        $this->assertEquals($validName, (string) $name);
+        self::assertNotNull($name);
+        self::assertEquals($validName, $name->getName());
+        self::assertEquals($validName, (string) $name);
     }
 
     /** @return iterable<int, string[]> */
@@ -44,7 +44,7 @@ class DatabaseNameTest extends TestCase
     #[DataProvider('providerForTestInvalidNames')]
     public function testInvalidNames(mixed $name, string $exceptionMessage): void
     {
-        $this->assertNull(DatabaseName::tryFrom($name));
+        self::assertNull(DatabaseName::tryFrom($name));
         $this->expectException(InvalidDatabaseName::class);
         $this->expectExceptionMessage($exceptionMessage);
         DatabaseName::from($name);
diff --git a/tests/classes/Identifiers/TableNameTest.php b/tests/classes/Identifiers/TableNameTest.php
index 4d601ff5c5..5f71c16855 100644
--- a/tests/classes/Identifiers/TableNameTest.php
+++ b/tests/classes/Identifiers/TableNameTest.php
@@ -20,17 +20,17 @@ class TableNameTest extends TestCase
     public function testValidName(string $validName): void
     {
         $name = TableName::from($validName);
-        $this->assertEquals($validName, $name->getName());
-        $this->assertEquals($validName, (string) $name);
+        self::assertEquals($validName, $name->getName());
+        self::assertEquals($validName, (string) $name);
     }
 
     #[DataProvider('providerForTestValidNames')]
     public function testTryFromValueValidName(string $validName): void
     {
         $name = TableName::tryFrom($validName);
-        $this->assertNotNull($name);
-        $this->assertEquals($validName, $name->getName());
-        $this->assertEquals($validName, (string) $name);
+        self::assertNotNull($name);
+        self::assertEquals($validName, $name->getName());
+        self::assertEquals($validName, (string) $name);
     }
 
     /** @return iterable<int, string[]> */
@@ -44,7 +44,7 @@ class TableNameTest extends TestCase
     #[DataProvider('providerForTestInvalidNames')]
     public function testInvalidNames(mixed $name, string $exceptionMessage): void
     {
-        $this->assertNull(TableName::tryFrom($name));
+        self::assertNull(TableName::tryFrom($name));
         $this->expectException(InvalidTableName::class);
         $this->expectExceptionMessage($exceptionMessage);
         TableName::from($name);
diff --git a/tests/classes/Identifiers/TriggerNameTest.php b/tests/classes/Identifiers/TriggerNameTest.php
index 342188cfec..76986df031 100644
--- a/tests/classes/Identifiers/TriggerNameTest.php
+++ b/tests/classes/Identifiers/TriggerNameTest.php
@@ -20,17 +20,17 @@ final class TriggerNameTest extends TestCase
     public function testValidName(string $validName): void
     {
         $name = TriggerName::from($validName);
-        $this->assertEquals($validName, $name->getName());
-        $this->assertEquals($validName, (string) $name);
+        self::assertEquals($validName, $name->getName());
+        self::assertEquals($validName, (string) $name);
     }
 
     #[DataProvider('providerForTestValidNames')]
     public function testTryFromValueValidName(string $validName): void
     {
         $name = TriggerName::tryFrom($validName);
-        $this->assertNotNull($name);
-        $this->assertEquals($validName, $name->getName());
-        $this->assertEquals($validName, (string) $name);
+        self::assertNotNull($name);
+        self::assertEquals($validName, $name->getName());
+        self::assertEquals($validName, (string) $name);
     }
 
     /** @return iterable<int, string[]> */
@@ -44,7 +44,7 @@ final class TriggerNameTest extends TestCase
     #[DataProvider('providerForTestInvalidNames')]
     public function testInvalidNames(mixed $name, string $exceptionMessage): void
     {
-        $this->assertNull(TriggerName::tryFrom($name));
+        self::assertNull(TriggerName::tryFrom($name));
         $this->expectException(InvalidTriggerName::class);
         $this->expectExceptionMessage($exceptionMessage);
         TriggerName::from($name);
diff --git a/tests/classes/Import/AjaxTest.php b/tests/classes/Import/AjaxTest.php
index ec1c4a2dfb..7cf19d29dc 100644
--- a/tests/classes/Import/AjaxTest.php
+++ b/tests/classes/Import/AjaxTest.php
@@ -13,6 +13,6 @@ class AjaxTest extends TestCase
 {
     public function testNopluginCheck(): void
     {
-        $this->assertTrue(Ajax::nopluginCheck());
+        self::assertTrue(Ajax::nopluginCheck());
     }
 }
diff --git a/tests/classes/Import/ImportTest.php b/tests/classes/Import/ImportTest.php
index ba2911eae8..45d35ae23a 100644
--- a/tests/classes/Import/ImportTest.php
+++ b/tests/classes/Import/ImportTest.php
@@ -49,35 +49,35 @@ class ImportTest extends AbstractTestCase
         $GLOBALS['maximum_time'] = 0;
         $GLOBALS['timeout_passed'] = false;
 
-        $this->assertFalse($this->import->checkTimeout());
+        self::assertFalse($this->import->checkTimeout());
 
         //Reinit values.
         $GLOBALS['timestamp'] = time();
         $GLOBALS['maximum_time'] = 0;
         $GLOBALS['timeout_passed'] = true;
 
-        $this->assertFalse($this->import->checkTimeout());
+        self::assertFalse($this->import->checkTimeout());
 
         //Reinit values.
         $GLOBALS['timestamp'] = time();
         $GLOBALS['maximum_time'] = 30;
         $GLOBALS['timeout_passed'] = true;
 
-        $this->assertTrue($this->import->checkTimeout());
+        self::assertTrue($this->import->checkTimeout());
 
         //Reinit values.
         $GLOBALS['timestamp'] = time() - 15;
         $GLOBALS['maximum_time'] = 30;
         $GLOBALS['timeout_passed'] = false;
 
-        $this->assertFalse($this->import->checkTimeout());
+        self::assertFalse($this->import->checkTimeout());
 
         //Reinit values.
         $GLOBALS['timestamp'] = time() - 60;
         $GLOBALS['maximum_time'] = 30;
         $GLOBALS['timeout_passed'] = false;
 
-        $this->assertTrue($this->import->checkTimeout());
+        self::assertTrue($this->import->checkTimeout());
     }
 
     /**
@@ -85,17 +85,17 @@ class ImportTest extends AbstractTestCase
      */
     public function testLookForUse(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             '',
             $this->import->lookForUse('select 1 from myTable'),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'anotherDb',
             $this->import->lookForUse('use anotherDb'),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'anotherDb',
             $this->import->lookForUse('use `anotherDb`;'),
         );
@@ -110,7 +110,7 @@ class ImportTest extends AbstractTestCase
     #[DataProvider('provGetColumnAlphaName')]
     public function testGetColumnAlphaName(string $expected, int $num): void
     {
-        $this->assertEquals($expected, $this->import->getColumnAlphaName($num));
+        self::assertEquals($expected, $this->import->getColumnAlphaName($num));
     }
 
     /**
@@ -132,7 +132,7 @@ class ImportTest extends AbstractTestCase
     #[DataProvider('provGetColumnNumberFromName')]
     public function testGetColumnNumberFromName(int $expected, string $name): void
     {
-        $this->assertEquals($expected, $this->import->getColumnNumberFromName($name));
+        self::assertEquals($expected, $this->import->getColumnNumberFromName($name));
     }
 
     /**
@@ -154,7 +154,7 @@ class ImportTest extends AbstractTestCase
     #[DataProvider('provGetDecimalPrecision')]
     public function testGetDecimalPrecision(int $expected, string $size): void
     {
-        $this->assertEquals($expected, $this->import->getDecimalPrecision($size));
+        self::assertEquals($expected, $this->import->getDecimalPrecision($size));
     }
 
     /**
@@ -176,7 +176,7 @@ class ImportTest extends AbstractTestCase
     #[DataProvider('provGetDecimalScale')]
     public function testGetDecimalScale(int $expected, string $size): void
     {
-        $this->assertEquals($expected, $this->import->getDecimalScale($size));
+        self::assertEquals($expected, $this->import->getDecimalScale($size));
     }
 
     /**
@@ -198,7 +198,7 @@ class ImportTest extends AbstractTestCase
     #[DataProvider('provGetDecimalSize')]
     public function testGetDecimalSize(array $expected, string $cell): void
     {
-        $this->assertEquals($expected, $this->import->getDecimalSize($cell));
+        self::assertEquals($expected, $this->import->getDecimalSize($cell));
     }
 
     /**
@@ -223,7 +223,7 @@ class ImportTest extends AbstractTestCase
     #[DataProvider('provDetectType')]
     public function testDetectType(int $expected, int|null $type, string|null $cell): void
     {
-        $this->assertEquals($expected, $this->import->detectType($type, $cell));
+        self::assertEquals($expected, $this->import->detectType($type, $cell));
     }
 
     /**
@@ -269,7 +269,7 @@ class ImportTest extends AbstractTestCase
 
         $sqlQuery = 'UPDATE `table_1` AS t1, `table_2` t2 SET `table_1`.`id` = `table_2`.`id` WHERE 1';
 
-        $this->assertTrue($this->import->checkIfRollbackPossible($sqlQuery));
+        self::assertTrue($this->import->checkIfRollbackPossible($sqlQuery));
     }
 
     /**
@@ -303,7 +303,7 @@ class ImportTest extends AbstractTestCase
     #[DataProvider('providerContentWithByteOrderMarks')]
     public function testSkipByteOrderMarksFromContents(string $input, string $cleanContents): void
     {
-        $this->assertEquals($cleanContents, $this->import->skipByteOrderMarksFromContents($input));
+        self::assertEquals($cleanContents, $this->import->skipByteOrderMarksFromContents($input));
     }
 
     /**
@@ -316,24 +316,24 @@ class ImportTest extends AbstractTestCase
 
         $this->import->runQuery('SELECT 1', $sqlData);
 
-        $this->assertSame([], $sqlData);
-        $this->assertSame('', $GLOBALS['sql_query']);
-        $this->assertNull($GLOBALS['complete_query']);
-        $this->assertNull($GLOBALS['display_query']);
+        self::assertSame([], $sqlData);
+        self::assertSame('', $GLOBALS['sql_query']);
+        self::assertNull($GLOBALS['complete_query']);
+        self::assertNull($GLOBALS['display_query']);
 
         $this->import->runQuery('SELECT 2', $sqlData);
 
-        $this->assertSame(['SELECT 1;'], $sqlData);
-        $this->assertSame('SELECT 1;', $GLOBALS['sql_query']);
-        $this->assertSame('SELECT 1;', $GLOBALS['complete_query']);
-        $this->assertSame('SELECT 1;', $GLOBALS['display_query']);
+        self::assertSame(['SELECT 1;'], $sqlData);
+        self::assertSame('SELECT 1;', $GLOBALS['sql_query']);
+        self::assertSame('SELECT 1;', $GLOBALS['complete_query']);
+        self::assertSame('SELECT 1;', $GLOBALS['display_query']);
 
         $this->import->runQuery('', $sqlData);
 
-        $this->assertSame(['SELECT 1;', 'SELECT 2;'], $sqlData);
+        self::assertSame(['SELECT 1;', 'SELECT 2;'], $sqlData);
 
-        $this->assertSame('SELECT 2;', $GLOBALS['sql_query']);
-        $this->assertSame('SELECT 1;SELECT 2;', $GLOBALS['complete_query']);
-        $this->assertSame('SELECT 1;SELECT 2;', $GLOBALS['display_query']);
+        self::assertSame('SELECT 2;', $GLOBALS['sql_query']);
+        self::assertSame('SELECT 1;SELECT 2;', $GLOBALS['complete_query']);
+        self::assertSame('SELECT 1;SELECT 2;', $GLOBALS['display_query']);
     }
 }
diff --git a/tests/classes/Import/SimulateDmlTest.php b/tests/classes/Import/SimulateDmlTest.php
index 5eeb04cbad..92ae9e87a9 100644
--- a/tests/classes/Import/SimulateDmlTest.php
+++ b/tests/classes/Import/SimulateDmlTest.php
@@ -49,7 +49,7 @@ class SimulateDmlTest extends AbstractTestCase
 
         $dummyDbi->assertAllSelectsConsumed();
         $dummyDbi->assertAllQueriesConsumed();
-        $this->assertEquals([
+        self::assertEquals([
             'sql_query' => Generator::formatSql($sqlQuery),
             'matched_rows' => count($result),
             'matched_rows_url' => $matchedRowsUrl,
diff --git a/tests/classes/IndexColumnTest.php b/tests/classes/IndexColumnTest.php
index 0dc3ed0883..b4082420e5 100644
--- a/tests/classes/IndexColumnTest.php
+++ b/tests/classes/IndexColumnTest.php
@@ -21,36 +21,36 @@ class IndexColumnTest extends TestCase
     public function testGetNull(): void
     {
         $this->object->set(['Null' => '']);
-        $this->assertEquals('No', $this->object->getNull());
+        self::assertEquals('No', $this->object->getNull());
         $this->object->set(['Null' => 'YES']);
-        $this->assertEquals('Yes', $this->object->getNull());
+        self::assertEquals('Yes', $this->object->getNull());
     }
 
     public function testIsNullable(): void
     {
         $this->object->set(['Null' => '']);
-        $this->assertEquals(false, $this->object->isNullable());
+        self::assertEquals(false, $this->object->isNullable());
         $this->object->set(['Null' => 'YES']);
-        $this->assertEquals(true, $this->object->isNullable());
+        self::assertEquals(true, $this->object->isNullable());
     }
 
     public function testGetSeqInIndex(): void
     {
-        $this->assertEquals(1, $this->object->getSeqInIndex());
+        self::assertEquals(1, $this->object->getSeqInIndex());
         $this->object->set(['Seq_in_index' => 2]);
-        $this->assertEquals(2, $this->object->getSeqInIndex());
+        self::assertEquals(2, $this->object->getSeqInIndex());
     }
 
     public function testGetSubPart(): void
     {
-        $this->assertNull($this->object->getSubPart());
+        self::assertNull($this->object->getSubPart());
         $this->object->set(['Sub_part' => 2]);
-        $this->assertEquals(2, $this->object->getSubPart());
+        self::assertEquals(2, $this->object->getSubPart());
     }
 
     public function testGetCompareData(): void
     {
-        $this->assertSame(
+        self::assertSame(
             ['Column_name' => '', 'Seq_in_index' => 1, 'Collation' => null, 'Sub_part' => null, 'Null' => ''],
             $this->object->getCompareData(),
         );
@@ -61,7 +61,7 @@ class IndexColumnTest extends TestCase
             'Sub_part' => 2,
             'Null' => 'NO',
         ]);
-        $this->assertSame(
+        self::assertSame(
             [
                 'Column_name' => 'name',
                 'Seq_in_index' => 2,
@@ -75,22 +75,22 @@ class IndexColumnTest extends TestCase
 
     public function testGetName(): void
     {
-        $this->assertEquals('', $this->object->getName());
+        self::assertEquals('', $this->object->getName());
         $this->object->set(['Column_name' => 'name']);
-        $this->assertEquals('name', $this->object->getName());
+        self::assertEquals('name', $this->object->getName());
     }
 
     public function testGetCardinality(): void
     {
-        $this->assertNull($this->object->getCardinality());
+        self::assertNull($this->object->getCardinality());
         $this->object->set(['Cardinality' => 2]);
-        $this->assertEquals(2, $this->object->getCardinality());
+        self::assertEquals(2, $this->object->getCardinality());
     }
 
     public function testGetCollation(): void
     {
-        $this->assertNull($this->object->getCollation());
+        self::assertNull($this->object->getCollation());
         $this->object->set(['Collation' => 'collation']);
-        $this->assertEquals('collation', $this->object->getCollation());
+        self::assertEquals('collation', $this->object->getCollation());
     }
 }
diff --git a/tests/classes/IndexTest.php b/tests/classes/IndexTest.php
index 67aa4e040c..74f2c2dfb5 100644
--- a/tests/classes/IndexTest.php
+++ b/tests/classes/IndexTest.php
@@ -62,35 +62,35 @@ class IndexTest extends AbstractTestCase
     public function testConstructor(): void
     {
         $index = new Index($this->params);
-        $this->assertEquals(
+        self::assertEquals(
             'PMA_Index_comment',
             $index->getComment(),
         );
-        $this->assertEquals(
+        self::assertEquals(
             'PMA_Comment',
             $index->getRemarks(),
         );
-        $this->assertEquals(
+        self::assertEquals(
             'PMA_Index_choice',
             $index->getChoice(),
         );
-        $this->assertEquals(
+        self::assertEquals(
             'PMA_Packed',
             $index->getPacked(),
         );
-        $this->assertEquals(
+        self::assertEquals(
             'PMA_Non_unique',
             $index->getNonUnique(),
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             'PMA_Comment',
             $index->getComments(),
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             'PMA_Index_comment',
             $index->getComments(),
         );
-        $this->assertEquals(
+        self::assertEquals(
             'PMA_Index_choice',
             $index->getChoice(),
         );
@@ -103,10 +103,10 @@ class IndexTest extends AbstractTestCase
     {
         $this->params['Non_unique'] = '0';
         $index = new Index($this->params);
-        $this->assertTrue(
+        self::assertTrue(
             $index->isUnique(),
         );
-        $this->assertEquals(
+        self::assertEquals(
             'Yes',
             $index->isUnique(true),
         );
@@ -119,10 +119,10 @@ class IndexTest extends AbstractTestCase
     {
         $index = new Index();
         $index->addColumns($this->params['columns']);
-        $this->assertTrue($index->hasColumn('column1'));
-        $this->assertTrue($index->hasColumn('column2'));
-        $this->assertTrue($index->hasColumn('column3'));
-        $this->assertEquals(
+        self::assertTrue($index->hasColumn('column1'));
+        self::assertTrue($index->hasColumn('column2'));
+        self::assertTrue($index->hasColumn('column3'));
+        self::assertEquals(
             3,
             $index->getColumnCount(),
         );
@@ -135,7 +135,7 @@ class IndexTest extends AbstractTestCase
     {
         $index = new Index();
         $index->setName('PMA_name');
-        $this->assertEquals(
+        self::assertEquals(
             'PMA_name',
             $index->getName(),
         );
@@ -148,19 +148,19 @@ class IndexTest extends AbstractTestCase
 
         $indexColumns = $index->getColumns();
         $indexColumn = $indexColumns['column1'];
-        $this->assertEquals(
+        self::assertEquals(
             'column1',
             $indexColumn->getName(),
         );
-        $this->assertEquals(
+        self::assertEquals(
             '1',
             $indexColumn->getSeqInIndex(),
         );
-        $this->assertEquals(
+        self::assertEquals(
             'Collation1',
             $indexColumn->getCollation(),
         );
-        $this->assertEquals(
+        self::assertEquals(
             '1',
             $indexColumn->getCardinality(),
         );
diff --git a/tests/classes/InsertEditTest.php b/tests/classes/InsertEditTest.php
index 7d8d5de573..f8cdf6e926 100644
--- a/tests/classes/InsertEditTest.php
+++ b/tests/classes/InsertEditTest.php
@@ -134,7 +134,7 @@ class InsertEditTest extends AbstractTestCase
             'localhost',
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             [
                 'db' => 'dbname',
                 'table' => 'tablename',
@@ -168,7 +168,7 @@ class InsertEditTest extends AbstractTestCase
             'localhost',
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             [
                 'db' => 'dbname',
                 'table' => 'tablename',
@@ -190,26 +190,26 @@ class InsertEditTest extends AbstractTestCase
     {
         $clauses = ['a=1', 'b="fo\o"'];
 
-        $resultStub1 = $this->createMock(DummyResult::class);
-        $resultStub2 = $this->createMock(DummyResult::class);
+        $resultStub1 = self::createMock(DummyResult::class);
+        $resultStub2 = self::createMock(DummyResult::class);
 
         $dbi = $this->getMockBuilder(DatabaseInterface::class)
             ->disableOriginalConstructor()
             ->getMock();
 
-        $dbi->expects($this->exactly(2))
+        $dbi->expects(self::exactly(2))
             ->method('query')
             ->willReturn($resultStub1, $resultStub2);
 
-        $resultStub1->expects($this->once())
+        $resultStub1->expects(self::once())
             ->method('fetchAssoc')
             ->willReturn(['assoc1']);
 
-        $resultStub2->expects($this->once())
+        $resultStub2->expects(self::once())
             ->method('fetchAssoc')
             ->willReturn(['assoc2']);
 
-        $dbi->expects($this->exactly(2))
+        $dbi->expects(self::exactly(2))
             ->method('getFieldsMeta')
             ->willReturn([], []);
 
@@ -228,7 +228,7 @@ class InsertEditTest extends AbstractTestCase
             [$clauses, 'table', 'db'],
         );
 
-        $this->assertSame(
+        self::assertSame(
             [['a=1', 'b="fo\\\\o"'], [$resultStub1, $resultStub2], [['assoc1'], ['assoc2']], false],
             $result,
         );
@@ -246,13 +246,13 @@ class InsertEditTest extends AbstractTestCase
             'orgname' => 'orgname',
         ]);
 
-        $resultStub = $this->createMock(DummyResult::class);
+        $resultStub = self::createMock(DummyResult::class);
 
         $dbi = $this->getMockBuilder(DatabaseInterface::class)
             ->disableOriginalConstructor()
             ->getMock();
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('getFieldsMeta')
             ->with($resultStub)
             ->willReturn([$meta]);
@@ -273,7 +273,7 @@ class InsertEditTest extends AbstractTestCase
             [['1' => ['1' => 1]], 1, [], 'SELECT', ['1' => $resultStub]],
         );
 
-        $this->assertTrue($result);
+        self::assertTrue($result);
 
         // case 2
         Config::getInstance()->settings['ShowSQL'] = false;
@@ -296,18 +296,18 @@ class InsertEditTest extends AbstractTestCase
 
         $response->setValue(null, $restoreInstance);
 
-        $this->assertFalse($result);
+        self::assertFalse($result);
     }
 
     public function testLoadFirstRow(): void
     {
-        $resultStub = $this->createMock(DummyResult::class);
+        $resultStub = self::createMock(DummyResult::class);
 
         $dbi = $this->getMockBuilder(DatabaseInterface::class)
             ->disableOriginalConstructor()
             ->getMock();
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('query')
             ->with('SELECT * FROM `db`.`table` LIMIT 1;')
             ->willReturn($resultStub);
@@ -328,7 +328,7 @@ class InsertEditTest extends AbstractTestCase
             ['table', 'db'],
         );
 
-        $this->assertEquals($resultStub, $result);
+        self::assertEquals($resultStub, $result);
     }
 
     /** @return list<array{int, array<false>}> */
@@ -354,7 +354,7 @@ class InsertEditTest extends AbstractTestCase
             [],
         );
 
-        $this->assertEquals($rowsValue, $result);
+        self::assertEquals($rowsValue, $result);
     }
 
     /**
@@ -369,42 +369,42 @@ class InsertEditTest extends AbstractTestCase
 
         $result = $this->insertEdit->showTypeOrFunction('function', $urlParams, false);
 
-        $this->assertStringContainsString('index.php?route=/table/change', $result);
-        $this->assertStringContainsString(
+        self::assertStringContainsString('index.php?route=/table/change', $result);
+        self::assertStringContainsString(
             'ShowFunctionFields=1&ShowFieldTypesInDataEditView=1&goto=index.php%3Froute%3D%2Fsql',
             $result,
         );
-        $this->assertStringContainsString('Function', $result);
+        self::assertStringContainsString('Function', $result);
 
         // case 2
         $result = $this->insertEdit->showTypeOrFunction('function', $urlParams, true);
 
-        $this->assertStringContainsString('index.php?route=/table/change', $result);
-        $this->assertStringContainsString(
+        self::assertStringContainsString('index.php?route=/table/change', $result);
+        self::assertStringContainsString(
             'ShowFunctionFields=0&ShowFieldTypesInDataEditView=1&goto=index.php%3Froute%3D%2Fsql',
             $result,
         );
-        $this->assertStringContainsString('Function', $result);
+        self::assertStringContainsString('Function', $result);
 
         // case 3
         $result = $this->insertEdit->showTypeOrFunction('type', $urlParams, false);
 
-        $this->assertStringContainsString('index.php?route=/table/change', $result);
-        $this->assertStringContainsString(
+        self::assertStringContainsString('index.php?route=/table/change', $result);
+        self::assertStringContainsString(
             'ShowFunctionFields=1&ShowFieldTypesInDataEditView=1&goto=index.php%3Froute%3D%2Fsql',
             $result,
         );
-        $this->assertStringContainsString('Type', $result);
+        self::assertStringContainsString('Type', $result);
 
         // case 4
         $result = $this->insertEdit->showTypeOrFunction('type', $urlParams, true);
 
-        $this->assertStringContainsString('index.php?route=/table/change', $result);
-        $this->assertStringContainsString(
+        self::assertStringContainsString('index.php?route=/table/change', $result);
+        self::assertStringContainsString(
             'ShowFunctionFields=1&ShowFieldTypesInDataEditView=0&goto=index.php%3Froute%3D%2Fsql',
             $result,
         );
-        $this->assertStringContainsString('Type', $result);
+        self::assertStringContainsString('Type', $result);
     }
 
     /**
@@ -414,7 +414,7 @@ class InsertEditTest extends AbstractTestCase
     {
         $fieldName = 'f1<';
 
-        $this->assertEquals(
+        self::assertEquals(
             $this->callFunction(
                 $this->insertEdit,
                 InsertEdit::class,
@@ -436,9 +436,9 @@ class InsertEditTest extends AbstractTestCase
 
         $result = $this->parseString($result);
 
-        $this->assertStringContainsString('title="comment&gt;"', $result);
+        self::assertStringContainsString('title="comment&gt;"', $result);
 
-        $this->assertStringContainsString('f1&lt;', $result);
+        self::assertStringContainsString('f1&lt;', $result);
     }
 
     /**
@@ -449,47 +449,47 @@ class InsertEditTest extends AbstractTestCase
         $types = ['binary', 'varbinary'];
 
         $columnType = 'binaryfoo';
-        $this->assertTrue($this->insertEdit->isColumn($columnType, $types));
+        self::assertTrue($this->insertEdit->isColumn($columnType, $types));
 
         $columnType = 'Binaryfoo';
-        $this->assertTrue($this->insertEdit->isColumn($columnType, $types));
+        self::assertTrue($this->insertEdit->isColumn($columnType, $types));
 
         $columnType = 'varbinaryfoo';
-        $this->assertTrue($this->insertEdit->isColumn($columnType, $types));
+        self::assertTrue($this->insertEdit->isColumn($columnType, $types));
 
         $columnType = 'barbinaryfoo';
-        $this->assertFalse($this->insertEdit->isColumn($columnType, $types));
+        self::assertFalse($this->insertEdit->isColumn($columnType, $types));
 
         $types = ['char', 'varchar'];
 
         $columnType = 'char(10)';
-        $this->assertTrue($this->insertEdit->isColumn($columnType, $types));
+        self::assertTrue($this->insertEdit->isColumn($columnType, $types));
 
         $columnType = 'VarChar(20)';
-        $this->assertTrue($this->insertEdit->isColumn($columnType, $types));
+        self::assertTrue($this->insertEdit->isColumn($columnType, $types));
 
         $columnType = 'foochar';
-        $this->assertFalse($this->insertEdit->isColumn($columnType, $types));
+        self::assertFalse($this->insertEdit->isColumn($columnType, $types));
 
         $types = ['blob', 'tinyblob', 'mediumblob', 'longblob'];
 
         $columnType = 'blob';
-        $this->assertTrue($this->insertEdit->isColumn($columnType, $types));
+        self::assertTrue($this->insertEdit->isColumn($columnType, $types));
 
         $columnType = 'bloB';
-        $this->assertTrue($this->insertEdit->isColumn($columnType, $types));
+        self::assertTrue($this->insertEdit->isColumn($columnType, $types));
 
         $columnType = 'mediumBloB';
-        $this->assertTrue($this->insertEdit->isColumn($columnType, $types));
+        self::assertTrue($this->insertEdit->isColumn($columnType, $types));
 
         $columnType = 'tinyblobabc';
-        $this->assertTrue($this->insertEdit->isColumn($columnType, $types));
+        self::assertTrue($this->insertEdit->isColumn($columnType, $types));
 
         $columnType = 'longblob';
-        $this->assertTrue($this->insertEdit->isColumn($columnType, $types));
+        self::assertTrue($this->insertEdit->isColumn($columnType, $types));
 
         $columnType = 'foolongblobbar';
-        $this->assertFalse($this->insertEdit->isColumn($columnType, $types));
+        self::assertFalse($this->insertEdit->isColumn($columnType, $types));
     }
 
     /**
@@ -512,7 +512,7 @@ class InsertEditTest extends AbstractTestCase
             false,
             false,
         );
-        $this->assertEquals(
+        self::assertEquals(
             '1',
             $this->callFunction(
                 $this->insertEdit,
@@ -535,7 +535,7 @@ class InsertEditTest extends AbstractTestCase
             false,
             false,
         );
-        $this->assertEquals(
+        self::assertEquals(
             '2',
             $this->callFunction(
                 $this->insertEdit,
@@ -546,7 +546,7 @@ class InsertEditTest extends AbstractTestCase
         );
 
         $column = new InsertEditColumn('f', 'set', false, '', null, '', -1, false, false, false, false);
-        $this->assertEquals(
+        self::assertEquals(
             '3',
             $this->callFunction(
                 $this->insertEdit,
@@ -559,7 +559,7 @@ class InsertEditTest extends AbstractTestCase
         $column = new InsertEditColumn('f', '', false, '', null, '', -1, false, false, false, false);
         $foreigners['f'] = ['something'/* What should the mocked value actually be? */];
         $foreignData['foreign_link'] = '';
-        $this->assertEquals(
+        self::assertEquals(
             '4',
             $this->callFunction(
                 $this->insertEdit,
@@ -605,7 +605,7 @@ class InsertEditTest extends AbstractTestCase
 
         $result = $this->parseString($result);
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             '<textarea name="fieldsb" class="char charField" '
             . 'data-maxlength="10" rows="7" cols="1" dir="abc/" '
             . 'id="field_2_3" tabindex="2" data-type="CHAR">',
@@ -628,7 +628,7 @@ class InsertEditTest extends AbstractTestCase
             [$column, 'a', 'b', 30, 'c', 'DATE'],
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             '<input type="text" name="fieldsa" value="b" size="30" data-type="DATE"'
             . ' class="textfield datefield" onchange="c" tabindex="23" id="field_23_3">',
             $result,
@@ -642,7 +642,7 @@ class InsertEditTest extends AbstractTestCase
             'getHtmlInput',
             [$column, 'a', 'b', 30, 'c', 'DATE'],
         );
-        $this->assertEquals(
+        self::assertEquals(
             '<input type="text" name="fieldsa" value="b" size="30" data-type="DATE"'
             . ' class="textfield datetimefield" onchange="c" tabindex="23" id="field_23_3">',
             $result,
@@ -656,7 +656,7 @@ class InsertEditTest extends AbstractTestCase
             'getHtmlInput',
             [$column, 'a', 'b', 30, 'c', 'DATE'],
         );
-        $this->assertEquals(
+        self::assertEquals(
             '<input type="text" name="fieldsa" value="b" size="30" data-type="DATE"'
             . ' class="textfield datetimefield" onchange="c" tabindex="23" id="field_23_3">',
             $result,
@@ -670,7 +670,7 @@ class InsertEditTest extends AbstractTestCase
             'getHtmlInput',
             [$column, 'a', 'b', 11, 'c', 'INT'],
         );
-        $this->assertEquals(
+        self::assertEquals(
             '<input type="text" name="fieldsa" value="b" size="11" min="-2147483648" max="2147483647" data-type="INT"'
             . ' class="textfield" onchange="c" tabindex="23" inputmode="numeric" id="field_23_3">',
             $result,
@@ -692,7 +692,7 @@ class InsertEditTest extends AbstractTestCase
             [$pmaType],
         );
 
-        $this->assertEquals("(Max: 256B)\n", $result);
+        self::assertEquals("(Max: 256B)\n", $result);
 
         // case 2
         $config->set('max_upload_size', 250);
@@ -704,7 +704,7 @@ class InsertEditTest extends AbstractTestCase
             [$pmaType],
         );
 
-        $this->assertEquals("(Max: 250B)\n", $result);
+        self::assertEquals("(Max: 250B)\n", $result);
     }
 
     /**
@@ -745,7 +745,7 @@ class InsertEditTest extends AbstractTestCase
             ],
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             "a\na\n"
             . '<textarea name="fieldsb" class="char charField" '
             . 'data-maxlength="25" rows="7" cols="1" dir="/" '
@@ -786,7 +786,7 @@ class InsertEditTest extends AbstractTestCase
             ],
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             "a\n"
             . '<input type="text" name="fieldsb" value="&lt;" size="20" data-type="'
             . 'DATE" class="textfield datetimefield" onchange="c" tabindex="22" id="field_22_3"'
@@ -829,7 +829,7 @@ class InsertEditTest extends AbstractTestCase
 
         $result = $this->parseString($result);
 
-        $this->assertStringContainsString('<input type="hidden" name="fields_typeb" value="datetime">', $result);
+        self::assertStringContainsString('<input type="hidden" name="fields_typeb" value="datetime">', $result);
 
         // case 4: (else -> date)
         $column = new InsertEditColumn('f', 'date', false, '', null, 'auto_increment', 20, false, false, false, false);
@@ -853,7 +853,7 @@ class InsertEditTest extends AbstractTestCase
 
         $result = $this->parseString($result);
 
-        $this->assertStringContainsString('<input type="hidden" name="fields_typeb" value="date">', $result);
+        self::assertStringContainsString('<input type="hidden" name="fields_typeb" value="date">', $result);
 
         // case 5: (else -> bit)
         $column = new InsertEditColumn('f', 'bit', false, '', null, 'auto_increment', 20, false, false, false, false);
@@ -877,7 +877,7 @@ class InsertEditTest extends AbstractTestCase
 
         $result = $this->parseString($result);
 
-        $this->assertStringContainsString('<input type="hidden" name="fields_typeb" value="bit">', $result);
+        self::assertStringContainsString('<input type="hidden" name="fields_typeb" value="bit">', $result);
 
         // case 6: (else -> uuid)
         $column = new InsertEditColumn('f', 'uuid', false, '', null, 'auto_increment', 20, false, false, false, false);
@@ -901,7 +901,7 @@ class InsertEditTest extends AbstractTestCase
 
         $result = $this->parseString($result);
 
-        $this->assertStringContainsString('<input type="hidden" name="fields_typeb" value="uuid">', $result);
+        self::assertStringContainsString('<input type="hidden" name="fields_typeb" value="uuid">', $result);
     }
 
     /**
@@ -927,7 +927,7 @@ class InsertEditTest extends AbstractTestCase
         $config->settings['MinSizeForInputField'] = 30;
         $config->settings['MaxSizeForInputField'] = 40;
 
-        $this->assertEquals(
+        self::assertEquals(
             40,
             $this->callFunction(
                 $this->insertEdit,
@@ -937,7 +937,7 @@ class InsertEditTest extends AbstractTestCase
             ),
         );
 
-        $this->assertEquals('textarea', $config->settings['CharEditing']);
+        self::assertEquals('textarea', $config->settings['CharEditing']);
 
         // case 2
         $column = new InsertEditColumn(
@@ -953,7 +953,7 @@ class InsertEditTest extends AbstractTestCase
             false,
             false,
         );
-        $this->assertEquals(
+        self::assertEquals(
             30,
             $this->callFunction(
                 $this->insertEdit,
@@ -979,34 +979,34 @@ class InsertEditTest extends AbstractTestCase
 
         $result = $this->insertEdit->getContinueInsertionForm('tbl', 'db', $whereClauseArray, 'localhost');
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             '<form id="continueForm" method="post" action="' . Url::getFromRoute('/table/change')
             . '" name="continueForm" class="row g-3">',
             $result,
         );
 
-        $this->assertStringContainsString('<input type="hidden" name="db" value="db">', $result);
+        self::assertStringContainsString('<input type="hidden" name="db" value="db">', $result);
 
-        $this->assertStringContainsString('<input type="hidden" name="table" value="tbl">', $result);
+        self::assertStringContainsString('<input type="hidden" name="table" value="tbl">', $result);
 
-        $this->assertStringContainsString('<input type="hidden" name="goto" value="index.php">', $result);
+        self::assertStringContainsString('<input type="hidden" name="goto" value="index.php">', $result);
 
-        $this->assertStringContainsString('<input type="hidden" name="err_url" value="localhost">', $result);
+        self::assertStringContainsString('<input type="hidden" name="err_url" value="localhost">', $result);
 
-        $this->assertStringContainsString('<input type="hidden" name="sql_query" value="SELECT 1">', $result);
+        self::assertStringContainsString('<input type="hidden" name="sql_query" value="SELECT 1">', $result);
 
-        $this->assertStringContainsString('<input type="hidden" name="where_clause[0]" value="a&lt;b">', $result);
+        self::assertStringContainsString('<input type="hidden" name="where_clause[0]" value="a&lt;b">', $result);
     }
 
     public function testIsWhereClauseNumeric(): void
     {
-        $this->assertFalse(InsertEdit::isWhereClauseNumeric(null));
-        $this->assertFalse(InsertEdit::isWhereClauseNumeric(''));
-        $this->assertFalse(InsertEdit::isWhereClauseNumeric([]));
-        $this->assertTrue(InsertEdit::isWhereClauseNumeric('`actor`.`actor_id` = 1'));
-        $this->assertTrue(InsertEdit::isWhereClauseNumeric(['`actor`.`actor_id` = 1']));
-        $this->assertFalse(InsertEdit::isWhereClauseNumeric('`actor`.`first_name` = \'value\''));
-        $this->assertFalse(InsertEdit::isWhereClauseNumeric(['`actor`.`first_name` = \'value\'']));
+        self::assertFalse(InsertEdit::isWhereClauseNumeric(null));
+        self::assertFalse(InsertEdit::isWhereClauseNumeric(''));
+        self::assertFalse(InsertEdit::isWhereClauseNumeric([]));
+        self::assertTrue(InsertEdit::isWhereClauseNumeric('`actor`.`actor_id` = 1'));
+        self::assertTrue(InsertEdit::isWhereClauseNumeric(['`actor`.`actor_id` = 1']));
+        self::assertFalse(InsertEdit::isWhereClauseNumeric('`actor`.`first_name` = \'value\''));
+        self::assertFalse(InsertEdit::isWhereClauseNumeric(['`actor`.`first_name` = \'value\'']));
     }
 
     /**
@@ -1029,11 +1029,11 @@ class InsertEditTest extends AbstractTestCase
 
         $result = $this->parseString($result);
 
-        $this->assertStringContainsString('index.php?route=/table/change', $result);
+        self::assertStringContainsString('index.php?route=/table/change', $result);
 
-        $this->assertStringContainsString('ShowFunctionFields=1&ShowFieldTypesInDataEditView=0', $result);
+        self::assertStringContainsString('ShowFunctionFields=1&ShowFieldTypesInDataEditView=0', $result);
 
-        $this->assertStringContainsString('ShowFunctionFields=0&ShowFieldTypesInDataEditView=1', $result);
+        self::assertStringContainsString('ShowFunctionFields=0&ShowFieldTypesInDataEditView=1', $result);
     }
 
     /**
@@ -1065,7 +1065,7 @@ class InsertEditTest extends AbstractTestCase
             [$currentRow, $column, [], 'a', false],
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             [true, null, null, null, '<input type="hidden" name="fields_preva" value="">'],
             $result,
         );
@@ -1096,7 +1096,7 @@ class InsertEditTest extends AbstractTestCase
             [$currentRow, $column, $extractedColumnSpec, 'a', false],
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             [false, '', '00000000000001111011', null, '<input type="hidden" name="fields_preva" value="123">'],
             $result,
         );
@@ -1109,7 +1109,7 @@ class InsertEditTest extends AbstractTestCase
             [$currentRow, $column, $extractedColumnSpec, 'a', true],
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             [false, '', 'abcd', null, '<input type="hidden" name="fields_preva" value="abcd">'],
             $result,
         );
@@ -1151,7 +1151,7 @@ class InsertEditTest extends AbstractTestCase
             [$currentRow, $column, $extractedColumnSpec, 'a', false],
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             [false, '', "'',", null, '<input type="hidden" name="fields_preva" value="\'\',">'],
             $result,
         );
@@ -1183,7 +1183,7 @@ class InsertEditTest extends AbstractTestCase
             [$currentRow, $column, $extractedColumnSpec, 'a', false],
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             [
                 false,
                 '3131303031',
@@ -1204,7 +1204,7 @@ class InsertEditTest extends AbstractTestCase
             [$currentRow, $column, $extractedColumnSpec, 'a', false],
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             [
                 false,
                 '313130303100',
@@ -1237,7 +1237,7 @@ class InsertEditTest extends AbstractTestCase
             [$defaultValue, $trueType],
         );
 
-        $this->assertEquals($expected, $result);
+        self::assertEquals($expected, $result);
     }
 
     /**
@@ -1306,22 +1306,22 @@ class InsertEditTest extends AbstractTestCase
 
         $row = ['1' => 1];
 
-        $resultStub = $this->createMock(DummyResult::class);
+        $resultStub = self::createMock(DummyResult::class);
 
         $dbi = $this->getMockBuilder(DatabaseInterface::class)
             ->disableOriginalConstructor()
             ->getMock();
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('query')
             ->with('SELECT * FROM `db`.`table` WHERE `a` > 2 LIMIT 1;')
             ->willReturn($resultStub);
 
-        $resultStub->expects($this->once())
+        $resultStub->expects(self::once())
             ->method('fetchRow')
             ->willReturn($row);
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('getFieldsMeta')
             ->with($resultStub)
             ->willReturn([$meta]);
@@ -1338,7 +1338,7 @@ class InsertEditTest extends AbstractTestCase
         );
         $this->insertEdit->setSessionForEditNext('`a` = 2');
 
-        $this->assertEquals('CONCAT(`table`.`orgname`) IS NULL', $_SESSION['edit_next']);
+        self::assertEquals('CONCAT(`table`.`orgname`) IS NULL', $_SESSION['edit_next']);
     }
 
     /**
@@ -1349,35 +1349,35 @@ class InsertEditTest extends AbstractTestCase
         $GLOBALS['goto'] = '123.php';
         Current::$table = '';
 
-        $this->assertEquals(
+        self::assertEquals(
             '/database/sql',
             $this->insertEdit->getGotoInclude('index'),
         );
 
         Current::$table = 'tbl';
-        $this->assertEquals(
+        self::assertEquals(
             '/table/sql',
             $this->insertEdit->getGotoInclude('index'),
         );
 
         $GLOBALS['goto'] = 'index.php?route=/database/sql';
 
-        $this->assertEquals(
+        self::assertEquals(
             '/database/sql',
             $this->insertEdit->getGotoInclude('index'),
         );
 
-        $this->assertEquals('', Current::$table);
+        self::assertEquals('', Current::$table);
 
         $GLOBALS['goto'] = 'index.php?route=/sql&server=2';
 
-        $this->assertEquals(
+        self::assertEquals(
             '/sql',
             $this->insertEdit->getGotoInclude('index'),
         );
 
         $_POST['after_insert'] = 'new_insert';
-        $this->assertEquals(
+        self::assertEquals(
             '/table/change',
             $this->insertEdit->getGotoInclude('index'),
         );
@@ -1389,13 +1389,13 @@ class InsertEditTest extends AbstractTestCase
     public function testGetErrorUrl(): void
     {
         Config::getInstance()->settings['ServerDefault'] = 1;
-        $this->assertEquals(
+        self::assertEquals(
             'index.php?route=/table/change&lang=en',
             $this->insertEdit->getErrorUrl([]),
         );
 
         $_POST['err_url'] = 'localhost';
-        $this->assertEquals(
+        self::assertEquals(
             'localhost',
             $this->insertEdit->getErrorUrl([]),
         );
@@ -1420,7 +1420,7 @@ class InsertEditTest extends AbstractTestCase
         );
         $result = $this->insertEdit->executeSqlQuery($query);
 
-        $this->assertEquals([], $result[3]);
+        self::assertEquals([], $result[3]);
     }
 
     /**
@@ -1442,7 +1442,7 @@ class InsertEditTest extends AbstractTestCase
         );
         $result = $this->insertEdit->executeSqlQuery($query);
 
-        $this->assertEquals([], $result[3]);
+        self::assertEquals([], $result[3]);
     }
 
     /**
@@ -1459,7 +1459,7 @@ class InsertEditTest extends AbstractTestCase
             ->disableOriginalConstructor()
             ->getMock();
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('getWarnings')
             ->willReturn($warnings);
 
@@ -1479,7 +1479,7 @@ class InsertEditTest extends AbstractTestCase
             [],
         );
 
-        $this->assertEquals(['Error: #1001 Message 1', 'Warning: #1002 Message 2'], $result);
+        self::assertEquals(['Error: #1001 Message 1', 'Warning: #1002 Message 2'], $result);
     }
 
     /**
@@ -1492,22 +1492,22 @@ class InsertEditTest extends AbstractTestCase
         $map['f']['foreign_table'] = 'TABLES';
         $map['f']['foreign_field'] = 'f';
 
-        $resultStub = $this->createMock(DummyResult::class);
+        $resultStub = self::createMock(DummyResult::class);
 
         $dbi = $this->getMockBuilder(DatabaseInterface::class)
             ->disableOriginalConstructor()
             ->getMock();
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('tryQuery')
             ->with('SELECT `TABLE_COMMENT` FROM `information_schema`.`TABLES` WHERE `f`=1')
             ->willReturn($resultStub);
 
-        $resultStub->expects($this->once())
+        $resultStub->expects(self::once())
             ->method('numRows')
             ->willReturn(2);
 
-        $resultStub->expects($this->once())
+        $resultStub->expects(self::once())
             ->method('fetchValue')
             ->with(0)
             ->willReturn('2');
@@ -1523,7 +1523,7 @@ class InsertEditTest extends AbstractTestCase
 
         $result = $this->insertEdit->getDisplayValueForForeignTableColumn('=1', $map, 'f');
 
-        $this->assertEquals(2, $result);
+        self::assertEquals(2, $result);
     }
 
     /**
@@ -1542,7 +1542,7 @@ class InsertEditTest extends AbstractTestCase
 
         $sqlSignature = Core::signSqlQuery('SELECT * FROM `information_schema`.`TABLES` WHERE `f`=1');
 
-        $this->assertEquals(
+        self::assertEquals(
             '<a href="index.php?route=/sql&db=information_schema&table=TABLES&pos=0&'
             . 'sql_signature=' . $sqlSignature . '&'
             . 'sql_query=SELECT+%2A+FROM+%60information_schema%60.%60TABLES%60+WHERE'
@@ -1553,7 +1553,7 @@ class InsertEditTest extends AbstractTestCase
         $_SESSION['tmpval']['relational_display'] = 'D';
         $result = $this->insertEdit->getLinkForRelationalDisplayField($map, 'f', '=1', 'a>', 'b<');
 
-        $this->assertEquals(
+        self::assertEquals(
             '<a href="index.php?route=/sql&db=information_schema&table=TABLES&pos=0&'
             . 'sql_signature=' . $sqlSignature . '&'
             . 'sql_query=SELECT+%2A+FROM+%60information_schema%60.%60TABLES%60+WHERE'
@@ -1586,7 +1586,7 @@ class InsertEditTest extends AbstractTestCase
             'transformation',
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             ['a' => 'b', 'transformations' => ['cnameoption ,, quoted']],
             $result,
         );
@@ -1614,7 +1614,7 @@ class InsertEditTest extends AbstractTestCase
             false,
             '',
         );
-        $this->assertEquals("'foo'", $result);
+        self::assertEquals("'foo'", $result);
 
         // Test for file upload
         $result = $this->insertEdit->getQueryValueForInsert(
@@ -1634,7 +1634,7 @@ class InsertEditTest extends AbstractTestCase
             '',
         );
 
-        $this->assertEquals('0x123', $result);
+        self::assertEquals('0x123', $result);
 
         // Test functions
         $this->dummyDbi->addResult(
@@ -1662,7 +1662,7 @@ class InsertEditTest extends AbstractTestCase
             '',
         );
 
-        $this->assertEquals("'uuid1234'", $result);
+        self::assertEquals("'uuid1234'", $result);
 
         // case 2
         $result = $this->insertEdit->getQueryValueForInsert(
@@ -1681,7 +1681,7 @@ class InsertEditTest extends AbstractTestCase
             false,
             '',
         );
-        $this->assertEquals("AES_ENCRYPT('\\'','')", $result);
+        self::assertEquals("AES_ENCRYPT('\\'','')", $result);
 
         // case 3
         $result = $this->insertEdit->getQueryValueForInsert(
@@ -1700,7 +1700,7 @@ class InsertEditTest extends AbstractTestCase
             false,
             '',
         );
-        $this->assertEquals("ABS('\\'')", $result);
+        self::assertEquals("ABS('\\'')", $result);
 
         // case 4
         $result = $this->insertEdit->getQueryValueForInsert(
@@ -1719,7 +1719,7 @@ class InsertEditTest extends AbstractTestCase
             false,
             '',
         );
-        $this->assertEquals('RAND()', $result);
+        self::assertEquals('RAND()', $result);
 
         // case 5
         $result = $this->insertEdit->getQueryValueForInsert(
@@ -1738,7 +1738,7 @@ class InsertEditTest extends AbstractTestCase
             false,
             '',
         );
-        $this->assertTrue(password_verify("a'c", mb_substr($result, 1, -1)));
+        self::assertTrue(password_verify("a'c", mb_substr($result, 1, -1)));
 
         // case 7
         $result = $this->insertEdit->getQueryValueForInsert(
@@ -1746,7 +1746,7 @@ class InsertEditTest extends AbstractTestCase
             false,
             '',
         );
-        $this->assertEquals('ST_GeomFromText(\'POINT(3 4)\',4326)', $result);
+        self::assertEquals('ST_GeomFromText(\'POINT(3 4)\',4326)', $result);
 
         // case 8
         $result = $this->insertEdit->getQueryValueForInsert(
@@ -1754,7 +1754,7 @@ class InsertEditTest extends AbstractTestCase
             false,
             '',
         );
-        $this->assertEquals('ST_GeomFromText(\'POINT(3 4)\',4326)', $result);
+        self::assertEquals('ST_GeomFromText(\'POINT(3 4)\',4326)', $result);
 
         // case 9
         $result = $this->insertEdit->getQueryValueForInsert(
@@ -1762,7 +1762,7 @@ class InsertEditTest extends AbstractTestCase
             false,
             '',
         );
-        $this->assertEquals('ST_GeomFromText(\'POINT(3 4)\')', $result);
+        self::assertEquals('ST_GeomFromText(\'POINT(3 4)\')', $result);
 
         // case 10
         $result = $this->insertEdit->getQueryValueForInsert(
@@ -1770,7 +1770,7 @@ class InsertEditTest extends AbstractTestCase
             false,
             '',
         );
-        $this->assertEquals('ST_GeomFromText(\'POINT(3 4)\')', $result);
+        self::assertEquals('ST_GeomFromText(\'POINT(3 4)\')', $result);
 
         // Test different data types
 
@@ -1792,7 +1792,7 @@ class InsertEditTest extends AbstractTestCase
             true,
             '`id` = 4',
         );
-        $this->assertEquals('0x313031', $result);
+        self::assertEquals('0x313031', $result);
 
         // An empty value for auto increment column should be converted to NULL
         $result = $this->insertEdit->getQueryValueForInsert(
@@ -1811,7 +1811,7 @@ class InsertEditTest extends AbstractTestCase
             false,
             '',
         );
-        $this->assertEquals('NULL', $result);
+        self::assertEquals('NULL', $result);
 
         // Simple empty value
         $result = $this->insertEdit->getQueryValueForInsert(
@@ -1830,7 +1830,7 @@ class InsertEditTest extends AbstractTestCase
             false,
             '',
         );
-        $this->assertEquals("''", $result);
+        self::assertEquals("''", $result);
 
         // Datatype: set
         $result = $this->insertEdit->getQueryValueForInsert(
@@ -1849,7 +1849,7 @@ class InsertEditTest extends AbstractTestCase
             false,
             '',
         );
-        $this->assertEquals("''", $result);
+        self::assertEquals("''", $result);
 
         // Datatype: protected with no value should produce an empty string
         $result = $this->insertEdit->getQueryValueForInsert(
@@ -1868,7 +1868,7 @@ class InsertEditTest extends AbstractTestCase
             false,
             '',
         );
-        $this->assertEquals('', $result);
+        self::assertEquals('', $result);
 
         // Datatype: protected with null flag set
         $result = $this->insertEdit->getQueryValueForInsert(
@@ -1887,7 +1887,7 @@ class InsertEditTest extends AbstractTestCase
             false,
             '',
         );
-        $this->assertEquals('NULL', $result);
+        self::assertEquals('NULL', $result);
 
         // Datatype: bit
         $result = $this->insertEdit->getQueryValueForInsert(
@@ -1906,7 +1906,7 @@ class InsertEditTest extends AbstractTestCase
             false,
             '',
         );
-        $this->assertEquals("b'00010'", $result);
+        self::assertEquals("b'00010'", $result);
 
         // Datatype: date
         $result = $this->insertEdit->getQueryValueForInsert(
@@ -1925,7 +1925,7 @@ class InsertEditTest extends AbstractTestCase
             false,
             '',
         );
-        $this->assertEquals("'20\\'12'", $result);
+        self::assertEquals("'20\\'12'", $result);
 
         // A NULL checkbox
         $result = $this->insertEdit->getQueryValueForInsert(
@@ -1944,7 +1944,7 @@ class InsertEditTest extends AbstractTestCase
             false,
             '',
         );
-        $this->assertEquals('NULL', $result);
+        self::assertEquals('NULL', $result);
 
         // Datatype: protected but NULL checkbox was unchecked without uploading a file
         $result = $this->insertEdit->getQueryValueForInsert(
@@ -1963,7 +1963,7 @@ class InsertEditTest extends AbstractTestCase
             false,
             '',
         );
-        $this->assertEquals("''", $result);
+        self::assertEquals("''", $result);
 
         // Datatype: date with default value
         $result = $this->insertEdit->getQueryValueForInsert(
@@ -1982,7 +1982,7 @@ class InsertEditTest extends AbstractTestCase
             false,
             '',
         );
-        $this->assertEquals('current_timestamp()', $result);
+        self::assertEquals('current_timestamp()', $result);
 
         // Datatype: hex without 0x
         $result = $this->insertEdit->getQueryValueForInsert(
@@ -2001,7 +2001,7 @@ class InsertEditTest extends AbstractTestCase
             false,
             '',
         );
-        $this->assertEquals('0x222aaafff', $result);
+        self::assertEquals('0x222aaafff', $result);
 
         // Datatype: hex with 0x
         $result = $this->insertEdit->getQueryValueForInsert(
@@ -2020,7 +2020,7 @@ class InsertEditTest extends AbstractTestCase
             false,
             '',
         );
-        $this->assertEquals('0x222aaafff', $result);
+        self::assertEquals('0x222aaafff', $result);
     }
 
     /**
@@ -2043,7 +2043,7 @@ class InsertEditTest extends AbstractTestCase
                 false,
             ),
         );
-        $this->assertEquals("`fld` = 'foo'", $result);
+        self::assertEquals("`fld` = 'foo'", $result);
 
         // Update of null when it was null previously
         $result = $this->insertEdit->getQueryValueForUpdate(
@@ -2060,7 +2060,7 @@ class InsertEditTest extends AbstractTestCase
                 false,
             ),
         );
-        $this->assertEquals('', $result);
+        self::assertEquals('', $result);
 
         // Update of null when it was NOT null previously
         $result = $this->insertEdit->getQueryValueForUpdate(
@@ -2077,7 +2077,7 @@ class InsertEditTest extends AbstractTestCase
                 false,
             ),
         );
-        $this->assertEquals('`fld` = NULL', $result);
+        self::assertEquals('`fld` = NULL', $result);
 
         // Update to NOT null when it was null previously
         $result = $this->insertEdit->getQueryValueForUpdate(
@@ -2094,7 +2094,7 @@ class InsertEditTest extends AbstractTestCase
                 false,
             ),
         );
-        $this->assertEquals("`fld` = 'ab\'c'", $result);
+        self::assertEquals("`fld` = 'ab\'c'", $result);
 
         // Test to see if a zero-string is not ignored
         $result = $this->insertEdit->getQueryValueForUpdate(
@@ -2111,7 +2111,7 @@ class InsertEditTest extends AbstractTestCase
                 false,
             ),
         );
-        $this->assertEquals("`fld` = '0'", $result);
+        self::assertEquals("`fld` = '0'", $result);
 
         // Test to check if blob field that was left unchanged during edit will be ignored
         $result = $this->insertEdit->getQueryValueForUpdate(
@@ -2128,7 +2128,7 @@ class InsertEditTest extends AbstractTestCase
                 false,
             ),
         );
-        $this->assertEquals('', $result);
+        self::assertEquals('', $result);
 
         // Test to see if a field will be ignored if it the value is unchanged
         $result = $this->insertEdit->getQueryValueForUpdate(
@@ -2146,7 +2146,7 @@ class InsertEditTest extends AbstractTestCase
             ),
         );
 
-        $this->assertEquals('', $result);
+        self::assertEquals('', $result);
 
         // Test that an empty value uses the uuid function to generate a value
         $result = $this->insertEdit->getQueryValueForUpdate(
@@ -2164,7 +2164,7 @@ class InsertEditTest extends AbstractTestCase
             ),
         );
 
-        $this->assertEquals('`fld` = uuid()', $result);
+        self::assertEquals('`fld` = uuid()', $result);
 
         // Test that the uuid function as a value uses the uuid function to generate a value
         $result = $this->insertEdit->getQueryValueForUpdate(
@@ -2182,7 +2182,7 @@ class InsertEditTest extends AbstractTestCase
             ),
         );
 
-        $this->assertEquals('`fld` = uuid()', $result);
+        self::assertEquals('`fld` = uuid()', $result);
 
         // Test that the uuid function as a value uses the uuid function to generate a value
         $result = $this->insertEdit->getQueryValueForUpdate(
@@ -2200,7 +2200,7 @@ class InsertEditTest extends AbstractTestCase
             ),
         );
 
-        $this->assertEquals('`fld` = uuid()', $result);
+        self::assertEquals('`fld` = uuid()', $result);
 
         // Test that the uuid type does not have a default value other than null when it is nullable
         $result = $this->insertEdit->getQueryValueForUpdate(
@@ -2218,7 +2218,7 @@ class InsertEditTest extends AbstractTestCase
             ),
         );
 
-        $this->assertEquals('`fld` = NULL', $result);
+        self::assertEquals('`fld` = NULL', $result);
     }
 
     /**
@@ -2235,9 +2235,9 @@ class InsertEditTest extends AbstractTestCase
             ->disableOriginalConstructor()
             ->getMock();
 
-        $resultStub = $this->createMock(DummyResult::class);
+        $resultStub = self::createMock(DummyResult::class);
 
-        $dbi->expects($this->exactly(3))
+        $dbi->expects(self::exactly(3))
             ->method('tryQuery')
             ->with('SELECT `table`.`a` FROM `db`.`table` WHERE 1')
             ->willReturn($resultStub);
@@ -2245,11 +2245,11 @@ class InsertEditTest extends AbstractTestCase
         $meta1 = FieldHelper::fromArray(['type' => MYSQLI_TYPE_TINY]);
         $meta2 = FieldHelper::fromArray(['type' => MYSQLI_TYPE_TINY]);
         $meta3 = FieldHelper::fromArray(['type' => MYSQLI_TYPE_TIMESTAMP]);
-        $dbi->expects($this->exactly(3))
+        $dbi->expects(self::exactly(3))
             ->method('getFieldsMeta')
             ->willReturn([$meta1], [$meta2], [$meta3]);
 
-        $resultStub->expects($this->exactly(3))
+        $resultStub->expects(self::exactly(3))
             ->method('fetchValue')
             ->willReturn(false, '123', '2013-08-28 06:34:14');
 
@@ -2264,17 +2264,17 @@ class InsertEditTest extends AbstractTestCase
 
         $this->insertEdit->verifyWhetherValueCanBeTruncatedAndAppendExtraData('db', 'table', 'a', $extraData);
 
-        $this->assertFalse($extraData['isNeedToRecheck']);
+        self::assertFalse($extraData['isNeedToRecheck']);
 
         $this->insertEdit->verifyWhetherValueCanBeTruncatedAndAppendExtraData('db', 'table', 'a', $extraData);
 
-        $this->assertEquals('123', $extraData['truncatableFieldValue']);
-        $this->assertTrue($extraData['isNeedToRecheck']);
+        self::assertEquals('123', $extraData['truncatableFieldValue']);
+        self::assertTrue($extraData['isNeedToRecheck']);
 
         $this->insertEdit->verifyWhetherValueCanBeTruncatedAndAppendExtraData('db', 'table', 'a', $extraData);
 
-        $this->assertEquals('2013-08-28 06:34:14.000000', $extraData['truncatableFieldValue']);
-        $this->assertTrue($extraData['isNeedToRecheck']);
+        self::assertEquals('2013-08-28 06:34:14.000000', $extraData['truncatableFieldValue']);
+        self::assertTrue($extraData['isNeedToRecheck']);
     }
 
     /**
@@ -2286,7 +2286,7 @@ class InsertEditTest extends AbstractTestCase
             ->disableOriginalConstructor()
             ->getMock();
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('selectDb')
             ->with('db');
 
@@ -2295,7 +2295,7 @@ class InsertEditTest extends AbstractTestCase
             new ColumnFull('f', 'h', null, true, '', null, '', '', ''),
         ];
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('getColumns')
             ->with('db', 'table')
             ->willReturn($columns);
@@ -2311,7 +2311,7 @@ class InsertEditTest extends AbstractTestCase
 
         $result = $this->insertEdit->getTableColumns('db', 'table');
 
-        $this->assertEquals(
+        self::assertEquals(
             [
                 new ColumnFull('b', 'd', null, false, '', null, '', '', ''),
                 new ColumnFull('f', 'h', null, true, '', null, '', '', ''),
@@ -2329,9 +2329,9 @@ class InsertEditTest extends AbstractTestCase
             ->disableOriginalConstructor()
             ->getMock();
 
-        $resultStub = $this->createMock(DummyResult::class);
+        $resultStub = self::createMock(DummyResult::class);
 
-        $dbi->expects($this->exactly(2))
+        $dbi->expects(self::exactly(2))
             ->method('query')
             ->willReturn($resultStub);
 
@@ -2365,7 +2365,7 @@ class InsertEditTest extends AbstractTestCase
 
         $result = $this->insertEdit->determineInsertOrEdit('1', 'db', 'table');
 
-        $this->assertEquals(
+        self::assertEquals(
             [false, null, [1], null, [$resultStub], [[]], false, 'edit_next'],
             $result,
         );
@@ -2379,7 +2379,7 @@ class InsertEditTest extends AbstractTestCase
 
         $response->setValue(null, $restoreInstance);
 
-        $this->assertEquals(
+        self::assertEquals(
             [true, null, [], null, $resultStub, [false, false], false, 'edit_next'],
             $result,
         );
@@ -2397,12 +2397,12 @@ class InsertEditTest extends AbstractTestCase
             ->disableOriginalConstructor()
             ->getMock();
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('getColumns')
             ->with('db', 'table', true)
             ->willReturn([new ColumnFull('d', 'd', null, false, '', null, '', '', 'b')]);
 
-        $dbi->expects($this->any())
+        $dbi->expects(self::any())
             ->method('getTable')
             ->willReturn(new Table('table', 'db', $dbi));
 
@@ -2415,14 +2415,14 @@ class InsertEditTest extends AbstractTestCase
             new Template(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             [],
             $this->insertEdit->getCommentsMap('db', 'table'),
         );
 
         $config->settings['ShowPropertyComments'] = true;
 
-        $this->assertEquals(
+        self::assertEquals(
             ['d' => 'b'],
             $this->insertEdit->getCommentsMap('db', 'table'),
         );
@@ -2437,12 +2437,12 @@ class InsertEditTest extends AbstractTestCase
             . ' id="insert_ignore_1"><label for="insert_ignore_1">'
             . 'Ignore</label><br>' . "\n";
         $checked = 'checked="checked" ';
-        $this->assertEquals(
+        self::assertEquals(
             sprintf($expected, $checked),
             $this->insertEdit->getHtmlForIgnoreOption(1),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             sprintf($expected, ''),
             $this->insertEdit->getHtmlForIgnoreOption(1, false),
         );
@@ -2491,13 +2491,13 @@ class InsertEditTest extends AbstractTestCase
 
         $actual = $this->parseString($actual);
 
-        $this->assertStringContainsString('col', $actual);
-        $this->assertStringContainsString('<option>AES_ENCRYPT</option>', $actual);
-        $this->assertStringContainsString('<span class="column_type" dir="ltr">varchar(20)</span>', $actual);
-        $this->assertStringContainsString('<tr class="noclick">', $actual);
-        $this->assertStringContainsString('<span class="default_value hide">', $actual);
-        $this->assertStringContainsString('<img src="" width="150" height="100" alt="Image preview here">', $actual);
-        $this->assertStringContainsString(
+        self::assertStringContainsString('col', $actual);
+        self::assertStringContainsString('<option>AES_ENCRYPT</option>', $actual);
+        self::assertStringContainsString('<span class="column_type" dir="ltr">varchar(20)</span>', $actual);
+        self::assertStringContainsString('<tr class="noclick">', $actual);
+        self::assertStringContainsString('<span class="default_value hide">', $actual);
+        self::assertStringContainsString('<img src="" width="150" height="100" alt="Image preview here">', $actual);
+        self::assertStringContainsString(
             '<input type="file" '
             . 'name="fields_upload[multi_edit][0][d89e2ddb530bb8953b290ab0793aecb0]" '
             . 'accept="image/*" '
@@ -2536,48 +2536,48 @@ class InsertEditTest extends AbstractTestCase
 
         $actual = $this->parseString($actual);
 
-        $this->assertStringContainsString('qwerty', $actual);
-        $this->assertStringContainsString('<option>UUID</option>', $actual);
-        $this->assertStringContainsString('<span class="column_type" dir="ltr">datetime</span>', $actual);
-        $this->assertStringContainsString(
+        self::assertStringContainsString('qwerty', $actual);
+        self::assertStringContainsString('<option>UUID</option>', $actual);
+        self::assertStringContainsString('<span class="column_type" dir="ltr">datetime</span>', $actual);
+        self::assertStringContainsString(
             '<input type="text" name="fields[multi_edit][0][d8578edf8458ce06fbc5bb76a58c5ca4]" value="12-10-14.000000"',
             $actual,
         );
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             '<select name="funcs[multi_edit][0][d8578edf8458ce06fbc5bb76a58c5ca4]"'
             . ' onchange="return verificationsAfterFieldChange(\'d8578edf8458ce06fbc5bb76a58c5ca4\','
             . ' \'0\', \'datetime\')" id="field_1_1">',
             $actual,
         );
-        $this->assertStringContainsString('<option>DATE</option>', $actual);
+        self::assertStringContainsString('<option>DATE</option>', $actual);
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             '<input type="hidden" name="fields_null_prev[multi_edit][0][d8578edf8458ce06fbc5bb76a58c5ca4]">',
             $actual,
         );
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             '<input type="checkbox" class="checkbox_null"'
             . ' name="fields_null[multi_edit][0][d8578edf8458ce06fbc5bb76a58c5ca4]" id="field_1_2"'
             . ' aria-label="Use the NULL value for this column.">',
             $actual,
         );
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             '<input type="hidden" class="nullify_code"'
             . ' name="nullify_code[multi_edit][0][d8578edf8458ce06fbc5bb76a58c5ca4]" value="5"',
             $actual,
         );
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             '<input type="hidden" class="hashed_field"'
             . ' name="hashed_field[multi_edit][0][d8578edf8458ce06fbc5bb76a58c5ca4]" '
             . 'value="d8578edf8458ce06fbc5bb76a58c5ca4">',
             $actual,
         );
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             '<input type="hidden" class="multi_edit"'
             . ' name="multi_edit[multi_edit][0][d8578edf8458ce06fbc5bb76a58c5ca4]" value="[multi_edit][0]"',
             $actual,
@@ -2600,8 +2600,8 @@ class InsertEditTest extends AbstractTestCase
             new ColumnFull('test', 'longtext', null, true, '', null, '', 'select,insert,update,references', ''),
         ];
 
-        $resultStub = $this->createMock(DummyResult::class);
-        $resultStub->expects($this->any())
+        $resultStub = self::createMock(DummyResult::class);
+        $resultStub->expects(self::any())
             ->method('getFieldsMeta')
             ->willReturn([FieldHelper::fromArray(['type' => 0, 'length' => -1])]);
 
@@ -2621,12 +2621,12 @@ class InsertEditTest extends AbstractTestCase
             [],
             ['wc'],
         );
-        $this->assertStringContainsString('test', $actual);
-        $this->assertStringContainsString('<th>Column</th>', $actual);
-        $this->assertStringContainsString('<a', $actual);
-        $this->assertStringContainsString('<th class="w-50">Value</th>', $actual);
-        $this->assertStringContainsString('<span class="column_type" dir="ltr">longtext</span>', $actual);
-        $this->assertStringContainsString(
+        self::assertStringContainsString('test', $actual);
+        self::assertStringContainsString('<th>Column</th>', $actual);
+        self::assertStringContainsString('<a', $actual);
+        self::assertStringContainsString('<th class="w-50">Value</th>', $actual);
+        self::assertStringContainsString('<span class="column_type" dir="ltr">longtext</span>', $actual);
+        self::assertStringContainsString(
             '<textarea name="fields[multi_edit][0][098f6bcd4621d373cade4e832627b4f6]" id="field_1_3"'
                 . ' data-type="CHAR" dir="ltr" rows="20" cols="22"',
             $actual,
@@ -2650,8 +2650,8 @@ class InsertEditTest extends AbstractTestCase
             new ColumnFull('bar', 'longtext', null, true, '', null, '', 'select,insert,references', ''),
         ];
 
-        $resultStub = $this->createMock(DummyResult::class);
-        $resultStub->expects($this->any())
+        $resultStub = self::createMock(DummyResult::class);
+        $resultStub->expects(self::any())
             ->method('getFieldsMeta')
             ->willReturn([
                 FieldHelper::fromArray(['type' => 0, 'length' => -1]),
@@ -2675,8 +2675,8 @@ class InsertEditTest extends AbstractTestCase
             [],
             ['wc'],
         );
-        $this->assertStringContainsString('foo', $actual);
-        $this->assertStringContainsString('bar', $actual);
+        self::assertStringContainsString('foo', $actual);
+        self::assertStringContainsString('bar', $actual);
 
         // insert
         $tableColumns = [
@@ -2700,12 +2700,12 @@ class InsertEditTest extends AbstractTestCase
             [],
             ['wc'],
         );
-        $this->assertStringContainsString('foo', $actual);
-        $this->assertStringContainsString(
+        self::assertStringContainsString('foo', $actual);
+        self::assertStringContainsString(
             '<textarea name="fields[multi_edit][0][37b51d194a7513e45b56f6524f2d51f2]"',
             $actual,
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             '<a href="#" ><span class="text-nowrap"><img src="themes/dot.gif" title="Edit/Insert"' .
             ' alt="Edit/Insert" class="icon ic_b_edit">&nbsp;Edit/Insert</span></a>',
             $actual,
diff --git a/tests/classes/IpAllowDenyTest.php b/tests/classes/IpAllowDenyTest.php
index 4cac1e44e6..eb3ea1594e 100644
--- a/tests/classes/IpAllowDenyTest.php
+++ b/tests/classes/IpAllowDenyTest.php
@@ -68,7 +68,7 @@ class IpAllowDenyTest extends AbstractTestCase
             $_SERVER['TEST_FORWARDED_HEADER'] = $header;
         }
 
-        $this->assertEquals(
+        self::assertEquals(
             $expected,
             Core::getIp(),
         );
@@ -109,23 +109,23 @@ class IpAllowDenyTest extends AbstractTestCase
         //IPV4 testing
         $testRange = '255.255.0.0/8';
         $ipToTest = '10.0.0.0';
-        $this->assertFalse(
+        self::assertFalse(
             $this->ipAllowDeny->ipMaskTest($testRange, $ipToTest),
         );
 
         $testRange = '255.255.0.0/4';
         $ipToTest = '255.3.0.0';
-        $this->assertTrue(
+        self::assertTrue(
             $this->ipAllowDeny->ipMaskTest($testRange, $ipToTest),
         );
 
         $testRange = '255.255.0.[0-10]';
         $ipToTest = '255.3.0.3';
-        $this->assertFalse(
+        self::assertFalse(
             $this->ipAllowDeny->ipMaskTest($testRange, $ipToTest),
         );
         $ipToTest = '255.3.0.12';
-        $this->assertFalse(
+        self::assertFalse(
             $this->ipAllowDeny->ipMaskTest($testRange, $ipToTest),
         );
 
@@ -133,36 +133,36 @@ class IpAllowDenyTest extends AbstractTestCase
         //not range
         $ipToTest = '2001:4998:c:a0d:0000:0000:4998:1020';
         $testRange = '2001:4998:c:a0d:0000:0000:4998:1020';
-        $this->assertTrue(
+        self::assertTrue(
             $this->ipAllowDeny->ipMaskTest($testRange, $ipToTest),
         );
         $ipToTest = '2001:4998:c:a0d:0000:0000:4998:1020';
         $testRange = '2001:4998:c:a0d:0000:0000:4998:2020';
-        $this->assertFalse(
+        self::assertFalse(
             $this->ipAllowDeny->ipMaskTest($testRange, $ipToTest),
         );
 
         //range
         $ipToTest = '2001:4998:c:a0d:0000:0000:4998:1020';
         $testRange = '2001:4998:c:a0d:0000:0000:4998:[1001-2010]';
-        $this->assertTrue(
+        self::assertTrue(
             $this->ipAllowDeny->ipMaskTest($testRange, $ipToTest),
         );
         $ipToTest = '2001:4998:c:a0d:0000:0000:4998:3020';
         $testRange = '2001:4998:c:a0d:0000:0000:4998:[1001-2010]';
-        $this->assertFalse(
+        self::assertFalse(
             $this->ipAllowDeny->ipMaskTest($testRange, $ipToTest),
         );
 
         //CDIR
         $ipToTest = '2001:4998:c:a0d:0000:0000:4998:1020';
         $testRange = '2001:4998:c:a0d:0000:0000:4998:[1001-2010]';
-        $this->assertTrue(
+        self::assertTrue(
             $this->ipAllowDeny->ipMaskTest($testRange, $ipToTest),
         );
         $ipToTest = '2001:4998:c:a0d:0000:0000:4998:1000';
         $testRange = '2001:4998:c:a0d:0000:0000:4998:3020/24';
-        $this->assertFalse(
+        self::assertFalse(
             $this->ipAllowDeny->ipMaskTest($testRange, $ipToTest),
         );
     }
@@ -173,43 +173,43 @@ class IpAllowDenyTest extends AbstractTestCase
     public function testAllowDeny(): void
     {
         $_SERVER['REMOTE_ADDR'] = '';
-        $this->assertFalse(
+        self::assertFalse(
             $this->ipAllowDeny->allow(),
         );
 
         $_SERVER['REMOTE_ADDR'] = '255.0.1.0';
-        $this->assertTrue(
+        self::assertTrue(
             $this->ipAllowDeny->allow(),
         );
         $_SERVER['REMOTE_ADDR'] = '10.0.0.0';
-        $this->assertFalse(
+        self::assertFalse(
             $this->ipAllowDeny->allow(),
         );
 
         $_SERVER['REMOTE_ADDR'] = '255.255.0.1';
-        $this->assertTrue(
+        self::assertTrue(
             $this->ipAllowDeny->deny(),
         );
         $_SERVER['REMOTE_ADDR'] = '255.124.0.5';
-        $this->assertTrue(
+        self::assertTrue(
             $this->ipAllowDeny->deny(),
         );
         $_SERVER['REMOTE_ADDR'] = '122.124.0.5';
-        $this->assertFalse(
+        self::assertFalse(
             $this->ipAllowDeny->deny(),
         );
 
         //IPV6
         $_SERVER['REMOTE_ADDR'] = '2001:4998:c:a0d:0000:0000:4998:1020';
-        $this->assertTrue(
+        self::assertTrue(
             $this->ipAllowDeny->allow(),
         );
         $_SERVER['REMOTE_ADDR'] = '2001:4998:c:a0d:0000:0000:4998:1000';
-        $this->assertFalse(
+        self::assertFalse(
             $this->ipAllowDeny->allow(),
         );
         $_SERVER['REMOTE_ADDR'] = '2001:4998:c:a0d:0000:0000:4998:1020';
-        $this->assertTrue(
+        self::assertTrue(
             $this->ipAllowDeny->allow(),
         );
     }
diff --git a/tests/classes/LanguageTest.php b/tests/classes/LanguageTest.php
index a01833110d..a266fc112e 100644
--- a/tests/classes/LanguageTest.php
+++ b/tests/classes/LanguageTest.php
@@ -32,7 +32,7 @@ class LanguageTest extends AbstractTestCase
 
         $loc = LOCALE_PATH . '/cs/LC_MESSAGES/phpmyadmin.mo';
         if (! is_readable($loc)) {
-            $this->markTestSkipped('Missing compiled locales.');
+            self::markTestSkipped('Missing compiled locales.');
         }
 
         $this->manager = new LanguageManager();
@@ -61,8 +61,8 @@ class LanguageTest extends AbstractTestCase
 
         $langs = $this->manager->availableLocales();
 
-        $this->assertCount(2, $langs);
-        $this->assertContains('cs', $langs);
+        self::assertCount(2, $langs);
+        self::assertContains('cs', $langs);
         $config->set('FilterLanguages', '');
     }
 
@@ -75,8 +75,8 @@ class LanguageTest extends AbstractTestCase
 
         $langs = $this->manager->availableLocales();
 
-        $this->assertContains('cs', $langs);
-        $this->assertContains('en', $langs);
+        self::assertContains('cs', $langs);
+        self::assertContains('en', $langs);
     }
 
     /**
@@ -85,8 +85,8 @@ class LanguageTest extends AbstractTestCase
     public function testList(): void
     {
         $langs = $this->manager->listLocaleDir();
-        $this->assertContains('cs', $langs);
-        $this->assertContains('en', $langs);
+        self::assertContains('cs', $langs);
+        self::assertContains('en', $langs);
     }
 
     /**
@@ -95,11 +95,11 @@ class LanguageTest extends AbstractTestCase
     public function testLanguages(): void
     {
         $langs = $this->manager->availableLanguages();
-        $this->assertGreaterThan(1, count($langs));
+        self::assertGreaterThan(1, count($langs));
 
         /* Ensure we have name for every language */
         foreach ($langs as $lang) {
-            $this->assertNotEquals(
+            self::assertNotEquals(
                 $lang->getCode(),
                 strtolower($lang->getEnglishName()),
                 'Maybe this language does not exist in LanguageManager class'
@@ -115,12 +115,12 @@ class LanguageTest extends AbstractTestCase
     {
         Config::getInstance()->set('FilterLanguages', '');
         $czech = $this->manager->getLanguage('cs');
-        $this->assertNotFalse($czech);
-        $this->assertEquals('cs_CZ', $czech->getMySQLLocale());
+        self::assertNotFalse($czech);
+        self::assertEquals('cs_CZ', $czech->getMySQLLocale());
 
         $azerbaijani = $this->manager->getLanguage('az');
-        $this->assertNotFalse($azerbaijani);
-        $this->assertEquals('', $azerbaijani->getMySQLLocale());
+        self::assertNotFalse($azerbaijani);
+        self::assertEquals('', $azerbaijani->getMySQLLocale());
     }
 
     /**
@@ -129,7 +129,7 @@ class LanguageTest extends AbstractTestCase
     public function testSortedLanguages(): void
     {
         $langs = $this->manager->sortedLanguages();
-        $this->assertGreaterThan(1, count($langs));
+        self::assertGreaterThan(1, count($langs));
     }
 
     /**
@@ -139,11 +139,11 @@ class LanguageTest extends AbstractTestCase
     {
         Config::getInstance()->set('FilterLanguages', '');
         $lang = $this->manager->getLanguage('cs');
-        $this->assertNotFalse($lang);
-        $this->assertEquals('Czech', $lang->getEnglishName());
-        $this->assertEquals('Čeština', $lang->getNativeName());
+        self::assertNotFalse($lang);
+        self::assertEquals('Czech', $lang->getEnglishName());
+        self::assertEquals('Čeština', $lang->getNativeName());
         $lang = $this->manager->getLanguage('nonexisting');
-        $this->assertFalse($lang);
+        self::assertFalse($lang);
     }
 
     /**
@@ -171,7 +171,7 @@ class LanguageTest extends AbstractTestCase
     ): void {
         if ($expect !== 'en' && ! file_exists(LOCALE_PATH . '/' . $expect . '/LC_MESSAGES/phpmyadmin.mo')) {
             // This could happen after removing incomplete .mo files.
-            $this->markTestSkipped('Locale file does not exists: ' . $expect);
+            self::markTestSkipped('Locale file does not exists: ' . $expect);
         }
 
         $config = Config::getInstance();
@@ -187,7 +187,7 @@ class LanguageTest extends AbstractTestCase
 
         $lang = $this->manager->selectLanguage();
 
-        $this->assertEquals($expect, $lang->getCode());
+        self::assertEquals($expect, $lang->getCode());
 
         $config->set('Lang', '');
         $_POST['lang'] = '';
@@ -243,14 +243,14 @@ class LanguageTest extends AbstractTestCase
         Config::getInstance()->set('FilterLanguages', '');
         /* We should be able to set the language */
         $lang = $this->manager->getLanguage($locale);
-        $this->assertNotFalse($lang);
+        self::assertNotFalse($lang);
         $lang->activate();
 
         /* Grab some texts */
-        $this->assertStringContainsString('%s', _ngettext('%s table', '%s tables', 10));
-        $this->assertStringContainsString('%s', _ngettext('%s table', '%s tables', 1));
+        self::assertStringContainsString('%s', _ngettext('%s table', '%s tables', 10));
+        self::assertStringContainsString('%s', _ngettext('%s table', '%s tables', 1));
 
-        $this->assertEquals(
+        self::assertEquals(
             $locale,
             $this->manager->getCurrentLanguage()->getCode(),
         );
diff --git a/tests/classes/LinterTest.php b/tests/classes/LinterTest.php
index d8745333b1..59aad5310e 100644
--- a/tests/classes/LinterTest.php
+++ b/tests/classes/LinterTest.php
@@ -29,9 +29,9 @@ class LinterTest extends AbstractTestCase
      */
     public function testGetLines(): void
     {
-        $this->assertEquals([0], Linter::getLines(''));
-        $this->assertEquals([0, 2], Linter::getLines("a\nb"));
-        $this->assertEquals([0, 4, 7], Linter::getLines("abc\nde\n"));
+        self::assertEquals([0], Linter::getLines(''));
+        self::assertEquals([0, 2], Linter::getLines("a\nb"));
+        self::assertEquals([0, 4, 7], Linter::getLines("abc\nde\n"));
     }
 
     /**
@@ -50,19 +50,19 @@ class LinterTest extends AbstractTestCase
         //      ( a, 0), ( b, 1), ( c, 2), (\n, 3),
         //      ( d, 4), ( e, 5), (\n, 6),
         //      (\n, 7).
-        $this->assertEquals(
+        self::assertEquals(
             [1, 0],
             Linter::findLineNumberAndColumn([0, 4, 7], 4),
         );
-        $this->assertEquals(
+        self::assertEquals(
             [1, 1],
             Linter::findLineNumberAndColumn([0, 4, 7], 5),
         );
-        $this->assertEquals(
+        self::assertEquals(
             [1, 2],
             Linter::findLineNumberAndColumn([0, 4, 7], 6),
         );
-        $this->assertEquals(
+        self::assertEquals(
             [2, 0],
             Linter::findLineNumberAndColumn([0, 4, 7], 7),
         );
@@ -77,7 +77,7 @@ class LinterTest extends AbstractTestCase
     #[DataProvider('lintProvider')]
     public function testLint(array $expected, string $query): void
     {
-        $this->assertEquals($expected, Linter::lint($query));
+        self::assertEquals($expected, Linter::lint($query));
     }
 
     /**
diff --git a/tests/classes/ListDatabaseTest.php b/tests/classes/ListDatabaseTest.php
index 894f7b66b6..eac80e8ebf 100644
--- a/tests/classes/ListDatabaseTest.php
+++ b/tests/classes/ListDatabaseTest.php
@@ -42,7 +42,7 @@ class ListDatabaseTest extends AbstractTestCase
         $config->selectedServer['DisableIS'] = false;
         $config->selectedServer['only_db'] = ['single\\_db'];
         $arr = new ListDatabase($dbi, $config, new CheckUserPrivileges($dbi));
-        $this->assertTrue($arr->exists('single_db'));
+        self::assertTrue($arr->exists('single_db'));
     }
 
     public function testGetList(): void
@@ -54,13 +54,13 @@ class ListDatabaseTest extends AbstractTestCase
         $arr = new ListDatabase($dbi, $config, new CheckUserPrivileges($dbi));
 
         Current::$database = 'db';
-        $this->assertEquals(
+        self::assertEquals(
             [['name' => 'single_db', 'is_selected' => false]],
             $arr->getList(),
         );
 
         Current::$database = 'single_db';
-        $this->assertEquals(
+        self::assertEquals(
             [['name' => 'single_db', 'is_selected' => true]],
             $arr->getList(),
         );
@@ -72,7 +72,7 @@ class ListDatabaseTest extends AbstractTestCase
     public function testCheckHideDatabase(): void
     {
         Config::getInstance()->selectedServer['hide_db'] = 'single\\_db';
-        $this->assertEquals(
+        self::assertEquals(
             $this->callFunction(
                 $this->object,
                 ListDatabase::class,
diff --git a/tests/classes/LoggingTest.php b/tests/classes/LoggingTest.php
index 299ae7a4e4..06701f5b39 100644
--- a/tests/classes/LoggingTest.php
+++ b/tests/classes/LoggingTest.php
@@ -14,8 +14,8 @@ class LoggingTest extends AbstractTestCase
     {
         $_SERVER['REMOTE_ADDR'] = '0.0.0.0';
         $log = Logging::getLogMessage('user', 'ok');
-        $this->assertEquals('user authenticated: user from 0.0.0.0', $log);
+        self::assertEquals('user authenticated: user from 0.0.0.0', $log);
         $log = Logging::getLogMessage('user', 'error');
-        $this->assertEquals('user denied: user (error) from 0.0.0.0', $log);
+        self::assertEquals('user denied: user (error) from 0.0.0.0', $log);
     }
 }
diff --git a/tests/classes/MenuTest.php b/tests/classes/MenuTest.php
index e49e02f2c1..0349a1bfe5 100644
--- a/tests/classes/MenuTest.php
+++ b/tests/classes/MenuTest.php
@@ -43,7 +43,7 @@ class MenuTest extends AbstractTestCase
     public function testServer(): void
     {
         $menu = new Menu($this->dbi, new Template(), '', '');
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             'floating_menubar',
             $menu->getDisplay(),
         );
@@ -55,7 +55,7 @@ class MenuTest extends AbstractTestCase
     public function testDatabase(): void
     {
         $menu = new Menu($this->dbi, new Template(), 'pma_test', '');
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             'floating_menubar',
             $menu->getDisplay(),
         );
@@ -67,7 +67,7 @@ class MenuTest extends AbstractTestCase
     public function testTable(): void
     {
         $menu = new Menu($this->dbi, new Template(), 'pma_test', 'table1');
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             'floating_menubar',
             $menu->getDisplay(),
         );
@@ -80,7 +80,7 @@ class MenuTest extends AbstractTestCase
     {
         $menu = new Menu($this->dbi, new Template(), 'pma_test', '');
         $menu->setTable('table1');
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             'table1',
             $menu->getDisplay(),
         );
diff --git a/tests/classes/MessageTest.php b/tests/classes/MessageTest.php
index bd32ea6487..c41bed09e8 100644
--- a/tests/classes/MessageTest.php
+++ b/tests/classes/MessageTest.php
@@ -32,7 +32,7 @@ class MessageTest extends AbstractTestCase
     public function testToString(): void
     {
         $this->object->setMessage('test<&>');
-        $this->assertEquals('test<&>', (string) $this->object);
+        self::assertEquals('test<&>', (string) $this->object);
     }
 
     /**
@@ -41,8 +41,8 @@ class MessageTest extends AbstractTestCase
     public function testSuccess(): void
     {
         $this->object = new Message('test<&>', Message::SUCCESS);
-        $this->assertEquals($this->object, Message::success('test<&>'));
-        $this->assertEquals(
+        self::assertEquals($this->object, Message::success('test<&>'));
+        self::assertEquals(
             'Your SQL query has been executed successfully.',
             Message::success()->getString(),
         );
@@ -54,8 +54,8 @@ class MessageTest extends AbstractTestCase
     public function testError(): void
     {
         $this->object = new Message('test<&>', Message::ERROR);
-        $this->assertEquals($this->object, Message::error('test<&>'));
-        $this->assertEquals('Error', Message::error()->getString());
+        self::assertEquals($this->object, Message::error('test<&>'));
+        self::assertEquals('Error', Message::error()->getString());
     }
 
     /**
@@ -64,7 +64,7 @@ class MessageTest extends AbstractTestCase
     public function testNotice(): void
     {
         $this->object = new Message('test<&>', Message::NOTICE);
-        $this->assertEquals($this->object, Message::notice('test<&>'));
+        self::assertEquals($this->object, Message::notice('test<&>'));
     }
 
     /**
@@ -76,7 +76,7 @@ class MessageTest extends AbstractTestCase
         $this->object->setMessage('test<&>');
         $this->object->setBBCode(false);
 
-        $this->assertEquals($this->object, Message::rawError('test<&>'));
+        self::assertEquals($this->object, Message::rawError('test<&>'));
     }
 
     /**
@@ -88,7 +88,7 @@ class MessageTest extends AbstractTestCase
         $this->object->setMessage('test<&>');
         $this->object->setBBCode(false);
 
-        $this->assertEquals($this->object, Message::rawNotice('test<&>'));
+        self::assertEquals($this->object, Message::rawNotice('test<&>'));
     }
 
     /**
@@ -100,7 +100,7 @@ class MessageTest extends AbstractTestCase
         $this->object->setMessage('test<&>');
         $this->object->setBBCode(false);
 
-        $this->assertEquals($this->object, Message::rawSuccess('test<&>'));
+        self::assertEquals($this->object, Message::rawSuccess('test<&>'));
     }
 
     /**
@@ -108,9 +108,9 @@ class MessageTest extends AbstractTestCase
      */
     public function testIsSuccess(): void
     {
-        $this->assertFalse($this->object->isSuccess());
+        self::assertFalse($this->object->isSuccess());
         $this->object->setType(Message::SUCCESS);
-        $this->assertTrue($this->object->isSuccess());
+        self::assertTrue($this->object->isSuccess());
     }
 
     /**
@@ -118,11 +118,11 @@ class MessageTest extends AbstractTestCase
      */
     public function testIsNotice(): void
     {
-        $this->assertTrue($this->object->isNotice());
+        self::assertTrue($this->object->isNotice());
         $this->object->setType(Message::ERROR);
-        $this->assertFalse($this->object->isNotice());
+        self::assertFalse($this->object->isNotice());
         $this->object->setType(Message::NOTICE);
-        $this->assertTrue($this->object->isNotice());
+        self::assertTrue($this->object->isNotice());
     }
 
     /**
@@ -130,9 +130,9 @@ class MessageTest extends AbstractTestCase
      */
     public function testIsError(): void
     {
-        $this->assertFalse($this->object->isError());
+        self::assertFalse($this->object->isError());
         $this->object->setType(Message::ERROR);
-        $this->assertTrue($this->object->isError());
+        self::assertTrue($this->object->isError());
     }
 
     /**
@@ -141,7 +141,7 @@ class MessageTest extends AbstractTestCase
     public function testSetMessage(): void
     {
         $this->object->setMessage('test&<>');
-        $this->assertEquals('test&<>', $this->object->getMessage());
+        self::assertEquals('test&<>', $this->object->getMessage());
     }
 
     /**
@@ -150,7 +150,7 @@ class MessageTest extends AbstractTestCase
     public function testSetString(): void
     {
         $this->object->setString('test&<>');
-        $this->assertEquals('test&<>', $this->object->getString());
+        self::assertEquals('test&<>', $this->object->getString());
     }
 
     /**
@@ -159,17 +159,17 @@ class MessageTest extends AbstractTestCase
     public function testAddParam(): void
     {
         $this->object->addParam(Message::notice('test'));
-        $this->assertEquals(
+        self::assertEquals(
             [Message::notice('test')],
             $this->object->getParams(),
         );
         $this->object->addParam('test');
-        $this->assertEquals(
+        self::assertEquals(
             [Message::notice('test'), 'test'],
             $this->object->getParams(),
         );
         $this->object->addParam('test');
-        $this->assertEquals(
+        self::assertEquals(
             [Message::notice('test'), 'test', Message::notice('test')],
             $this->object->getParams(),
         );
@@ -184,7 +184,7 @@ class MessageTest extends AbstractTestCase
         $this->object->addParamHtml('<a href="">');
         $this->object->addParam('user<>');
         $this->object->addParamHtml('</a>');
-        $this->assertEquals(
+        self::assertEquals(
             'Hello <a href="">user&lt;&gt;</a>',
             $this->object->getMessage(),
         );
@@ -196,12 +196,12 @@ class MessageTest extends AbstractTestCase
     public function testAddString(): void
     {
         $this->object->addText('test', '*');
-        $this->assertEquals(
+        self::assertEquals(
             ['*', Message::notice('test')],
             $this->object->getAddedMessages(),
         );
         $this->object->addText('test', '');
-        $this->assertEquals(
+        self::assertEquals(
             ['*', Message::notice('test'), Message::notice('test')],
             $this->object->getAddedMessages(),
         );
@@ -213,17 +213,17 @@ class MessageTest extends AbstractTestCase
     public function testAddMessage(): void
     {
         $this->object->addText('test<>', '');
-        $this->assertEquals(
+        self::assertEquals(
             [Message::notice('test&lt;&gt;')],
             $this->object->getAddedMessages(),
         );
         $this->object->addHtml('<b>test</b>');
-        $this->assertEquals(
+        self::assertEquals(
             [Message::notice('test&lt;&gt;'), ' ', Message::rawNotice('<b>test</b>')],
             $this->object->getAddedMessages(),
         );
         $this->object->addMessage(Message::notice('test<>'));
-        $this->assertEquals(
+        self::assertEquals(
             'test&lt;&gt; <b>test</b> test<>',
             $this->object->getMessage(),
         );
@@ -240,7 +240,7 @@ class MessageTest extends AbstractTestCase
         $messages[] = new Message('Test3');
         $this->object->addMessages($messages, '');
 
-        $this->assertEquals(
+        self::assertEquals(
             [Message::notice('Test1'), Message::error('PMA_Test2'), Message::notice('Test3')],
             $this->object->getAddedMessages(),
         );
@@ -254,12 +254,12 @@ class MessageTest extends AbstractTestCase
         $messages = ['test1', 'test<b>', 'test2'];
         $this->object->addMessagesString($messages, '');
 
-        $this->assertEquals(
+        self::assertEquals(
             [Message::notice('test1'), Message::notice('test&lt;b&gt;'), Message::notice('test2')],
             $this->object->getAddedMessages(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'test1test&lt;b&gt;test2',
             $this->object->getMessage(),
         );
@@ -271,7 +271,7 @@ class MessageTest extends AbstractTestCase
     public function testSetParams(): void
     {
         $this->object->setParams(['test&<>']);
-        $this->assertEquals(['test&<>'], $this->object->getParams());
+        self::assertEquals(['test&<>'], $this->object->getParams());
     }
 
     /**
@@ -281,7 +281,7 @@ class MessageTest extends AbstractTestCase
     {
         $this->object->setString('<&>test');
         $this->object->setMessage('<&>test');
-        $this->assertEquals(
+        self::assertEquals(
             md5(Message::NOTICE . '<&>test<&>test'),
             $this->object->getHash(),
         );
@@ -297,7 +297,7 @@ class MessageTest extends AbstractTestCase
         $this->object->setString('test string %s %s');
         $this->object->addParam('test param 1');
         $this->object->addParam('test param 2');
-        $this->assertEquals(
+        self::assertEquals(
             'test string test param 1 test param 2',
             $this->object->getMessage(),
         );
@@ -310,7 +310,7 @@ class MessageTest extends AbstractTestCase
     {
         $this->object->setMessage('');
         $this->object->setString('');
-        $this->assertEquals('', $this->object->getMessage());
+        self::assertEquals('', $this->object->getMessage());
     }
 
     /**
@@ -320,7 +320,7 @@ class MessageTest extends AbstractTestCase
     public function testGetMessageWithMessageWithBBCode(): void
     {
         $this->object->setMessage('[kbd]test[/kbd] [doc@cfg_Example]test[/doc]');
-        $this->assertEquals(
+        self::assertEquals(
             '<kbd>test</kbd> <a href="index.php?route=/url&url=https%3A%2F%2Fdocs.phpmyadmin.'
             . 'net%2Fen%2Flatest%2Fconfig.html%23cfg_Example"'
             . ' target="documentation">test</a>',
@@ -333,11 +333,11 @@ class MessageTest extends AbstractTestCase
      */
     public function testGetLevel(): void
     {
-        $this->assertEquals('notice', $this->object->getLevel());
+        self::assertEquals('notice', $this->object->getLevel());
         $this->object->setType(Message::SUCCESS);
-        $this->assertEquals('success', $this->object->getLevel());
+        self::assertEquals('success', $this->object->getLevel());
         $this->object->setType(Message::ERROR);
-        $this->assertEquals('error', $this->object->getLevel());
+        self::assertEquals('error', $this->object->getLevel());
     }
 
     /**
@@ -345,15 +345,15 @@ class MessageTest extends AbstractTestCase
      */
     public function testGetDisplay(): void
     {
-        $this->assertFalse($this->object->isDisplayed());
+        self::assertFalse($this->object->isDisplayed());
         $this->object->setMessage('Test Message');
-        $this->assertEquals(
+        self::assertEquals(
             '<div class="alert alert-primary" role="alert">' . "\n"
             . '  <img src="themes/dot.gif" title="" alt="" class="icon ic_s_notice"> Test Message' . "\n"
             . '</div>' . "\n",
             $this->object->getDisplay(),
         );
-        $this->assertTrue($this->object->isDisplayed());
+        self::assertTrue($this->object->isDisplayed());
     }
 
     /**
@@ -361,9 +361,9 @@ class MessageTest extends AbstractTestCase
      */
     public function testIsDisplayed(): void
     {
-        $this->assertFalse($this->object->isDisplayed(false));
-        $this->assertTrue($this->object->isDisplayed(true));
-        $this->assertTrue($this->object->isDisplayed(false));
+        self::assertFalse($this->object->isDisplayed(false));
+        self::assertTrue($this->object->isDisplayed(true));
+        self::assertTrue($this->object->isDisplayed(false));
     }
 
     /**
@@ -407,7 +407,7 @@ class MessageTest extends AbstractTestCase
         $this->object = new Message();
         $msg = $this->object->getMessageForAffectedRows($rows);
         $this->object->addMessage($msg);
-        $this->assertEquals($output, $this->object->getDisplay());
+        self::assertEquals($output, $this->object->getDisplay());
     }
 
     /**
@@ -451,7 +451,7 @@ class MessageTest extends AbstractTestCase
         $this->object = new Message();
         $msg = $this->object->getMessageForInsertedRows($rows);
         $this->object->addMessage($msg);
-        $this->assertEquals($output, $this->object->getDisplay());
+        self::assertEquals($output, $this->object->getDisplay());
     }
 
     /**
@@ -495,6 +495,6 @@ class MessageTest extends AbstractTestCase
         $this->object = new Message();
         $msg = $this->object->getMessageForDeletedRows($rows);
         $this->object->addMessage($msg);
-        $this->assertEquals($output, $this->object->getDisplay());
+        self::assertEquals($output, $this->object->getDisplay());
     }
 }
diff --git a/tests/classes/MimeTest.php b/tests/classes/MimeTest.php
index e5b2453204..5aff251881 100644
--- a/tests/classes/MimeTest.php
+++ b/tests/classes/MimeTest.php
@@ -22,7 +22,7 @@ class MimeTest extends AbstractTestCase
     #[DataProvider('providerForTestDetect')]
     public function testDetect(string $test, string $output): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             Mime::detect($test),
             $output,
         );
diff --git a/tests/classes/Navigation/NavigationTest.php b/tests/classes/Navigation/NavigationTest.php
index 2c9de381f2..fe6123358b 100644
--- a/tests/classes/Navigation/NavigationTest.php
+++ b/tests/classes/Navigation/NavigationTest.php
@@ -74,10 +74,10 @@ class NavigationTest extends AbstractTestCase
         $dbi = $this->getMockBuilder(DatabaseInterface::class)
             ->disableOriginalConstructor()
             ->getMock();
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('tryQueryAsControlUser')
             ->with($expectedQuery);
-        $dbi->expects($this->any())->method('quoteString')
+        $dbi->expects(self::any())->method('quoteString')
             ->willReturnCallback(static fn (string $string): string => "'" . $string . "'");
 
         DatabaseInterface::$instance = $dbi;
@@ -96,11 +96,11 @@ class NavigationTest extends AbstractTestCase
         $dbi = $this->getMockBuilder(DatabaseInterface::class)
             ->disableOriginalConstructor()
             ->getMock();
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('tryQueryAsControlUser')
             ->with($expectedQuery);
 
-        $dbi->expects($this->any())->method('quoteString')
+        $dbi->expects(self::any())->method('quoteString')
             ->willReturnCallback(static fn (string $string): string => "'" . $string . "'");
         DatabaseInterface::$instance = $dbi;
         $this->object = new Navigation(new Template(), new Relation($dbi), $dbi);
@@ -113,8 +113,8 @@ class NavigationTest extends AbstractTestCase
     public function testGetItemUnhideDialog(): void
     {
         $html = $this->object->getItemUnhideDialog('db');
-        $this->assertStringContainsString('<td>tableName</td>', $html);
-        $this->assertStringContainsString(
+        self::assertStringContainsString('<td>tableName</td>', $html);
+        self::assertStringContainsString(
             '<a class="unhideNavItem ajax" href="' . Url::getFromRoute('/navigation') . '" data-post="'
             . 'unhideNavItem=1&itemType=table&'
             . 'itemName=tableName&dbName=db&lang=en">',
diff --git a/tests/classes/Navigation/NavigationTreeTest.php b/tests/classes/Navigation/NavigationTreeTest.php
index ca58901a9d..b2cdc17559 100644
--- a/tests/classes/Navigation/NavigationTreeTest.php
+++ b/tests/classes/Navigation/NavigationTreeTest.php
@@ -61,7 +61,7 @@ class NavigationTreeTest extends AbstractTestCase
     public function testRenderState(): void
     {
         $result = $this->object->renderState();
-        $this->assertStringContainsString('pma_quick_warp', $result);
+        self::assertStringContainsString('pma_quick_warp', $result);
     }
 
     /**
@@ -70,8 +70,8 @@ class NavigationTreeTest extends AbstractTestCase
     public function testRenderPath(): void
     {
         $result = $this->object->renderPath();
-        $this->assertIsString($result);
-        $this->assertStringContainsString('list_container', $result);
+        self::assertIsString($result);
+        self::assertStringContainsString('list_container', $result);
     }
 
     /**
@@ -80,7 +80,7 @@ class NavigationTreeTest extends AbstractTestCase
     public function testRenderDbSelect(): void
     {
         $result = $this->object->renderDbSelect();
-        $this->assertStringContainsString('pma_navigation_select_database', $result);
+        self::assertStringContainsString('pma_navigation_select_database', $result);
     }
 
     public function testDatabaseGrouping(): void
@@ -110,10 +110,10 @@ class NavigationTreeTest extends AbstractTestCase
 
         $object = new NavigationTree(new Template(), $dbi, new Relation($dbi));
         $result = $object->renderState();
-        $this->assertStringContainsString('<li class="first navGroup">', $result);
-        $this->assertStringContainsString('functions' . "\n", $result);
-        $this->assertStringContainsString('<div class="list_container" style="display: none;">', $result);
-        $this->assertStringContainsString('functions__a', $result);
-        $this->assertStringContainsString('functions__b', $result);
+        self::assertStringContainsString('<li class="first navGroup">', $result);
+        self::assertStringContainsString('functions' . "\n", $result);
+        self::assertStringContainsString('<div class="list_container" style="display: none;">', $result);
+        self::assertStringContainsString('functions__a', $result);
+        self::assertStringContainsString('functions__b', $result);
     }
 }
diff --git a/tests/classes/Navigation/Nodes/NodeColumnContainerTest.php b/tests/classes/Navigation/Nodes/NodeColumnContainerTest.php
index 3c1d12268b..9ecfeb119c 100644
--- a/tests/classes/Navigation/Nodes/NodeColumnContainerTest.php
+++ b/tests/classes/Navigation/Nodes/NodeColumnContainerTest.php
@@ -15,27 +15,27 @@ final class NodeColumnContainerTest extends AbstractTestCase
     public function testColumnContainer(): void
     {
         $nodeColumnContainer = new NodeColumnContainer();
-        $this->assertSame('Columns', $nodeColumnContainer->name);
-        $this->assertSame(NodeType::Container, $nodeColumnContainer->type);
-        $this->assertFalse($nodeColumnContainer->isGroup);
-        $this->assertSame(['image' => 'pause', 'title' => 'Columns'], $nodeColumnContainer->icon);
-        $this->assertSame(
+        self::assertSame('Columns', $nodeColumnContainer->name);
+        self::assertSame(NodeType::Container, $nodeColumnContainer->type);
+        self::assertFalse($nodeColumnContainer->isGroup);
+        self::assertSame(['image' => 'pause', 'title' => 'Columns'], $nodeColumnContainer->icon);
+        self::assertSame(
             [
                 'text' => ['route' => '/table/structure', 'params' => ['db' => null, 'table' => null]],
                 'icon' => ['route' => '/table/structure', 'params' => ['db' => null, 'table' => null]],
             ],
             $nodeColumnContainer->links,
         );
-        $this->assertSame('columns', $nodeColumnContainer->realName);
-        $this->assertCount(1, $nodeColumnContainer->children);
-        $this->assertArrayHasKey(0, $nodeColumnContainer->children);
+        self::assertSame('columns', $nodeColumnContainer->realName);
+        self::assertCount(1, $nodeColumnContainer->children);
+        self::assertArrayHasKey(0, $nodeColumnContainer->children);
         $newNode = $nodeColumnContainer->children[0];
-        $this->assertSame('New', $newNode->name);
-        $this->assertSame('New', $newNode->title);
-        $this->assertTrue($newNode->isNew);
-        $this->assertSame('new_column italics', $newNode->classes);
-        $this->assertSame(['image' => 'b_column_add', 'title' => 'New'], $newNode->icon);
-        $this->assertSame(
+        self::assertSame('New', $newNode->name);
+        self::assertSame('New', $newNode->title);
+        self::assertTrue($newNode->isNew);
+        self::assertSame('new_column italics', $newNode->classes);
+        self::assertSame(['image' => 'b_column_add', 'title' => 'New'], $newNode->icon);
+        self::assertSame(
             [
                 'text' => [
                     'route' => '/table/add-field',
diff --git a/tests/classes/Navigation/Nodes/NodeColumnTest.php b/tests/classes/Navigation/Nodes/NodeColumnTest.php
index d1090e202e..1e2059a341 100644
--- a/tests/classes/Navigation/Nodes/NodeColumnTest.php
+++ b/tests/classes/Navigation/Nodes/NodeColumnTest.php
@@ -21,12 +21,12 @@ final class NodeColumnTest extends AbstractTestCase
             'default' => null,
             'nullable' => '',
         ]);
-        $this->assertSame('actor_id', $nodeColumn->name);
-        $this->assertSame(NodeType::Object, $nodeColumn->type);
-        $this->assertFalse($nodeColumn->isGroup);
-        $this->assertSame('actor_id (PRI, smallint)', $nodeColumn->displayName);
-        $this->assertSame(['image' => 'b_primary', 'title' => 'Column'], $nodeColumn->icon);
-        $this->assertSame(
+        self::assertSame('actor_id', $nodeColumn->name);
+        self::assertSame(NodeType::Object, $nodeColumn->type);
+        self::assertFalse($nodeColumn->isGroup);
+        self::assertSame('actor_id (PRI, smallint)', $nodeColumn->displayName);
+        self::assertSame(['image' => 'b_primary', 'title' => 'Column'], $nodeColumn->icon);
+        self::assertSame(
             [
                 'text' => [
                     'route' => '/table/structure/change',
@@ -40,7 +40,7 @@ final class NodeColumnTest extends AbstractTestCase
             ],
             $nodeColumn->links,
         );
-        $this->assertSame('field', $nodeColumn->urlParamName);
+        self::assertSame('field', $nodeColumn->urlParamName);
     }
 
     public function testColumnNodeWithTruncatedDefaultValue(): void
@@ -52,8 +52,8 @@ final class NodeColumnTest extends AbstractTestCase
             'default' => 'current_timestamp()',
             'nullable' => '',
         ]);
-        $this->assertSame('last_update (timestamp, curren...)', $nodeColumn->displayName);
-        $this->assertSame(['image' => 'pause', 'title' => 'Column'], $nodeColumn->icon);
+        self::assertSame('last_update (timestamp, curren...)', $nodeColumn->displayName);
+        self::assertSame(['image' => 'pause', 'title' => 'Column'], $nodeColumn->icon);
     }
 
     public function testColumnNodeWithTruncatedDefaultValue2(): void
@@ -65,8 +65,8 @@ final class NodeColumnTest extends AbstractTestCase
             'default' => 'default',
             'nullable' => 'nullable',
         ]);
-        $this->assertSame('email (UNI, varchar, defaul..., nullable)', $nodeColumn->displayName);
-        $this->assertSame(['image' => 'bd_primary', 'title' => 'Column'], $nodeColumn->icon);
+        self::assertSame('email (UNI, varchar, defaul..., nullable)', $nodeColumn->displayName);
+        self::assertSame(['image' => 'bd_primary', 'title' => 'Column'], $nodeColumn->icon);
     }
 
     public function testColumnNodeWithoutTruncatedDefaultValue(): void
@@ -78,7 +78,7 @@ final class NodeColumnTest extends AbstractTestCase
             'default' => 'column',
             'nullable' => '',
         ]);
-        $this->assertSame('email (varchar, column)', $nodeColumn->displayName);
-        $this->assertSame(['image' => 'pause', 'title' => 'Column'], $nodeColumn->icon);
+        self::assertSame('email (varchar, column)', $nodeColumn->displayName);
+        self::assertSame(['image' => 'pause', 'title' => 'Column'], $nodeColumn->icon);
     }
 }
diff --git a/tests/classes/Navigation/Nodes/NodeDatabaseChildTest.php b/tests/classes/Navigation/Nodes/NodeDatabaseChildTest.php
index 517071055f..18a17ce1f2 100644
--- a/tests/classes/Navigation/Nodes/NodeDatabaseChildTest.php
+++ b/tests/classes/Navigation/Nodes/NodeDatabaseChildTest.php
@@ -68,14 +68,14 @@ class NodeDatabaseChildTest extends AbstractTestCase
 
         $parent = new NodeDatabase('parent');
         $parent->addChild($this->object);
-        $this->object->expects($this->once())
+        $this->object->expects(self::once())
             ->method('getItemType')
             ->willReturn('itemType');
         $html = $this->object->getHtmlForControlButtons($relationParameters->navigationItemsHidingFeature);
 
-        $this->assertStringStartsWith('<span class="navItemControls">', $html);
-        $this->assertStringEndsWith('</span>', $html);
-        $this->assertStringContainsString(
+        self::assertStringStartsWith('<span class="navItemControls">', $html);
+        self::assertStringEndsWith('</span>', $html);
+        self::assertStringContainsString(
             '<a href="' . Url::getFromRoute('/navigation') . '" data-post="'
             . 'hideNavItem=1&itemType=itemType&itemName=child'
             . '&dbName=parent&lang=en" class="hideNavItem ajax">',
diff --git a/tests/classes/Navigation/Nodes/NodeDatabaseTest.php b/tests/classes/Navigation/Nodes/NodeDatabaseTest.php
index 2938739ea8..ee2056454c 100644
--- a/tests/classes/Navigation/Nodes/NodeDatabaseTest.php
+++ b/tests/classes/Navigation/Nodes/NodeDatabaseTest.php
@@ -20,7 +20,7 @@ class NodeDatabaseTest extends AbstractTestCase
     public function testConstructor(): void
     {
         $parent = new NodeDatabase('default');
-        $this->assertEquals(
+        self::assertEquals(
             [
                 'text' => ['route' => '/database/structure', 'params' => ['db' => null]],
                 'icon' => ['route' => '/database/operations', 'params' => ['db' => null]],
@@ -28,7 +28,7 @@ class NodeDatabaseTest extends AbstractTestCase
             ],
             $parent->links,
         );
-        $this->assertStringContainsString('database', $parent->classes);
+        self::assertStringContainsString('database', $parent->classes);
     }
 
     /**
@@ -40,23 +40,23 @@ class NodeDatabaseTest extends AbstractTestCase
         DatabaseInterface::$instance = $this->createDatabaseInterface();
 
         $parent = new NodeDatabase('default');
-        $this->assertEquals(
+        self::assertEquals(
             2,
             $parent->getPresence('tables'),
         );
-        $this->assertEquals(
+        self::assertEquals(
             0,
             $parent->getPresence('views'),
         );
-        $this->assertEquals(
+        self::assertEquals(
             1,
             $parent->getPresence('functions'),
         );
-        $this->assertEquals(
+        self::assertEquals(
             0,
             $parent->getPresence('procedures'),
         );
-        $this->assertEquals(
+        self::assertEquals(
             0,
             $parent->getPresence('events'),
         );
@@ -79,18 +79,18 @@ class NodeDatabaseTest extends AbstractTestCase
         $parent = new NodeDatabase('default');
 
         $tables = $parent->getData($relationParameters, 'tables', 0);
-        $this->assertContains('test1', $tables);
-        $this->assertContains('test2', $tables);
+        self::assertContains('test1', $tables);
+        self::assertContains('test2', $tables);
 
         $views = $parent->getData($relationParameters, 'views', 0);
-        $this->assertEmpty($views);
+        self::assertEmpty($views);
 
         $functions = $parent->getData($relationParameters, 'functions', 0);
-        $this->assertContains('testFunction', $functions);
-        $this->assertCount(1, $functions);
+        self::assertContains('testFunction', $functions);
+        self::assertCount(1, $functions);
 
-        $this->assertEmpty($parent->getData($relationParameters, 'procedures', 0));
-        $this->assertEmpty($parent->getData($relationParameters, 'events', 0));
+        self::assertEmpty($parent->getData($relationParameters, 'procedures', 0));
+        self::assertEmpty($parent->getData($relationParameters, 'events', 0));
     }
 
     /**
@@ -100,10 +100,10 @@ class NodeDatabaseTest extends AbstractTestCase
     {
         $parent = new NodeDatabase('default');
         $parent->setHiddenCount(1);
-        $this->assertSame(1, $parent->getHiddenCount());
+        self::assertSame(1, $parent->getHiddenCount());
         $parent->setHiddenCount(0);
-        $this->assertSame(0, $parent->getHiddenCount());
+        self::assertSame(0, $parent->getHiddenCount());
         $parent->setHiddenCount(-1);
-        $this->assertSame(0, $parent->getHiddenCount());
+        self::assertSame(0, $parent->getHiddenCount());
     }
 }
diff --git a/tests/classes/Navigation/Nodes/NodeEventContainerTest.php b/tests/classes/Navigation/Nodes/NodeEventContainerTest.php
index 5ba3380bde..289a91a4f8 100644
--- a/tests/classes/Navigation/Nodes/NodeEventContainerTest.php
+++ b/tests/classes/Navigation/Nodes/NodeEventContainerTest.php
@@ -17,13 +17,13 @@ class NodeEventContainerTest extends AbstractTestCase
     public function testConstructor(): void
     {
         $parent = new NodeEventContainer();
-        $this->assertEquals(
+        self::assertEquals(
             [
                 'text' => ['route' => '/database/events', 'params' => ['db' => null]],
                 'icon' => ['route' => '/database/events', 'params' => ['db' => null]],
             ],
             $parent->links,
         );
-        $this->assertEquals('events', $parent->realName);
+        self::assertEquals('events', $parent->realName);
     }
 }
diff --git a/tests/classes/Navigation/Nodes/NodeEventTest.php b/tests/classes/Navigation/Nodes/NodeEventTest.php
index e107bc5bd0..9c5f37e7ba 100644
--- a/tests/classes/Navigation/Nodes/NodeEventTest.php
+++ b/tests/classes/Navigation/Nodes/NodeEventTest.php
@@ -17,7 +17,7 @@ class NodeEventTest extends AbstractTestCase
     public function testConstructor(): void
     {
         $parent = new NodeEvent('default');
-        $this->assertEquals(
+        self::assertEquals(
             [
                 'text' => [
                     'route' => '/database/events',
diff --git a/tests/classes/Navigation/Nodes/NodeFunctionContainerTest.php b/tests/classes/Navigation/Nodes/NodeFunctionContainerTest.php
index 46b68282f6..e3e5001b17 100644
--- a/tests/classes/Navigation/Nodes/NodeFunctionContainerTest.php
+++ b/tests/classes/Navigation/Nodes/NodeFunctionContainerTest.php
@@ -17,13 +17,13 @@ class NodeFunctionContainerTest extends AbstractTestCase
     public function testConstructor(): void
     {
         $parent = new NodeFunctionContainer();
-        $this->assertEquals(
+        self::assertEquals(
             [
                 'text' => ['route' => '/database/routines', 'params' => ['type' => 'FUNCTION', 'db' => null]],
                 'icon' => ['route' => '/database/routines', 'params' => ['type' => 'FUNCTION', 'db' => null]],
             ],
             $parent->links,
         );
-        $this->assertEquals('functions', $parent->realName);
+        self::assertEquals('functions', $parent->realName);
     }
 }
diff --git a/tests/classes/Navigation/Nodes/NodeFunctionTest.php b/tests/classes/Navigation/Nodes/NodeFunctionTest.php
index 7536310d69..16dad7173f 100644
--- a/tests/classes/Navigation/Nodes/NodeFunctionTest.php
+++ b/tests/classes/Navigation/Nodes/NodeFunctionTest.php
@@ -17,7 +17,7 @@ class NodeFunctionTest extends AbstractTestCase
     public function testConstructor(): void
     {
         $parent = new NodeFunction('default');
-        $this->assertEquals(
+        self::assertEquals(
             [
                 'text' => [
                     'route' => '/database/routines',
diff --git a/tests/classes/Navigation/Nodes/NodeIndexContainerTest.php b/tests/classes/Navigation/Nodes/NodeIndexContainerTest.php
index 0c89baa923..cca7a958db 100644
--- a/tests/classes/Navigation/Nodes/NodeIndexContainerTest.php
+++ b/tests/classes/Navigation/Nodes/NodeIndexContainerTest.php
@@ -17,13 +17,13 @@ class NodeIndexContainerTest extends AbstractTestCase
     public function testConstructor(): void
     {
         $parent = new NodeIndexContainer();
-        $this->assertEquals(
+        self::assertEquals(
             [
                 'text' => ['route' => '/table/structure', 'params' => ['db' => null, 'table' => null]],
                 'icon' => ['route' => '/table/structure', 'params' => ['db' => null, 'table' => null]],
             ],
             $parent->links,
         );
-        $this->assertEquals('indexes', $parent->realName);
+        self::assertEquals('indexes', $parent->realName);
     }
 }
diff --git a/tests/classes/Navigation/Nodes/NodeIndexTest.php b/tests/classes/Navigation/Nodes/NodeIndexTest.php
index 7c98e0fb68..e06d77372a 100644
--- a/tests/classes/Navigation/Nodes/NodeIndexTest.php
+++ b/tests/classes/Navigation/Nodes/NodeIndexTest.php
@@ -17,7 +17,7 @@ class NodeIndexTest extends AbstractTestCase
     public function testConstructor(): void
     {
         $parent = new NodeIndex('default');
-        $this->assertEquals(
+        self::assertEquals(
             [
                 'text' => ['route' => '/table/indexes', 'params' => ['db' => null, 'table' => null, 'index' => null]],
                 'icon' => ['route' => '/table/indexes', 'params' => ['db' => null, 'table' => null, 'index' => null]],
diff --git a/tests/classes/Navigation/Nodes/NodeProcedureContainerTest.php b/tests/classes/Navigation/Nodes/NodeProcedureContainerTest.php
index c88b22215a..0237ede928 100644
--- a/tests/classes/Navigation/Nodes/NodeProcedureContainerTest.php
+++ b/tests/classes/Navigation/Nodes/NodeProcedureContainerTest.php
@@ -17,13 +17,13 @@ class NodeProcedureContainerTest extends AbstractTestCase
     public function testConstructor(): void
     {
         $parent = new NodeProcedureContainer();
-        $this->assertEquals(
+        self::assertEquals(
             [
                 'text' => ['route' => '/database/routines', 'params' => ['type' => 'PROCEDURE', 'db' => null]],
                 'icon' => ['route' => '/database/routines', 'params' => ['type' => 'PROCEDURE', 'db' => null]],
             ],
             $parent->links,
         );
-        $this->assertEquals('procedures', $parent->realName);
+        self::assertEquals('procedures', $parent->realName);
     }
 }
diff --git a/tests/classes/Navigation/Nodes/NodeProcedureTest.php b/tests/classes/Navigation/Nodes/NodeProcedureTest.php
index 313cd68ba6..96aa43428f 100644
--- a/tests/classes/Navigation/Nodes/NodeProcedureTest.php
+++ b/tests/classes/Navigation/Nodes/NodeProcedureTest.php
@@ -17,7 +17,7 @@ class NodeProcedureTest extends AbstractTestCase
     public function testConstructor(): void
     {
         $parent = new NodeProcedure('default');
-        $this->assertEquals(
+        self::assertEquals(
             [
                 'text' => [
                     'route' => '/database/routines',
diff --git a/tests/classes/Navigation/Nodes/NodeTableContainerTest.php b/tests/classes/Navigation/Nodes/NodeTableContainerTest.php
index 6b5fe8796a..9a5f5e32d7 100644
--- a/tests/classes/Navigation/Nodes/NodeTableContainerTest.php
+++ b/tests/classes/Navigation/Nodes/NodeTableContainerTest.php
@@ -17,14 +17,14 @@ class NodeTableContainerTest extends AbstractTestCase
     public function testConstructor(): void
     {
         $parent = new NodeTableContainer();
-        $this->assertEquals(
+        self::assertEquals(
             [
                 'text' => ['route' => '/database/structure', 'params' => ['tbl_type' => 'table', 'db' => null]],
                 'icon' => ['route' => '/database/structure', 'params' => ['tbl_type' => 'table', 'db' => null]],
             ],
             $parent->links,
         );
-        $this->assertEquals('tables', $parent->realName);
-        $this->assertStringContainsString('tableContainer', $parent->classes);
+        self::assertEquals('tables', $parent->realName);
+        self::assertStringContainsString('tableContainer', $parent->classes);
     }
 }
diff --git a/tests/classes/Navigation/Nodes/NodeTableTest.php b/tests/classes/Navigation/Nodes/NodeTableTest.php
index 987638af4e..13970bc099 100644
--- a/tests/classes/Navigation/Nodes/NodeTableTest.php
+++ b/tests/classes/Navigation/Nodes/NodeTableTest.php
@@ -23,7 +23,7 @@ class NodeTableTest extends AbstractTestCase
         $config->settings['NavigationTreeDefaultTabTable2'] = 'insert';
 
         $parent = new NodeTable('default');
-        $this->assertEquals(
+        self::assertEquals(
             [
                 'text' => ['route' => '/sql', 'params' => ['pos' => 0, 'db' => null, 'table' => null]],
                 'icon' => ['route' => '/table/search', 'params' => ['db' => null, 'table' => null]],
@@ -32,7 +32,7 @@ class NodeTableTest extends AbstractTestCase
             ],
             $parent->links,
         );
-        $this->assertStringContainsString('table', $parent->classes);
+        self::assertStringContainsString('table', $parent->classes);
     }
 
     /**
@@ -46,8 +46,8 @@ class NodeTableTest extends AbstractTestCase
     {
         Config::getInstance()->settings['NavigationTreeDefaultTabTable'] = $target;
         $node = new NodeTable('default');
-        $this->assertEquals($imageName, $node->icon['image']);
-        $this->assertEquals($imageTitle, $node->icon['title']);
+        self::assertEquals($imageName, $node->icon['image']);
+        self::assertEquals($imageTitle, $node->icon['title']);
     }
 
     /**
diff --git a/tests/classes/Navigation/Nodes/NodeTest.php b/tests/classes/Navigation/Nodes/NodeTest.php
index f4eabb8214..db32bf75d7 100644
--- a/tests/classes/Navigation/Nodes/NodeTest.php
+++ b/tests/classes/Navigation/Nodes/NodeTest.php
@@ -21,37 +21,37 @@ final class NodeTest extends AbstractTestCase
     public function testNewNode(): void
     {
         $node = new Node('Object Node');
-        $this->assertSame('Object Node', $node->name);
-        $this->assertSame('Object Node', $node->realName);
-        $this->assertSame(NodeType::Object, $node->type);
-        $this->assertFalse($node->isGroup);
+        self::assertSame('Object Node', $node->name);
+        self::assertSame('Object Node', $node->realName);
+        self::assertSame(NodeType::Object, $node->type);
+        self::assertFalse($node->isGroup);
     }
 
     public function testNewNodeWithEmptyName(): void
     {
         $node = new Node('');
-        $this->assertSame('', $node->name);
-        $this->assertSame('', $node->realName);
-        $this->assertSame(NodeType::Object, $node->type);
-        $this->assertFalse($node->isGroup);
+        self::assertSame('', $node->name);
+        self::assertSame('', $node->realName);
+        self::assertSame(NodeType::Object, $node->type);
+        self::assertFalse($node->isGroup);
     }
 
     public function testNewContainerNode(): void
     {
         $node = new Node('Container Node', NodeType::Container);
-        $this->assertSame('Container Node', $node->name);
-        $this->assertSame('Container Node', $node->realName);
-        $this->assertSame(NodeType::Container, $node->type);
-        $this->assertFalse($node->isGroup);
+        self::assertSame('Container Node', $node->name);
+        self::assertSame('Container Node', $node->realName);
+        self::assertSame(NodeType::Container, $node->type);
+        self::assertFalse($node->isGroup);
     }
 
     public function testNewGroupNode(): void
     {
         $node = new Node('Group Node', NodeType::Object, true);
-        $this->assertSame('Group Node', $node->name);
-        $this->assertSame('Group Node', $node->realName);
-        $this->assertSame(NodeType::Object, $node->type);
-        $this->assertTrue($node->isGroup);
+        self::assertSame('Group Node', $node->name);
+        self::assertSame('Group Node', $node->realName);
+        self::assertSame(NodeType::Object, $node->type);
+        self::assertTrue($node->isGroup);
     }
 
     /** @psalm-suppress DocblockTypeContradiction */
@@ -60,17 +60,17 @@ final class NodeTest extends AbstractTestCase
         $parent = new Node('parent');
         $childOne = new Node('child one');
         $childTwo = new Node('child two');
-        $this->assertSame([], $parent->children);
-        $this->assertNull($childOne->parent);
-        $this->assertNull($childTwo->parent);
+        self::assertSame([], $parent->children);
+        self::assertNull($childOne->parent);
+        self::assertNull($childTwo->parent);
         $parent->addChild($childOne);
-        $this->assertSame([$childOne], $parent->children);
-        $this->assertSame($parent, $childOne->parent);
-        $this->assertNull($childTwo->parent);
+        self::assertSame([$childOne], $parent->children);
+        self::assertSame($parent, $childOne->parent);
+        self::assertNull($childTwo->parent);
         $parent->addChild($childTwo);
-        $this->assertSame([$childOne, $childTwo], $parent->children);
-        $this->assertSame($parent, $childOne->parent);
-        $this->assertSame($parent, $childTwo->parent);
+        self::assertSame([$childOne, $childTwo], $parent->children);
+        self::assertSame($parent, $childOne->parent);
+        self::assertSame($parent, $childTwo->parent);
     }
 
     public function testGetChildNode(): void
@@ -78,20 +78,20 @@ final class NodeTest extends AbstractTestCase
         $parent = new Node('parent');
         $child = new Node('child real name');
         $child->name = 'child';
-        $this->assertNull($parent->getChild('child'));
-        $this->assertNull($parent->getChild('child', true));
-        $this->assertNull($parent->getChild('child real name'));
-        $this->assertNull($parent->getChild('child real name', true));
+        self::assertNull($parent->getChild('child'));
+        self::assertNull($parent->getChild('child', true));
+        self::assertNull($parent->getChild('child real name'));
+        self::assertNull($parent->getChild('child real name', true));
         $parent->addChild($child);
-        $this->assertSame($child, $parent->getChild('child'));
-        $this->assertNull($parent->getChild('child', true));
-        $this->assertNull($parent->getChild('child real name'));
-        $this->assertSame($child, $parent->getChild('child real name', true));
+        self::assertSame($child, $parent->getChild('child'));
+        self::assertNull($parent->getChild('child', true));
+        self::assertNull($parent->getChild('child real name'));
+        self::assertSame($child, $parent->getChild('child real name', true));
         $child->isNew = true;
-        $this->assertNull($parent->getChild('child'));
-        $this->assertNull($parent->getChild('child', true));
-        $this->assertNull($parent->getChild('child real name'));
-        $this->assertSame($child, $parent->getChild('child real name', true));
+        self::assertNull($parent->getChild('child'));
+        self::assertNull($parent->getChild('child', true));
+        self::assertNull($parent->getChild('child real name'));
+        self::assertSame($child, $parent->getChild('child real name', true));
     }
 
     public function testRemoveChildNode(): void
@@ -104,10 +104,10 @@ final class NodeTest extends AbstractTestCase
         $parent->addChild($childTwo);
         $parent->addChild($childThree);
         $parent->addChild($childTwo);
-        $this->assertSame([0 => $childOne, 1 => $childTwo, 2 => $childThree, 3 => $childTwo], $parent->children);
+        self::assertSame([0 => $childOne, 1 => $childTwo, 2 => $childThree, 3 => $childTwo], $parent->children);
         $parent->removeChild('child two');
         /** @psalm-suppress DocblockTypeContradiction */
-        $this->assertSame([0 => $childOne, 2 => $childThree, 3 => $childTwo], $parent->children);
+        self::assertSame([0 => $childOne, 2 => $childThree, 3 => $childTwo], $parent->children);
     }
 
     public function testParents(): void
@@ -123,17 +123,17 @@ final class NodeTest extends AbstractTestCase
         $dbGroup->addChild($dbTwo);
         $dbOne->addChild($tableContainer);
         $tableContainer->addChild($table);
-        $this->assertSame([], $dbContainer->parents(false, true));
-        $this->assertSame([$dbContainer], $dbContainer->parents(true, true));
-        $this->assertSame([$dbContainer], $dbGroup->parents(false, true, true));
-        $this->assertSame([$dbGroup, $dbContainer], $dbGroup->parents(true, true, true));
-        $this->assertSame([$dbOne], $table->parents());
-        $this->assertSame([$table, $dbOne], $table->parents(true));
-        $this->assertSame([$tableContainer, $dbOne, $dbContainer], $table->parents(false, true));
-        $this->assertSame([$table, $tableContainer, $dbOne, $dbContainer], $table->parents(true, true));
-        $this->assertSame([$dbOne], $table->parents(false, false, true));
-        $this->assertSame([$tableContainer, $dbOne, $dbGroup, $dbContainer], $table->parents(false, true, true));
-        $this->assertSame(
+        self::assertSame([], $dbContainer->parents(false, true));
+        self::assertSame([$dbContainer], $dbContainer->parents(true, true));
+        self::assertSame([$dbContainer], $dbGroup->parents(false, true, true));
+        self::assertSame([$dbGroup, $dbContainer], $dbGroup->parents(true, true, true));
+        self::assertSame([$dbOne], $table->parents());
+        self::assertSame([$table, $dbOne], $table->parents(true));
+        self::assertSame([$tableContainer, $dbOne, $dbContainer], $table->parents(false, true));
+        self::assertSame([$table, $tableContainer, $dbOne, $dbContainer], $table->parents(true, true));
+        self::assertSame([$dbOne], $table->parents(false, false, true));
+        self::assertSame([$tableContainer, $dbOne, $dbGroup, $dbContainer], $table->parents(false, true, true));
+        self::assertSame(
             [$table, $tableContainer, $dbOne, $dbGroup, $dbContainer],
             $table->parents(true, true, true),
         );
@@ -146,20 +146,20 @@ final class NodeTest extends AbstractTestCase
         $grandchild = new Node('grandchild');
         $parent->addChild($child);
         $child->addChild($grandchild);
-        $this->assertFalse($parent->realParent());
-        $this->assertSame($parent, $child->realParent());
-        $this->assertSame($child, $grandchild->realParent());
+        self::assertFalse($parent->realParent());
+        self::assertSame($parent, $child->realParent());
+        self::assertSame($child, $grandchild->realParent());
     }
 
     public function testNodeHasChildren(): void
     {
         $parent = new Node('parent');
         $child = new Node('child');
-        $this->assertFalse($parent->hasChildren(true));
-        $this->assertFalse($parent->hasChildren(false));
+        self::assertFalse($parent->hasChildren(true));
+        self::assertFalse($parent->hasChildren(false));
         $parent->addChild($child);
-        $this->assertTrue($parent->hasChildren(true));
-        $this->assertTrue($parent->hasChildren(false));
+        self::assertTrue($parent->hasChildren(true));
+        self::assertTrue($parent->hasChildren(false));
     }
 
     public function testNodeHasChildrenWithContainers(): void
@@ -168,17 +168,17 @@ final class NodeTest extends AbstractTestCase
         $containerOne = new Node('container 1', NodeType::Container);
         $containerTwo = new Node('container 2', NodeType::Container);
         $child = new Node('child');
-        $this->assertFalse($parent->hasChildren());
-        $this->assertFalse($parent->hasChildren(false));
+        self::assertFalse($parent->hasChildren());
+        self::assertFalse($parent->hasChildren(false));
         $parent->addChild($containerOne);
-        $this->assertTrue($parent->hasChildren());
-        $this->assertFalse($parent->hasChildren(false));
+        self::assertTrue($parent->hasChildren());
+        self::assertFalse($parent->hasChildren(false));
         $containerOne->addChild($containerTwo);
-        $this->assertTrue($parent->hasChildren());
-        $this->assertFalse($parent->hasChildren(false));
+        self::assertTrue($parent->hasChildren());
+        self::assertFalse($parent->hasChildren(false));
         $containerTwo->addChild($child);
-        $this->assertTrue($parent->hasChildren());
-        $this->assertTrue($parent->hasChildren(false));
+        self::assertTrue($parent->hasChildren());
+        self::assertTrue($parent->hasChildren(false));
     }
 
     public function testNodeHasSiblings(): void
@@ -187,10 +187,10 @@ final class NodeTest extends AbstractTestCase
         $childOne = new Node('child one');
         $childTwo = new Node('child two');
         $parent->addChild($childOne);
-        $this->assertFalse($parent->hasSiblings());
-        $this->assertFalse($childOne->hasSiblings());
+        self::assertFalse($parent->hasSiblings());
+        self::assertFalse($childOne->hasSiblings());
         $parent->addChild($childTwo);
-        $this->assertTrue($childOne->hasSiblings());
+        self::assertTrue($childOne->hasSiblings());
     }
 
     public function testNodeHasSiblingsWithContainers(): void
@@ -202,14 +202,14 @@ final class NodeTest extends AbstractTestCase
         $childTwo = new Node('child two');
         $parent->addChild($childOne);
         $parent->addChild($containerOne);
-        $this->assertFalse($childOne->hasSiblings(), 'An empty container node should not be considered a sibling.');
+        self::assertFalse($childOne->hasSiblings(), 'An empty container node should not be considered a sibling.');
         $containerOne->addChild($containerTwo);
-        $this->assertFalse(
+        self::assertFalse(
             $childOne->hasSiblings(),
             'A container node with empty children should not be considered a sibling.',
         );
         $containerOne->addChild($childTwo);
-        $this->assertTrue($childOne->hasSiblings(), 'A container node with children should be considered a sibling.');
+        self::assertTrue($childOne->hasSiblings(), 'A container node with children should be considered a sibling.');
     }
 
     public function testNodeHasSiblingsForNodesAtLevelThree(): void
@@ -222,31 +222,31 @@ final class NodeTest extends AbstractTestCase
         $child->addChild($grandchild);
         $grandchild->addChild($greatGrandchild);
         // Should return false for node that are two levels deeps
-        $this->assertFalse($grandchild->hasSiblings());
+        self::assertFalse($grandchild->hasSiblings());
         // Should return true for node that are three levels deeps
-        $this->assertTrue($greatGrandchild->hasSiblings());
+        self::assertTrue($greatGrandchild->hasSiblings());
     }
 
     public function testNumChildren(): void
     {
         $parent = new Node('parent');
-        $this->assertSame(0, $parent->numChildren());
+        self::assertSame(0, $parent->numChildren());
         $child = new Node('child one');
         $parent->addChild($child);
-        $this->assertSame(1, $parent->numChildren());
+        self::assertSame(1, $parent->numChildren());
         // add a direct grandchild, this one doesn't count as it's not enclosed in a CONTAINER
         $child->addChild(new Node('child two'));
-        $this->assertSame(1, $parent->numChildren());
+        self::assertSame(1, $parent->numChildren());
         // add a container, this one doesn't count wither
         $container = new Node('container', NodeType::Container);
         $parent->addChild($container);
-        $this->assertSame(1, $parent->numChildren());
+        self::assertSame(1, $parent->numChildren());
         // add a grandchild to container, this one counts
         $container->addChild(new Node('child three'));
-        $this->assertSame(2, $parent->numChildren());
+        self::assertSame(2, $parent->numChildren());
         // add another grandchild to container, this one counts
         $container->addChild(new Node('child four'));
-        $this->assertSame(3, $parent->numChildren());
+        self::assertSame(3, $parent->numChildren());
     }
 
     public function testGetPaths(): void
@@ -260,7 +260,7 @@ final class NodeTest extends AbstractTestCase
         $group->addChild($childOne);
         $childOne->addChild($container);
         $container->addChild($childTwo);
-        $this->assertSame(
+        self::assertSame(
             [
                 'aPath' => 'cGFyZW50.Y2hpbGQgb25l.Y29udGFpbmVy.Y2hpbGQgdHdv',
                 'aPath_clean' => ['parent', 'child one', 'container', 'child two'],
@@ -278,10 +278,10 @@ final class NodeTest extends AbstractTestCase
 
         // Vanilla case
         $node = new Node('default');
-        $this->assertSame('WHERE TRUE ', $method->invoke($node, 'SCHEMA_NAME'));
+        self::assertSame('WHERE TRUE ', $method->invoke($node, 'SCHEMA_NAME'));
 
         // When a schema names is passed as search clause
-        $this->assertSame(
+        self::assertSame(
             "WHERE TRUE AND `SCHEMA_NAME` LIKE '%schemaName%' ",
             $method->invoke($node, 'SCHEMA_NAME', 'schemaName'),
         );
@@ -293,7 +293,7 @@ final class NodeTest extends AbstractTestCase
 
         // When hide_db regular expression is present
         $config->selectedServer['hide_db'] = 'regexpHideDb';
-        $this->assertSame(
+        self::assertSame(
             "WHERE TRUE AND `SCHEMA_NAME` NOT REGEXP 'regexpHideDb' ",
             $method->invoke($node, 'SCHEMA_NAME'),
         );
@@ -301,7 +301,7 @@ final class NodeTest extends AbstractTestCase
 
         // When only_db directive is present and it's a single db
         $config->selectedServer['only_db'] = 'stringOnlyDb';
-        $this->assertSame(
+        self::assertSame(
             "WHERE TRUE AND ( `SCHEMA_NAME` LIKE 'stringOnlyDb' ) ",
             $method->invoke($node, 'SCHEMA_NAME'),
         );
@@ -309,7 +309,7 @@ final class NodeTest extends AbstractTestCase
 
         // When only_db directive is present and it's an array of dbs
         $config->selectedServer['only_db'] = ['onlyDbOne', 'onlyDbTwo'];
-        $this->assertSame(
+        self::assertSame(
             'WHERE TRUE AND ( `SCHEMA_NAME` LIKE \'onlyDbOne\' OR `SCHEMA_NAME` LIKE \'onlyDbTwo\' ) ',
             $method->invoke($node, 'SCHEMA_NAME'),
         );
@@ -353,9 +353,9 @@ final class NodeTest extends AbstractTestCase
 
         $node = new Node('node');
 
-        $dbi = $this->createMock(DatabaseInterface::class);
-        $dbi->expects($this->once())->method('fetchResult')->with($expectedSql);
-        $dbi->expects($this->any())->method('quoteString')
+        $dbi = self::createMock(DatabaseInterface::class);
+        $dbi->expects(self::once())->method('fetchResult')->with($expectedSql);
+        $dbi->expects(self::any())->method('quoteString')
             ->willReturnCallback(static fn (string $string): string => "'" . $string . "'");
         DatabaseInterface::$instance = $dbi;
         $node->getData($relationParameters, '', 10);
@@ -385,8 +385,8 @@ final class NodeTest extends AbstractTestCase
 
         $node = new Node('node');
 
-        $dbi = $this->createMock(DatabaseInterface::class);
-        $dbi->expects($this->once())->method('fetchResult')->with($expectedSql);
+        $dbi = self::createMock(DatabaseInterface::class);
+        $dbi->expects(self::once())->method('fetchResult')->with($expectedSql);
 
         DatabaseInterface::$instance = $dbi;
         $node->getData($relationParameters, '', 10);
@@ -412,27 +412,27 @@ final class NodeTest extends AbstractTestCase
 
         $node = new Node('node');
 
-        $resultStub = $this->createMock(DummyResult::class);
+        $resultStub = self::createMock(DummyResult::class);
 
-        $dbi = $this->createMock(DatabaseInterface::class);
-        $dbi->expects($this->once())
+        $dbi = self::createMock(DatabaseInterface::class);
+        $dbi->expects(self::once())
             ->method('tryQuery')
             ->with("SHOW DATABASES WHERE TRUE AND `Database` LIKE '%db%' ")
             ->willReturn($resultStub);
-        $resultStub->expects($this->exactly(3))
+        $resultStub->expects(self::exactly(3))
             ->method('fetchRow')
             ->willReturn(['0' => 'db'], ['0' => 'aa_db'], []);
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('fetchResult')
             ->with(
                 "SHOW DATABASES WHERE TRUE AND `Database` LIKE '%db%' AND ("
                 . " LOCATE('db_', CONCAT(`Database`, '_')) = 1"
                 . " OR LOCATE('aa_', CONCAT(`Database`, '_')) = 1 )",
             );
-        $dbi->expects($this->any())->method('escapeMysqlWildcards')
+        $dbi->expects(self::any())->method('escapeMysqlWildcards')
             ->willReturnArgument(0);
-        $dbi->expects($this->any())->method('quoteString')
+        $dbi->expects(self::any())->method('quoteString')
             ->willReturnCallback(static fn (string $string): string => "'" . $string . "'");
 
         DatabaseInterface::$instance = $dbi;
@@ -459,10 +459,10 @@ final class NodeTest extends AbstractTestCase
 
         $node = new Node('node');
 
-        $dbi = $this->createMock(DatabaseInterface::class);
-        $dbi->expects($this->once())->method('fetchValue')->with($query);
+        $dbi = self::createMock(DatabaseInterface::class);
+        $dbi->expects(self::once())->method('fetchValue')->with($query);
         DatabaseInterface::$instance = $dbi;
-        $this->assertSame(0, $node->getPresence());
+        self::assertSame(0, $node->getPresence());
     }
 
     /**
@@ -479,10 +479,10 @@ final class NodeTest extends AbstractTestCase
         $query .= 'WHERE TRUE ';
 
         $node = new Node('node');
-        $dbi = $this->createMock(DatabaseInterface::class);
-        $dbi->expects($this->once())->method('fetchValue')->with($query);
+        $dbi = self::createMock(DatabaseInterface::class);
+        $dbi->expects(self::once())->method('fetchValue')->with($query);
         DatabaseInterface::$instance = $dbi;
-        $this->assertSame(0, $node->getPresence());
+        self::assertSame(0, $node->getPresence());
     }
 
     /**
@@ -497,41 +497,41 @@ final class NodeTest extends AbstractTestCase
 
         $node = new Node('node');
 
-        $resultStub = $this->createMock(DummyResult::class);
+        $resultStub = self::createMock(DummyResult::class);
 
         // test with no search clause
-        $dbi = $this->createMock(DatabaseInterface::class);
-        $dbi->expects($this->once())
+        $dbi = self::createMock(DatabaseInterface::class);
+        $dbi->expects(self::once())
             ->method('tryQuery')
             ->with('SHOW DATABASES WHERE TRUE ')
             ->willReturn($resultStub);
 
         DatabaseInterface::$instance = $dbi;
-        $this->assertSame(0, $node->getPresence());
+        self::assertSame(0, $node->getPresence());
 
         // test with a search clause
-        $dbi = $this->createMock(DatabaseInterface::class);
-        $dbi->expects($this->once())
+        $dbi = self::createMock(DatabaseInterface::class);
+        $dbi->expects(self::once())
             ->method('tryQuery')
             ->with("SHOW DATABASES WHERE TRUE AND `Database` LIKE '%dbname%' ")
             ->willReturn($resultStub);
-        $dbi->expects($this->any())->method('escapeMysqlWildcards')
+        $dbi->expects(self::any())->method('escapeMysqlWildcards')
             ->willReturnArgument(0);
-        $dbi->expects($this->any())->method('quoteString')
+        $dbi->expects(self::any())->method('quoteString')
             ->willReturnCallback(static fn (string $string): string => "'" . $string . "'");
 
         DatabaseInterface::$instance = $dbi;
-        $this->assertSame(0, $node->getPresence('', 'dbname'));
+        self::assertSame(0, $node->getPresence('', 'dbname'));
     }
 
     public function testGetInstanceForNewNode(): void
     {
         $node = (new Node())->getInstanceForNewNode('New', 'new_database italics');
-        $this->assertEquals('New', $node->name);
-        $this->assertEquals(NodeType::Object, $node->type);
-        $this->assertFalse($node->isGroup);
-        $this->assertEquals('New', $node->title);
-        $this->assertTrue($node->isNew);
-        $this->assertEquals('new_database italics', $node->classes);
+        self::assertEquals('New', $node->name);
+        self::assertEquals(NodeType::Object, $node->type);
+        self::assertFalse($node->isGroup);
+        self::assertEquals('New', $node->title);
+        self::assertTrue($node->isNew);
+        self::assertEquals('new_database italics', $node->classes);
     }
 }
diff --git a/tests/classes/Navigation/Nodes/NodeTriggerContainerTest.php b/tests/classes/Navigation/Nodes/NodeTriggerContainerTest.php
index 2ff583d368..8445ea48ee 100644
--- a/tests/classes/Navigation/Nodes/NodeTriggerContainerTest.php
+++ b/tests/classes/Navigation/Nodes/NodeTriggerContainerTest.php
@@ -17,13 +17,13 @@ class NodeTriggerContainerTest extends AbstractTestCase
     public function testConstructor(): void
     {
         $parent = new NodeTriggerContainer();
-        $this->assertEquals(
+        self::assertEquals(
             [
                 'text' => ['route' => '/triggers', 'params' => ['db' => null, 'table' => null]],
                 'icon' => ['route' => '/triggers', 'params' => ['db' => null, 'table' => null]],
             ],
             $parent->links,
         );
-        $this->assertEquals('triggers', $parent->realName);
+        self::assertEquals('triggers', $parent->realName);
     }
 }
diff --git a/tests/classes/Navigation/Nodes/NodeTriggerTest.php b/tests/classes/Navigation/Nodes/NodeTriggerTest.php
index dae1da4790..b655a803b9 100644
--- a/tests/classes/Navigation/Nodes/NodeTriggerTest.php
+++ b/tests/classes/Navigation/Nodes/NodeTriggerTest.php
@@ -17,7 +17,7 @@ class NodeTriggerTest extends AbstractTestCase
     public function testConstructor(): void
     {
         $parent = new NodeTrigger('default');
-        $this->assertEquals(
+        self::assertEquals(
             [
                 'text' => [
                     'route' => '/triggers',
diff --git a/tests/classes/Navigation/Nodes/NodeViewContainerTest.php b/tests/classes/Navigation/Nodes/NodeViewContainerTest.php
index cac8ea73d8..d53376c1f3 100644
--- a/tests/classes/Navigation/Nodes/NodeViewContainerTest.php
+++ b/tests/classes/Navigation/Nodes/NodeViewContainerTest.php
@@ -17,14 +17,14 @@ class NodeViewContainerTest extends AbstractTestCase
     public function testConstructor(): void
     {
         $parent = new NodeViewContainer();
-        $this->assertEquals(
+        self::assertEquals(
             [
                 'text' => ['route' => '/database/structure', 'params' => ['tbl_type' => 'view', 'db' => null]],
                 'icon' => ['route' => '/database/structure', 'params' => ['tbl_type' => 'view', 'db' => null]],
             ],
             $parent->links,
         );
-        $this->assertEquals('views', $parent->realName);
-        $this->assertStringContainsString('viewContainer', $parent->classes);
+        self::assertEquals('views', $parent->realName);
+        self::assertStringContainsString('viewContainer', $parent->classes);
     }
 }
diff --git a/tests/classes/Navigation/Nodes/NodeViewTest.php b/tests/classes/Navigation/Nodes/NodeViewTest.php
index 8ba2f729d9..72ee7b3595 100644
--- a/tests/classes/Navigation/Nodes/NodeViewTest.php
+++ b/tests/classes/Navigation/Nodes/NodeViewTest.php
@@ -17,15 +17,15 @@ class NodeViewTest extends AbstractTestCase
     public function testConstructor(): void
     {
         $parent = new NodeView('default');
-        $this->assertEquals(
+        self::assertEquals(
             [
                 'text' => ['route' => '/sql', 'params' => ['pos' => 0, 'db' => null, 'table' => null]],
                 'icon' => ['route' => '/table/structure', 'params' => ['db' => null, 'table' => null]],
             ],
             $parent->links,
         );
-        $this->assertEquals('b_props', $parent->icon['image']);
-        $this->assertEquals('View', $parent->icon['title']);
-        $this->assertStringContainsString('view', $parent->classes);
+        self::assertEquals('b_props', $parent->icon['image']);
+        self::assertEquals('View', $parent->icon['title']);
+        self::assertStringContainsString('view', $parent->classes);
     }
 }
diff --git a/tests/classes/NormalizationTest.php b/tests/classes/NormalizationTest.php
index 1cc93cba8c..73dc837e25 100644
--- a/tests/classes/NormalizationTest.php
+++ b/tests/classes/NormalizationTest.php
@@ -64,17 +64,17 @@ class NormalizationTest extends AbstractTestCase
         $dbi->types = new Types($dbi);
         DatabaseInterface::$instance = $dbi;
         // set expectations
-        $dbi->expects($this->any())
+        $dbi->expects(self::any())
             ->method('selectDb')
             ->willReturn(true);
-        $dbi->expects($this->any())
+        $dbi->expects(self::any())
             ->method('getColumns')
             ->willReturn([
                 'id' => new ColumnFull('id', 'integer', null, false, '', null, '', '', ''),
                 'col1' => new ColumnFull('col1', 'varchar(100)', null, false, '', null, '', '', ''),
                 'col2' => new ColumnFull('col2', 'DATETIME', null, false, '', null, '', '', ''),
             ]);
-        $dbi->expects($this->any())
+        $dbi->expects(self::any())
             ->method('getColumnNames')
             ->willReturn(['id', 'col1', 'col2']);
         $map = [
@@ -87,13 +87,13 @@ class NormalizationTest extends AbstractTestCase
                 [['Key_name' => 'PRIMARY','Column_name' => 'id'], ['Key_name' => 'PRIMARY','Column_name' => 'col1']],
             ],
         ];
-        $dbi->expects($this->any())
+        $dbi->expects(self::any())
             ->method('getTableIndexes')
             ->willReturnMap($map);
-        $dbi->expects($this->any())
+        $dbi->expects(self::any())
             ->method('tryQuery')
-            ->willReturn($this->createStub(DummyResult::class));
-        $dbi->expects($this->any())
+            ->willReturn(self::createStub(DummyResult::class));
+        $dbi->expects(self::any())
             ->method('fetchResult')
             ->willReturn([0]);
 
@@ -107,11 +107,11 @@ class NormalizationTest extends AbstractTestCase
     {
         $db = 'PMA_db';
         $table = 'PMA_table';
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             '<option value="id">id [ integer ]</option>',
             $this->normalization->getHtmlForColumnsList($table, $db),
         );
-        $this->assertEquals(
+        self::assertEquals(
             '<input type="checkbox" value="col1">col1 [ varchar(100) ]<br>',
             $this->normalization->getHtmlForColumnsList($table, $db, 'String', 'checkbox'),
         );
@@ -138,7 +138,7 @@ class NormalizationTest extends AbstractTestCase
             new Template(),
         );
         $result = $normalization->getHtmlForCreateNewColumn($numFields, $db, $table);
-        $this->assertStringContainsString('<table id="table_columns"', $result);
+        self::assertStringContainsString('<table id="table_columns"', $result);
     }
 
     /**
@@ -150,17 +150,17 @@ class NormalizationTest extends AbstractTestCase
         $table = 'PMA_table';
         $normalizedTo = '1nf';
         $result = $this->normalization->getHtmlFor1NFStep1($db, $table, $normalizedTo);
-        $this->assertStringContainsString('<h3>' . __('First step of normalization (1NF)') . '</h3>', $result);
-        $this->assertStringContainsString('<div class="card" id="mainContent"', $result);
-        $this->assertStringContainsString('<div class="card-header">' . __('Step 1.'), $result);
+        self::assertStringContainsString('<h3>' . __('First step of normalization (1NF)') . '</h3>', $result);
+        self::assertStringContainsString('<div class="card" id="mainContent"', $result);
+        self::assertStringContainsString('<div class="card-header">' . __('Step 1.'), $result);
 
-        $this->assertStringContainsString('<h4', $result);
+        self::assertStringContainsString('<h4', $result);
 
-        $this->assertStringContainsString('<p', $result);
+        self::assertStringContainsString('<p', $result);
 
-        $this->assertStringContainsString("<select id='selectNonAtomicCol'", $result);
+        self::assertStringContainsString("<select id='selectNonAtomicCol'", $result);
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             $this->normalization->getHtmlForColumnsList(
                 $db,
                 $table,
@@ -178,17 +178,17 @@ class NormalizationTest extends AbstractTestCase
         $db = 'PMA_db';
         $table = 'PMA_table1';
         $result = $this->normalization->getHtmlContentsFor1NFStep2($db, $table);
-        $this->assertArrayHasKey('legendText', $result);
-        $this->assertArrayHasKey('headText', $result);
-        $this->assertArrayHasKey('subText', $result);
-        $this->assertArrayHasKey('hasPrimaryKey', $result);
-        $this->assertArrayHasKey('extra', $result);
-        $this->assertStringContainsString('<a href="#" id="createPrimaryKey">', $result['subText']);
-        $this->assertStringContainsString('<a href="#" id="addNewPrimary">', $result['extra']);
-        $this->assertEquals('0', $result['hasPrimaryKey']);
-        $this->assertStringContainsString(__('Step 1.') . 2, $result['legendText']);
+        self::assertArrayHasKey('legendText', $result);
+        self::assertArrayHasKey('headText', $result);
+        self::assertArrayHasKey('subText', $result);
+        self::assertArrayHasKey('hasPrimaryKey', $result);
+        self::assertArrayHasKey('extra', $result);
+        self::assertStringContainsString('<a href="#" id="createPrimaryKey">', $result['subText']);
+        self::assertStringContainsString('<a href="#" id="addNewPrimary">', $result['extra']);
+        self::assertEquals('0', $result['hasPrimaryKey']);
+        self::assertStringContainsString(__('Step 1.') . 2, $result['legendText']);
         $result1 = $this->normalization->getHtmlContentsFor1NFStep2($db, 'PMA_table');
-        $this->assertEquals('1', $result1['hasPrimaryKey']);
+        self::assertEquals('1', $result1['hasPrimaryKey']);
     }
 
     /**
@@ -199,16 +199,16 @@ class NormalizationTest extends AbstractTestCase
         $db = 'PMA_db';
         $table = 'PMA_table';
         $result = $this->normalization->getHtmlContentsFor1NFStep4($db, $table);
-        $this->assertArrayHasKey('legendText', $result);
-        $this->assertArrayHasKey('headText', $result);
-        $this->assertArrayHasKey('subText', $result);
-        $this->assertArrayHasKey('extra', $result);
-        $this->assertStringContainsString(__('Step 1.') . 4, $result['legendText']);
-        $this->assertStringContainsString(
+        self::assertArrayHasKey('legendText', $result);
+        self::assertArrayHasKey('headText', $result);
+        self::assertArrayHasKey('subText', $result);
+        self::assertArrayHasKey('extra', $result);
+        self::assertStringContainsString(__('Step 1.') . 4, $result['legendText']);
+        self::assertStringContainsString(
             $this->normalization->getHtmlForColumnsList($db, $table, 'all', 'checkbox'),
             $result['extra'],
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             '<input class="btn btn-secondary" type="submit" id="removeRedundant"',
             $result['extra'],
         );
@@ -222,21 +222,21 @@ class NormalizationTest extends AbstractTestCase
         $db = 'PMA_db';
         $table = 'PMA_table';
         $result = $this->normalization->getHtmlContentsFor1NFStep3($db, $table);
-        $this->assertArrayHasKey('legendText', $result);
-        $this->assertArrayHasKey('headText', $result);
-        $this->assertArrayHasKey('subText', $result);
-        $this->assertArrayHasKey('extra', $result);
-        $this->assertArrayHasKey('primary_key', $result);
-        $this->assertStringContainsString(__('Step 1.') . 3, $result['legendText']);
-        $this->assertStringContainsString(
+        self::assertArrayHasKey('legendText', $result);
+        self::assertArrayHasKey('headText', $result);
+        self::assertArrayHasKey('subText', $result);
+        self::assertArrayHasKey('extra', $result);
+        self::assertArrayHasKey('primary_key', $result);
+        self::assertStringContainsString(__('Step 1.') . 3, $result['legendText']);
+        self::assertStringContainsString(
             $this->normalization->getHtmlForColumnsList($db, $table, 'all', 'checkbox'),
             $result['extra'],
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             '<input class="btn btn-secondary" type="submit" id="moveRepeatingGroup"',
             $result['extra'],
         );
-        $this->assertEquals(json_encode(['id']), $result['primary_key']);
+        self::assertEquals(json_encode(['id']), $result['primary_key']);
     }
 
     /**
@@ -247,17 +247,17 @@ class NormalizationTest extends AbstractTestCase
         $db = 'PMA_db';
         $table = 'PMA_table';
         $result = $this->normalization->getHtmlFor2NFstep1($db, $table);
-        $this->assertArrayHasKey('legendText', $result);
-        $this->assertArrayHasKey('headText', $result);
-        $this->assertArrayHasKey('subText', $result);
-        $this->assertArrayHasKey('extra', $result);
-        $this->assertArrayHasKey('primary_key', $result);
-        $this->assertStringContainsString(__('Step 2.') . 1, $result['legendText']);
-        $this->assertEquals('id', $result['primary_key']);
+        self::assertArrayHasKey('legendText', $result);
+        self::assertArrayHasKey('headText', $result);
+        self::assertArrayHasKey('subText', $result);
+        self::assertArrayHasKey('extra', $result);
+        self::assertArrayHasKey('primary_key', $result);
+        self::assertStringContainsString(__('Step 2.') . 1, $result['legendText']);
+        self::assertEquals('id', $result['primary_key']);
         $result1 = $this->normalization->getHtmlFor2NFstep1($db, 'PMA_table2');
-        $this->assertEquals('id, col1', $result1['primary_key']);
-        $this->assertStringContainsString('<a href="#" id="showPossiblePd"', $result1['headText']);
-        $this->assertStringContainsString('<input type="checkbox" name="pd" value="id"', $result1['extra']);
+        self::assertEquals('id, col1', $result1['primary_key']);
+        self::assertStringContainsString('<a href="#" id="showPossiblePd"', $result1['headText']);
+        self::assertStringContainsString('<input type="checkbox" name="pd" value="id"', $result1['extra']);
     }
 
     /**
@@ -268,7 +268,7 @@ class NormalizationTest extends AbstractTestCase
         $table = 'PMA_table';
         $partialDependencies = ['col1' => ['col2']];
         $result = $this->normalization->getHtmlForNewTables2NF($partialDependencies, $table);
-        $this->assertStringContainsString('<input type="text" name="col1"', $result);
+        self::assertStringContainsString('<input type="text" name="col1"', $result);
     }
 
     /**
@@ -283,14 +283,14 @@ class NormalizationTest extends AbstractTestCase
         $tablesName->col1 = 'PMA_table1';
         $partialDependencies = ['id' => ['col2']];
         $result = $this->normalization->createNewTablesFor2NF($partialDependencies, $tablesName, $table, $db);
-        $this->assertArrayHasKey('legendText', $result);
-        $this->assertArrayHasKey('headText', $result);
-        $this->assertArrayHasKey('queryError', $result);
+        self::assertArrayHasKey('legendText', $result);
+        self::assertArrayHasKey('headText', $result);
+        self::assertArrayHasKey('queryError', $result);
         $partialDependencies = ['id' => ['col2'], 'col1' => ['col2']];
         $result1 = $this->normalization->createNewTablesFor2NF($partialDependencies, $tablesName, $table, $db);
-        $this->assertArrayHasKey('extra', $result1);
-        $this->assertEquals(__('End of step'), $result1['legendText']);
-        $this->assertEquals('', $result1['extra']);
+        self::assertArrayHasKey('extra', $result1);
+        self::assertEquals(__('End of step'), $result1['legendText']);
+        self::assertEquals('', $result1['extra']);
     }
 
     /**
@@ -303,7 +303,7 @@ class NormalizationTest extends AbstractTestCase
         $dependencies = new stdClass();
         $dependencies->col1 = ['col2'];
         $result = $this->normalization->getHtmlForNewTables3NF($dependencies, $tables, $db);
-        $this->assertEquals(
+        self::assertEquals(
             ['html' => '', 'success' => true, 'newTables' => []],
             $result,
         );
@@ -311,8 +311,8 @@ class NormalizationTest extends AbstractTestCase
         // phpcs:ignore Squiz.NamingConventions.ValidVariableName.MemberNotCamelCaps
         $dependencies->PMA_table = ['col4', 'col5'];
         $result1 = $this->normalization->getHtmlForNewTables3NF($dependencies, $tables, $db);
-        $this->assertStringContainsString('<input type="text" name="PMA_table"', $result1['html']);
-        $this->assertEquals(
+        self::assertStringContainsString('<input type="text" name="PMA_table"', $result1['html']);
+        self::assertEquals(
             [
                 'PMA_table' => [
                     'PMA_table' => ['pk' => 'col1', 'nonpk' => 'col2'],
@@ -336,14 +336,14 @@ class NormalizationTest extends AbstractTestCase
             ],
         ];
         $result = $this->normalization->createNewTablesFor3NF($newTables, $db);
-        $this->assertArrayHasKey('legendText', $result);
-        $this->assertArrayHasKey('headText', $result);
-        $this->assertArrayHasKey('queryError', $result);
+        self::assertArrayHasKey('legendText', $result);
+        self::assertArrayHasKey('headText', $result);
+        self::assertArrayHasKey('queryError', $result);
         $newTables1 = [];
         $result1 = $this->normalization->createNewTablesFor3NF($newTables1, $db);
-        $this->assertArrayHasKey('queryError', $result1);
-        $this->assertEquals(__('End of step'), $result1['legendText']);
-        $this->assertFalse($result1['queryError']);
+        self::assertArrayHasKey('queryError', $result1);
+        self::assertEquals(__('End of step'), $result1['legendText']);
+        self::assertFalse($result1['queryError']);
     }
 
     /**
@@ -365,9 +365,9 @@ class NormalizationTest extends AbstractTestCase
             $table,
             $db,
         );
-        $this->assertArrayHasKey('queryError', $result);
-        $this->assertArrayHasKey('message', $result);
-        $this->assertInstanceOf(Message::class, $result['message']);
+        self::assertArrayHasKey('queryError', $result);
+        self::assertArrayHasKey('message', $result);
+        self::assertInstanceOf(Message::class, $result['message']);
     }
 
     /**
@@ -378,15 +378,15 @@ class NormalizationTest extends AbstractTestCase
         $db = 'PMA_db';
         $tables = ['PMA_table'];
         $result = $this->normalization->getHtmlFor3NFstep1($db, $tables);
-        $this->assertArrayHasKey('legendText', $result);
-        $this->assertArrayHasKey('headText', $result);
-        $this->assertArrayHasKey('subText', $result);
-        $this->assertArrayHasKey('extra', $result);
-        $this->assertStringContainsString(__('Step 3.') . 1, $result['legendText']);
-        $this->assertStringContainsString('<form', $result['extra']);
-        $this->assertStringContainsString('<input type="checkbox" name="pd" value="col1"', $result['extra']);
+        self::assertArrayHasKey('legendText', $result);
+        self::assertArrayHasKey('headText', $result);
+        self::assertArrayHasKey('subText', $result);
+        self::assertArrayHasKey('extra', $result);
+        self::assertStringContainsString(__('Step 3.') . 1, $result['legendText']);
+        self::assertStringContainsString('<form', $result['extra']);
+        self::assertStringContainsString('<input type="checkbox" name="pd" value="col1"', $result['extra']);
         $result1 = $this->normalization->getHtmlFor3NFstep1($db, ['PMA_table2']);
-        $this->assertEquals('', $result1['subText']);
+        self::assertEquals('', $result1['subText']);
     }
 
     /**
@@ -397,8 +397,8 @@ class NormalizationTest extends AbstractTestCase
         $table = 'PMA_table2';
         $db = 'PMA_db';
         $result = $this->normalization->findPartialDependencies($table, $db);
-        $this->assertStringContainsString('<div class="dependencies_box"', $result);
-        $this->assertStringContainsString(__('No partial dependencies found!'), $result);
+        self::assertStringContainsString('<div class="dependencies_box"', $result);
+        self::assertStringContainsString(__('No partial dependencies found!'), $result);
     }
 
     /**
@@ -414,7 +414,7 @@ class NormalizationTest extends AbstractTestCase
             [$primaryKey],
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             ['', 'id', 'col1', 'col1,id', 'col2', 'col2,id', 'col2,col1'],
             $result,
         );
diff --git a/tests/classes/OpenDocumentTest.php b/tests/classes/OpenDocumentTest.php
index 8ad92b7c17..2c3952ecd4 100644
--- a/tests/classes/OpenDocumentTest.php
+++ b/tests/classes/OpenDocumentTest.php
@@ -22,30 +22,30 @@ class OpenDocumentTest extends AbstractTestCase
     public function testCreateDocument(): void
     {
         $document = OpenDocument::create('application/vnd.oasis.opendocument.text', '<data>');
-        $this->assertNotFalse($document);
+        self::assertNotFalse($document);
 
         $tmpFile = tempnam('./', 'open-document-test');
-        $this->assertNotFalse($tmpFile);
-        $this->assertNotFalse(file_put_contents($tmpFile, $document), 'The temp file should be written');
+        self::assertNotFalse($tmpFile);
+        self::assertNotFalse(file_put_contents($tmpFile, $document), 'The temp file should be written');
 
         $zipExtension = new ZipExtension(new ZipArchive());
-        $this->assertSame([
+        self::assertSame([
             'error' => '',
             'data' => 'application/vnd.oasis.opendocument.text',
         ], $zipExtension->getContents($tmpFile));
 
-        $this->assertSame(['error' => '', 'data' => '<data>'], $zipExtension->getContents($tmpFile, '/content\.xml/'));
+        self::assertSame(['error' => '', 'data' => '<data>'], $zipExtension->getContents($tmpFile, '/content\.xml/'));
 
         $dateTimeCreation = (new DateTime())->format('Y-m-d\TH:i');
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             // Do not use a full version or seconds could be out of sync and cause flaky test failures
             '<meta:creation-date>' . $dateTimeCreation,
             $zipExtension->getContents($tmpFile, '/meta\.xml/')['data'],
         );
 
-        $this->assertSame(5, $zipExtension->getNumberOfFiles($tmpFile));
+        self::assertSame(5, $zipExtension->getNumberOfFiles($tmpFile));
         // Unset to close any file that were left open.
         unset($zipExtension);
-        $this->assertTrue(unlink($tmpFile));
+        self::assertTrue(unlink($tmpFile));
     }
 }
diff --git a/tests/classes/OperationsTest.php b/tests/classes/OperationsTest.php
index adfdcd5224..8b4978620d 100644
--- a/tests/classes/OperationsTest.php
+++ b/tests/classes/OperationsTest.php
@@ -52,7 +52,7 @@ class OperationsTest extends AbstractTestCase
         $expected = array_merge($choices, $extraChoice);
 
         $actual = $this->object->getPartitionMaintenanceChoices();
-        $this->assertEquals($expected, $actual);
+        self::assertEquals($expected, $actual);
     }
 
     /** @psalm-return array<string, array{0: string, 1: array<string, string>}> */
diff --git a/tests/classes/ParseAnalyzeTest.php b/tests/classes/ParseAnalyzeTest.php
index 898be9b183..89770c337a 100644
--- a/tests/classes/ParseAnalyzeTest.php
+++ b/tests/classes/ParseAnalyzeTest.php
@@ -30,16 +30,16 @@ class ParseAnalyzeTest extends AbstractTestCase
         $actual = ParseAnalyze::sqlQuery('SELECT * FROM `sakila`.`actor`', 'sakila_test');
 
         /** @psalm-suppress TypeDoesNotContainType */
-        $this->assertSame('SELECT * FROM `sakila`.`actor`', $GLOBALS['unparsed_sql']);
-        $this->assertCount(3, $actual);
-        $this->assertInstanceOf(StatementInfo::class, $actual[0]);
-        $this->assertSame('sakila', $actual[1]);
-        $this->assertSame('actor', $actual[2]);
-        $this->assertTrue($actual[0]->reload);
-        $this->assertNotEmpty($actual[0]->selectTables);
-        $this->assertSame([['actor', 'sakila']], $actual[0]->selectTables);
-        $this->assertNotEmpty($actual[0]->selectExpression);
-        $this->assertSame(['*'], $actual[0]->selectExpression);
+        self::assertSame('SELECT * FROM `sakila`.`actor`', $GLOBALS['unparsed_sql']);
+        self::assertCount(3, $actual);
+        self::assertInstanceOf(StatementInfo::class, $actual[0]);
+        self::assertSame('sakila', $actual[1]);
+        self::assertSame('actor', $actual[2]);
+        self::assertTrue($actual[0]->reload);
+        self::assertNotEmpty($actual[0]->selectTables);
+        self::assertSame([['actor', 'sakila']], $actual[0]->selectTables);
+        self::assertNotEmpty($actual[0]->selectExpression);
+        self::assertSame(['*'], $actual[0]->selectExpression);
     }
 
     public function testSqlQuery2(): void
@@ -52,15 +52,15 @@ class ParseAnalyzeTest extends AbstractTestCase
         $actual = ParseAnalyze::sqlQuery('SELECT `first_name`, `title` FROM `actor`, `film`', 'sakila');
 
         /** @psalm-suppress TypeDoesNotContainType */
-        $this->assertSame('SELECT `first_name`, `title` FROM `actor`, `film`', $GLOBALS['unparsed_sql']);
-        $this->assertCount(3, $actual);
-        $this->assertInstanceOf(StatementInfo::class, $actual[0]);
-        $this->assertSame('sakila', $actual[1]);
-        $this->assertSame('', $actual[2]);
-        $this->assertFalse($actual[0]->reload);
-        $this->assertNotEmpty($actual[0]->selectTables);
-        $this->assertSame([['actor', null], ['film', null]], $actual[0]->selectTables);
-        $this->assertNotEmpty($actual[0]->selectExpression);
-        $this->assertSame(['`first_name`', '`title`'], $actual[0]->selectExpression);
+        self::assertSame('SELECT `first_name`, `title` FROM `actor`, `film`', $GLOBALS['unparsed_sql']);
+        self::assertCount(3, $actual);
+        self::assertInstanceOf(StatementInfo::class, $actual[0]);
+        self::assertSame('sakila', $actual[1]);
+        self::assertSame('', $actual[2]);
+        self::assertFalse($actual[0]->reload);
+        self::assertNotEmpty($actual[0]->selectTables);
+        self::assertSame([['actor', null], ['film', null]], $actual[0]->selectTables);
+        self::assertNotEmpty($actual[0]->selectExpression);
+        self::assertSame(['`first_name`', '`title`'], $actual[0]->selectExpression);
     }
 }
diff --git a/tests/classes/Partitioning/PartitionTest.php b/tests/classes/Partitioning/PartitionTest.php
index ad835fa6c1..3c8364a525 100644
--- a/tests/classes/Partitioning/PartitionTest.php
+++ b/tests/classes/Partitioning/PartitionTest.php
@@ -25,13 +25,13 @@ class PartitionTest extends AbstractTestCase
     public function testGetPartitionMethodReturnsNull(): void
     {
         $actual = Partition::getPartitionMethod('database', 'no_partition_method');
-        $this->assertNull($actual);
+        self::assertNull($actual);
     }
 
     public function testGetPartitionMethodWithRangeMethod(): void
     {
         $actual = Partition::getPartitionMethod('database', 'range_partition_method');
-        $this->assertEquals('RANGE', $actual);
+        self::assertEquals('RANGE', $actual);
     }
 
     /** @param array<int, array<string, string>> $pluginValue */
@@ -40,12 +40,12 @@ class PartitionTest extends AbstractTestCase
     #[RunInSeparateProcess]
     public function testHavePartitioning(bool $expected, int $version, string|false $varValue, array $pluginValue): void
     {
-        $mock = $this->createStub(DatabaseInterface::class);
+        $mock = self::createStub(DatabaseInterface::class);
         $mock->method('getVersion')->willReturn($version);
         $mock->method('fetchValue')->willReturn($varValue);
         $mock->method('fetchResult')->willReturn($pluginValue);
         DatabaseInterface::$instance = $mock;
-        $this->assertSame($expected, Partition::havePartitioning());
+        self::assertSame($expected, Partition::havePartitioning());
     }
 
     /**
diff --git a/tests/classes/Partitioning/SubPartitionTest.php b/tests/classes/Partitioning/SubPartitionTest.php
index dac3c9ad5e..26697bab77 100644
--- a/tests/classes/Partitioning/SubPartitionTest.php
+++ b/tests/classes/Partitioning/SubPartitionTest.php
@@ -26,13 +26,13 @@ class SubPartitionTest extends TestCase
             'PARTITION_COMMENT' => 'partition_comment',
         ];
         $object = new SubPartition($row);
-        $this->assertEquals('subpartition_name', $object->getName());
-        $this->assertEquals(1, $object->getOrdinal());
-        $this->assertEquals('subpartition_method', $object->getMethod());
-        $this->assertEquals('subpartition_expression', $object->getExpression());
-        $this->assertEquals(2, $object->getRows());
-        $this->assertEquals(3, $object->getDataLength());
-        $this->assertEquals(4, $object->getIndexLength());
-        $this->assertEquals('partition_comment', $object->getComment());
+        self::assertEquals('subpartition_name', $object->getName());
+        self::assertEquals(1, $object->getOrdinal());
+        self::assertEquals('subpartition_method', $object->getMethod());
+        self::assertEquals('subpartition_expression', $object->getExpression());
+        self::assertEquals(2, $object->getRows());
+        self::assertEquals(3, $object->getDataLength());
+        self::assertEquals(4, $object->getIndexLength());
+        self::assertEquals('partition_comment', $object->getComment());
     }
 }
diff --git a/tests/classes/Partitioning/TablePartitionDefinitionTest.php b/tests/classes/Partitioning/TablePartitionDefinitionTest.php
index 24d06942ba..8094a9476f 100644
--- a/tests/classes/Partitioning/TablePartitionDefinitionTest.php
+++ b/tests/classes/Partitioning/TablePartitionDefinitionTest.php
@@ -139,7 +139,7 @@ class TablePartitionDefinitionTest extends TestCase
         $_POST['ignored_key'] = 'ignored_value';
 
         $actual = TablePartitionDefinition::getDetails();
-        $this->assertEquals($expected, $actual);
+        self::assertEquals($expected, $actual);
     }
 
     /**
@@ -233,7 +233,7 @@ class TablePartitionDefinitionTest extends TestCase
         ];
 
         $actual = TablePartitionDefinition::getDetails();
-        $this->assertEquals($expected, $actual);
+        self::assertEquals($expected, $actual);
     }
 
     #[DataProvider('providerGetDetailsWithMaxPartitions')]
@@ -241,11 +241,11 @@ class TablePartitionDefinitionTest extends TestCase
     {
         $_POST = ['partition_count' => $partitionCountFromPost];
         $actual = TablePartitionDefinition::getDetails();
-        $this->assertArrayHasKey('partition_count', $actual);
-        $this->assertArrayHasKey('partitions', $actual);
-        $this->assertSame($partitionCount, $actual['partition_count']);
-        $this->assertIsArray($actual['partitions']);
-        $this->assertEquals($partitionCount, count($actual['partitions']));
+        self::assertArrayHasKey('partition_count', $actual);
+        self::assertArrayHasKey('partitions', $actual);
+        self::assertSame($partitionCount, $actual['partition_count']);
+        self::assertIsArray($actual['partitions']);
+        self::assertEquals($partitionCount, count($actual['partitions']));
     }
 
     /** @psalm-return array{0: int, 1: string}[] */
diff --git a/tests/classes/PdfTest.php b/tests/classes/PdfTest.php
index 1f2494caf4..2234d0fe48 100644
--- a/tests/classes/PdfTest.php
+++ b/tests/classes/PdfTest.php
@@ -28,7 +28,7 @@ class PdfTest extends AbstractTestCase
     public function testBasic(): void
     {
         $arr = new Pdf();
-        $this->assertStringContainsString('PDF', $arr->getPDFData());
+        self::assertStringContainsString('PDF', $arr->getPDFData());
     }
 
     /**
@@ -39,7 +39,7 @@ class PdfTest extends AbstractTestCase
     {
         $arr = new Pdf();
         $arr->setAlias('{00}', '32');
-        $this->assertStringContainsString('PDF', $arr->getPDFData());
+        self::assertStringContainsString('PDF', $arr->getPDFData());
     }
 
     /**
@@ -61,6 +61,6 @@ class PdfTest extends AbstractTestCase
         $pdf->setMargins(0, 0);
         $pdf->setDrawColor(200, 200, 200);
         $pdf->Line(0, 0, 100, 100);
-        $this->assertStringContainsString('PDF', $pdf->getPDFData());
+        self::assertStringContainsString('PDF', $pdf->getPDFData());
     }
 }
diff --git a/tests/classes/Plugins/Auth/AuthenticationConfigTest.php b/tests/classes/Plugins/Auth/AuthenticationConfigTest.php
index 78bada3fd6..b02c1df6f7 100644
--- a/tests/classes/Plugins/Auth/AuthenticationConfigTest.php
+++ b/tests/classes/Plugins/Auth/AuthenticationConfigTest.php
@@ -70,14 +70,14 @@ class AuthenticationConfigTest extends AbstractTestCase
     public function testAuthCheck(): void
     {
         Config::getInstance()->selectedServer = ['user' => 'username', 'password' => 'password'];
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->readCredentials(),
         );
     }
 
     public function testAuthSetUser(): void
     {
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->storeCredentials(),
         );
     }
@@ -104,17 +104,17 @@ class AuthenticationConfigTest extends AbstractTestCase
 
         $html = ob_get_clean();
 
-        $this->assertInstanceOf(ExitException::class, $throwable);
+        self::assertInstanceOf(ExitException::class, $throwable);
 
-        $this->assertIsString($html);
+        self::assertIsString($html);
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             'You probably did not create a configuration file. You might want ' .
             'to use the <a href="setup/">setup script</a> to create one.',
             $html,
         );
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             '<strong>MySQL said: </strong><a href="index.php?route=/url&url=https%3A%2F%2F' .
             'dev.mysql.com%2Fdoc%2Frefman%2F5.5%2Fen%2Fserver-error-reference.html"' .
             ' target="mysql_doc">' .
@@ -123,9 +123,9 @@ class AuthenticationConfigTest extends AbstractTestCase
             $html,
         );
 
-        $this->assertStringContainsString('Cannot connect: invalid settings.', $html);
+        self::assertStringContainsString('Cannot connect: invalid settings.', $html);
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             '<a href="index.php?route=/&server=2&lang=en" '
             . 'class="btn btn-primary mt-1 mb-1 disableAjax">Retry to connect</a>',
             $html,
diff --git a/tests/classes/Plugins/Auth/AuthenticationCookieTest.php b/tests/classes/Plugins/Auth/AuthenticationCookieTest.php
index 2d571d0377..540b9fa4fe 100644
--- a/tests/classes/Plugins/Auth/AuthenticationCookieTest.php
+++ b/tests/classes/Plugins/Auth/AuthenticationCookieTest.php
@@ -91,11 +91,11 @@ class AuthenticationCookieTest extends AbstractTestCase
         } catch (Throwable $throwable) {
         }
 
-        $this->assertInstanceOf(ExitException::class, $throwable);
+        self::assertInstanceOf(ExitException::class, $throwable);
         $response = $responseStub->getResponse();
-        $this->assertSame(200, $response->getStatusCode());
-        $this->assertFalse($responseStub->hasSuccessState());
-        $this->assertSame(['redirect_flag' => '1'], $responseStub->getJSONResult());
+        self::assertSame(200, $response->getStatusCode());
+        self::assertFalse($responseStub->hasSuccessState());
+        self::assertSame(['redirect_flag' => '1'], $responseStub->getJSONResult());
     }
 
     private function getAuthErrorMockResponse(): void
@@ -107,7 +107,7 @@ class AuthenticationCookieTest extends AbstractTestCase
             ->onlyMethods(['hasDisplayErrors'])
             ->getMock();
 
-        $mockErrorHandler->expects($this->once())
+        $mockErrorHandler->expects(self::once())
             ->method('hasDisplayErrors')
             ->with()
             ->willReturn(true);
@@ -151,45 +151,45 @@ class AuthenticationCookieTest extends AbstractTestCase
 
         $result = $responseStub->getHTMLResult();
 
-        $this->assertInstanceOf(ExitException::class, $throwable);
+        self::assertInstanceOf(ExitException::class, $throwable);
 
-        $this->assertStringContainsString(' id="imLogo"', $result);
+        self::assertStringContainsString(' id="imLogo"', $result);
 
-        $this->assertStringContainsString('<div class="alert alert-danger" role="alert">', $result);
+        self::assertStringContainsString('<div class="alert alert-danger" role="alert">', $result);
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             '<form method="post" id="login_form" action="index.php?route=/" name="login_form" ' .
             'class="disableAjax hide js-show">',
             $result,
         );
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             '<input type="text" name="pma_servername" id="serverNameInput" value="localhost"',
             $result,
         );
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             '<input type="text" name="pma_username" id="input_username" ' .
             'value="pmauser" class="form-control" autocomplete="username" spellcheck="false" autofocus>',
             $result,
         );
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             '<input type="password" name="pma_password" id="input_password" ' .
             'value="" class="form-control" autocomplete="current-password" spellcheck="false">',
             $result,
         );
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             '<select name="server" id="select_server" class="form-select" ' .
             'onchange="document.forms[\'login_form\'].' .
             'elements[\'pma_servername\'].value = \'\'">',
             $result,
         );
 
-        $this->assertStringContainsString('<input type="hidden" name="db" value="testDb">', $result);
+        self::assertStringContainsString('<input type="hidden" name="db" value="testDb">', $result);
 
-        $this->assertStringContainsString('<input type="hidden" name="table" value="testTable">', $result);
+        self::assertStringContainsString('<input type="hidden" name="table" value="testTable">', $result);
     }
 
     #[RunInSeparateProcess]
@@ -221,34 +221,34 @@ class AuthenticationCookieTest extends AbstractTestCase
 
         $result = $responseStub->getHTMLResult();
 
-        $this->assertInstanceOf(ExitException::class, $throwable);
+        self::assertInstanceOf(ExitException::class, $throwable);
 
-        $this->assertStringContainsString('id="imLogo"', $result);
+        self::assertStringContainsString('id="imLogo"', $result);
 
         // Check for language selection if locales are there
         $loc = LOCALE_PATH . '/cs/LC_MESSAGES/phpmyadmin.mo';
         if (is_readable($loc)) {
-            $this->assertStringContainsString(
+            self::assertStringContainsString(
                 '<select name="lang" class="form-select autosubmit" lang="en" dir="ltr"'
                 . ' id="languageSelect" aria-labelledby="languageSelectLabel">',
                 $result,
             );
         }
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             '<form method="post" id="login_form" action="index.php?route=/" name="login_form"' .
             ' class="disableAjax hide js-show" autocomplete="off">',
             $result,
         );
 
-        $this->assertStringContainsString('<input type="hidden" name="server" value="2">', $result);
+        self::assertStringContainsString('<input type="hidden" name="server" value="2">', $result);
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             '<script src="https://www.google.com/recaptcha/api.js?hl=en" async defer></script>',
             $result,
         );
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             '<input class="btn btn-primary g-recaptcha" data-sitekey="testpubkey"'
             . ' data-callback="recaptchaCallback" value="Log in" type="submit" id="input_go">',
             $result,
@@ -285,36 +285,36 @@ class AuthenticationCookieTest extends AbstractTestCase
 
         $result = $responseStub->getHTMLResult();
 
-        $this->assertInstanceOf(ExitException::class, $throwable);
+        self::assertInstanceOf(ExitException::class, $throwable);
 
-        $this->assertStringContainsString('id="imLogo"', $result);
+        self::assertStringContainsString('id="imLogo"', $result);
 
         // Check for language selection if locales are there
         $loc = LOCALE_PATH . '/cs/LC_MESSAGES/phpmyadmin.mo';
         if (is_readable($loc)) {
-            $this->assertStringContainsString(
+            self::assertStringContainsString(
                 '<select name="lang" class="form-select autosubmit" lang="en" dir="ltr"'
                 . ' id="languageSelect" aria-labelledby="languageSelectLabel">',
                 $result,
             );
         }
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             '<form method="post" id="login_form" action="index.php?route=/" name="login_form"' .
             ' class="disableAjax hide js-show" autocomplete="off">',
             $result,
         );
 
-        $this->assertStringContainsString('<input type="hidden" name="server" value="2">', $result);
+        self::assertStringContainsString('<input type="hidden" name="server" value="2">', $result);
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             '<script src="https://www.google.com/recaptcha/api.js?hl=en" async defer></script>',
             $result,
         );
 
-        $this->assertStringContainsString('<div class="g-recaptcha" data-sitekey="testpubkey"></div>', $result);
+        self::assertStringContainsString('<div class="g-recaptcha" data-sitekey="testpubkey"></div>', $result);
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             '<input class="btn btn-primary" value="Log in" type="submit" id="input_go">',
             $result,
         );
@@ -337,8 +337,8 @@ class AuthenticationCookieTest extends AbstractTestCase
         $this->object->logOut();
 
         $response = $responseStub->getResponse();
-        $this->assertSame(['https://example.com/logout'], $response->getHeader('Location'));
-        $this->assertSame(302, $response->getStatusCode());
+        self::assertSame(['https://example.com/logout'], $response->getHeader('Location'));
+        self::assertSame(302, $response->getStatusCode());
     }
 
     #[RunInSeparateProcess]
@@ -360,8 +360,8 @@ class AuthenticationCookieTest extends AbstractTestCase
         $this->object->logOut();
 
         $response = $responseStub->getResponse();
-        $this->assertSame(['/phpmyadmin/index.php?route=/&server=2&lang=en'], $response->getHeader('Location'));
-        $this->assertSame(302, $response->getStatusCode());
+        self::assertSame(['/phpmyadmin/index.php?route=/&server=2&lang=en'], $response->getHeader('Location'));
+        self::assertSame(302, $response->getStatusCode());
     }
 
     public function testAuthCheckCaptcha(): void
@@ -375,11 +375,11 @@ class AuthenticationCookieTest extends AbstractTestCase
         $_POST['g-recaptcha-response'] = '';
         $_POST['pma_username'] = 'testPMAUser';
 
-        $this->assertFalse(
+        self::assertFalse(
             $this->object->readCredentials(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'Missing Captcha verification, maybe it has been blocked by adblock?',
             $GLOBALS['conn_error'],
         );
@@ -408,10 +408,10 @@ class AuthenticationCookieTest extends AbstractTestCase
         $this->object->logOut();
 
         $response = $responseStub->getResponse();
-        $this->assertSame(['/phpmyadmin/index.php?route=/'], $response->getHeader('Location'));
-        $this->assertSame(302, $response->getStatusCode());
+        self::assertSame(['/phpmyadmin/index.php?route=/'], $response->getHeader('Location'));
+        self::assertSame(302, $response->getStatusCode());
 
-        $this->assertArrayNotHasKey('pmaAuth-0', $_COOKIE);
+        self::assertArrayNotHasKey('pmaAuth-0', $_COOKIE);
     }
 
     #[RunInSeparateProcess]
@@ -438,10 +438,10 @@ class AuthenticationCookieTest extends AbstractTestCase
         $this->object->logOut();
 
         $response = $responseStub->getResponse();
-        $this->assertSame(['/phpmyadmin/index.php?route=/'], $response->getHeader('Location'));
-        $this->assertSame(302, $response->getStatusCode());
+        self::assertSame(['/phpmyadmin/index.php?route=/'], $response->getHeader('Location'));
+        self::assertSame(302, $response->getStatusCode());
 
-        $this->assertArrayNotHasKey('pmaAuth-1', $_COOKIE);
+        self::assertArrayNotHasKey('pmaAuth-1', $_COOKIE);
     }
 
     public function testAuthCheckArbitrary(): void
@@ -458,17 +458,17 @@ class AuthenticationCookieTest extends AbstractTestCase
         $_POST['pma_password'] = 'testPMAPSWD';
         $config->settings['AllowArbitraryServer'] = true;
 
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->readCredentials(),
         );
 
-        $this->assertEquals('testPMAUser', $this->object->user);
+        self::assertEquals('testPMAUser', $this->object->user);
 
-        $this->assertEquals('testPMAPSWD', $this->object->password);
+        self::assertEquals('testPMAPSWD', $this->object->password);
 
-        $this->assertEquals('testPMAServer', $GLOBALS['pma_auth_server']);
+        self::assertEquals('testPMAServer', $GLOBALS['pma_auth_server']);
 
-        $this->assertArrayNotHasKey('pmaAuth-1', $_COOKIE);
+        self::assertArrayNotHasKey('pmaAuth-1', $_COOKIE);
     }
 
     public function testAuthCheckInvalidCookie(): void
@@ -480,7 +480,7 @@ class AuthenticationCookieTest extends AbstractTestCase
         $_COOKIE['pmaUser-1'] = '';
         $_COOKIE['pma_iv-1'] = base64_encode('testiv09testiv09');
 
-        $this->assertFalse(
+        self::assertFalse(
             $this->object->readCredentials(),
         );
     }
@@ -496,7 +496,7 @@ class AuthenticationCookieTest extends AbstractTestCase
         $_SESSION['last_access_time'] = time() - 1000;
         $config->settings['LoginCookieValidity'] = 1440;
 
-        $this->assertFalse(
+        self::assertFalse(
             $this->object->readCredentials(),
         );
     }
@@ -524,15 +524,15 @@ class AuthenticationCookieTest extends AbstractTestCase
             ->onlyMethods(['cookieDecrypt'])
             ->getMock();
 
-        $this->object->expects($this->once())
+        $this->object->expects(self::once())
             ->method('cookieDecrypt')
             ->willReturn('testBF');
 
-        $this->assertFalse(
+        self::assertFalse(
             $this->object->readCredentials(),
         );
 
-        $this->assertEquals('testBF', $this->object->user);
+        self::assertEquals('testBF', $this->object->user);
     }
 
     public function testAuthCheckDecryptPassword(): void
@@ -560,17 +560,17 @@ class AuthenticationCookieTest extends AbstractTestCase
             ->onlyMethods(['cookieDecrypt'])
             ->getMock();
 
-        $this->object->expects($this->exactly(2))
+        $this->object->expects(self::exactly(2))
             ->method('cookieDecrypt')
             ->willReturn('{"password":""}');
 
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->readCredentials(),
         );
 
-        $this->assertTrue($GLOBALS['from_cookie']);
+        self::assertTrue($GLOBALS['from_cookie']);
 
-        $this->assertEquals('', $this->object->password);
+        self::assertEquals('', $this->object->password);
     }
 
     public function testAuthCheckAuthFails(): void
@@ -598,11 +598,11 @@ class AuthenticationCookieTest extends AbstractTestCase
             ->onlyMethods(['showFailure', 'cookieDecrypt'])
             ->getMock();
 
-        $this->object->expects($this->once())
+        $this->object->expects(self::once())
             ->method('cookieDecrypt')
             ->willReturn('testBF');
 
-        $this->object->expects($this->once())
+        $this->object->expects(self::once())
             ->method('showFailure')
             ->willThrowException(new ExitException());
 
@@ -631,14 +631,14 @@ class AuthenticationCookieTest extends AbstractTestCase
 
         $this->object->rememberCredentials();
 
-        $this->assertArrayHasKey('pmaUser-2', $_COOKIE);
+        self::assertArrayHasKey('pmaUser-2', $_COOKIE);
 
-        $this->assertArrayHasKey('pmaAuth-2', $_COOKIE);
+        self::assertArrayHasKey('pmaAuth-2', $_COOKIE);
 
         $arr['password'] = 'testPW';
         $arr['host'] = 'b';
         $arr['port'] = '2';
-        $this->assertEquals($arr, $config->selectedServer);
+        self::assertEquals($arr, $config->selectedServer);
     }
 
     public function testAuthSetUserWithHeaders(): void
@@ -674,7 +674,7 @@ class AuthenticationCookieTest extends AbstractTestCase
             ->onlyMethods(['showLoginForm'])
             ->getMock();
 
-        $this->object->expects($this->exactly(1))
+        $this->object->expects(self::exactly(1))
             ->method('showLoginForm')
             ->willThrowException(new ExitException());
 
@@ -688,13 +688,13 @@ class AuthenticationCookieTest extends AbstractTestCase
         } catch (Throwable $throwable) {
         }
 
-        $this->assertInstanceOf(ExitException::class, $throwable);
+        self::assertInstanceOf(ExitException::class, $throwable);
         $response = $responseStub->getResponse();
-        $this->assertSame(['no-store, no-cache, must-revalidate'], $response->getHeader('Cache-Control'));
-        $this->assertSame(['no-cache'], $response->getHeader('Pragma'));
-        $this->assertSame(200, $response->getStatusCode());
+        self::assertSame(['no-store, no-cache, must-revalidate'], $response->getHeader('Cache-Control'));
+        self::assertSame(['no-cache'], $response->getHeader('Pragma'));
+        self::assertSame(200, $response->getStatusCode());
 
-        $this->assertEquals(
+        self::assertEquals(
             $GLOBALS['conn_error'],
             'Login without a password is forbidden by configuration (see AllowNoPassword)',
         );
@@ -728,16 +728,16 @@ class AuthenticationCookieTest extends AbstractTestCase
         $_POST['pma_password'] = $password;
 
         if ($trueFalse === false) {
-            $this->assertFalse(
+            self::assertFalse(
                 $this->object->readCredentials(),
             );
         } else {
-            $this->assertTrue(
+            self::assertTrue(
                 $this->object->readCredentials(),
             );
         }
 
-        $this->assertEquals($GLOBALS['conn_error'], $connError);
+        self::assertEquals($GLOBALS['conn_error'], $connError);
     }
 
     #[RunInSeparateProcess]
@@ -749,7 +749,7 @@ class AuthenticationCookieTest extends AbstractTestCase
             ->onlyMethods(['showLoginForm'])
             ->getMock();
 
-        $this->object->expects($this->exactly(1))
+        $this->object->expects(self::exactly(1))
             ->method('showLoginForm')
             ->willThrowException(new ExitException());
 
@@ -763,13 +763,13 @@ class AuthenticationCookieTest extends AbstractTestCase
         } catch (Throwable $throwable) {
         }
 
-        $this->assertInstanceOf(ExitException::class, $throwable);
+        self::assertInstanceOf(ExitException::class, $throwable);
         $response = $responseStub->getResponse();
-        $this->assertSame(['no-store, no-cache, must-revalidate'], $response->getHeader('Cache-Control'));
-        $this->assertSame(['no-cache'], $response->getHeader('Pragma'));
-        $this->assertSame(200, $response->getStatusCode());
+        self::assertSame(['no-store, no-cache, must-revalidate'], $response->getHeader('Cache-Control'));
+        self::assertSame(['no-cache'], $response->getHeader('Pragma'));
+        self::assertSame(200, $response->getStatusCode());
 
-        $this->assertEquals($GLOBALS['conn_error'], 'Access denied!');
+        self::assertEquals($GLOBALS['conn_error'], 'Access denied!');
     }
 
     #[RunInSeparateProcess]
@@ -781,7 +781,7 @@ class AuthenticationCookieTest extends AbstractTestCase
             ->onlyMethods(['showLoginForm'])
             ->getMock();
 
-        $this->object->expects($this->exactly(1))
+        $this->object->expects(self::exactly(1))
             ->method('showLoginForm')
             ->willThrowException(new ExitException());
 
@@ -798,13 +798,13 @@ class AuthenticationCookieTest extends AbstractTestCase
         } catch (Throwable $throwable) {
         }
 
-        $this->assertInstanceOf(ExitException::class, $throwable);
+        self::assertInstanceOf(ExitException::class, $throwable);
         $response = $responseStub->getResponse();
-        $this->assertSame(['no-store, no-cache, must-revalidate'], $response->getHeader('Cache-Control'));
-        $this->assertSame(['no-cache'], $response->getHeader('Pragma'));
-        $this->assertSame(200, $response->getStatusCode());
+        self::assertSame(['no-store, no-cache, must-revalidate'], $response->getHeader('Cache-Control'));
+        self::assertSame(['no-cache'], $response->getHeader('Pragma'));
+        self::assertSame(200, $response->getStatusCode());
 
-        $this->assertEquals(
+        self::assertEquals(
             $GLOBALS['conn_error'],
             'You have been automatically logged out due to inactivity of 10 seconds.'
             . ' Once you log in again, you should be able to resume the work where you left off.',
@@ -820,7 +820,7 @@ class AuthenticationCookieTest extends AbstractTestCase
             ->onlyMethods(['showLoginForm'])
             ->getMock();
 
-        $this->object->expects($this->exactly(1))
+        $this->object->expects(self::exactly(1))
             ->method('showLoginForm')
             ->willThrowException(new ExitException());
 
@@ -830,7 +830,7 @@ class AuthenticationCookieTest extends AbstractTestCase
             ->disableOriginalConstructor()
             ->getMock();
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('getError')
             ->willReturn('');
 
@@ -845,13 +845,13 @@ class AuthenticationCookieTest extends AbstractTestCase
         } catch (Throwable $throwable) {
         }
 
-        $this->assertInstanceOf(ExitException::class, $throwable);
+        self::assertInstanceOf(ExitException::class, $throwable);
         $response = $responseStub->getResponse();
-        $this->assertSame(['no-store, no-cache, must-revalidate'], $response->getHeader('Cache-Control'));
-        $this->assertSame(['no-cache'], $response->getHeader('Pragma'));
-        $this->assertSame(200, $response->getStatusCode());
+        self::assertSame(['no-store, no-cache, must-revalidate'], $response->getHeader('Cache-Control'));
+        self::assertSame(['no-cache'], $response->getHeader('Pragma'));
+        self::assertSame(200, $response->getStatusCode());
 
-        $this->assertEquals($GLOBALS['conn_error'], '#42 Cannot log in to the MySQL server');
+        self::assertEquals($GLOBALS['conn_error'], '#42 Cannot log in to the MySQL server');
     }
 
     #[RunInSeparateProcess]
@@ -863,7 +863,7 @@ class AuthenticationCookieTest extends AbstractTestCase
             ->onlyMethods(['showLoginForm'])
             ->getMock();
 
-        $this->object->expects($this->exactly(1))
+        $this->object->expects(self::exactly(1))
             ->method('showLoginForm')
             ->willThrowException(new ExitException());
 
@@ -871,7 +871,7 @@ class AuthenticationCookieTest extends AbstractTestCase
             ->disableOriginalConstructor()
             ->getMock();
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('getError')
             ->willReturn('');
 
@@ -888,13 +888,13 @@ class AuthenticationCookieTest extends AbstractTestCase
         } catch (Throwable $throwable) {
         }
 
-        $this->assertInstanceOf(ExitException::class, $throwable);
+        self::assertInstanceOf(ExitException::class, $throwable);
         $response = $responseStub->getResponse();
-        $this->assertSame(['no-store, no-cache, must-revalidate'], $response->getHeader('Cache-Control'));
-        $this->assertSame(['no-cache'], $response->getHeader('Pragma'));
-        $this->assertSame(200, $response->getStatusCode());
+        self::assertSame(['no-store, no-cache, must-revalidate'], $response->getHeader('Cache-Control'));
+        self::assertSame(['no-cache'], $response->getHeader('Pragma'));
+        self::assertSame(200, $response->getStatusCode());
 
-        $this->assertEquals($GLOBALS['conn_error'], 'Cannot log in to the MySQL server');
+        self::assertEquals($GLOBALS['conn_error'], 'Cannot log in to the MySQL server');
     }
 
     public function testGetEncryptionSecretEmpty(): void
@@ -906,8 +906,8 @@ class AuthenticationCookieTest extends AbstractTestCase
 
         $result = $method->invoke($this->object, null);
 
-        $this->assertSame($result, $_SESSION['encryption_key']);
-        $this->assertSame(SODIUM_CRYPTO_SECRETBOX_KEYBYTES, mb_strlen($result, '8bit'));
+        self::assertSame($result, $_SESSION['encryption_key']);
+        self::assertSame(SODIUM_CRYPTO_SECRETBOX_KEYBYTES, mb_strlen($result, '8bit'));
     }
 
     public function testGetEncryptionSecretConfigured(): void
@@ -920,7 +920,7 @@ class AuthenticationCookieTest extends AbstractTestCase
 
         $result = $method->invoke($this->object, null);
 
-        $this->assertSame($key, $result);
+        self::assertSame($key, $result);
     }
 
     public function testGetSessionEncryptionSecretConfigured(): void
@@ -933,28 +933,28 @@ class AuthenticationCookieTest extends AbstractTestCase
 
         $result = $method->invoke($this->object, null);
 
-        $this->assertSame($key, $result);
+        self::assertSame($key, $result);
     }
 
     public function testCookieEncryption(): void
     {
         $key = random_bytes(SODIUM_CRYPTO_SECRETBOX_KEYBYTES);
         $encrypted = $this->object->cookieEncrypt('data123', $key);
-        $this->assertNotFalse(base64_decode($encrypted, true));
-        $this->assertSame('data123', $this->object->cookieDecrypt($encrypted, $key));
+        self::assertNotFalse(base64_decode($encrypted, true));
+        self::assertSame('data123', $this->object->cookieDecrypt($encrypted, $key));
     }
 
     public function testCookieDecryptInvalid(): void
     {
-        $this->assertNull($this->object->cookieDecrypt('', ''));
+        self::assertNull($this->object->cookieDecrypt('', ''));
 
         $key = random_bytes(SODIUM_CRYPTO_SECRETBOX_KEYBYTES);
         $encrypted = $this->object->cookieEncrypt('data123', $key);
-        $this->assertSame('data123', $this->object->cookieDecrypt($encrypted, $key));
+        self::assertSame('data123', $this->object->cookieDecrypt($encrypted, $key));
 
-        $this->assertNull($this->object->cookieDecrypt('', $key));
-        $this->assertNull($this->object->cookieDecrypt($encrypted, ''));
-        $this->assertNull($this->object->cookieDecrypt($encrypted, random_bytes(SODIUM_CRYPTO_SECRETBOX_KEYBYTES)));
+        self::assertNull($this->object->cookieDecrypt('', $key));
+        self::assertNull($this->object->cookieDecrypt($encrypted, ''));
+        self::assertNull($this->object->cookieDecrypt($encrypted, random_bytes(SODIUM_CRYPTO_SECRETBOX_KEYBYTES)));
     }
 
     /** @throws ReflectionException */
@@ -973,12 +973,12 @@ class AuthenticationCookieTest extends AbstractTestCase
         $payload = ['password' => $newPassword, 'server' => 'b 2'];
 
         /** @psalm-suppress EmptyArrayAccess */
-        $this->assertIsString($_COOKIE['pmaAuth-' . Current::$server]);
+        self::assertIsString($_COOKIE['pmaAuth-' . Current::$server]);
         $decryptedCookie = $this->object->cookieDecrypt(
             $_COOKIE['pmaAuth-' . Current::$server],
             $_SESSION['encryption_key'],
         );
-        $this->assertSame(json_encode($payload), $decryptedCookie);
+        self::assertSame(json_encode($payload), $decryptedCookie);
     }
 
     public function testAuthenticate(): void
@@ -1000,15 +1000,15 @@ class AuthenticationCookieTest extends AbstractTestCase
         $result = ob_get_clean();
 
         /* Nothing should be printed */
-        $this->assertEquals('', $result);
+        self::assertEquals('', $result);
 
         /* Verify readCredentials worked */
-        $this->assertEquals('testUser', $this->object->user);
-        $this->assertEquals('testPassword', $this->object->password);
+        self::assertEquals('testUser', $this->object->user);
+        self::assertEquals('testPassword', $this->object->password);
 
         /* Verify storeCredentials worked */
-        $this->assertEquals('testUser', $config->selectedServer['user']);
-        $this->assertEquals('testPassword', $config->selectedServer['password']);
+        self::assertEquals('testUser', $config->selectedServer['user']);
+        self::assertEquals('testPassword', $config->selectedServer['password']);
     }
 
     /**
@@ -1058,13 +1058,13 @@ class AuthenticationCookieTest extends AbstractTestCase
         $result = $responseStub->getHTMLResult();
 
         if ($expected !== '') {
-            $this->assertInstanceOf(ExitException::class, $throwable ?? null);
+            self::assertInstanceOf(ExitException::class, $throwable ?? null);
         }
 
         if ($expected === '') {
-            $this->assertEquals($expected, $result);
+            self::assertEquals($expected, $result);
         } else {
-            $this->assertStringContainsString($expected, $result);
+            self::assertStringContainsString($expected, $result);
         }
 
         ErrorHandler::$instance = null;
diff --git a/tests/classes/Plugins/Auth/AuthenticationHttpTest.php b/tests/classes/Plugins/Auth/AuthenticationHttpTest.php
index 932b624e00..0c58316792 100644
--- a/tests/classes/Plugins/Auth/AuthenticationHttpTest.php
+++ b/tests/classes/Plugins/Auth/AuthenticationHttpTest.php
@@ -74,8 +74,8 @@ class AuthenticationHttpTest extends AbstractTestCase
         $this->object->logOut();
 
         $response = $responseStub->getResponse();
-        $this->assertSame(['https://example.com/logout'], $response->getHeader('Location'));
-        $this->assertSame(302, $response->getStatusCode());
+        self::assertSame(['https://example.com/logout'], $response->getHeader('Location'));
+        self::assertSame(302, $response->getStatusCode());
     }
 
     #[RunInSeparateProcess]
@@ -94,10 +94,10 @@ class AuthenticationHttpTest extends AbstractTestCase
         } catch (Throwable $throwable) {
         }
 
-        $this->assertInstanceOf(ExitException::class, $throwable);
+        self::assertInstanceOf(ExitException::class, $throwable);
         $response = $responseStub->getResponse();
-        $this->assertSame(['Basic realm="phpMyAdmin verboseMessag"'], $response->getHeader('WWW-Authenticate'));
-        $this->assertSame(401, $response->getStatusCode());
+        self::assertSame(['Basic realm="phpMyAdmin verboseMessag"'], $response->getHeader('WWW-Authenticate'));
+        self::assertSame(401, $response->getStatusCode());
     }
 
     #[RunInSeparateProcess]
@@ -117,10 +117,10 @@ class AuthenticationHttpTest extends AbstractTestCase
         } catch (Throwable $throwable) {
         }
 
-        $this->assertInstanceOf(ExitException::class, $throwable);
+        self::assertInstanceOf(ExitException::class, $throwable);
         $response = $responseStub->getResponse();
-        $this->assertSame(['Basic realm="phpMyAdmin hst"'], $response->getHeader('WWW-Authenticate'));
-        $this->assertSame(401, $response->getStatusCode());
+        self::assertSame(['Basic realm="phpMyAdmin hst"'], $response->getHeader('WWW-Authenticate'));
+        self::assertSame(401, $response->getStatusCode());
     }
 
     #[RunInSeparateProcess]
@@ -140,10 +140,10 @@ class AuthenticationHttpTest extends AbstractTestCase
         } catch (Throwable $throwable) {
         }
 
-        $this->assertInstanceOf(ExitException::class, $throwable);
+        self::assertInstanceOf(ExitException::class, $throwable);
         $response = $responseStub->getResponse();
-        $this->assertSame(['Basic realm="realmmessage"'], $response->getHeader('WWW-Authenticate'));
-        $this->assertSame(401, $response->getStatusCode());
+        self::assertSame(['Basic realm="realmmessage"'], $response->getHeader('WWW-Authenticate'));
+        self::assertSame(401, $response->getStatusCode());
     }
 
     /**
@@ -172,14 +172,14 @@ class AuthenticationHttpTest extends AbstractTestCase
 
         $_REQUEST['old_usr'] = $oldUsr;
 
-        $this->assertEquals(
+        self::assertEquals(
             $expectedReturn,
             $this->object->readCredentials(),
         );
 
-        $this->assertEquals($expectedUser, $this->object->user);
+        self::assertEquals($expectedUser, $this->object->user);
 
-        $this->assertEquals($expectedPass, $this->object->password);
+        self::assertEquals($expectedPass, $this->object->password);
 
         unset($_SERVER[$userIndex]);
         unset($_SERVER[$passIndex]);
@@ -227,17 +227,17 @@ class AuthenticationHttpTest extends AbstractTestCase
         $config = Config::getInstance();
         $config->selectedServer['user'] = 'testUser';
 
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->storeCredentials(),
         );
 
-        $this->assertEquals('testUser', $config->selectedServer['user']);
+        self::assertEquals('testUser', $config->selectedServer['user']);
 
-        $this->assertEquals('testPass', $config->selectedServer['password']);
+        self::assertEquals('testPass', $config->selectedServer['password']);
 
-        $this->assertArrayNotHasKey('PHP_AUTH_PW', $_SERVER);
+        self::assertArrayNotHasKey('PHP_AUTH_PW', $_SERVER);
 
-        $this->assertEquals(2, Current::$server);
+        self::assertEquals(2, Current::$server);
 
         // case 2
         $this->object->user = 'testUser';
@@ -246,16 +246,16 @@ class AuthenticationHttpTest extends AbstractTestCase
 
         $config->selectedServer = ['host' => 'a', 'user' => 'user2'];
 
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->storeCredentials(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             ['user' => 'testUser', 'password' => 'testPass', 'host' => 'a'],
             $config->selectedServer,
         );
 
-        $this->assertEquals(2, Current::$server);
+        self::assertEquals(2, Current::$server);
 
         // case 3
         Current::$server = 3;
@@ -265,16 +265,16 @@ class AuthenticationHttpTest extends AbstractTestCase
 
         $config->selectedServer = ['host' => 'a', 'user' => 'user2'];
 
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->storeCredentials(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             ['user' => 'testUser', 'password' => 'testPass', 'host' => 'a'],
             $config->selectedServer,
         );
 
-        $this->assertEquals(3, Current::$server);
+        self::assertEquals(3, Current::$server);
     }
 
     #[Group('medium')]
@@ -291,7 +291,7 @@ class AuthenticationHttpTest extends AbstractTestCase
             ->disableOriginalConstructor()
             ->getMock();
 
-        $dbi->expects($this->exactly(3))
+        $dbi->expects(self::exactly(3))
             ->method('getError')
             ->willReturn('error 123', 'error 321', '');
 
@@ -306,18 +306,18 @@ class AuthenticationHttpTest extends AbstractTestCase
 
         $result = ob_get_clean();
 
-        $this->assertInstanceOf(ExitException::class, $throwable);
+        self::assertInstanceOf(ExitException::class, $throwable);
 
-        $this->assertIsString($result);
+        self::assertIsString($result);
 
-        $this->assertStringContainsString('<p>error 123</p>', $result);
+        self::assertStringContainsString('<p>error 123</p>', $result);
 
         $this->object = $this->getMockBuilder(AuthenticationHttp::class)
             ->disableOriginalConstructor()
             ->onlyMethods(['authForm'])
             ->getMock();
 
-        $this->object->expects($this->exactly(2))
+        $this->object->expects(self::exactly(2))
             ->method('authForm')
             ->willThrowException(new ExitException());
         // case 2
diff --git a/tests/classes/Plugins/Auth/AuthenticationSignonTest.php b/tests/classes/Plugins/Auth/AuthenticationSignonTest.php
index 463467667b..548be15ee7 100644
--- a/tests/classes/Plugins/Auth/AuthenticationSignonTest.php
+++ b/tests/classes/Plugins/Auth/AuthenticationSignonTest.php
@@ -74,11 +74,11 @@ class AuthenticationSignonTest extends AbstractTestCase
 
         $result = ob_get_clean();
 
-        $this->assertInstanceOf(ExitException::class, $throwable);
+        self::assertInstanceOf(ExitException::class, $throwable);
 
-        $this->assertIsString($result);
+        self::assertIsString($result);
 
-        $this->assertStringContainsString('You must set SignonURL!', $result);
+        self::assertStringContainsString('You must set SignonURL!', $result);
     }
 
     #[RunInSeparateProcess]
@@ -95,8 +95,8 @@ class AuthenticationSignonTest extends AbstractTestCase
         $this->object->logOut();
 
         $response = $responseStub->getResponse();
-        $this->assertSame(['https://example.com/logoutURL'], $response->getHeader('Location'));
-        $this->assertSame(302, $response->getStatusCode());
+        self::assertSame(['https://example.com/logoutURL'], $response->getHeader('Location'));
+        self::assertSame(302, $response->getStatusCode());
     }
 
     #[RunInSeparateProcess]
@@ -114,8 +114,8 @@ class AuthenticationSignonTest extends AbstractTestCase
         $this->object->logOut();
 
         $response = $responseStub->getResponse();
-        $this->assertSame(['https://example.com/SignonURL'], $response->getHeader('Location'));
-        $this->assertSame(302, $response->getStatusCode());
+        self::assertSame(['https://example.com/SignonURL'], $response->getHeader('Location'));
+        self::assertSame(302, $response->getStatusCode());
     }
 
     public function testAuthCheckEmpty(): void
@@ -123,7 +123,7 @@ class AuthenticationSignonTest extends AbstractTestCase
         Config::getInstance()->selectedServer['SignonURL'] = 'https://example.com/SignonURL';
         $_SESSION['LAST_SIGNON_URL'] = 'https://example.com/SignonDiffURL';
 
-        $this->assertFalse(
+        self::assertFalse(
             $this->object->readCredentials(),
         );
     }
@@ -140,15 +140,15 @@ class AuthenticationSignonTest extends AbstractTestCase
         $config->selectedServer['port'] = '80';
         $config->selectedServer['user'] = 'user';
 
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->readCredentials(),
         );
 
-        $this->assertEquals('user', $this->object->user);
+        self::assertEquals('user', $this->object->user);
 
-        $this->assertEquals('password', $this->object->password);
+        self::assertEquals('password', $this->object->password);
 
-        $this->assertEquals('https://example.com/SignonURL', $_SESSION['LAST_SIGNON_URL']);
+        self::assertEquals('https://example.com/SignonURL', $_SESSION['LAST_SIGNON_URL']);
     }
 
     #[RunInSeparateProcess]
@@ -183,10 +183,10 @@ class AuthenticationSignonTest extends AbstractTestCase
         $this->object->logOut();
 
         $response = $responseStub->getResponse();
-        $this->assertSame(['https://example.com/SignonURL'], $response->getHeader('Location'));
-        $this->assertSame(302, $response->getStatusCode());
+        self::assertSame(['https://example.com/SignonURL'], $response->getHeader('Location'));
+        self::assertSame(302, $response->getStatusCode());
 
-        $this->assertEquals(
+        self::assertEquals(
             (new Server([
                 'SignonURL' => 'https://example.com/SignonURL',
                 'SignonScript' => '',
@@ -199,17 +199,17 @@ class AuthenticationSignonTest extends AbstractTestCase
             $config->selectedServer,
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             $sessionName,
             session_name(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             $sessionID,
             session_id(),
         );
 
-        $this->assertArrayNotHasKey('LAST_SIGNON_URL', $_SESSION);
+        self::assertArrayNotHasKey('LAST_SIGNON_URL', $_SESSION);
     }
 
     public function testAuthCheckKeep(): void
@@ -231,13 +231,13 @@ class AuthenticationSignonTest extends AbstractTestCase
         $_SESSION['PMA_single_signon_cfgupdate'] = ['foo' => 'bar'];
         $_SESSION['PMA_single_signon_token'] = 'pmaToken';
 
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->readCredentials(),
         );
 
-        $this->assertEquals('user123', $this->object->user);
+        self::assertEquals('user123', $this->object->user);
 
-        $this->assertEquals('pass123', $this->object->password);
+        self::assertEquals('pass123', $this->object->password);
     }
 
     public function testAuthSetUser(): void
@@ -245,14 +245,14 @@ class AuthenticationSignonTest extends AbstractTestCase
         $this->object->user = 'testUser123';
         $this->object->password = 'testPass123';
 
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->storeCredentials(),
         );
 
         $config = Config::getInstance();
-        $this->assertEquals('testUser123', $config->selectedServer['user']);
+        self::assertEquals('testUser123', $config->selectedServer['user']);
 
-        $this->assertEquals('testPass123', $config->selectedServer['password']);
+        self::assertEquals('testPass123', $config->selectedServer['password']);
     }
 
     public function testAuthFailsForbidden(): void
@@ -265,7 +265,7 @@ class AuthenticationSignonTest extends AbstractTestCase
             ->onlyMethods(['showLoginForm'])
             ->getMock();
 
-        $this->object->expects($this->exactly(1))
+        $this->object->expects(self::exactly(1))
             ->method('showLoginForm')
             ->willThrowException(new ExitException());
 
@@ -274,7 +274,7 @@ class AuthenticationSignonTest extends AbstractTestCase
         } catch (ExitException) {
         }
 
-        $this->assertEquals(
+        self::assertEquals(
             'Login without a password is forbidden by configuration (see AllowNoPassword)',
             $_SESSION['PMA_single_signon_error_message'],
         );
@@ -290,7 +290,7 @@ class AuthenticationSignonTest extends AbstractTestCase
             ->onlyMethods(['showLoginForm'])
             ->getMock();
 
-        $this->object->expects($this->exactly(1))
+        $this->object->expects(self::exactly(1))
             ->method('showLoginForm')
             ->willThrowException(new ExitException());
 
@@ -299,7 +299,7 @@ class AuthenticationSignonTest extends AbstractTestCase
         } catch (ExitException) {
         }
 
-        $this->assertEquals('Access denied!', $_SESSION['PMA_single_signon_error_message']);
+        self::assertEquals('Access denied!', $_SESSION['PMA_single_signon_error_message']);
     }
 
     public function testAuthFailsTimeout(): void
@@ -313,7 +313,7 @@ class AuthenticationSignonTest extends AbstractTestCase
             ->onlyMethods(['showLoginForm'])
             ->getMock();
 
-        $this->object->expects($this->exactly(1))
+        $this->object->expects(self::exactly(1))
             ->method('showLoginForm')
             ->willThrowException(new ExitException());
 
@@ -324,7 +324,7 @@ class AuthenticationSignonTest extends AbstractTestCase
         } catch (ExitException) {
         }
 
-        $this->assertEquals(
+        self::assertEquals(
             'You have been automatically logged out due to inactivity of'
             . ' 1440 seconds. Once you log in again, you should be able to'
             . ' resume the work where you left off.',
@@ -342,7 +342,7 @@ class AuthenticationSignonTest extends AbstractTestCase
             ->onlyMethods(['showLoginForm'])
             ->getMock();
 
-        $this->object->expects($this->exactly(1))
+        $this->object->expects(self::exactly(1))
             ->method('showLoginForm')
             ->willThrowException(new ExitException());
 
@@ -350,7 +350,7 @@ class AuthenticationSignonTest extends AbstractTestCase
             ->disableOriginalConstructor()
             ->getMock();
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('getError')
             ->willReturn('error<123>');
 
@@ -361,7 +361,7 @@ class AuthenticationSignonTest extends AbstractTestCase
         } catch (ExitException) {
         }
 
-        $this->assertEquals('error&lt;123&gt;', $_SESSION['PMA_single_signon_error_message']);
+        self::assertEquals('error&lt;123&gt;', $_SESSION['PMA_single_signon_error_message']);
     }
 
     public function testAuthFailsConnect(): void
@@ -375,7 +375,7 @@ class AuthenticationSignonTest extends AbstractTestCase
             ->onlyMethods(['showLoginForm'])
             ->getMock();
 
-        $this->object->expects($this->exactly(1))
+        $this->object->expects(self::exactly(1))
             ->method('showLoginForm')
             ->willThrowException(new ExitException());
 
@@ -383,7 +383,7 @@ class AuthenticationSignonTest extends AbstractTestCase
             ->disableOriginalConstructor()
             ->getMock();
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('getError')
             ->willReturn('');
 
@@ -394,7 +394,7 @@ class AuthenticationSignonTest extends AbstractTestCase
         } catch (ExitException) {
         }
 
-        $this->assertEquals('Cannot log in to the MySQL server', $_SESSION['PMA_single_signon_error_message']);
+        self::assertEquals('Cannot log in to the MySQL server', $_SESSION['PMA_single_signon_error_message']);
     }
 
     public function testSetCookieParamsDefaults(): void
@@ -415,7 +415,7 @@ class AuthenticationSignonTest extends AbstractTestCase
             'samesite' => '',
         ];
 
-        $this->assertSame(
+        self::assertSame(
             $defaultOptions,
             session_get_cookie_params(),
         );
diff --git a/tests/classes/Plugins/AuthenticationPluginFactoryTest.php b/tests/classes/Plugins/AuthenticationPluginFactoryTest.php
index fb442b21f5..41c7bf5466 100644
--- a/tests/classes/Plugins/AuthenticationPluginFactoryTest.php
+++ b/tests/classes/Plugins/AuthenticationPluginFactoryTest.php
@@ -27,7 +27,7 @@ class AuthenticationPluginFactoryTest extends AbstractTestCase
     {
         Config::getInstance()->selectedServer['auth_type'] = $type;
         $plugin = (new AuthenticationPluginFactory())->create();
-        $this->assertInstanceOf($class, $plugin);
+        self::assertInstanceOf($class, $plugin);
     }
 
     /** @return iterable<string, array{non-empty-string, class-string}> */
@@ -54,11 +54,11 @@ class AuthenticationPluginFactoryTest extends AbstractTestCase
         $factory = new AuthenticationPluginFactory();
         $firstInstance = $factory->create();
         $secondInstance = (new AuthenticationPluginFactory())->create();
-        $this->assertNotSame($firstInstance, $secondInstance);
+        self::assertNotSame($firstInstance, $secondInstance);
         $thirdInstance = $factory->create();
-        $this->assertSame($firstInstance, $thirdInstance);
+        self::assertSame($firstInstance, $thirdInstance);
         $config->selectedServer['auth_type'] = 'config';
         $forthInstance = $factory->create();
-        $this->assertSame($firstInstance, $forthInstance);
+        self::assertSame($firstInstance, $forthInstance);
     }
 }
diff --git a/tests/classes/Plugins/Export/ExportCodegenTest.php b/tests/classes/Plugins/Export/ExportCodegenTest.php
index 3d2beca22d..bb348bd5da 100644
--- a/tests/classes/Plugins/Export/ExportCodegenTest.php
+++ b/tests/classes/Plugins/Export/ExportCodegenTest.php
@@ -63,33 +63,33 @@ class ExportCodegenTest extends AbstractTestCase
         $attrProperties = new ReflectionProperty(ExportCodegen::class, 'properties');
         $properties = $attrProperties->getValue($this->object);
 
-        $this->assertInstanceOf(ExportPluginProperties::class, $properties);
+        self::assertInstanceOf(ExportPluginProperties::class, $properties);
 
-        $this->assertEquals(
+        self::assertEquals(
             'CodeGen',
             $properties->getText(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'cs',
             $properties->getExtension(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'text/cs',
             $properties->getMimeType(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'Options',
             $properties->getOptionsText(),
         );
 
         $options = $properties->getOptions();
 
-        $this->assertInstanceOf(OptionsPropertyRootGroup::class, $options);
+        self::assertInstanceOf(OptionsPropertyRootGroup::class, $options);
 
-        $this->assertEquals(
+        self::assertEquals(
             'Format Specific Options',
             $options->getName(),
         );
@@ -97,9 +97,9 @@ class ExportCodegenTest extends AbstractTestCase
         $generalOptionsArray = $options->getProperties();
         $generalOptions = $generalOptionsArray->current();
 
-        $this->assertInstanceOf(OptionsPropertyMainGroup::class, $generalOptions);
+        self::assertInstanceOf(OptionsPropertyMainGroup::class, $generalOptions);
 
-        $this->assertEquals(
+        self::assertEquals(
             'general_opts',
             $generalOptions->getName(),
         );
@@ -109,28 +109,28 @@ class ExportCodegenTest extends AbstractTestCase
         $hidden = $generalProperties->current();
         $generalProperties->next();
 
-        $this->assertInstanceOf(HiddenPropertyItem::class, $hidden);
+        self::assertInstanceOf(HiddenPropertyItem::class, $hidden);
 
-        $this->assertEquals(
+        self::assertEquals(
             'structure_or_data',
             $hidden->getName(),
         );
 
         $select = $generalProperties->current();
 
-        $this->assertInstanceOf(SelectPropertyItem::class, $select);
+        self::assertInstanceOf(SelectPropertyItem::class, $select);
 
-        $this->assertEquals(
+        self::assertEquals(
             'format',
             $select->getName(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'Format:',
             $select->getText(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             ['NHibernate C# DO', 'NHibernate XML'],
             $select->getValues(),
         );
@@ -138,28 +138,28 @@ class ExportCodegenTest extends AbstractTestCase
 
     public function testExportHeader(): void
     {
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportHeader(),
         );
     }
 
     public function testExportFooter(): void
     {
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportFooter(),
         );
     }
 
     public function testExportDBHeader(): void
     {
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportDBHeader('testDB'),
         );
     }
 
     public function testExportDBFooter(): void
     {
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportDBFooter('testDB'),
         );
     }
@@ -177,8 +177,8 @@ class ExportCodegenTest extends AbstractTestCase
         $this->object->exportData('test_db', 'test_table', 'localhost', 'SELECT * FROM `test_db`.`test_table`;');
         $result = ob_get_clean();
 
-        $this->assertIsString($result);
-        $this->assertEquals(
+        self::assertIsString($result);
+        self::assertEquals(
             '<?xml version="1.0" encoding="utf-8" ?>' . "\n"
             . '<hibernate-mapping xmlns="urn:nhibernate-mapping-2.2" namespace="Test_db" assembly="Test_db">' . "\n"
             . '    <class name="Test_table" table="Test_table">' . "\n"
@@ -206,17 +206,17 @@ class ExportCodegenTest extends AbstractTestCase
 
     public function testCgMakeIdentifier(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             '_Ⅲfoo',
             ExportCodegen::cgMakeIdentifier('Ⅲ{}96`{}foo', true),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'TestⅢ',
             ExportCodegen::cgMakeIdentifier('`98testⅢ{}96`{}', true),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'testⅢ',
             ExportCodegen::cgMakeIdentifier('`98testⅢ{}96`{}', false),
         );
@@ -227,7 +227,7 @@ class ExportCodegenTest extends AbstractTestCase
         $method = new ReflectionMethod(ExportCodegen::class, 'handleNHibernateCSBody');
         $result = $method->invoke($this->object, 'test_db', 'test_table');
 
-        $this->assertEquals(
+        self::assertEquals(
             'using System;' . "\n" .
             'using System.Collections;' . "\n" .
             'using System.Collections.Generic;' . "\n" .
@@ -279,7 +279,7 @@ class ExportCodegenTest extends AbstractTestCase
         $method = new ReflectionMethod(ExportCodegen::class, 'handleNHibernateXMLBody');
         $result = $method->invoke($this->object, 'test_db', 'test_table');
 
-        $this->assertEquals(
+        self::assertEquals(
             '<?xml version="1.0" encoding="utf-8" ?>' . "\n" .
             '<hibernate-mapping xmlns="urn:nhibernate-mapping-2.2" namespace="Test_db" assembly="Test_db">' . "\n" .
             '    <class name="Test_table" table="Test_table">' . "\n" .
diff --git a/tests/classes/Plugins/Export/ExportCsvTest.php b/tests/classes/Plugins/Export/ExportCsvTest.php
index 8721a0afd2..9ea6bf3b0d 100644
--- a/tests/classes/Plugins/Export/ExportCsvTest.php
+++ b/tests/classes/Plugins/Export/ExportCsvTest.php
@@ -72,33 +72,33 @@ class ExportCsvTest extends AbstractTestCase
         $attrProperties = new ReflectionProperty(ExportCsv::class, 'properties');
         $properties = $attrProperties->getValue($this->object);
 
-        $this->assertInstanceOf(ExportPluginProperties::class, $properties);
+        self::assertInstanceOf(ExportPluginProperties::class, $properties);
 
-        $this->assertEquals(
+        self::assertEquals(
             'CSV',
             $properties->getText(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'csv',
             $properties->getExtension(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'text/comma-separated-values',
             $properties->getMimeType(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'Options',
             $properties->getOptionsText(),
         );
 
         $options = $properties->getOptions();
 
-        $this->assertInstanceOf(OptionsPropertyRootGroup::class, $options);
+        self::assertInstanceOf(OptionsPropertyRootGroup::class, $options);
 
-        $this->assertEquals(
+        self::assertEquals(
             'Format Specific Options',
             $options->getName(),
         );
@@ -106,9 +106,9 @@ class ExportCsvTest extends AbstractTestCase
         $generalOptionsArray = $options->getProperties();
         $generalOptions = $generalOptionsArray->current();
 
-        $this->assertInstanceOf(OptionsPropertyMainGroup::class, $generalOptions);
+        self::assertInstanceOf(OptionsPropertyMainGroup::class, $generalOptions);
 
-        $this->assertEquals(
+        self::assertEquals(
             'general_opts',
             $generalOptions->getName(),
         );
@@ -118,14 +118,14 @@ class ExportCsvTest extends AbstractTestCase
         $property = $generalProperties->current();
         $generalProperties->next();
 
-        $this->assertInstanceOf(TextPropertyItem::class, $property);
+        self::assertInstanceOf(TextPropertyItem::class, $property);
 
-        $this->assertEquals(
+        self::assertEquals(
             'separator',
             $property->getName(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'Columns separated with:',
             $property->getText(),
         );
@@ -133,14 +133,14 @@ class ExportCsvTest extends AbstractTestCase
         $property = $generalProperties->current();
         $generalProperties->next();
 
-        $this->assertInstanceOf(TextPropertyItem::class, $property);
+        self::assertInstanceOf(TextPropertyItem::class, $property);
 
-        $this->assertEquals(
+        self::assertEquals(
             'enclosed',
             $property->getName(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'Columns enclosed with:',
             $property->getText(),
         );
@@ -148,14 +148,14 @@ class ExportCsvTest extends AbstractTestCase
         $property = $generalProperties->current();
         $generalProperties->next();
 
-        $this->assertInstanceOf(TextPropertyItem::class, $property);
+        self::assertInstanceOf(TextPropertyItem::class, $property);
 
-        $this->assertEquals(
+        self::assertEquals(
             'escaped',
             $property->getName(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'Columns escaped with:',
             $property->getText(),
         );
@@ -163,14 +163,14 @@ class ExportCsvTest extends AbstractTestCase
         $property = $generalProperties->current();
         $generalProperties->next();
 
-        $this->assertInstanceOf(TextPropertyItem::class, $property);
+        self::assertInstanceOf(TextPropertyItem::class, $property);
 
-        $this->assertEquals(
+        self::assertEquals(
             'terminated',
             $property->getName(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'Lines terminated with:',
             $property->getText(),
         );
@@ -178,14 +178,14 @@ class ExportCsvTest extends AbstractTestCase
         $property = $generalProperties->current();
         $generalProperties->next();
 
-        $this->assertInstanceOf(TextPropertyItem::class, $property);
+        self::assertInstanceOf(TextPropertyItem::class, $property);
 
-        $this->assertEquals(
+        self::assertEquals(
             'null',
             $property->getName(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'Replace NULL with:',
             $property->getText(),
         );
@@ -193,14 +193,14 @@ class ExportCsvTest extends AbstractTestCase
         $property = $generalProperties->current();
         $generalProperties->next();
 
-        $this->assertInstanceOf(BoolPropertyItem::class, $property);
+        self::assertInstanceOf(BoolPropertyItem::class, $property);
 
-        $this->assertEquals(
+        self::assertEquals(
             'removeCRLF',
             $property->getName(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'Remove carriage return/line feed characters within columns',
             $property->getText(),
         );
@@ -208,23 +208,23 @@ class ExportCsvTest extends AbstractTestCase
         $property = $generalProperties->current();
         $generalProperties->next();
 
-        $this->assertInstanceOf(BoolPropertyItem::class, $property);
+        self::assertInstanceOf(BoolPropertyItem::class, $property);
 
-        $this->assertEquals(
+        self::assertEquals(
             'columns',
             $property->getName(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'Put columns names in the first row',
             $property->getText(),
         );
 
         $property = $generalProperties->current();
 
-        $this->assertInstanceOf(HiddenPropertyItem::class, $property);
+        self::assertInstanceOf(HiddenPropertyItem::class, $property);
 
-        $this->assertEquals(
+        self::assertEquals(
             'structure_or_data',
             $property->getName(),
         );
@@ -238,19 +238,19 @@ class ExportCsvTest extends AbstractTestCase
         $GLOBALS['excel_edition'] = 'win';
         $GLOBALS['excel_columns'] = true;
 
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportHeader(),
         );
 
-        $this->assertEquals("\015\012", $GLOBALS['csv_terminated']);
+        self::assertEquals("\015\012", $GLOBALS['csv_terminated']);
 
-        $this->assertEquals(';', $GLOBALS['csv_separator']);
+        self::assertEquals(';', $GLOBALS['csv_separator']);
 
-        $this->assertEquals('"', $GLOBALS['csv_enclosed']);
+        self::assertEquals('"', $GLOBALS['csv_enclosed']);
 
-        $this->assertEquals('"', $GLOBALS['csv_escaped']);
+        self::assertEquals('"', $GLOBALS['csv_escaped']);
 
-        $this->assertTrue($GLOBALS['csv_columns']);
+        self::assertTrue($GLOBALS['csv_columns']);
 
         // case 2
 
@@ -258,48 +258,48 @@ class ExportCsvTest extends AbstractTestCase
         unset($GLOBALS['excel_columns']);
         $GLOBALS['csv_columns'] = false;
 
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportHeader(),
         );
 
-        $this->assertEquals("\015\012", $GLOBALS['csv_terminated']);
+        self::assertEquals("\015\012", $GLOBALS['csv_terminated']);
 
-        $this->assertEquals(';', $GLOBALS['csv_separator']);
+        self::assertEquals(';', $GLOBALS['csv_separator']);
 
-        $this->assertEquals('"', $GLOBALS['csv_enclosed']);
+        self::assertEquals('"', $GLOBALS['csv_enclosed']);
 
-        $this->assertEquals('"', $GLOBALS['csv_escaped']);
+        self::assertEquals('"', $GLOBALS['csv_escaped']);
 
-        $this->assertFalse($GLOBALS['csv_columns']);
+        self::assertFalse($GLOBALS['csv_columns']);
 
         // case 3
 
         $GLOBALS['excel_edition'] = 'mac_excel2008';
 
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportHeader(),
         );
 
-        $this->assertEquals("\015\012", $GLOBALS['csv_terminated']);
+        self::assertEquals("\015\012", $GLOBALS['csv_terminated']);
 
-        $this->assertEquals(',', $GLOBALS['csv_separator']);
+        self::assertEquals(',', $GLOBALS['csv_separator']);
 
-        $this->assertEquals('"', $GLOBALS['csv_enclosed']);
+        self::assertEquals('"', $GLOBALS['csv_enclosed']);
 
-        $this->assertEquals('"', $GLOBALS['csv_escaped']);
+        self::assertEquals('"', $GLOBALS['csv_escaped']);
 
-        $this->assertFalse($GLOBALS['csv_columns']);
+        self::assertFalse($GLOBALS['csv_columns']);
 
         // case 4
 
         $GLOBALS['excel_edition'] = 'testBlank';
         $GLOBALS['csv_separator'] = '#';
 
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportHeader(),
         );
 
-        $this->assertEquals('#', $GLOBALS['csv_separator']);
+        self::assertEquals('#', $GLOBALS['csv_separator']);
 
         // case 5
 
@@ -307,61 +307,61 @@ class ExportCsvTest extends AbstractTestCase
         $GLOBALS['csv_terminated'] = '';
         $GLOBALS['csv_separator'] = 'a\\t';
 
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportHeader(),
         );
 
-        $this->assertEquals($GLOBALS['csv_terminated'], "\n");
+        self::assertEquals($GLOBALS['csv_terminated'], "\n");
 
-        $this->assertEquals($GLOBALS['csv_separator'], "a\011");
+        self::assertEquals($GLOBALS['csv_separator'], "a\011");
         // case 6
 
         $GLOBALS['csv_terminated'] = 'AUTO';
 
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportHeader(),
         );
 
-        $this->assertEquals($GLOBALS['csv_terminated'], "\n");
+        self::assertEquals($GLOBALS['csv_terminated'], "\n");
 
         // case 7
 
         $GLOBALS['csv_terminated'] = 'a\\rb\\nc\\t';
         $GLOBALS['csv_separator'] = 'a\\t';
 
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportHeader(),
         );
 
-        $this->assertEquals($GLOBALS['csv_terminated'], "a\015b\012c\011");
+        self::assertEquals($GLOBALS['csv_terminated'], "a\015b\012c\011");
 
-        $this->assertEquals($GLOBALS['csv_separator'], "a\011");
+        self::assertEquals($GLOBALS['csv_separator'], "a\011");
     }
 
     public function testExportFooter(): void
     {
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportFooter(),
         );
     }
 
     public function testExportDBHeader(): void
     {
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportDBHeader('testDB'),
         );
     }
 
     public function testExportDBFooter(): void
     {
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportDBFooter('testDB'),
         );
     }
 
     public function testExportDBCreate(): void
     {
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportDBCreate('testDB', 'database'),
         );
     }
@@ -380,7 +380,7 @@ class ExportCsvTest extends AbstractTestCase
         $GLOBALS['file_handle'] = null;
 
         ob_start();
-        $this->assertFalse($this->object->exportData(
+        self::assertFalse($this->object->exportData(
             'test_db',
             'test_table',
             'localhost',
@@ -400,7 +400,7 @@ class ExportCsvTest extends AbstractTestCase
         $GLOBALS['csv_separator'] = '';
 
         ob_start();
-        $this->assertTrue($this->object->exportData(
+        self::assertTrue($this->object->exportData(
             'test_db',
             'test_table',
             'localhost',
@@ -408,7 +408,7 @@ class ExportCsvTest extends AbstractTestCase
         ));
         $result = ob_get_clean();
 
-        $this->assertEquals(
+        self::assertEquals(
             'idnamedatetimefield;1abcd2011-01-20 02:00:02;2foo2010-01-20 02:00:02;3Abcd2012-01-20 02:00:02;',
             $result,
         );
@@ -418,7 +418,7 @@ class ExportCsvTest extends AbstractTestCase
         $GLOBALS['csv_escaped'] = '';
 
         ob_start();
-        $this->assertTrue($this->object->exportData(
+        self::assertTrue($this->object->exportData(
             'test_db',
             'test_table',
             'localhost',
@@ -426,7 +426,7 @@ class ExportCsvTest extends AbstractTestCase
         ));
         $result = ob_get_clean();
 
-        $this->assertEquals(
+        self::assertEquals(
             '"id""name""datetimefield";"1""abcd""2011-01-20 02:00:02";'
             . '"2""foo""2010-01-20 02:00:02";"3""Abcd""2012-01-20 02:00:02";',
             $result,
@@ -439,7 +439,7 @@ class ExportCsvTest extends AbstractTestCase
         $GLOBALS['csv_escaped'] = '"';
 
         ob_start();
-        $this->assertTrue($this->object->exportData(
+        self::assertTrue($this->object->exportData(
             'test_db',
             'test_table',
             'localhost',
@@ -447,7 +447,7 @@ class ExportCsvTest extends AbstractTestCase
         ));
         $result = ob_get_clean();
 
-        $this->assertEquals(
+        self::assertEquals(
             '"id""name""datetimefield";"1""abcd""2011-01-20 02:00:02";'
             . '"2""foo""2010-01-20 02:00:02";"3""Abcd""2012-01-20 02:00:02";',
             $result,
@@ -459,7 +459,7 @@ class ExportCsvTest extends AbstractTestCase
         $GLOBALS['csv_escaped'] = ';';
 
         ob_start();
-        $this->assertTrue($this->object->exportData(
+        self::assertTrue($this->object->exportData(
             'test_db',
             'test_table',
             'localhost',
@@ -467,7 +467,7 @@ class ExportCsvTest extends AbstractTestCase
         ));
         $result = ob_get_clean();
 
-        $this->assertEquals(
+        self::assertEquals(
             '"id""name""datetimefield";"1""abcd""2011-01-20 02:00:02";'
             . '"2""foo""2010-01-20 02:00:02";"3""Abcd""2012-01-20 02:00:02";',
             $result,
@@ -479,7 +479,7 @@ class ExportCsvTest extends AbstractTestCase
         $GLOBALS['csv_escaped'] = '#';
 
         ob_start();
-        $this->assertTrue($this->object->exportData(
+        self::assertTrue($this->object->exportData(
             'test_db',
             'test_table',
             'localhost',
@@ -487,7 +487,7 @@ class ExportCsvTest extends AbstractTestCase
         ));
         $result = ob_get_clean();
 
-        $this->assertEquals(
+        self::assertEquals(
             '"id""name""datetimefield";"1""abcd""2011-01-20 02:00:02";'
             . '"2""foo""2010-01-20 02:00:02";"3""Abcd""2012-01-20 02:00:02";',
             $result,
diff --git a/tests/classes/Plugins/Export/ExportExcelTest.php b/tests/classes/Plugins/Export/ExportExcelTest.php
index e11e60a04c..45b7329d16 100644
--- a/tests/classes/Plugins/Export/ExportExcelTest.php
+++ b/tests/classes/Plugins/Export/ExportExcelTest.php
@@ -62,33 +62,33 @@ class ExportExcelTest extends AbstractTestCase
         $attrProperties = new ReflectionProperty(ExportExcel::class, 'properties');
         $properties = $attrProperties->getValue($this->object);
 
-        $this->assertInstanceOf(ExportPluginProperties::class, $properties);
+        self::assertInstanceOf(ExportPluginProperties::class, $properties);
 
-        $this->assertEquals(
+        self::assertEquals(
             'CSV for MS Excel',
             $properties->getText(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'csv',
             $properties->getExtension(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'text/comma-separated-values',
             $properties->getMimeType(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'Options',
             $properties->getOptionsText(),
         );
 
         $options = $properties->getOptions();
 
-        $this->assertInstanceOf(OptionsPropertyRootGroup::class, $options);
+        self::assertInstanceOf(OptionsPropertyRootGroup::class, $options);
 
-        $this->assertEquals(
+        self::assertEquals(
             'Format Specific Options',
             $options->getName(),
         );
@@ -96,9 +96,9 @@ class ExportExcelTest extends AbstractTestCase
         $generalOptionsArray = $options->getProperties();
         $generalOptions = $generalOptionsArray->current();
 
-        $this->assertInstanceOf(OptionsPropertyMainGroup::class, $generalOptions);
+        self::assertInstanceOf(OptionsPropertyMainGroup::class, $generalOptions);
 
-        $this->assertEquals(
+        self::assertEquals(
             'general_opts',
             $generalOptions->getName(),
         );
@@ -108,14 +108,14 @@ class ExportExcelTest extends AbstractTestCase
         $property = $generalProperties->current();
         $generalProperties->next();
 
-        $this->assertInstanceOf(TextPropertyItem::class, $property);
+        self::assertInstanceOf(TextPropertyItem::class, $property);
 
-        $this->assertEquals(
+        self::assertEquals(
             'null',
             $property->getName(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'Replace NULL with:',
             $property->getText(),
         );
@@ -123,14 +123,14 @@ class ExportExcelTest extends AbstractTestCase
         $property = $generalProperties->current();
         $generalProperties->next();
 
-        $this->assertInstanceOf(BoolPropertyItem::class, $property);
+        self::assertInstanceOf(BoolPropertyItem::class, $property);
 
-        $this->assertEquals(
+        self::assertEquals(
             'removeCRLF',
             $property->getName(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'Remove carriage return/line feed characters within columns',
             $property->getText(),
         );
@@ -138,14 +138,14 @@ class ExportExcelTest extends AbstractTestCase
         $property = $generalProperties->current();
         $generalProperties->next();
 
-        $this->assertInstanceOf(BoolPropertyItem::class, $property);
+        self::assertInstanceOf(BoolPropertyItem::class, $property);
 
-        $this->assertEquals(
+        self::assertEquals(
             'columns',
             $property->getName(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'Put columns names in the first row',
             $property->getText(),
         );
@@ -153,14 +153,14 @@ class ExportExcelTest extends AbstractTestCase
         $property = $generalProperties->current();
         $generalProperties->next();
 
-        $this->assertInstanceOf(SelectPropertyItem::class, $property);
+        self::assertInstanceOf(SelectPropertyItem::class, $property);
 
-        $this->assertEquals(
+        self::assertEquals(
             'edition',
             $property->getName(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             [
                 'win' => 'Windows',
                 'mac_excel2003' => 'Excel 2003 / Macintosh',
@@ -169,16 +169,16 @@ class ExportExcelTest extends AbstractTestCase
             $property->getValues(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'Excel edition:',
             $property->getText(),
         );
 
         $property = $generalProperties->current();
 
-        $this->assertInstanceOf(HiddenPropertyItem::class, $property);
+        self::assertInstanceOf(HiddenPropertyItem::class, $property);
 
-        $this->assertEquals(
+        self::assertEquals(
             'structure_or_data',
             $property->getName(),
         );
diff --git a/tests/classes/Plugins/Export/ExportHtmlwordTest.php b/tests/classes/Plugins/Export/ExportHtmlwordTest.php
index 97f7311523..2edfd8f3ad 100644
--- a/tests/classes/Plugins/Export/ExportHtmlwordTest.php
+++ b/tests/classes/Plugins/Export/ExportHtmlwordTest.php
@@ -90,37 +90,37 @@ class ExportHtmlwordTest extends AbstractTestCase
         $attrProperties = new ReflectionProperty(ExportHtmlword::class, 'properties');
         $properties = $attrProperties->getValue($this->object);
 
-        $this->assertInstanceOf(ExportPluginProperties::class, $properties);
+        self::assertInstanceOf(ExportPluginProperties::class, $properties);
 
-        $this->assertEquals(
+        self::assertEquals(
             'Microsoft Word 2000',
             $properties->getText(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'doc',
             $properties->getExtension(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'application/vnd.ms-word',
             $properties->getMimeType(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'Options',
             $properties->getOptionsText(),
         );
 
-        $this->assertTrue(
+        self::assertTrue(
             $properties->getForceFile(),
         );
 
         $options = $properties->getOptions();
 
-        $this->assertInstanceOf(OptionsPropertyRootGroup::class, $options);
+        self::assertInstanceOf(OptionsPropertyRootGroup::class, $options);
 
-        $this->assertEquals(
+        self::assertEquals(
             'Format Specific Options',
             $options->getName(),
         );
@@ -129,14 +129,14 @@ class ExportHtmlwordTest extends AbstractTestCase
         $generalOptions = $generalOptionsArray->current();
         $generalOptionsArray->next();
 
-        $this->assertInstanceOf(OptionsPropertyMainGroup::class, $generalOptions);
+        self::assertInstanceOf(OptionsPropertyMainGroup::class, $generalOptions);
 
-        $this->assertEquals(
+        self::assertEquals(
             'dump_what',
             $generalOptions->getName(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'Dump table',
             $generalOptions->getText(),
         );
@@ -145,33 +145,33 @@ class ExportHtmlwordTest extends AbstractTestCase
 
         $property = $generalProperties->current();
 
-        $this->assertInstanceOf(RadioPropertyItem::class, $property);
+        self::assertInstanceOf(RadioPropertyItem::class, $property);
 
-        $this->assertEquals(
+        self::assertEquals(
             'structure_or_data',
             $property->getName(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             ['structure' => __('structure'), 'data' => __('data'), 'structure_and_data' => __('structure and data')],
             $property->getValues(),
         );
 
         $generalOptions = $generalOptionsArray->current();
 
-        $this->assertInstanceOf(OptionsPropertyMainGroup::class, $generalOptions);
+        self::assertInstanceOf(OptionsPropertyMainGroup::class, $generalOptions);
 
-        $this->assertEquals(
+        self::assertEquals(
             'dump_what',
             $generalOptions->getName(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'Data dump options',
             $generalOptions->getText(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'structure',
             $generalOptions->getForce(),
         );
@@ -181,28 +181,28 @@ class ExportHtmlwordTest extends AbstractTestCase
         $property = $generalProperties->current();
         $generalProperties->next();
 
-        $this->assertInstanceOf(TextPropertyItem::class, $property);
+        self::assertInstanceOf(TextPropertyItem::class, $property);
 
-        $this->assertEquals(
+        self::assertEquals(
             'null',
             $property->getName(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'Replace NULL with:',
             $property->getText(),
         );
 
         $property = $generalProperties->current();
 
-        $this->assertInstanceOf(BoolPropertyItem::class, $property);
+        self::assertInstanceOf(BoolPropertyItem::class, $property);
 
-        $this->assertEquals(
+        self::assertEquals(
             'columns',
             $property->getName(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'Put columns names in the first row',
             $property->getText(),
         );
@@ -227,7 +227,7 @@ class ExportHtmlwordTest extends AbstractTestCase
             </head>
             <body>';
 
-        $this->assertEquals($expected, $result);
+        self::assertEquals($expected, $result);
 
         // case 2
 
@@ -249,41 +249,41 @@ class ExportHtmlwordTest extends AbstractTestCase
             </head>
             <body>';
 
-        $this->assertEquals($expected, $result);
+        self::assertEquals($expected, $result);
     }
 
     public function testExportFooter(): void
     {
         ob_start();
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportFooter(),
         );
         $result = ob_get_clean();
 
-        $this->assertEquals('</body></html>', $result);
+        self::assertEquals('</body></html>', $result);
     }
 
     public function testExportDBHeader(): void
     {
         ob_start();
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportDBHeader('d"b'),
         );
         $result = ob_get_clean();
 
-        $this->assertEquals('<h1>Database d&quot;b</h1>', $result);
+        self::assertEquals('<h1>Database d&quot;b</h1>', $result);
     }
 
     public function testExportDBFooter(): void
     {
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportDBFooter('testDB'),
         );
     }
 
     public function testExportDBCreate(): void
     {
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportDBCreate('testDB', 'database'),
         );
     }
@@ -301,7 +301,7 @@ class ExportHtmlwordTest extends AbstractTestCase
         $GLOBALS['save_on_server'] = false;
 
         ob_start();
-        $this->assertTrue($this->object->exportData(
+        self::assertTrue($this->object->exportData(
             'test_db',
             'test_table',
             'localhost',
@@ -309,7 +309,7 @@ class ExportHtmlwordTest extends AbstractTestCase
         ));
         $result = ob_get_clean();
 
-        $this->assertEquals(
+        self::assertEquals(
             '<h2>Dumping data for table test_table</h2>'
             . '<table width="100%" cellspacing="1"><tr class="print-category">'
             . '<td class="print"><strong>id</strong></td>'
@@ -341,26 +341,26 @@ class ExportHtmlwordTest extends AbstractTestCase
             ->disableOriginalConstructor()
             ->getMock();
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('getTableIndexes')
             ->with('database', 'view')
             ->willReturn($keys);
 
         $column = new Column('column', '', false, '', null, '');
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('getColumns')
             ->with('database', 'view')
             ->willReturn([$column]);
 
         DatabaseInterface::$instance = $dbi;
 
-        $this->object->expects($this->once())
+        $this->object->expects(self::once())
             ->method('formatOneColumnDefinition')
             ->with($column, ['name1'], 'column')
             ->willReturn('1');
 
-        $this->assertEquals(
+        self::assertEquals(
             '<table width="100%" cellspacing="1">' .
             '<tr class="print-category"><th class="print">Column</th>' .
             '<td class="print"><strong>Type</strong></td>' .
@@ -382,46 +382,46 @@ class ExportHtmlwordTest extends AbstractTestCase
 
         // case 1
 
-        $resultStub = $this->createMock(DummyResult::class);
+        $resultStub = self::createMock(DummyResult::class);
 
         $dbi = $this->getMockBuilder(DatabaseInterface::class)
             ->disableOriginalConstructor()
             ->getMock();
 
-        $dbi->expects($this->exactly(2))
+        $dbi->expects(self::exactly(2))
             ->method('fetchResult')
             ->willReturn(
                 [],
                 ['fieldname' => ['values' => 'test-', 'transformation' => 'testfoo', 'mimetype' => 'test<']],
             );
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('getTableIndexes')
             ->with('database', '')
             ->willReturn($keys);
 
         $column = new Column('fieldname', '', false, '', null, '');
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('getColumns')
             ->with('database', '')
             ->willReturn([$column]);
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('tryQueryAsControlUser')
             ->willReturn($resultStub);
 
-        $resultStub->expects($this->once())
+        $resultStub->expects(self::once())
             ->method('numRows')
             ->willReturn(1);
 
-        $resultStub->expects($this->once())
+        $resultStub->expects(self::once())
             ->method('fetchAssoc')
             ->willReturn(['comment' => 'testComment']);
 
         DatabaseInterface::$instance = $dbi;
         $this->object->relation = new Relation($dbi);
 
-        $this->object->expects($this->exactly(3))
+        $this->object->expects(self::exactly(3))
             ->method('formatOneColumnDefinition')
             ->with($column, ['name1'])
             ->willReturn('1');
@@ -438,7 +438,7 @@ class ExportHtmlwordTest extends AbstractTestCase
 
         $result = $this->object->getTableDef('database', '', true, true, true);
 
-        $this->assertEquals(
+        self::assertEquals(
             '<table width="100%" cellspacing="1">' .
             '<tr class="print-category"><th class="print">Column</th>' .
             '<td class="print"><strong>Type</strong></td>' .
@@ -452,40 +452,40 @@ class ExportHtmlwordTest extends AbstractTestCase
 
         // case 2
 
-        $resultStub = $this->createMock(DummyResult::class);
+        $resultStub = self::createMock(DummyResult::class);
 
         $dbi = $this->getMockBuilder(DatabaseInterface::class)
             ->disableOriginalConstructor()
             ->getMock();
 
-        $dbi->expects($this->exactly(2))
+        $dbi->expects(self::exactly(2))
             ->method('fetchResult')
             ->willReturn(
                 ['fieldname' => ['foreign_table' => 'ftable', 'foreign_field' => 'ffield']],
                 ['field' => ['values' => 'test-', 'transformation' => 'testfoo', 'mimetype' => 'test<']],
             );
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('getTableIndexes')
             ->with('database', '')
             ->willReturn($keys);
 
         $column = new Column('fieldname', '', false, '', null, '');
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('getColumns')
             ->with('database', '')
             ->willReturn([$column]);
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('tryQueryAsControlUser')
             ->willReturn($resultStub);
 
-        $resultStub->expects($this->once())
+        $resultStub->expects(self::once())
             ->method('numRows')
             ->willReturn(1);
 
-        $resultStub->expects($this->once())
+        $resultStub->expects(self::once())
             ->method('fetchAssoc')
             ->willReturn(['comment' => 'testComment']);
 
@@ -504,9 +504,9 @@ class ExportHtmlwordTest extends AbstractTestCase
 
         $result = $this->object->getTableDef('database', '', true, true, true);
 
-        $this->assertStringContainsString('<td class="print">ftable (ffield)</td>', $result);
+        self::assertStringContainsString('<td class="print">ftable (ffield)</td>', $result);
 
-        $this->assertStringContainsString('<td class="print"></td><td class="print"></td>', $result);
+        self::assertStringContainsString('<td class="print"></td><td class="print"></td>', $result);
 
         // case 3
 
@@ -514,19 +514,19 @@ class ExportHtmlwordTest extends AbstractTestCase
             ->disableOriginalConstructor()
             ->getMock();
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('getTableIndexes')
             ->with('database', '')
             ->willReturn($keys);
 
         $column = new Column('fieldname', '', false, '', null, '');
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('getColumns')
             ->with('database', '')
             ->willReturn([$column]);
 
-        $dbi->expects($this->never())
+        $dbi->expects(self::never())
             ->method('tryQuery');
 
         DatabaseInterface::$instance = $dbi;
@@ -540,7 +540,7 @@ class ExportHtmlwordTest extends AbstractTestCase
 
         $result = $this->object->getTableDef('database', '', false, false, false);
 
-        $this->assertEquals(
+        self::assertEquals(
             '<table width="100%" cellspacing="1">' .
             '<tr class="print-category"><th class="print">Column</th>' .
             '<td class="print"><strong>Type</strong></td>' .
@@ -566,7 +566,7 @@ class ExportHtmlwordTest extends AbstractTestCase
         $method = new ReflectionMethod(ExportHtmlword::class, 'getTriggers');
         $result = $method->invoke($this->object, $triggers);
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             '<td class="print">tna&quot;me</td>' .
             '<td class="print">BEFORE</td>' .
             '<td class="print">UPDATE</td>' .
@@ -579,7 +579,7 @@ class ExportHtmlwordTest extends AbstractTestCase
     {
         ob_start();
         $this->dummyDbi->addSelectDb('test_db');
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportStructure(
                 'test_db',
                 'test_table',
@@ -590,7 +590,7 @@ class ExportHtmlwordTest extends AbstractTestCase
         $this->dummyDbi->assertAllSelectsConsumed();
         $result = ob_get_clean();
 
-        $this->assertEquals(
+        self::assertEquals(
             '<h2>Table structure for table test_table</h2>'
             . '<table width="100%" cellspacing="1"><tr class="print-category">'
             . '<th class="print">Column</th><td class="print"><strong>Type</strong></td>'
@@ -605,7 +605,7 @@ class ExportHtmlwordTest extends AbstractTestCase
         );
 
         ob_start();
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportStructure(
                 'test_db',
                 'test_table',
@@ -615,7 +615,7 @@ class ExportHtmlwordTest extends AbstractTestCase
         );
         $result = ob_get_clean();
 
-        $this->assertEquals(
+        self::assertEquals(
             '<h2>Triggers test_table</h2><table width="100%" cellspacing="1">'
             . '<tr class="print-category"><th class="print">Name</th>'
             . '<td class="print"><strong>Time</strong></td><td class="print"><strong>Event</strong></td>'
@@ -627,7 +627,7 @@ class ExportHtmlwordTest extends AbstractTestCase
 
         ob_start();
         $this->dummyDbi->addSelectDb('test_db');
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportStructure(
                 'test_db',
                 'test_table',
@@ -638,7 +638,7 @@ class ExportHtmlwordTest extends AbstractTestCase
         $this->dummyDbi->assertAllSelectsConsumed();
         $result = ob_get_clean();
 
-        $this->assertEquals(
+        self::assertEquals(
             '<h2>Structure for view test_table</h2>'
             . '<table width="100%" cellspacing="1"><tr class="print-category">'
             . '<th class="print">Column</th><td class="print"><strong>Type</strong></td>'
@@ -653,7 +653,7 @@ class ExportHtmlwordTest extends AbstractTestCase
         );
 
         ob_start();
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportStructure(
                 'test_db',
                 'test_table',
@@ -663,7 +663,7 @@ class ExportHtmlwordTest extends AbstractTestCase
         );
         $result = ob_get_clean();
 
-        $this->assertEquals(
+        self::assertEquals(
             '<h2>Stand-in structure for view test_table</h2>'
             . '<table width="100%" cellspacing="1"><tr class="print-category">'
             . '<th class="print">Column</th><td class="print"><strong>Type</strong></td>'
@@ -687,7 +687,7 @@ class ExportHtmlwordTest extends AbstractTestCase
 
         $uniqueKeys = ['field'];
 
-        $this->assertEquals(
+        self::assertEquals(
             '<tr class="print-category"><td class="print"><em>' .
             '<strong>field</strong></em></td><td class="print">set(abc)</td>' .
             '<td class="print">Yes</td><td class="print">NULL</td>',
@@ -698,7 +698,7 @@ class ExportHtmlwordTest extends AbstractTestCase
 
         $uniqueKeys = ['field'];
 
-        $this->assertEquals(
+        self::assertEquals(
             '<tr class="print-category"><td class="print">fields</td>' .
             '<td class="print">&amp;nbsp;</td><td class="print">No</td>' .
             '<td class="print">def</td>',
diff --git a/tests/classes/Plugins/Export/ExportJsonTest.php b/tests/classes/Plugins/Export/ExportJsonTest.php
index fb77c97022..b0835913c3 100644
--- a/tests/classes/Plugins/Export/ExportJsonTest.php
+++ b/tests/classes/Plugins/Export/ExportJsonTest.php
@@ -65,33 +65,33 @@ class ExportJsonTest extends AbstractTestCase
         $attrProperties = new ReflectionProperty(ExportJson::class, 'properties');
         $properties = $attrProperties->getValue($this->object);
 
-        $this->assertInstanceOf(ExportPluginProperties::class, $properties);
+        self::assertInstanceOf(ExportPluginProperties::class, $properties);
 
-        $this->assertEquals(
+        self::assertEquals(
             'JSON',
             $properties->getText(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'json',
             $properties->getExtension(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'text/plain',
             $properties->getMimeType(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'Options',
             $properties->getOptionsText(),
         );
 
         $options = $properties->getOptions();
 
-        $this->assertInstanceOf(OptionsPropertyRootGroup::class, $options);
+        self::assertInstanceOf(OptionsPropertyRootGroup::class, $options);
 
-        $this->assertEquals(
+        self::assertEquals(
             'Format Specific Options',
             $options->getName(),
         );
@@ -99,9 +99,9 @@ class ExportJsonTest extends AbstractTestCase
         $generalOptionsArray = $options->getProperties();
         $generalOptions = $generalOptionsArray->current();
 
-        $this->assertInstanceOf(OptionsPropertyMainGroup::class, $generalOptions);
+        self::assertInstanceOf(OptionsPropertyMainGroup::class, $generalOptions);
 
-        $this->assertEquals(
+        self::assertEquals(
             'general_opts',
             $generalOptions->getName(),
         );
@@ -110,9 +110,9 @@ class ExportJsonTest extends AbstractTestCase
 
         $property = $generalProperties->current();
 
-        $this->assertInstanceOf(HiddenPropertyItem::class, $property);
+        self::assertInstanceOf(HiddenPropertyItem::class, $property);
 
-        $this->assertEquals(
+        self::assertEquals(
             'structure_or_data',
             $property->getName(),
         );
@@ -127,7 +127,7 @@ class ExportJsonTest extends AbstractTestCase
             . "\n",
         );
 
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportHeader(),
         );
     }
@@ -136,7 +136,7 @@ class ExportJsonTest extends AbstractTestCase
     {
         $this->expectOutputString(']' . "\n");
 
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportFooter(),
         );
     }
@@ -145,21 +145,21 @@ class ExportJsonTest extends AbstractTestCase
     {
         $this->expectOutputString('{"type":"database","name":"testDB"},' . "\n");
 
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportDBHeader('testDB'),
         );
     }
 
     public function testExportDBFooter(): void
     {
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportDBFooter('testDB'),
         );
     }
 
     public function testExportDBCreate(): void
     {
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportDBCreate('testDB', 'database'),
         );
     }
@@ -176,7 +176,7 @@ class ExportJsonTest extends AbstractTestCase
             . '}' . "\n",
         );
 
-        $this->assertTrue($this->object->exportData(
+        self::assertTrue($this->object->exportData(
             'test_db',
             'test_table',
             'localhost',
@@ -198,7 +198,7 @@ class ExportJsonTest extends AbstractTestCase
             . "]\n}\n",
         );
 
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportData(
                 'test_db',
                 'test_table_complex',
@@ -221,7 +221,7 @@ class ExportJsonTest extends AbstractTestCase
             . "]\n}\n",
         );
 
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportRawQuery(
                 'example.com',
                 null,
diff --git a/tests/classes/Plugins/Export/ExportLatexTest.php b/tests/classes/Plugins/Export/ExportLatexTest.php
index 08753fc0f8..fb20549e45 100644
--- a/tests/classes/Plugins/Export/ExportLatexTest.php
+++ b/tests/classes/Plugins/Export/ExportLatexTest.php
@@ -90,33 +90,33 @@ class ExportLatexTest extends AbstractTestCase
         $method = new ReflectionMethod(ExportLatex::class, 'setProperties');
         $properties = $method->invoke($this->object, null);
 
-        $this->assertInstanceOf(ExportPluginProperties::class, $properties);
+        self::assertInstanceOf(ExportPluginProperties::class, $properties);
 
-        $this->assertEquals(
+        self::assertEquals(
             'LaTeX',
             $properties->getText(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'tex',
             $properties->getExtension(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'application/x-tex',
             $properties->getMimeType(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'Options',
             $properties->getOptionsText(),
         );
 
         $options = $properties->getOptions();
 
-        $this->assertInstanceOf(OptionsPropertyRootGroup::class, $options);
+        self::assertInstanceOf(OptionsPropertyRootGroup::class, $options);
 
-        $this->assertEquals(
+        self::assertEquals(
             'Format Specific Options',
             $options->getName(),
         );
@@ -126,9 +126,9 @@ class ExportLatexTest extends AbstractTestCase
         $generalOptions = $generalOptionsArray->current();
         $generalOptionsArray->next();
 
-        $this->assertInstanceOf(OptionsPropertyMainGroup::class, $generalOptions);
+        self::assertInstanceOf(OptionsPropertyMainGroup::class, $generalOptions);
 
-        $this->assertEquals(
+        self::assertEquals(
             'general_opts',
             $generalOptions->getName(),
         );
@@ -137,14 +137,14 @@ class ExportLatexTest extends AbstractTestCase
 
         $property = $generalProperties->current();
 
-        $this->assertInstanceOf(BoolPropertyItem::class, $property);
+        self::assertInstanceOf(BoolPropertyItem::class, $property);
 
-        $this->assertEquals(
+        self::assertEquals(
             'caption',
             $property->getName(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'Include table caption',
             $property->getText(),
         );
@@ -152,14 +152,14 @@ class ExportLatexTest extends AbstractTestCase
         $generalOptions = $generalOptionsArray->current();
         $generalOptionsArray->next();
 
-        $this->assertInstanceOf(OptionsPropertyMainGroup::class, $generalOptions);
+        self::assertInstanceOf(OptionsPropertyMainGroup::class, $generalOptions);
 
-        $this->assertEquals(
+        self::assertEquals(
             'dump_what',
             $generalOptions->getName(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'Dump table',
             $generalOptions->getText(),
         );
@@ -168,14 +168,14 @@ class ExportLatexTest extends AbstractTestCase
 
         $property = $generalProperties->current();
 
-        $this->assertInstanceOf(RadioPropertyItem::class, $property);
+        self::assertInstanceOf(RadioPropertyItem::class, $property);
 
-        $this->assertEquals(
+        self::assertEquals(
             'structure_or_data',
             $property->getName(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             ['structure' => __('structure'), 'data' => __('data'), 'structure_and_data' => __('structure and data')],
             $property->getValues(),
         );
@@ -184,19 +184,19 @@ class ExportLatexTest extends AbstractTestCase
         $generalOptions = $generalOptionsArray->current();
         $generalOptionsArray->next();
 
-        $this->assertInstanceOf(OptionsPropertyMainGroup::class, $generalOptions);
+        self::assertInstanceOf(OptionsPropertyMainGroup::class, $generalOptions);
 
-        $this->assertEquals(
+        self::assertEquals(
             'structure',
             $generalOptions->getName(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'Object creation options',
             $generalOptions->getText(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'data',
             $generalOptions->getForce(),
         );
@@ -206,19 +206,19 @@ class ExportLatexTest extends AbstractTestCase
         $property = $generalProperties->current();
         $generalProperties->next();
 
-        $this->assertInstanceOf(TextPropertyItem::class, $property);
+        self::assertInstanceOf(TextPropertyItem::class, $property);
 
-        $this->assertEquals(
+        self::assertEquals(
             'structure_caption',
             $property->getName(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'Table caption:',
             $property->getText(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'faq6-27',
             $property->getDoc(),
         );
@@ -226,19 +226,19 @@ class ExportLatexTest extends AbstractTestCase
         $property = $generalProperties->current();
         $generalProperties->next();
 
-        $this->assertInstanceOf(TextPropertyItem::class, $property);
+        self::assertInstanceOf(TextPropertyItem::class, $property);
 
-        $this->assertEquals(
+        self::assertEquals(
             'structure_continued_caption',
             $property->getName(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'Table caption (continued):',
             $property->getText(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'faq6-27',
             $property->getDoc(),
         );
@@ -246,19 +246,19 @@ class ExportLatexTest extends AbstractTestCase
         $property = $generalProperties->current();
         $generalProperties->next();
 
-        $this->assertInstanceOf(TextPropertyItem::class, $property);
+        self::assertInstanceOf(TextPropertyItem::class, $property);
 
-        $this->assertEquals(
+        self::assertEquals(
             'structure_label',
             $property->getName(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'Label key:',
             $property->getText(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'faq6-27',
             $property->getDoc(),
         );
@@ -266,14 +266,14 @@ class ExportLatexTest extends AbstractTestCase
         $property = $generalProperties->current();
         $generalProperties->next();
 
-        $this->assertInstanceOf(BoolPropertyItem::class, $property);
+        self::assertInstanceOf(BoolPropertyItem::class, $property);
 
-        $this->assertEquals(
+        self::assertEquals(
             'relation',
             $property->getName(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'Display foreign key relationships',
             $property->getText(),
         );
@@ -281,28 +281,28 @@ class ExportLatexTest extends AbstractTestCase
         $property = $generalProperties->current();
         $generalProperties->next();
 
-        $this->assertInstanceOf(BoolPropertyItem::class, $property);
+        self::assertInstanceOf(BoolPropertyItem::class, $property);
 
-        $this->assertEquals(
+        self::assertEquals(
             'comments',
             $property->getName(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'Display comments',
             $property->getText(),
         );
 
         $property = $generalProperties->current();
 
-        $this->assertInstanceOf(BoolPropertyItem::class, $property);
+        self::assertInstanceOf(BoolPropertyItem::class, $property);
 
-        $this->assertEquals(
+        self::assertEquals(
             'mime',
             $property->getName(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'Display media types',
             $property->getText(),
         );
@@ -310,19 +310,19 @@ class ExportLatexTest extends AbstractTestCase
         // data options
         $generalOptions = $generalOptionsArray->current();
 
-        $this->assertInstanceOf(OptionsPropertyMainGroup::class, $generalOptions);
+        self::assertInstanceOf(OptionsPropertyMainGroup::class, $generalOptions);
 
-        $this->assertEquals(
+        self::assertEquals(
             'data',
             $generalOptions->getName(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'Data dump options',
             $generalOptions->getText(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'structure',
             $generalOptions->getForce(),
         );
@@ -332,14 +332,14 @@ class ExportLatexTest extends AbstractTestCase
         $property = $generalProperties->current();
         $generalProperties->next();
 
-        $this->assertInstanceOf(BoolPropertyItem::class, $property);
+        self::assertInstanceOf(BoolPropertyItem::class, $property);
 
-        $this->assertEquals(
+        self::assertEquals(
             'columns',
             $property->getName(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'Put columns names in the first row:',
             $property->getText(),
         );
@@ -347,19 +347,19 @@ class ExportLatexTest extends AbstractTestCase
         $property = $generalProperties->current();
         $generalProperties->next();
 
-        $this->assertInstanceOf(TextPropertyItem::class, $property);
+        self::assertInstanceOf(TextPropertyItem::class, $property);
 
-        $this->assertEquals(
+        self::assertEquals(
             'data_caption',
             $property->getName(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'Table caption:',
             $property->getText(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'faq6-27',
             $property->getDoc(),
         );
@@ -367,19 +367,19 @@ class ExportLatexTest extends AbstractTestCase
         $property = $generalProperties->current();
         $generalProperties->next();
 
-        $this->assertInstanceOf(TextPropertyItem::class, $property);
+        self::assertInstanceOf(TextPropertyItem::class, $property);
 
-        $this->assertEquals(
+        self::assertEquals(
             'data_continued_caption',
             $property->getName(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'Table caption (continued):',
             $property->getText(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'faq6-27',
             $property->getDoc(),
         );
@@ -387,33 +387,33 @@ class ExportLatexTest extends AbstractTestCase
         $property = $generalProperties->current();
         $generalProperties->next();
 
-        $this->assertInstanceOf(TextPropertyItem::class, $property);
+        self::assertInstanceOf(TextPropertyItem::class, $property);
 
-        $this->assertEquals(
+        self::assertEquals(
             'data_label',
             $property->getName(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'Label key:',
             $property->getText(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'faq6-27',
             $property->getDoc(),
         );
 
         $property = $generalProperties->current();
 
-        $this->assertInstanceOf(TextPropertyItem::class, $property);
+        self::assertInstanceOf(TextPropertyItem::class, $property);
 
-        $this->assertEquals(
+        self::assertEquals(
             'null',
             $property->getName(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'Replace NULL with:',
             $property->getText(),
         );
@@ -426,7 +426,7 @@ class ExportLatexTest extends AbstractTestCase
 
         $generalOptionsArray = $options->getProperties();
 
-        $this->assertCount(4, $generalOptionsArray);
+        self::assertCount(4, $generalOptionsArray);
     }
 
     public function testExportHeader(): void
@@ -436,19 +436,19 @@ class ExportLatexTest extends AbstractTestCase
         $config->selectedServer['host'] = 'localhost';
 
         ob_start();
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportHeader(),
         );
         $result = ob_get_clean();
 
-        $this->assertIsString($result);
+        self::assertIsString($result);
 
-        $this->assertStringContainsString("\n% Host: localhost:80", $result);
+        self::assertStringContainsString("\n% Host: localhost:80", $result);
     }
 
     public function testExportFooter(): void
     {
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportFooter(),
         );
     }
@@ -457,21 +457,21 @@ class ExportLatexTest extends AbstractTestCase
     {
         $this->expectOutputString("% \n% Database: 'testDB'\n% \n");
 
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportDBHeader('testDB'),
         );
     }
 
     public function testExportDBFooter(): void
     {
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportDBFooter('testDB'),
         );
     }
 
     public function testExportDBCreate(): void
     {
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportDBCreate('testDB', 'database'),
         );
     }
@@ -489,7 +489,7 @@ class ExportLatexTest extends AbstractTestCase
         $config->selectedServer['verbose'] = 'verb';
 
         ob_start();
-        $this->assertTrue($this->object->exportData(
+        self::assertTrue($this->object->exportData(
             'test_db',
             'test_table',
             'localhost',
@@ -497,7 +497,7 @@ class ExportLatexTest extends AbstractTestCase
         ));
         $result = ob_get_clean();
 
-        $this->assertEquals(
+        self::assertEquals(
             "\n" . '%' . "\n" .
             '% Data: test_table' . "\n" .
             '%' . "\n" .
@@ -520,7 +520,7 @@ class ExportLatexTest extends AbstractTestCase
         unset($GLOBALS['latex_columns']);
 
         ob_start();
-        $this->assertTrue($this->object->exportData(
+        self::assertTrue($this->object->exportData(
             'test_db',
             'test_table',
             'localhost',
@@ -528,8 +528,8 @@ class ExportLatexTest extends AbstractTestCase
         ));
         $result = ob_get_clean();
 
-        $this->assertIsString($result);
-        $this->assertEquals(
+        self::assertIsString($result);
+        self::assertEquals(
             "\n" . '%' . "\n" .
             '% Data: test_table' . "\n" .
             '%' . "\n" .
@@ -550,18 +550,18 @@ class ExportLatexTest extends AbstractTestCase
 
         // case 1
 
-        $resultStub = $this->createMock(DummyResult::class);
+        $resultStub = self::createMock(DummyResult::class);
 
         $dbi = $this->getMockBuilder(DatabaseInterface::class)
             ->disableOriginalConstructor()
             ->getMock();
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('getTableIndexes')
             ->with('database', '')
             ->willReturn($keys);
 
-        $dbi->expects($this->exactly(2))
+        $dbi->expects(self::exactly(2))
             ->method('fetchResult')
             ->willReturn(
                 [],
@@ -572,20 +572,20 @@ class ExportLatexTest extends AbstractTestCase
             new Column('name1', 'set(abc)enum123', true, 'PRI', null, ''),
             new Column('fields', '', false, 'COMP', 'def', ''),
         ];
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('getColumns')
             ->with('database', '')
             ->willReturn($columns);
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('tryQueryAsControlUser')
             ->willReturn($resultStub);
 
-        $resultStub->expects($this->once())
+        $resultStub->expects(self::once())
             ->method('numRows')
             ->willReturn(1);
 
-        $resultStub->expects($this->once())
+        $resultStub->expects(self::once())
             ->method('fetchAssoc')
             ->willReturn(['comment' => 'testComment']);
 
@@ -606,7 +606,7 @@ class ExportLatexTest extends AbstractTestCase
         (new ReflectionProperty(Relation::class, 'cache'))->setValue(null, $relationParameters);
 
         ob_start();
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportStructure(
                 'database',
                 '',
@@ -620,7 +620,7 @@ class ExportLatexTest extends AbstractTestCase
         $result = ob_get_clean();
 
         //echo $result; die;
-        $this->assertEquals(
+        self::assertEquals(
             "\n" . '%' . "\n" .
             '% Structure: ' . "\n" .
             '%' . "\n" .
@@ -645,38 +645,38 @@ class ExportLatexTest extends AbstractTestCase
 
         // case 2
 
-        $resultStub = $this->createMock(DummyResult::class);
+        $resultStub = self::createMock(DummyResult::class);
 
         $dbi = $this->getMockBuilder(DatabaseInterface::class)
             ->disableOriginalConstructor()
             ->getMock();
 
-        $dbi->expects($this->exactly(2))
+        $dbi->expects(self::exactly(2))
             ->method('fetchResult')
             ->willReturn(
                 ['name1' => ['foreign_table' => 'ftable', 'foreign_field' => 'ffield'], 'foreign_keys_data' => []],
                 ['field' => ['values' => 'test-', 'transformation' => 'testfoo', 'mimetype' => 'test<']],
             );
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('getTableIndexes')
             ->with('database', '')
             ->willReturn($keys);
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('getColumns')
             ->with('database', '')
             ->willReturn($columns);
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('tryQueryAsControlUser')
             ->willReturn($resultStub);
 
-        $resultStub->expects($this->once())
+        $resultStub->expects(self::once())
             ->method('numRows')
             ->willReturn(1);
 
-        $resultStub->expects($this->once())
+        $resultStub->expects(self::once())
             ->method('fetchAssoc')
             ->willReturn(['comment' => 'testComment']);
 
@@ -694,7 +694,7 @@ class ExportLatexTest extends AbstractTestCase
         (new ReflectionProperty(Relation::class, 'cache'))->setValue(null, $relationParameters);
 
         ob_start();
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportStructure(
                 'database',
                 '',
@@ -707,9 +707,9 @@ class ExportLatexTest extends AbstractTestCase
         );
         $result = ob_get_clean();
 
-        $this->assertIsString($result);
+        self::assertIsString($result);
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             '\\textbf{\\textit{name1}} & set(abc) & Yes & NULL & ' .
             'ftable (ffield) &  &  \\\\ \\hline',
             $result,
@@ -721,17 +721,17 @@ class ExportLatexTest extends AbstractTestCase
             ->disableOriginalConstructor()
             ->getMock();
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('getTableIndexes')
             ->with('database', '')
             ->willReturn($keys);
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('getColumns')
             ->with('database', '')
             ->willReturn($columns);
 
-        $dbi->expects($this->never())
+        $dbi->expects(self::never())
             ->method('tryQuery');
 
         DatabaseInterface::$instance = $dbi;
@@ -752,7 +752,7 @@ class ExportLatexTest extends AbstractTestCase
         (new ReflectionProperty(Relation::class, 'cache'))->setValue(null, $relationParameters);
 
         ob_start();
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportStructure(
                 'database',
                 '',
@@ -762,14 +762,14 @@ class ExportLatexTest extends AbstractTestCase
         );
         $result = ob_get_clean();
 
-        $this->assertIsString($result);
+        self::assertIsString($result);
 
-        $this->assertStringContainsString('\\caption{latexstructure} \\label{latexlabel}', $result);
+        self::assertStringContainsString('\\caption{latexstructure} \\label{latexlabel}', $result);
 
-        $this->assertStringContainsString('caption{latexcontinued}', $result);
+        self::assertStringContainsString('caption{latexcontinued}', $result);
 
         // case 4
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportStructure(
                 'database',
                 '',
@@ -781,7 +781,7 @@ class ExportLatexTest extends AbstractTestCase
 
     public function testTexEscape(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             '\\$\\%\\{foo\\&bar\\}\\#\\_\\^',
             ExportLatex::texEscape('$%{foo&bar}#_^'),
         );
diff --git a/tests/classes/Plugins/Export/ExportMediawikiTest.php b/tests/classes/Plugins/Export/ExportMediawikiTest.php
index f264007b79..48ac62620c 100644
--- a/tests/classes/Plugins/Export/ExportMediawikiTest.php
+++ b/tests/classes/Plugins/Export/ExportMediawikiTest.php
@@ -76,33 +76,33 @@ class ExportMediawikiTest extends AbstractTestCase
         $attrProperties = new ReflectionProperty(ExportMediawiki::class, 'properties');
         $properties = $attrProperties->getValue($this->object);
 
-        $this->assertInstanceOf(ExportPluginProperties::class, $properties);
+        self::assertInstanceOf(ExportPluginProperties::class, $properties);
 
-        $this->assertEquals(
+        self::assertEquals(
             'MediaWiki Table',
             $properties->getText(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'mediawiki',
             $properties->getExtension(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'text/plain',
             $properties->getMimeType(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'Options',
             $properties->getOptionsText(),
         );
 
         $options = $properties->getOptions();
 
-        $this->assertInstanceOf(OptionsPropertyRootGroup::class, $options);
+        self::assertInstanceOf(OptionsPropertyRootGroup::class, $options);
 
-        $this->assertEquals(
+        self::assertEquals(
             'Format Specific Options',
             $options->getName(),
         );
@@ -110,14 +110,14 @@ class ExportMediawikiTest extends AbstractTestCase
         $generalOptionsArray = $options->getProperties();
         $generalOptions = $generalOptionsArray->current();
 
-        $this->assertInstanceOf(OptionsPropertyMainGroup::class, $generalOptions);
+        self::assertInstanceOf(OptionsPropertyMainGroup::class, $generalOptions);
 
-        $this->assertEquals(
+        self::assertEquals(
             'general_opts',
             $generalOptions->getName(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'Dump table',
             $generalOptions->getText(),
         );
@@ -127,28 +127,28 @@ class ExportMediawikiTest extends AbstractTestCase
         $property = $generalProperties->current();
         $generalProperties->next();
 
-        $this->assertInstanceOf(OptionsPropertySubgroup::class, $property);
+        self::assertInstanceOf(OptionsPropertySubgroup::class, $property);
 
-        $this->assertEquals(
+        self::assertEquals(
             'dump_table',
             $property->getName(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'Dump table',
             $property->getText(),
         );
 
         $sgHeader = $property->getSubgroupHeader();
 
-        $this->assertInstanceOf(RadioPropertyItem::class, $sgHeader);
+        self::assertInstanceOf(RadioPropertyItem::class, $sgHeader);
 
-        $this->assertEquals(
+        self::assertEquals(
             'structure_or_data',
             $sgHeader->getName(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             ['structure' => __('structure'), 'data' => __('data'), 'structure_and_data' => __('structure and data')],
             $sgHeader->getValues(),
         );
@@ -156,28 +156,28 @@ class ExportMediawikiTest extends AbstractTestCase
         $property = $generalProperties->current();
         $generalProperties->next();
 
-        $this->assertInstanceOf(BoolPropertyItem::class, $property);
+        self::assertInstanceOf(BoolPropertyItem::class, $property);
 
-        $this->assertEquals(
+        self::assertEquals(
             'caption',
             $property->getName(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'Export table names',
             $property->getText(),
         );
 
         $property = $generalProperties->current();
 
-        $this->assertInstanceOf(BoolPropertyItem::class, $property);
+        self::assertInstanceOf(BoolPropertyItem::class, $property);
 
-        $this->assertEquals(
+        self::assertEquals(
             'headers',
             $property->getName(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'Export table headers',
             $property->getText(),
         );
@@ -185,35 +185,35 @@ class ExportMediawikiTest extends AbstractTestCase
 
     public function testExportHeader(): void
     {
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportHeader(),
         );
     }
 
     public function testExportFooter(): void
     {
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportFooter(),
         );
     }
 
     public function testExportDBHeader(): void
     {
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportDBHeader('testDB'),
         );
     }
 
     public function testExportDBFooter(): void
     {
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportDBFooter('testDB'),
         );
     }
 
     public function testExportDBCreate(): void
     {
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportDBCreate('testDB', 'database'),
         );
     }
@@ -232,7 +232,7 @@ class ExportMediawikiTest extends AbstractTestCase
             new Column('fields', '', false, 'COMP', 'def', 'ext'),
         ];
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('getColumns')
             ->with('db', 'table')
             ->willReturn($columns);
@@ -242,7 +242,7 @@ class ExportMediawikiTest extends AbstractTestCase
         $GLOBALS['mediawiki_headers'] = true;
 
         ob_start();
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportStructure(
                 'db',
                 'table',
@@ -252,7 +252,7 @@ class ExportMediawikiTest extends AbstractTestCase
         );
         $result = ob_get_clean();
 
-        $this->assertEquals(
+        self::assertEquals(
             "\n<!--\n" .
             "Table structure for `table`\n" .
             "-->\n" .
@@ -290,7 +290,7 @@ class ExportMediawikiTest extends AbstractTestCase
         $GLOBALS['mediawiki_headers'] = true;
 
         ob_start();
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportData(
                 'test_db',
                 'test_table',
@@ -300,7 +300,7 @@ class ExportMediawikiTest extends AbstractTestCase
         );
         $result = ob_get_clean();
 
-        $this->assertEquals(
+        self::assertEquals(
             "\n<!--\n" .
             "Table data for `test_table`\n" .
             "-->\n" .
diff --git a/tests/classes/Plugins/Export/ExportOdsTest.php b/tests/classes/Plugins/Export/ExportOdsTest.php
index 5fa39001b1..ef3afb6e09 100644
--- a/tests/classes/Plugins/Export/ExportOdsTest.php
+++ b/tests/classes/Plugins/Export/ExportOdsTest.php
@@ -82,37 +82,37 @@ class ExportOdsTest extends AbstractTestCase
         $attrProperties = new ReflectionProperty(ExportOds::class, 'properties');
         $properties = $attrProperties->getValue($this->object);
 
-        $this->assertInstanceOf(ExportPluginProperties::class, $properties);
+        self::assertInstanceOf(ExportPluginProperties::class, $properties);
 
-        $this->assertEquals(
+        self::assertEquals(
             'OpenDocument Spreadsheet',
             $properties->getText(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'ods',
             $properties->getExtension(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'application/vnd.oasis.opendocument.spreadsheet',
             $properties->getMimeType(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'Options',
             $properties->getOptionsText(),
         );
 
-        $this->assertTrue(
+        self::assertTrue(
             $properties->getForceFile(),
         );
 
         $options = $properties->getOptions();
 
-        $this->assertInstanceOf(OptionsPropertyRootGroup::class, $options);
+        self::assertInstanceOf(OptionsPropertyRootGroup::class, $options);
 
-        $this->assertEquals(
+        self::assertEquals(
             'Format Specific Options',
             $options->getName(),
         );
@@ -120,9 +120,9 @@ class ExportOdsTest extends AbstractTestCase
         $generalOptionsArray = $options->getProperties();
         $generalOptions = $generalOptionsArray->current();
 
-        $this->assertInstanceOf(OptionsPropertyMainGroup::class, $generalOptions);
+        self::assertInstanceOf(OptionsPropertyMainGroup::class, $generalOptions);
 
-        $this->assertEquals(
+        self::assertEquals(
             'general_opts',
             $generalOptions->getName(),
         );
@@ -132,14 +132,14 @@ class ExportOdsTest extends AbstractTestCase
         $property = $generalProperties->current();
         $generalProperties->next();
 
-        $this->assertInstanceOf(TextPropertyItem::class, $property);
+        self::assertInstanceOf(TextPropertyItem::class, $property);
 
-        $this->assertEquals(
+        self::assertEquals(
             'null',
             $property->getName(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'Replace NULL with:',
             $property->getText(),
         );
@@ -147,23 +147,23 @@ class ExportOdsTest extends AbstractTestCase
         $property = $generalProperties->current();
         $generalProperties->next();
 
-        $this->assertInstanceOf(BoolPropertyItem::class, $property);
+        self::assertInstanceOf(BoolPropertyItem::class, $property);
 
-        $this->assertEquals(
+        self::assertEquals(
             'columns',
             $property->getName(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'Put columns names in the first row',
             $property->getText(),
         );
 
         $property = $generalProperties->current();
 
-        $this->assertInstanceOf(HiddenPropertyItem::class, $property);
+        self::assertInstanceOf(HiddenPropertyItem::class, $property);
 
-        $this->assertEquals(
+        self::assertEquals(
             'structure_or_data',
             $property->getName(),
         );
@@ -171,9 +171,9 @@ class ExportOdsTest extends AbstractTestCase
 
     public function testExportHeader(): void
     {
-        $this->assertArrayHasKey('ods_buffer', $GLOBALS);
+        self::assertArrayHasKey('ods_buffer', $GLOBALS);
 
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportHeader(),
         );
     }
@@ -181,32 +181,32 @@ class ExportOdsTest extends AbstractTestCase
     public function testExportFooter(): void
     {
         $GLOBALS['ods_buffer'] = 'header';
-        $this->assertTrue($this->object->exportFooter());
+        self::assertTrue($this->object->exportFooter());
         $output = $this->getActualOutputForAssertion();
-        $this->assertMatchesRegularExpression('/^504b.*636f6e74656e742e786d6c/', bin2hex($output));
-        $this->assertStringContainsString('header', $GLOBALS['ods_buffer']);
-        $this->assertStringContainsString('</office:spreadsheet>', $GLOBALS['ods_buffer']);
-        $this->assertStringContainsString('</office:body>', $GLOBALS['ods_buffer']);
-        $this->assertStringContainsString('</office:document-content>', $GLOBALS['ods_buffer']);
+        self::assertMatchesRegularExpression('/^504b.*636f6e74656e742e786d6c/', bin2hex($output));
+        self::assertStringContainsString('header', $GLOBALS['ods_buffer']);
+        self::assertStringContainsString('</office:spreadsheet>', $GLOBALS['ods_buffer']);
+        self::assertStringContainsString('</office:body>', $GLOBALS['ods_buffer']);
+        self::assertStringContainsString('</office:document-content>', $GLOBALS['ods_buffer']);
     }
 
     public function testExportDBHeader(): void
     {
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportDBHeader('testDB'),
         );
     }
 
     public function testExportDBFooter(): void
     {
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportDBFooter('testDB'),
         );
     }
 
     public function testExportDBCreate(): void
     {
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportDBCreate('testDB', 'database'),
         );
     }
@@ -231,23 +231,23 @@ class ExportOdsTest extends AbstractTestCase
             FieldHelper::fromArray(['type' => MYSQLI_TYPE_DECIMAL]),
             FieldHelper::fromArray(['type' => MYSQLI_TYPE_STRING]),
         ];
-        $resultStub = $this->createMock(DummyResult::class);
+        $resultStub = self::createMock(DummyResult::class);
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('getFieldsMeta')
             ->with($resultStub)
             ->willReturn($fields);
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('query')
             ->with('SELECT', ConnectionType::User, DatabaseInterface::QUERY_UNBUFFERED)
             ->willReturn($resultStub);
 
-        $resultStub->expects($this->once())
+        $resultStub->expects(self::once())
             ->method('numFields')
             ->willReturn(8);
 
-        $resultStub->expects($this->exactly(2))
+        $resultStub->expects(self::exactly(2))
             ->method('fetchRow')
             ->willReturn(
                 [null, '01-01-2000', '01-01-2000', '01-01-2000 10:00:00', '01-01-2014 10:02:00', 't>s', 'a&b', '<'],
@@ -260,7 +260,7 @@ class ExportOdsTest extends AbstractTestCase
         $GLOBALS['what'] = 'foo';
         $GLOBALS['foo_null'] = '&';
 
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportData(
                 'db',
                 'table',
@@ -269,7 +269,7 @@ class ExportOdsTest extends AbstractTestCase
             ),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             '<table:table table:name="table"><table:table-row><table:table-cell ' .
             'office:value-type="string"><text:p>&amp;</text:p></table:table-cell>' .
             '<table:table-cell office:value-type="string"><text:p></text:p>' .
@@ -309,23 +309,23 @@ class ExportOdsTest extends AbstractTestCase
             ]),
         ];
 
-        $resultStub = $this->createMock(DummyResult::class);
+        $resultStub = self::createMock(DummyResult::class);
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('getFieldsMeta')
             ->with($resultStub)
             ->willReturn($fields);
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('query')
             ->with('SELECT', ConnectionType::User, DatabaseInterface::QUERY_UNBUFFERED)
             ->willReturn($resultStub);
 
-        $resultStub->expects($this->once())
+        $resultStub->expects(self::once())
             ->method('numFields')
             ->willReturn(2);
 
-        $resultStub->expects($this->exactly(1))
+        $resultStub->expects(self::exactly(1))
             ->method('fetchRow')
             ->willReturn([]);
 
@@ -336,7 +336,7 @@ class ExportOdsTest extends AbstractTestCase
         $GLOBALS['foo_null'] = '&';
         $GLOBALS['foo_columns'] = true;
 
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportData(
                 'db',
                 'table',
@@ -345,7 +345,7 @@ class ExportOdsTest extends AbstractTestCase
             ),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             '<table:table table:name="table"><table:table-row><table:table-cell ' .
             'office:value-type="string"><text:p>fna\&quot;me</text:p></table:table' .
             '-cell><table:table-cell office:value-type="string"><text:p>' .
@@ -361,23 +361,23 @@ class ExportOdsTest extends AbstractTestCase
 
         $flags = [];
 
-        $resultStub = $this->createMock(DummyResult::class);
+        $resultStub = self::createMock(DummyResult::class);
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('getFieldsMeta')
             ->with($resultStub)
             ->willReturn($flags);
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('query')
             ->with('SELECT', ConnectionType::User, DatabaseInterface::QUERY_UNBUFFERED)
             ->willReturn($resultStub);
 
-        $resultStub->expects($this->once())
+        $resultStub->expects(self::once())
             ->method('numFields')
             ->willReturn(0);
 
-        $resultStub->expects($this->once())
+        $resultStub->expects(self::once())
             ->method('fetchRow')
             ->willReturn([]);
 
@@ -388,7 +388,7 @@ class ExportOdsTest extends AbstractTestCase
         $GLOBALS['foo_null'] = '&';
         $GLOBALS['ods_buffer'] = '';
 
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportData(
                 'db',
                 'table',
@@ -397,7 +397,7 @@ class ExportOdsTest extends AbstractTestCase
             ),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             '<table:table table:name="table"><table:table-row></table:table-row></table:table>',
             $GLOBALS['ods_buffer'],
         );
diff --git a/tests/classes/Plugins/Export/ExportOdtTest.php b/tests/classes/Plugins/Export/ExportOdtTest.php
index a46a2b6568..a8ba7e13f5 100644
--- a/tests/classes/Plugins/Export/ExportOdtTest.php
+++ b/tests/classes/Plugins/Export/ExportOdtTest.php
@@ -108,37 +108,37 @@ class ExportOdtTest extends AbstractTestCase
         $method = new ReflectionMethod(ExportOdt::class, 'setProperties');
         $properties = $method->invoke($this->object, null);
 
-        $this->assertInstanceOf(ExportPluginProperties::class, $properties);
+        self::assertInstanceOf(ExportPluginProperties::class, $properties);
 
-        $this->assertEquals(
+        self::assertEquals(
             'OpenDocument Text',
             $properties->getText(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'odt',
             $properties->getExtension(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'application/vnd.oasis.opendocument.text',
             $properties->getMimeType(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'Options',
             $properties->getOptionsText(),
         );
 
-        $this->assertTrue(
+        self::assertTrue(
             $properties->getForceFile(),
         );
 
         $options = $properties->getOptions();
 
-        $this->assertInstanceOf(OptionsPropertyRootGroup::class, $options);
+        self::assertInstanceOf(OptionsPropertyRootGroup::class, $options);
 
-        $this->assertEquals(
+        self::assertEquals(
             'Format Specific Options',
             $options->getName(),
         );
@@ -148,14 +148,14 @@ class ExportOdtTest extends AbstractTestCase
         $generalOptions = $generalOptionsArray->current();
         $generalOptionsArray->next();
 
-        $this->assertInstanceOf(OptionsPropertyMainGroup::class, $generalOptions);
+        self::assertInstanceOf(OptionsPropertyMainGroup::class, $generalOptions);
 
-        $this->assertEquals(
+        self::assertEquals(
             'general_opts',
             $generalOptions->getName(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'Dump table',
             $generalOptions->getText(),
         );
@@ -164,14 +164,14 @@ class ExportOdtTest extends AbstractTestCase
 
         $property = $generalProperties->current();
 
-        $this->assertInstanceOf(RadioPropertyItem::class, $property);
+        self::assertInstanceOf(RadioPropertyItem::class, $property);
 
-        $this->assertEquals(
+        self::assertEquals(
             'structure_or_data',
             $property->getName(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             ['structure' => __('structure'), 'data' => __('data'), 'structure_and_data' => __('structure and data')],
             $property->getValues(),
         );
@@ -179,19 +179,19 @@ class ExportOdtTest extends AbstractTestCase
         $generalOptions = $generalOptionsArray->current();
         $generalOptionsArray->next();
 
-        $this->assertInstanceOf(OptionsPropertyMainGroup::class, $generalOptions);
+        self::assertInstanceOf(OptionsPropertyMainGroup::class, $generalOptions);
 
-        $this->assertEquals(
+        self::assertEquals(
             'structure',
             $generalOptions->getName(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'Object creation options',
             $generalOptions->getText(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'data',
             $generalOptions->getForce(),
         );
@@ -201,14 +201,14 @@ class ExportOdtTest extends AbstractTestCase
         $property = $generalProperties->current();
         $generalProperties->next();
 
-        $this->assertInstanceOf(BoolPropertyItem::class, $property);
+        self::assertInstanceOf(BoolPropertyItem::class, $property);
 
-        $this->assertEquals(
+        self::assertEquals(
             'relation',
             $property->getName(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'Display foreign key relationships',
             $property->getText(),
         );
@@ -216,28 +216,28 @@ class ExportOdtTest extends AbstractTestCase
         $property = $generalProperties->current();
         $generalProperties->next();
 
-        $this->assertInstanceOf(BoolPropertyItem::class, $property);
+        self::assertInstanceOf(BoolPropertyItem::class, $property);
 
-        $this->assertEquals(
+        self::assertEquals(
             'comments',
             $property->getName(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'Display comments',
             $property->getText(),
         );
 
         $property = $generalProperties->current();
 
-        $this->assertInstanceOf(BoolPropertyItem::class, $property);
+        self::assertInstanceOf(BoolPropertyItem::class, $property);
 
-        $this->assertEquals(
+        self::assertEquals(
             'mime',
             $property->getName(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'Display media types',
             $property->getText(),
         );
@@ -245,19 +245,19 @@ class ExportOdtTest extends AbstractTestCase
         // hide structure
         $generalOptions = $generalOptionsArray->current();
 
-        $this->assertInstanceOf(OptionsPropertyMainGroup::class, $generalOptions);
+        self::assertInstanceOf(OptionsPropertyMainGroup::class, $generalOptions);
 
-        $this->assertEquals(
+        self::assertEquals(
             'data',
             $generalOptions->getName(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'Data dump options',
             $generalOptions->getText(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'structure',
             $generalOptions->getForce(),
         );
@@ -267,28 +267,28 @@ class ExportOdtTest extends AbstractTestCase
         $property = $generalProperties->current();
         $generalProperties->next();
 
-        $this->assertInstanceOf(BoolPropertyItem::class, $property);
+        self::assertInstanceOf(BoolPropertyItem::class, $property);
 
-        $this->assertEquals(
+        self::assertEquals(
             'columns',
             $property->getName(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'Put columns names in the first row',
             $property->getText(),
         );
 
         $property = $generalProperties->current();
 
-        $this->assertInstanceOf(TextPropertyItem::class, $property);
+        self::assertInstanceOf(TextPropertyItem::class, $property);
 
-        $this->assertEquals(
+        self::assertEquals(
             'null',
             $property->getName(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'Replace NULL with:',
             $property->getText(),
         );
@@ -301,27 +301,27 @@ class ExportOdtTest extends AbstractTestCase
 
         $generalOptionsArray = $options->getProperties();
 
-        $this->assertCount(3, $generalOptionsArray);
+        self::assertCount(3, $generalOptionsArray);
     }
 
     public function testExportHeader(): void
     {
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportHeader(),
         );
 
-        $this->assertStringContainsString('<office:document-content', $GLOBALS['odt_buffer']);
-        $this->assertStringContainsString('office:version', $GLOBALS['odt_buffer']);
+        self::assertStringContainsString('<office:document-content', $GLOBALS['odt_buffer']);
+        self::assertStringContainsString('office:version', $GLOBALS['odt_buffer']);
     }
 
     public function testExportFooter(): void
     {
         $GLOBALS['odt_buffer'] = 'header';
-        $this->assertTrue($this->object->exportFooter());
+        self::assertTrue($this->object->exportFooter());
         $output = $this->getActualOutputForAssertion();
-        $this->assertMatchesRegularExpression('/^504b.*636f6e74656e742e786d6c/', bin2hex($output));
-        $this->assertStringContainsString('header', $GLOBALS['odt_buffer']);
-        $this->assertStringContainsString(
+        self::assertMatchesRegularExpression('/^504b.*636f6e74656e742e786d6c/', bin2hex($output));
+        self::assertStringContainsString('header', $GLOBALS['odt_buffer']);
+        self::assertStringContainsString(
             '</office:text></office:body></office:document-content>',
             $GLOBALS['odt_buffer'],
         );
@@ -331,25 +331,25 @@ class ExportOdtTest extends AbstractTestCase
     {
         $GLOBALS['odt_buffer'] = 'header';
 
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportDBHeader('d&b'),
         );
 
-        $this->assertStringContainsString('header', $GLOBALS['odt_buffer']);
+        self::assertStringContainsString('header', $GLOBALS['odt_buffer']);
 
-        $this->assertStringContainsString('Database d&amp;b</text:h>', $GLOBALS['odt_buffer']);
+        self::assertStringContainsString('Database d&amp;b</text:h>', $GLOBALS['odt_buffer']);
     }
 
     public function testExportDBFooter(): void
     {
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportDBFooter('testDB'),
         );
     }
 
     public function testExportDBCreate(): void
     {
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportDBCreate('testDB', 'database'),
         );
     }
@@ -370,23 +370,23 @@ class ExportOdtTest extends AbstractTestCase
             FieldHelper::fromArray(['type' => MYSQLI_TYPE_DECIMAL, 'flags' => MYSQLI_NUM_FLAG]),
             FieldHelper::fromArray(['type' => MYSQLI_TYPE_STRING]),
         ];
-        $resultStub = $this->createMock(DummyResult::class);
+        $resultStub = self::createMock(DummyResult::class);
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('getFieldsMeta')
             ->with($resultStub)
             ->willReturn($fields);
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('query')
             ->with('SELECT', ConnectionType::User, DatabaseInterface::QUERY_UNBUFFERED)
             ->willReturn($resultStub);
 
-        $resultStub->expects($this->once())
+        $resultStub->expects(self::once())
             ->method('numFields')
             ->willReturn(4);
 
-        $resultStub->expects($this->exactly(2))
+        $resultStub->expects(self::exactly(2))
             ->method('fetchRow')
             ->willReturn([null, 'a<b', 'a>b', 'a&b'], []);
 
@@ -395,7 +395,7 @@ class ExportOdtTest extends AbstractTestCase
         $GLOBALS['foo_null'] = '&';
         unset($GLOBALS['foo_columns']);
 
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportData(
                 'db',
                 'ta<ble',
@@ -404,7 +404,7 @@ class ExportOdtTest extends AbstractTestCase
             ),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             '<text:h text:outline-level="2" text:style-name="Heading_2" ' .
             'text:is-list-header="true">Dumping data for table ta&lt;ble</text:h>' .
             '<table:table table:name="ta&lt;ble_structure"><table:table-column ' .
@@ -439,23 +439,23 @@ class ExportOdtTest extends AbstractTestCase
             ]),
         ];
 
-        $resultStub = $this->createMock(DummyResult::class);
+        $resultStub = self::createMock(DummyResult::class);
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('getFieldsMeta')
             ->with($resultStub)
             ->willReturn($fields);
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('query')
             ->with('SELECT', ConnectionType::User, DatabaseInterface::QUERY_UNBUFFERED)
             ->willReturn($resultStub);
 
-        $resultStub->expects($this->once())
+        $resultStub->expects(self::once())
             ->method('numFields')
             ->willReturn(2);
 
-        $resultStub->expects($this->exactly(1))
+        $resultStub->expects(self::exactly(1))
             ->method('fetchRow')
             ->willReturn([]);
 
@@ -464,7 +464,7 @@ class ExportOdtTest extends AbstractTestCase
         $GLOBALS['foo_null'] = '&';
         $GLOBALS['foo_columns'] = true;
 
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportData(
                 'db',
                 'table',
@@ -473,7 +473,7 @@ class ExportOdtTest extends AbstractTestCase
             ),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             '<text:h text:outline-level="2" text:style-name="Heading_2" text:' .
             'is-list-header="true">Dumping data for table table</text:h><table:' .
             'table table:name="table_structure"><table:table-column table:number-' .
@@ -491,23 +491,23 @@ class ExportOdtTest extends AbstractTestCase
 
         $flags = [];
 
-        $resultStub = $this->createMock(DummyResult::class);
+        $resultStub = self::createMock(DummyResult::class);
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('getFieldsMeta')
             ->with($resultStub)
             ->willReturn($flags);
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('query')
             ->with('SELECT', ConnectionType::User, DatabaseInterface::QUERY_UNBUFFERED)
             ->willReturn($resultStub);
 
-        $resultStub->expects($this->once())
+        $resultStub->expects(self::once())
             ->method('numFields')
             ->willReturn(0);
 
-        $resultStub->expects($this->once())
+        $resultStub->expects(self::once())
             ->method('fetchRow')
             ->willReturn([]);
 
@@ -518,7 +518,7 @@ class ExportOdtTest extends AbstractTestCase
         $GLOBALS['foo_null'] = '&';
         $GLOBALS['odt_buffer'] = '';
 
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportData(
                 'db',
                 'table',
@@ -527,7 +527,7 @@ class ExportOdtTest extends AbstractTestCase
             ),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             '<text:h text:outline-level="2" text:style-name="Heading_2" ' .
             'text:is-list-header="true">Dumping data for table table</text:h>' .
             '<table:table table:name="table_structure"><table:table-column ' .
@@ -540,13 +540,13 @@ class ExportOdtTest extends AbstractTestCase
     public function testGetTableDefStandIn(): void
     {
         $this->dummyDbi->addSelectDb('test_db');
-        $this->assertSame(
+        self::assertSame(
             $this->object->getTableDefStandIn('test_db', 'test_table'),
             '',
         );
         $this->dummyDbi->assertAllSelectsConsumed();
 
-        $this->assertEquals(
+        self::assertEquals(
             '<table:table table:name="test_table_data">'
             . '<table:table-column table:number-columns-repeated="4"/><table:table-row>'
             . '<table:table-cell office:value-type="string"><text:p>Column</text:p>'
@@ -582,13 +582,13 @@ class ExportOdtTest extends AbstractTestCase
 
         // case 1
 
-        $resultStub = $this->createMock(DummyResult::class);
+        $resultStub = self::createMock(DummyResult::class);
 
         $dbi = $this->getMockBuilder(DatabaseInterface::class)
             ->disableOriginalConstructor()
             ->getMock();
 
-        $dbi->expects($this->exactly(2))
+        $dbi->expects(self::exactly(2))
             ->method('fetchResult')
             ->willReturn(
                 [],
@@ -596,27 +596,27 @@ class ExportOdtTest extends AbstractTestCase
             );
 
         $column = new Column('fieldname', '', false, '', null, '');
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('getColumns')
             ->with('database', '')
             ->willReturn([$column]);
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('tryQueryAsControlUser')
             ->willReturn($resultStub);
 
-        $resultStub->expects($this->once())
+        $resultStub->expects(self::once())
             ->method('numRows')
             ->willReturn(1);
 
-        $resultStub->expects($this->once())
+        $resultStub->expects(self::once())
             ->method('fetchAssoc')
             ->willReturn(['comment' => 'testComment']);
 
         DatabaseInterface::$instance = $dbi;
         $this->object->relation = new Relation($dbi);
 
-        $this->object->expects($this->exactly(2))
+        $this->object->expects(self::exactly(2))
             ->method('formatOneColumnDefinition')
             ->with($column)
             ->willReturn('1');
@@ -631,7 +631,7 @@ class ExportOdtTest extends AbstractTestCase
         ]);
         (new ReflectionProperty(Relation::class, 'cache'))->setValue(null, $relationParameters);
 
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->getTableDef(
                 'database',
                 '',
@@ -641,22 +641,22 @@ class ExportOdtTest extends AbstractTestCase
             ),
         );
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             '<table:table table:name="_structure"><table:table-column table:number-columns-repeated="6"/>',
             $GLOBALS['odt_buffer'],
         );
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             '<table:table-cell office:value-type="string"><text:p>Comments</text:p></table:table-cell>',
             $GLOBALS['odt_buffer'],
         );
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             '<table:table-cell office:value-type="string"><text:p>Media type</text:p></table:table-cell>',
             $GLOBALS['odt_buffer'],
         );
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             '</table:table-row>1<table:table-cell office:value-type="string">' .
             '<text:p></text:p></table:table-cell><table:table-cell office:value-' .
             'type="string"><text:p>Test&lt;</text:p></table:table-cell>' .
@@ -666,13 +666,13 @@ class ExportOdtTest extends AbstractTestCase
 
         // case 2
 
-        $resultStub = $this->createMock(DummyResult::class);
+        $resultStub = self::createMock(DummyResult::class);
 
         $dbi = $this->getMockBuilder(DatabaseInterface::class)
             ->disableOriginalConstructor()
             ->getMock();
 
-        $dbi->expects($this->exactly(2))
+        $dbi->expects(self::exactly(2))
             ->method('fetchResult')
             ->willReturn(
                 ['fieldname' => ['foreign_table' => 'ftable', 'foreign_field' => 'ffield']],
@@ -680,20 +680,20 @@ class ExportOdtTest extends AbstractTestCase
             );
 
         $column = new Column('fieldname', '', false, '', null, '');
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('getColumns')
             ->with('database', '')
             ->willReturn([$column]);
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('tryQueryAsControlUser')
             ->willReturn($resultStub);
 
-        $resultStub->expects($this->once())
+        $resultStub->expects(self::once())
             ->method('numRows')
             ->willReturn(1);
 
-        $resultStub->expects($this->once())
+        $resultStub->expects(self::once())
             ->method('fetchAssoc')
             ->willReturn(['comment' => 'testComment']);
 
@@ -710,7 +710,7 @@ class ExportOdtTest extends AbstractTestCase
         ]);
         (new ReflectionProperty(Relation::class, 'cache'))->setValue(null, $relationParameters);
 
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->getTableDef(
                 'database',
                 '',
@@ -720,7 +720,7 @@ class ExportOdtTest extends AbstractTestCase
             ),
         );
 
-        $this->assertStringContainsString('<text:p>ftable (ffield)</text:p>', $GLOBALS['odt_buffer']);
+        self::assertStringContainsString('<text:p>ftable (ffield)</text:p>', $GLOBALS['odt_buffer']);
     }
 
     public function testGetTriggers(): void
@@ -739,24 +739,24 @@ class ExportOdtTest extends AbstractTestCase
         $method = new ReflectionMethod(ExportOdt::class, 'getTriggers');
         $result = $method->invoke($this->object, 'ta<ble', $triggers);
 
-        $this->assertSame($result, $GLOBALS['odt_buffer']);
+        self::assertSame($result, $GLOBALS['odt_buffer']);
 
-        $this->assertStringContainsString('<table:table table:name="ta&lt;ble_triggers">', $result);
+        self::assertStringContainsString('<table:table table:name="ta&lt;ble_triggers">', $result);
 
-        $this->assertStringContainsString('<text:p>tna&quot;me</text:p>', $result);
+        self::assertStringContainsString('<text:p>tna&quot;me</text:p>', $result);
 
-        $this->assertStringContainsString('<text:p>AFTER</text:p>', $result);
+        self::assertStringContainsString('<text:p>AFTER</text:p>', $result);
 
-        $this->assertStringContainsString('<text:p>INSERT</text:p>', $result);
+        self::assertStringContainsString('<text:p>INSERT</text:p>', $result);
 
-        $this->assertStringContainsString('<text:p>def</text:p>', $result);
+        self::assertStringContainsString('<text:p>def</text:p>', $result);
     }
 
     public function testExportStructure(): void
     {
         // case 1
         $this->dummyDbi->addSelectDb('test_db');
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportStructure(
                 'test_db',
                 'test_table',
@@ -766,7 +766,7 @@ class ExportOdtTest extends AbstractTestCase
         );
         $this->dummyDbi->assertAllSelectsConsumed();
 
-        $this->assertEquals(
+        self::assertEquals(
             '<text:h text:outline-level="2" text:style-name="Heading_2" text:is-list-header="true">'
             . 'Table structure for table test_table</text:h><table:table table:name="test_table_structure">'
             . '<table:table-column table:number-columns-repeated="4"/><table:table-row>'
@@ -796,7 +796,7 @@ class ExportOdtTest extends AbstractTestCase
         // case 2
         $GLOBALS['odt_buffer'] = '';
 
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportStructure(
                 'test_db',
                 'test_table',
@@ -805,7 +805,7 @@ class ExportOdtTest extends AbstractTestCase
             ),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             '<text:h text:outline-level="2" text:style-name="Heading_2" text:is-list-header="true">'
             . 'Triggers test_table</text:h><table:table table:name="test_table_triggers">'
             . '<table:table-column table:number-columns-repeated="4"/><table:table-row>'
@@ -826,7 +826,7 @@ class ExportOdtTest extends AbstractTestCase
         $GLOBALS['odt_buffer'] = '';
 
         $this->dummyDbi->addSelectDb('test_db');
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportStructure(
                 'test_db',
                 'test_table',
@@ -836,7 +836,7 @@ class ExportOdtTest extends AbstractTestCase
         );
         $this->dummyDbi->assertAllSelectsConsumed();
 
-        $this->assertEquals(
+        self::assertEquals(
             '<text:h text:outline-level="2" text:style-name="Heading_2" text:is-list-header="true">'
             . 'Structure for view test_table</text:h><table:table table:name="test_table_structure">'
             . '<table:table-column table:number-columns-repeated="4"/><table:table-row>'
@@ -866,7 +866,7 @@ class ExportOdtTest extends AbstractTestCase
         // case 4
         $this->dummyDbi->addSelectDb('test_db');
         $GLOBALS['odt_buffer'] = '';
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportStructure(
                 'test_db',
                 'test_table',
@@ -876,7 +876,7 @@ class ExportOdtTest extends AbstractTestCase
         );
         $this->dummyDbi->assertAllSelectsConsumed();
 
-        $this->assertEquals(
+        self::assertEquals(
             '<text:h text:outline-level="2" text:style-name="Heading_2" text:is-list-header="true">'
             . 'Stand-in structure for view test_table</text:h><table:table table:name="test_table_data">'
             . '<table:table-column table:number-columns-repeated="4"/><table:table-row>'
@@ -912,7 +912,7 @@ class ExportOdtTest extends AbstractTestCase
 
         $colAlias = 'alias';
 
-        $this->assertEquals(
+        self::assertEquals(
             '<table:table-row><table:table-cell office:value-type="string">' .
             '<text:p>alias</text:p></table:table-cell><table:table-cell off' .
             'ice:value-type="string"><text:p>set(abc)</text:p></table:table' .
@@ -924,7 +924,7 @@ class ExportOdtTest extends AbstractTestCase
 
         $column = new Column('fields', '', false, 'COMP', 'def', '');
 
-        $this->assertEquals(
+        self::assertEquals(
             '<table:table-row><table:table-cell office:value-type="string">' .
             '<text:p>fields</text:p></table:table-cell><table:table-cell off' .
             'ice:value-type="string"><text:p>&amp;nbsp;</text:p></table:table' .
diff --git a/tests/classes/Plugins/Export/ExportPdfTest.php b/tests/classes/Plugins/Export/ExportPdfTest.php
index 6959469a15..26448b2d05 100644
--- a/tests/classes/Plugins/Export/ExportPdfTest.php
+++ b/tests/classes/Plugins/Export/ExportPdfTest.php
@@ -68,37 +68,37 @@ class ExportPdfTest extends AbstractTestCase
         $attrProperties = new ReflectionProperty(ExportPdf::class, 'properties');
         $properties = $attrProperties->getValue($this->object);
 
-        $this->assertInstanceOf(ExportPluginProperties::class, $properties);
+        self::assertInstanceOf(ExportPluginProperties::class, $properties);
 
-        $this->assertEquals(
+        self::assertEquals(
             'PDF',
             $properties->getText(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'pdf',
             $properties->getExtension(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'application/pdf',
             $properties->getMimeType(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'Options',
             $properties->getOptionsText(),
         );
 
-        $this->assertTrue(
+        self::assertTrue(
             $properties->getForceFile(),
         );
 
         $options = $properties->getOptions();
 
-        $this->assertInstanceOf(OptionsPropertyRootGroup::class, $options);
+        self::assertInstanceOf(OptionsPropertyRootGroup::class, $options);
 
-        $this->assertEquals(
+        self::assertEquals(
             'Format Specific Options',
             $options->getName(),
         );
@@ -108,9 +108,9 @@ class ExportPdfTest extends AbstractTestCase
         $generalOptions = $generalOptionsArray->current();
         $generalOptionsArray->next();
 
-        $this->assertInstanceOf(OptionsPropertyMainGroup::class, $generalOptions);
+        self::assertInstanceOf(OptionsPropertyMainGroup::class, $generalOptions);
 
-        $this->assertEquals(
+        self::assertEquals(
             'general_opts',
             $generalOptions->getName(),
         );
@@ -119,23 +119,23 @@ class ExportPdfTest extends AbstractTestCase
 
         $property = $generalProperties->current();
 
-        $this->assertInstanceOf(TextPropertyItem::class, $property);
+        self::assertInstanceOf(TextPropertyItem::class, $property);
 
-        $this->assertEquals(
+        self::assertEquals(
             'report_title',
             $property->getName(),
         );
 
         $generalOptions = $generalOptionsArray->current();
 
-        $this->assertInstanceOf(OptionsPropertyMainGroup::class, $generalOptions);
+        self::assertInstanceOf(OptionsPropertyMainGroup::class, $generalOptions);
 
-        $this->assertEquals(
+        self::assertEquals(
             'dump_what',
             $generalOptions->getName(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'Dump table',
             $generalOptions->getText(),
         );
@@ -144,14 +144,14 @@ class ExportPdfTest extends AbstractTestCase
 
         $property = $generalProperties->current();
 
-        $this->assertInstanceOf(RadioPropertyItem::class, $property);
+        self::assertInstanceOf(RadioPropertyItem::class, $property);
 
-        $this->assertEquals(
+        self::assertEquals(
             'structure_or_data',
             $property->getName(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             ['structure' => __('structure'), 'data' => __('data'), 'structure_and_data' => __('structure and data')],
             $property->getValues(),
         );
@@ -163,16 +163,16 @@ class ExportPdfTest extends AbstractTestCase
             ->disableOriginalConstructor()
             ->getMock();
 
-        $pdf->expects($this->once())
+        $pdf->expects(self::once())
             ->method('Open');
 
-        $pdf->expects($this->once())
+        $pdf->expects(self::once())
             ->method('setTopMargin');
 
         $attrPdf = new ReflectionProperty(ExportPdf::class, 'pdf');
         $attrPdf->setValue($this->object, $pdf);
 
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportHeader(),
         );
     }
@@ -183,35 +183,35 @@ class ExportPdfTest extends AbstractTestCase
             ->disableOriginalConstructor()
             ->getMock();
 
-        $pdf->expects($this->once())
+        $pdf->expects(self::once())
             ->method('getPDFData')
             ->willReturn('');
 
         $attrPdf = new ReflectionProperty(ExportPdf::class, 'pdf');
         $attrPdf->setValue($this->object, $pdf);
 
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportFooter(),
         );
     }
 
     public function testExportDBHeader(): void
     {
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportDBHeader('testDB'),
         );
     }
 
     public function testExportDBFooter(): void
     {
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportDBFooter('testDB'),
         );
     }
 
     public function testExportDBCreate(): void
     {
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportDBCreate('testDB', 'database'),
         );
     }
@@ -222,14 +222,14 @@ class ExportPdfTest extends AbstractTestCase
             ->disableOriginalConstructor()
             ->getMock();
 
-        $pdf->expects($this->once())
+        $pdf->expects(self::once())
             ->method('mysqlReport')
             ->with('SELECT');
 
         $attrPdf = new ReflectionProperty(ExportPdf::class, 'pdf');
         $attrPdf->setValue($this->object, $pdf);
 
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportData(
                 'db',
                 'table',
@@ -250,7 +250,7 @@ class ExportPdfTest extends AbstractTestCase
         $setter->invoke($this->object, new Pdf());
 
         $getter = new ReflectionMethod(ExportPdf::class, 'getPdf');
-        $this->assertInstanceOf(
+        self::assertInstanceOf(
             Pdf::class,
             $getter->invoke($this->object),
         );
diff --git a/tests/classes/Plugins/Export/ExportPhparrayTest.php b/tests/classes/Plugins/Export/ExportPhparrayTest.php
index acc0fa946d..c7f763b990 100644
--- a/tests/classes/Plugins/Export/ExportPhparrayTest.php
+++ b/tests/classes/Plugins/Export/ExportPhparrayTest.php
@@ -71,33 +71,33 @@ class ExportPhparrayTest extends AbstractTestCase
         $attrProperties = new ReflectionProperty(ExportPhparray::class, 'properties');
         $properties = $attrProperties->getValue($this->object);
 
-        $this->assertInstanceOf(ExportPluginProperties::class, $properties);
+        self::assertInstanceOf(ExportPluginProperties::class, $properties);
 
-        $this->assertEquals(
+        self::assertEquals(
             'PHP array',
             $properties->getText(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'php',
             $properties->getExtension(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'text/plain',
             $properties->getMimeType(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'Options',
             $properties->getOptionsText(),
         );
 
         $options = $properties->getOptions();
 
-        $this->assertInstanceOf(OptionsPropertyRootGroup::class, $options);
+        self::assertInstanceOf(OptionsPropertyRootGroup::class, $options);
 
-        $this->assertEquals(
+        self::assertEquals(
             'Format Specific Options',
             $options->getName(),
         );
@@ -105,9 +105,9 @@ class ExportPhparrayTest extends AbstractTestCase
         $generalOptionsArray = $options->getProperties();
         $generalOptions = $generalOptionsArray->current();
 
-        $this->assertInstanceOf(OptionsPropertyMainGroup::class, $generalOptions);
+        self::assertInstanceOf(OptionsPropertyMainGroup::class, $generalOptions);
 
-        $this->assertEquals(
+        self::assertEquals(
             'general_opts',
             $generalOptions->getName(),
         );
@@ -116,25 +116,25 @@ class ExportPhparrayTest extends AbstractTestCase
 
         $property = $generalProperties->current();
 
-        $this->assertInstanceOf(HiddenPropertyItem::class, $property);
+        self::assertInstanceOf(HiddenPropertyItem::class, $property);
     }
 
     public function testExportHeader(): void
     {
         ob_start();
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportHeader(),
         );
         $result = ob_get_clean();
 
-        $this->assertIsString($result);
+        self::assertIsString($result);
 
-        $this->assertStringContainsString('<?php' . "\n", $result);
+        self::assertStringContainsString('<?php' . "\n", $result);
     }
 
     public function testExportFooter(): void
     {
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportFooter(),
         );
     }
@@ -142,26 +142,26 @@ class ExportPhparrayTest extends AbstractTestCase
     public function testExportDBHeader(): void
     {
         ob_start();
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportDBHeader('db'),
         );
         $result = ob_get_clean();
 
-        $this->assertIsString($result);
+        self::assertIsString($result);
 
-        $this->assertStringContainsString("/**\n * Database `db`\n */", $result);
+        self::assertStringContainsString("/**\n * Database `db`\n */", $result);
     }
 
     public function testExportDBFooter(): void
     {
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportDBFooter('testDB'),
         );
     }
 
     public function testExportDBCreate(): void
     {
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportDBCreate('testDB', 'database'),
         );
     }
@@ -169,7 +169,7 @@ class ExportPhparrayTest extends AbstractTestCase
     public function testExportData(): void
     {
         ob_start();
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportData(
                 'test_db',
                 'test_table',
@@ -179,7 +179,7 @@ class ExportPhparrayTest extends AbstractTestCase
         );
         $result = ob_get_clean();
 
-        $this->assertEquals(
+        self::assertEquals(
             "\n" . '/* `test_db`.`test_table` */' . "\n" .
             '$test_table = array(' . "\n" .
             '  array(\'id\' => \'1\',\'name\' => \'abcd\',\'datetimefield\' => \'2011-01-20 02:00:02\'),' . "\n" .
@@ -191,7 +191,7 @@ class ExportPhparrayTest extends AbstractTestCase
 
         // case 2: test invalid variable name fix
         ob_start();
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportData(
                 'test_db',
                 '0`932table',
@@ -201,8 +201,8 @@ class ExportPhparrayTest extends AbstractTestCase
         );
         $result = ob_get_clean();
 
-        $this->assertIsString($result);
-        $this->assertEquals(
+        self::assertIsString($result);
+        self::assertEquals(
             "\n" . '/* `test_db`.`0``932table` */' . "\n" .
             '$_0_932table = array(' . "\n" .
             '  array(\'id\' => \'1\',\'name\' => \'abcd\',\'datetimefield\' => \'2011-01-20 02:00:02\'),' . "\n" .
diff --git a/tests/classes/Plugins/Export/ExportSqlTest.php b/tests/classes/Plugins/Export/ExportSqlTest.php
index c6ed039886..7e179b7aef 100644
--- a/tests/classes/Plugins/Export/ExportSqlTest.php
+++ b/tests/classes/Plugins/Export/ExportSqlTest.php
@@ -103,9 +103,9 @@ class ExportSqlTest extends AbstractTestCase
         $method = new ReflectionMethod(ExportSql::class, 'setProperties');
         $properties = $method->invoke($this->object, null);
 
-        $this->assertInstanceOf(ExportPluginProperties::class, $properties);
-        $this->assertEquals('SQL', $properties->getText());
-        $this->assertNull($properties->getOptions());
+        self::assertInstanceOf(ExportPluginProperties::class, $properties);
+        self::assertEquals('SQL', $properties->getText());
+        self::assertNull($properties->getOptions());
     }
 
     #[Group('medium')]
@@ -116,7 +116,7 @@ class ExportSqlTest extends AbstractTestCase
             ->disableOriginalConstructor()
             ->getMock();
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('getCompatibilities')
             ->willReturn(['v1', 'v2']);
 
@@ -136,28 +136,28 @@ class ExportSqlTest extends AbstractTestCase
         $method = new ReflectionMethod(ExportSql::class, 'setProperties');
         $properties = $method->invoke($this->object, null);
 
-        $this->assertInstanceOf(ExportPluginProperties::class, $properties);
-        $this->assertEquals('SQL', $properties->getText());
+        self::assertInstanceOf(ExportPluginProperties::class, $properties);
+        self::assertEquals('SQL', $properties->getText());
 
         $options = $properties->getOptions();
 
-        $this->assertInstanceOf(OptionsPropertyRootGroup::class, $options);
+        self::assertInstanceOf(OptionsPropertyRootGroup::class, $options);
 
         $generalOptionsArray = $options->getProperties();
 
         $generalOptions = $generalOptionsArray->current();
         $generalOptionsArray->next();
 
-        $this->assertInstanceOf(OptionsPropertyMainGroup::class, $generalOptions);
+        self::assertInstanceOf(OptionsPropertyMainGroup::class, $generalOptions);
 
         $properties = $generalOptions->getProperties();
 
         $property = $properties->current();
         $properties->next();
 
-        $this->assertInstanceOf(OptionsPropertySubgroup::class, $property);
+        self::assertInstanceOf(OptionsPropertySubgroup::class, $property);
 
-        $this->assertInstanceOf(
+        self::assertInstanceOf(
             BoolPropertyItem::class,
             $property->getSubgroupHeader(),
         );
@@ -166,49 +166,49 @@ class ExportSqlTest extends AbstractTestCase
 
         $leaf = $leaves->current();
         $leaves->next();
-        $this->assertInstanceOf(TextPropertyItem::class, $leaf);
+        self::assertInstanceOf(TextPropertyItem::class, $leaf);
 
         $leaf = $leaves->current();
         $leaves->next();
-        $this->assertInstanceOf(BoolPropertyItem::class, $leaf);
+        self::assertInstanceOf(BoolPropertyItem::class, $leaf);
 
         $leaf = $leaves->current();
         $leaves->next();
-        $this->assertInstanceOf(BoolPropertyItem::class, $leaf);
+        self::assertInstanceOf(BoolPropertyItem::class, $leaf);
 
         $leaf = $leaves->current();
         $leaves->next();
-        $this->assertInstanceOf(BoolPropertyItem::class, $leaf);
+        self::assertInstanceOf(BoolPropertyItem::class, $leaf);
 
         $property = $properties->current();
         $properties->next();
-        $this->assertInstanceOf(BoolPropertyItem::class, $property);
+        self::assertInstanceOf(BoolPropertyItem::class, $property);
 
         $property = $properties->current();
         $properties->next();
-        $this->assertInstanceOf(BoolPropertyItem::class, $property);
+        self::assertInstanceOf(BoolPropertyItem::class, $property);
 
         $property = $properties->current();
         $properties->next();
-        $this->assertInstanceOf(BoolPropertyItem::class, $property);
+        self::assertInstanceOf(BoolPropertyItem::class, $property);
 
         $property = $properties->current();
         $properties->next();
-        $this->assertInstanceOf(BoolPropertyItem::class, $property);
+        self::assertInstanceOf(BoolPropertyItem::class, $property);
 
         $property = $properties->current();
         $properties->next();
-        $this->assertInstanceOf(SelectPropertyItem::class, $property);
+        self::assertInstanceOf(SelectPropertyItem::class, $property);
 
-        $this->assertEquals(
+        self::assertEquals(
             ['v1' => 'v1', 'v2' => 'v2'],
             $property->getValues(),
         );
 
         $property = $properties->current();
-        $this->assertInstanceOf(OptionsPropertySubgroup::class, $property);
+        self::assertInstanceOf(OptionsPropertySubgroup::class, $property);
 
-        $this->assertInstanceOf(
+        self::assertInstanceOf(
             RadioPropertyItem::class,
             $property->getSubgroupHeader(),
         );
@@ -216,16 +216,16 @@ class ExportSqlTest extends AbstractTestCase
         $structureOptions = $generalOptionsArray->current();
         $generalOptionsArray->next();
 
-        $this->assertInstanceOf(OptionsPropertyMainGroup::class, $structureOptions);
+        self::assertInstanceOf(OptionsPropertyMainGroup::class, $structureOptions);
 
         $properties = $structureOptions->getProperties();
 
         $property = $properties->current();
         $properties->next();
 
-        $this->assertInstanceOf(OptionsPropertySubgroup::class, $property);
+        self::assertInstanceOf(OptionsPropertySubgroup::class, $property);
 
-        $this->assertInstanceOf(
+        self::assertInstanceOf(
             MessageOnlyPropertyItem::class,
             $property->getSubgroupHeader(),
         );
@@ -234,69 +234,69 @@ class ExportSqlTest extends AbstractTestCase
 
         $leaf = $leaves->current();
         $leaves->next();
-        $this->assertInstanceOf(BoolPropertyItem::class, $leaf);
+        self::assertInstanceOf(BoolPropertyItem::class, $leaf);
 
         $leaf = $leaves->current();
         $leaves->next();
-        $this->assertInstanceOf(BoolPropertyItem::class, $leaf);
+        self::assertInstanceOf(BoolPropertyItem::class, $leaf);
 
-        $this->assertEquals(
+        self::assertEquals(
             'Add <code>DROP TABLE / VIEW / PROCEDURE / FUNCTION / EVENT</code><code> / TRIGGER</code> statement',
             $leaf->getText(),
         );
 
         $leaf = $leaves->current();
         $leaves->next();
-        $this->assertInstanceOf(OptionsPropertySubgroup::class, $leaf);
+        self::assertInstanceOf(OptionsPropertySubgroup::class, $leaf);
 
-        $this->assertCount(
+        self::assertCount(
             2,
             $leaf->getProperties(),
         );
 
-        $this->assertInstanceOf(
+        self::assertInstanceOf(
             BoolPropertyItem::class,
             $leaf->getSubgroupHeader(),
         );
 
         $leaf = $leaves->current();
         $leaves->next();
-        $this->assertInstanceOf(OptionsPropertySubgroup::class, $leaf);
+        self::assertInstanceOf(OptionsPropertySubgroup::class, $leaf);
 
-        $this->assertCount(
+        self::assertCount(
             3,
             $leaf->getProperties(),
         );
 
-        $this->assertInstanceOf(
+        self::assertInstanceOf(
             BoolPropertyItem::class,
             $leaf->getSubgroupHeader(),
         );
 
         $leaf = $leaves->current();
         $leaves->next();
-        $this->assertInstanceOf(BoolPropertyItem::class, $leaf);
+        self::assertInstanceOf(BoolPropertyItem::class, $leaf);
 
         $leaf = $leaves->current();
         $leaves->next();
-        $this->assertInstanceOf(BoolPropertyItem::class, $leaf);
+        self::assertInstanceOf(BoolPropertyItem::class, $leaf);
 
         $property = $properties->current();
-        $this->assertInstanceOf(BoolPropertyItem::class, $property);
+        self::assertInstanceOf(BoolPropertyItem::class, $property);
 
         $dataOptions = $generalOptionsArray->current();
-        $this->assertInstanceOf(OptionsPropertyMainGroup::class, $dataOptions);
+        self::assertInstanceOf(OptionsPropertyMainGroup::class, $dataOptions);
 
         $properties = $dataOptions->getProperties();
 
-        $this->assertCount(7, $properties);
+        self::assertCount(7, $properties);
 
         $properties->next();
 
         $property = $properties->current();
-        $this->assertInstanceOf(OptionsPropertyGroup::class, $property);
+        self::assertInstanceOf(OptionsPropertyGroup::class, $property);
 
-        $this->assertCount(
+        self::assertCount(
             2,
             $property->getProperties(),
         );
@@ -323,26 +323,26 @@ class ExportSqlTest extends AbstractTestCase
 
         $GLOBALS['sql_include_comments'] = true;
 
-        $this->assertEquals(
+        self::assertEquals(
             '--' . "\n",
             $method->invoke($this->object, ''),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             '-- Comment' . "\n",
             $method->invoke($this->object, 'Comment'),
         );
 
         $GLOBALS['sql_include_comments'] = false;
 
-        $this->assertEquals(
+        self::assertEquals(
             '',
             $method->invoke($this->object, 'Comment'),
         );
 
         unset($GLOBALS['sql_include_comments']);
 
-        $this->assertEquals(
+        self::assertEquals(
             '',
             $method->invoke($this->object, 'Comment'),
         );
@@ -354,26 +354,26 @@ class ExportSqlTest extends AbstractTestCase
 
         $GLOBALS['sql_include_comments'] = true;
 
-        $this->assertEquals(
+        self::assertEquals(
             "\n",
             $method->invoke($this->object, ''),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             "\n",
             $method->invoke($this->object, 'Comment'),
         );
 
         $GLOBALS['sql_include_comments'] = false;
 
-        $this->assertEquals(
+        self::assertEquals(
             '',
             $method->invoke($this->object, 'Comment'),
         );
 
         unset($GLOBALS['sql_include_comments']);
 
-        $this->assertEquals(
+        self::assertEquals(
             '',
             $method->invoke($this->object, 'Comment'),
         );
@@ -393,7 +393,7 @@ class ExportSqlTest extends AbstractTestCase
             ->disableOriginalConstructor()
             ->getMock();
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('query')
             ->with('SET time_zone = "GMT"');
 
@@ -401,7 +401,7 @@ class ExportSqlTest extends AbstractTestCase
 
         $this->expectOutputString('SET FOREIGN_KEY_CHECKS=1;' . "\n" . 'COMMIT;' . "\n");
 
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportFooter(),
         );
     }
@@ -427,38 +427,38 @@ class ExportSqlTest extends AbstractTestCase
             ->disableOriginalConstructor()
             ->getMock();
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('tryQuery')
             ->with('SET SQL_MODE=""');
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('fetchValue')
             ->with('SELECT @@session.time_zone')
             ->willReturn('old_tz');
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('query')
             ->with('SET time_zone = "+00:00"');
 
         DatabaseInterface::$instance = $dbi;
 
         ob_start();
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportHeader(),
         );
         $result = ob_get_clean();
 
-        $this->assertIsString($result);
+        self::assertIsString($result);
 
-        $this->assertStringContainsString('h1C', $result);
+        self::assertStringContainsString('h1C', $result);
 
-        $this->assertStringContainsString('h2C', $result);
+        self::assertStringContainsString('h2C', $result);
 
-        $this->assertStringContainsString("SET FOREIGN_KEY_CHECKS=0;\n", $result);
+        self::assertStringContainsString("SET FOREIGN_KEY_CHECKS=0;\n", $result);
 
-        $this->assertStringContainsString('40101 SET', $result);
+        self::assertStringContainsString('40101 SET', $result);
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             "SET FOREIGN_KEY_CHECKS=0;\n" .
             "SET SQL_MODE = \"NO_AUTO_VALUE_ON_ZERO\";\n" .
             "START TRANSACTION;\n" .
@@ -479,7 +479,7 @@ class ExportSqlTest extends AbstractTestCase
             ->disableOriginalConstructor()
             ->getMock();
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('getDbCollation')
             ->with('db')
             ->willReturn('utf8_general_ci');
@@ -489,21 +489,21 @@ class ExportSqlTest extends AbstractTestCase
         $this->object->useSqlBackquotes(true);
 
         ob_start();
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportDBCreate('db', 'database'),
         );
         $result = ob_get_clean();
 
-        $this->assertIsString($result);
+        self::assertIsString($result);
 
-        $this->assertStringContainsString("DROP DATABASE IF EXISTS `db`;\n", $result);
+        self::assertStringContainsString("DROP DATABASE IF EXISTS `db`;\n", $result);
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             'CREATE DATABASE IF NOT EXISTS `db` DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci;',
             $result,
         );
 
-        $this->assertStringContainsString('USE `db`;', $result);
+        self::assertStringContainsString('USE `db`;', $result);
 
         // case2: no backquotes
         unset($GLOBALS['sql_compatibility']);
@@ -513,7 +513,7 @@ class ExportSqlTest extends AbstractTestCase
             ->disableOriginalConstructor()
             ->getMock();
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('getDbCollation')
             ->with('db')
             ->willReturn('testcollation');
@@ -523,21 +523,21 @@ class ExportSqlTest extends AbstractTestCase
         $this->object->useSqlBackquotes(false);
 
         ob_start();
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportDBCreate('db', 'database'),
         );
         $result = ob_get_clean();
 
-        $this->assertIsString($result);
+        self::assertIsString($result);
 
-        $this->assertStringContainsString("DROP DATABASE IF EXISTS db;\n", $result);
+        self::assertStringContainsString("DROP DATABASE IF EXISTS db;\n", $result);
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             'CREATE DATABASE IF NOT EXISTS db DEFAULT CHARACTER SET testcollation;',
             $result,
         );
 
-        $this->assertStringContainsString('USE db;', $result);
+        self::assertStringContainsString('USE db;', $result);
     }
 
     public function testExportDBHeader(): void
@@ -548,14 +548,14 @@ class ExportSqlTest extends AbstractTestCase
         $this->object->useSqlBackquotes(true);
 
         ob_start();
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportDBHeader('testDB'),
         );
         $result = ob_get_clean();
 
-        $this->assertIsString($result);
+        self::assertIsString($result);
 
-        $this->assertStringContainsString('&quot;testDB&quot;', $result);
+        self::assertStringContainsString('&quot;testDB&quot;', $result);
 
         // case 2
         unset($GLOBALS['sql_compatibility']);
@@ -563,14 +563,14 @@ class ExportSqlTest extends AbstractTestCase
         $this->object->useSqlBackquotes(false);
 
         ob_start();
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportDBHeader('testDB'),
         );
         $result = ob_get_clean();
 
-        $this->assertIsString($result);
+        self::assertIsString($result);
 
-        $this->assertStringContainsString('testDB', $result);
+        self::assertStringContainsString('testDB', $result);
     }
 
     public function testExportEvents(): void
@@ -582,37 +582,37 @@ class ExportSqlTest extends AbstractTestCase
             ->disableOriginalConstructor()
             ->getMock();
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('fetchResult')
             ->with('SELECT EVENT_NAME FROM information_schema.EVENTS WHERE EVENT_SCHEMA= \'db\'')
             ->willReturn(['f1', 'f2']);
 
-        $dbi->expects($this->exactly(2))
+        $dbi->expects(self::exactly(2))
             ->method('fetchValue')
             ->willReturnMap([
                 ['SHOW CREATE EVENT `db`.`f1`', 'Create Event', ConnectionType::User, 'f1event'],
                 ['SHOW CREATE EVENT `db`.`f2`', 'Create Event', ConnectionType::User, 'f2event'],
             ]);
-        $dbi->expects($this->any())->method('quoteString')
+        $dbi->expects(self::any())->method('quoteString')
             ->willReturnCallback(static fn (string $string): string => "'" . $string . "'");
 
         DatabaseInterface::$instance = $dbi;
 
         ob_start();
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportEvents('db'),
         );
         $result = ob_get_clean();
 
-        $this->assertIsString($result);
+        self::assertIsString($result);
 
-        $this->assertStringContainsString("DELIMITER $$\n", $result);
+        self::assertStringContainsString("DELIMITER $$\n", $result);
 
-        $this->assertStringContainsString("DELIMITER ;\n", $result);
+        self::assertStringContainsString("DELIMITER ;\n", $result);
 
-        $this->assertStringContainsString("f1event$$\n", $result);
+        self::assertStringContainsString("f1event$$\n", $result);
 
-        $this->assertStringContainsString("f2event$$\n", $result);
+        self::assertStringContainsString("f2event$$\n", $result);
     }
 
     public function testExportDBFooter(): void
@@ -628,12 +628,12 @@ class ExportSqlTest extends AbstractTestCase
         DatabaseInterface::$instance = $dbi;
 
         ob_start();
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportDBFooter('db'),
         );
         $result = ob_get_clean();
 
-        $this->assertEquals('SqlConstraints', $result);
+        self::assertEquals('SqlConstraints', $result);
     }
 
     public function testGetTableDefStandIn(): void
@@ -645,7 +645,7 @@ class ExportSqlTest extends AbstractTestCase
             ->disableOriginalConstructor()
             ->getMock();
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('getColumnsFull')
             ->with('db', 'view')
             ->willReturn(['cname' => ['Type' => 'int']]);
@@ -654,9 +654,9 @@ class ExportSqlTest extends AbstractTestCase
 
         $result = $this->object->getTableDefStandIn('db', 'view');
 
-        $this->assertStringContainsString('DROP VIEW IF EXISTS `view`;', $result);
+        self::assertStringContainsString('DROP VIEW IF EXISTS `view`;', $result);
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             'CREATE TABLE IF NOT EXISTS `view` (' . "\n" . '`cname` int' . "\n" . ');' . "\n",
             $result,
         );
@@ -670,10 +670,10 @@ class ExportSqlTest extends AbstractTestCase
         $dbi = $this->getMockBuilder(DatabaseInterface::class)
             ->disableOriginalConstructor()
             ->getMock();
-        $dbi->expects($this->any())->method('quoteString')
+        $dbi->expects(self::any())->method('quoteString')
             ->willReturnCallback(static fn (string $string): string => "'" . $string . "'");
 
-        $dbi->expects($this->any())
+        $dbi->expects(self::any())
             ->method('getColumns')
             ->with('db', 'view')
             ->willReturn([
@@ -696,7 +696,7 @@ class ExportSqlTest extends AbstractTestCase
         $method = new ReflectionMethod(ExportSql::class, 'getTableDefForView');
         $result = $method->invoke($this->object, 'db', 'view');
 
-        $this->assertEquals(
+        self::assertEquals(
             "CREATE TABLE `view`(\n" .
             "    `fname` char COLLATE utf-8 NOT NULL DEFAULT 'a' COMMENT 'cmt'\n" .
             ");\n",
@@ -709,10 +709,10 @@ class ExportSqlTest extends AbstractTestCase
         $dbi = $this->getMockBuilder(DatabaseInterface::class)
             ->disableOriginalConstructor()
             ->getMock();
-        $dbi->expects($this->any())->method('quoteString')
+        $dbi->expects(self::any())->method('quoteString')
             ->willReturnCallback(static fn (string $string): string => "'" . $string . "'");
 
-        $dbi->expects($this->any())
+        $dbi->expects(self::any())
             ->method('getColumns')
             ->with('db', 'view')
             ->willReturn([
@@ -732,7 +732,7 @@ class ExportSqlTest extends AbstractTestCase
 
         $result = $method->invoke($this->object, 'db', 'view');
 
-        $this->assertEquals(
+        self::assertEquals(
             "CREATE TABLE IF NOT EXISTS `view`(\n" .
             "    `fname` char COLLATE utf-8 DEFAULT NULL COMMENT 'cmt'\n" .
             ");\n",
@@ -804,19 +804,19 @@ SQL;
         $result = $this->object->getTableDef('db', 'table', true, true, false);
 
         $dbiDummy->assertAllQueriesConsumed();
-        $this->assertStringContainsString('-- Creation: Jan 01, 2000 at 10:00 AM', $result);
-        $this->assertStringContainsString('-- Last update: Jan 02, 2000 at 12:00 PM', $result);
-        $this->assertStringContainsString('-- Last check: Jan 02, 2000 at 01:00 PM', $result);
-        $this->assertStringContainsString('DROP TABLE IF EXISTS `table`;', $result);
-        $this->assertStringContainsString('CREATE TABLE `table`', $result);
-        $this->assertStringContainsString('-- Constraints for dumped tables', $GLOBALS['sql_constraints']);
-        $this->assertStringContainsString('-- Constraints for table "table"', $GLOBALS['sql_constraints']);
-        $this->assertStringContainsString('ALTER TABLE "table"', $GLOBALS['sql_constraints']);
-        $this->assertStringContainsString('ADD CONSTRAINT', $GLOBALS['sql_constraints']);
-        $this->assertStringContainsString('ALTER TABLE "table"', $GLOBALS['sql_constraints_query']);
-        $this->assertStringContainsString('ADD CONSTRAINT', $GLOBALS['sql_constraints_query']);
-        $this->assertStringContainsString('ALTER TABLE "table"', $GLOBALS['sql_drop_foreign_keys']);
-        $this->assertStringContainsString('DROP FOREIGN KEY', $GLOBALS['sql_drop_foreign_keys']);
+        self::assertStringContainsString('-- Creation: Jan 01, 2000 at 10:00 AM', $result);
+        self::assertStringContainsString('-- Last update: Jan 02, 2000 at 12:00 PM', $result);
+        self::assertStringContainsString('-- Last check: Jan 02, 2000 at 01:00 PM', $result);
+        self::assertStringContainsString('DROP TABLE IF EXISTS `table`;', $result);
+        self::assertStringContainsString('CREATE TABLE `table`', $result);
+        self::assertStringContainsString('-- Constraints for dumped tables', $GLOBALS['sql_constraints']);
+        self::assertStringContainsString('-- Constraints for table "table"', $GLOBALS['sql_constraints']);
+        self::assertStringContainsString('ALTER TABLE "table"', $GLOBALS['sql_constraints']);
+        self::assertStringContainsString('ADD CONSTRAINT', $GLOBALS['sql_constraints']);
+        self::assertStringContainsString('ALTER TABLE "table"', $GLOBALS['sql_constraints_query']);
+        self::assertStringContainsString('ADD CONSTRAINT', $GLOBALS['sql_constraints_query']);
+        self::assertStringContainsString('ALTER TABLE "table"', $GLOBALS['sql_drop_foreign_keys']);
+        self::assertStringContainsString('DROP FOREIGN KEY', $GLOBALS['sql_drop_foreign_keys']);
     }
 
     public function testGetTableDefWithError(): void
@@ -854,7 +854,7 @@ SQL;
 
         $dbiDummy->assertAllQueriesConsumed();
         $dbiDummy->assertAllErrorCodesConsumed();
-        $this->assertStringContainsString('-- Error reading structure for table db.table: error occurred', $result);
+        self::assertStringContainsString('-- Error reading structure for table db.table: error occurred', $result);
     }
 
     public function testGetTableComments(): void
@@ -874,7 +874,7 @@ SQL;
             ->disableOriginalConstructor()
             ->getMock();
 
-        $dbi->expects($this->exactly(2))
+        $dbi->expects(self::exactly(2))
             ->method('fetchResult')
             ->willReturn(
                 ['foo' => ['foreign_table' => 'ftable', 'foreign_field' => 'ffield']],
@@ -887,17 +887,17 @@ SQL;
         $method = new ReflectionMethod(ExportSql::class, 'getTableComments');
         $result = $method->invoke($this->object, 'db', '', true, true);
 
-        $this->assertStringContainsString(
-            "-- MEDIA TYPES FOR TABLE :\n" .
-            "--   fieldname\n" .
-            '--       Test<',
+        self::assertStringContainsString(
+            '-- MEDIA TYPES FOR TABLE :' . "\n"
+            . '--   fieldname' . "\n"
+            . '--       Test<',
             $result,
         );
 
-        $this->assertStringContainsString(
-            "-- RELATIONSHIPS FOR TABLE :\n" .
-            "--   foo\n" .
-            '--       ftable -> ffield',
+        self::assertStringContainsString(
+            '-- RELATIONSHIPS FOR TABLE :' . "\n"
+            . '--   foo' . "\n"
+            . '--       ftable -> ffield',
             $result,
         );
     }
@@ -912,7 +912,7 @@ SQL;
 
         // case 1
         ob_start();
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportStructure(
                 'test_db',
                 'test_table',
@@ -922,9 +922,9 @@ SQL;
         );
         $result = ob_get_clean();
 
-        $this->assertIsString($result);
-        $this->assertStringContainsString('-- Table structure for table &quot;test_table&quot;', $result);
-        $this->assertStringContainsString('CREATE TABLE `test_table`', $result);
+        self::assertIsString($result);
+        self::assertStringContainsString('-- Table structure for table &quot;test_table&quot;', $result);
+        self::assertStringContainsString('CREATE TABLE `test_table`', $result);
 
         // case 2
         unset($GLOBALS['sql_compatibility']);
@@ -935,7 +935,7 @@ SQL;
         $this->object->useSqlBackquotes(false);
 
         ob_start();
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportStructure(
                 'test_db',
                 'test_table',
@@ -945,9 +945,9 @@ SQL;
         );
         $result = ob_get_clean();
 
-        $this->assertIsString($result);
-        $this->assertStringContainsString('-- Triggers test_table', $result);
-        $this->assertStringContainsString(
+        self::assertIsString($result);
+        self::assertStringContainsString('-- Triggers test_table', $result);
+        self::assertStringContainsString(
             'CREATE TRIGGER `test_trigger` AFTER INSERT ON `test_table` FOR EACH ROW BEGIN END',
             $result,
         );
@@ -961,7 +961,7 @@ SQL;
         $this->object->useSqlBackquotes(false);
 
         ob_start();
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportStructure(
                 'test_db',
                 'test_table',
@@ -971,17 +971,17 @@ SQL;
         );
         $result = ob_get_clean();
 
-        $this->assertIsString($result);
-        $this->assertStringContainsString('-- Structure for view test_table', $result);
-        $this->assertStringContainsString('DROP TABLE IF EXISTS `test_table`;', $result);
-        $this->assertStringContainsString('CREATE TABLE `test_table`', $result);
+        self::assertIsString($result);
+        self::assertStringContainsString('-- Structure for view test_table', $result);
+        self::assertStringContainsString('DROP TABLE IF EXISTS `test_table`;', $result);
+        self::assertStringContainsString('CREATE TABLE `test_table`', $result);
 
         // case 4
         $GLOBALS['sql_views_as_tables'] = true;
         unset($GLOBALS['sql_if_not_exists']);
 
         ob_start();
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportStructure(
                 'test_db',
                 'test_table',
@@ -991,14 +991,14 @@ SQL;
         );
         $result = ob_get_clean();
 
-        $this->assertIsString($result);
-        $this->assertStringContainsString('-- Structure for view test_table exported as a table', $result);
-        $this->assertStringContainsString('DROP TABLE IF EXISTS `test_table`;', $result);
-        $this->assertStringContainsString('CREATE TABLE`test_table`', $result);
+        self::assertIsString($result);
+        self::assertStringContainsString('-- Structure for view test_table exported as a table', $result);
+        self::assertStringContainsString('DROP TABLE IF EXISTS `test_table`;', $result);
+        self::assertStringContainsString('CREATE TABLE`test_table`', $result);
 
         // case 5
         ob_start();
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportStructure(
                 'test_db',
                 'test_table',
@@ -1008,9 +1008,9 @@ SQL;
         );
         $result = ob_get_clean();
 
-        $this->assertIsString($result);
-        $this->assertStringContainsString('-- Stand-in structure for view test_table', $result);
-        $this->assertStringContainsString('CREATE TABLE `test_table`', $result);
+        self::assertIsString($result);
+        self::assertStringContainsString('-- Stand-in structure for view test_table', $result);
+        self::assertStringContainsString('CREATE TABLE `test_table`', $result);
     }
 
     #[Group('medium')]
@@ -1052,39 +1052,39 @@ SQL;
             ]),
         ];
 
-        $resultStub = $this->createMock(DummyResult::class);
+        $resultStub = self::createMock(DummyResult::class);
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('getFieldsMeta')
             ->with($resultStub)
             ->willReturn($fields);
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('tryQuery')
             ->with('SELECT a FROM b WHERE 1', ConnectionType::User, DatabaseInterface::QUERY_UNBUFFERED)
             ->willReturn($resultStub);
 
-        $resultStub->expects($this->once())
+        $resultStub->expects(self::once())
             ->method('numFields')
             ->willReturn(5);
 
-        $resultStub->expects($this->exactly(2))
+        $resultStub->expects(self::exactly(2))
             ->method('fetchRow')
             ->willReturn([null, 'test', '10', '6', "\x00\x0a\x0d\x1a"], []);
-        $dbi->expects($this->any())->method('quoteString')
+        $dbi->expects(self::any())->method('quoteString')
             ->willReturnCallback(static fn (string $string): string => "'" . $string . "'");
 
         $tableObj = $this->getMockBuilder(Table::class)
             ->disableOriginalConstructor()
             ->getMock();
-        $tableObj->expects($this->once())
+        $tableObj->expects(self::once())
             ->method('isMerge')
             ->willReturn(false);
-        $tableObj->expects($this->once())
+        $tableObj->expects(self::once())
             ->method('isView')
             ->willReturn(false);
 
-        $dbi->expects($this->any())
+        $dbi->expects(self::any())
             ->method('getTable')
             ->willReturn($tableObj);
 
@@ -1106,22 +1106,22 @@ SQL;
         $this->object->exportData('db', 'table', 'example.com/err', 'SELECT a FROM b WHERE 1');
         $result = ob_get_clean();
 
-        $this->assertIsString($result);
+        self::assertIsString($result);
 
-        $this->assertStringContainsString('TRUNCATE TABLE &quot;table&quot;;', $result);
+        self::assertStringContainsString('TRUNCATE TABLE &quot;table&quot;;', $result);
 
-        $this->assertStringContainsString('SET IDENTITY_INSERT &quot;table&quot; ON ;', $result);
+        self::assertStringContainsString('SET IDENTITY_INSERT &quot;table&quot; ON ;', $result);
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             'INSERT DELAYED IGNORE INTO &quot;table&quot; (&quot;name&quot;, ' .
             '&quot;name&quot;, &quot;name&quot;, &quot;name&quot;, ' .
             '&quot;name&quot;) VALUES',
             $result,
         );
 
-        $this->assertStringContainsString('(NULL, \'test\', 0x3130, 0x36, 0x000a0d1a);', $result);
+        self::assertStringContainsString('(NULL, \'test\', 0x3130, 0x36, 0x000a0d1a);', $result);
 
-        $this->assertStringContainsString('SET IDENTITY_INSERT &quot;table&quot; OFF;', $result);
+        self::assertStringContainsString('SET IDENTITY_INSERT &quot;table&quot; OFF;', $result);
     }
 
     #[Group('medium')]
@@ -1152,37 +1152,37 @@ SQL;
             ]),
         ];
 
-        $resultStub = $this->createMock(DummyResult::class);
+        $resultStub = self::createMock(DummyResult::class);
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('getFieldsMeta')
             ->with($resultStub)
             ->willReturn($fields);
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('tryQuery')
             ->with('SELECT a FROM b WHERE 1', ConnectionType::User, DatabaseInterface::QUERY_UNBUFFERED)
             ->willReturn($resultStub);
 
-        $resultStub->expects($this->once())
+        $resultStub->expects(self::once())
             ->method('numFields')
             ->willReturn(2);
 
-        $resultStub->expects($this->exactly(2))
+        $resultStub->expects(self::exactly(2))
             ->method('fetchRow')
             ->willReturn([null, null], []);
 
         $tableObj = $this->getMockBuilder(Table::class)
             ->disableOriginalConstructor()
             ->getMock();
-        $tableObj->expects($this->once())
+        $tableObj->expects(self::once())
             ->method('isMerge')
             ->willReturn(false);
-        $tableObj->expects($this->once())
+        $tableObj->expects(self::once())
             ->method('isView')
             ->willReturn(false);
 
-        $dbi->expects($this->any())
+        $dbi->expects(self::any())
             ->method('getTable')
             ->willReturn($tableObj);
 
@@ -1203,9 +1203,9 @@ SQL;
         $this->object->exportData('db', 'table', 'example.com/err', 'SELECT a FROM b WHERE 1');
         $result = ob_get_clean();
 
-        $this->assertIsString($result);
+        self::assertIsString($result);
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             'UPDATE IGNORE &quot;table&quot; SET &quot;name&quot; = NULL,' .
             '&quot;name&quot; = NULL WHERE CONCAT(`tbl`.`pma`) IS NULL;',
             $result,
@@ -1221,14 +1221,14 @@ SQL;
         $tableObj = $this->getMockBuilder(Table::class)
             ->disableOriginalConstructor()
             ->getMock();
-        $tableObj->expects($this->once())
+        $tableObj->expects(self::once())
             ->method('isMerge')
             ->willReturn(false);
-        $tableObj->expects($this->once())
+        $tableObj->expects(self::once())
             ->method('isView')
             ->willReturn(true);
 
-        $dbi->expects($this->any())
+        $dbi->expects(self::any())
             ->method('getTable')
             ->willReturn($tableObj);
 
@@ -1242,16 +1242,16 @@ SQL;
         $this->object->useSqlBackquotes(true);
 
         ob_start();
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportData('db', 'tbl', 'err.com', 'SELECT'),
         );
         $result = ob_get_clean();
 
-        $this->assertIsString($result);
+        self::assertIsString($result);
 
-        $this->assertStringContainsString("-- VIEW `tbl`\n", $result);
+        self::assertStringContainsString("-- VIEW `tbl`\n", $result);
 
-        $this->assertStringContainsString("-- Data: None\n", $result);
+        self::assertStringContainsString("-- Data: None\n", $result);
 
         // reset
         $GLOBALS['sql_compatibility'] = $oldVal;
@@ -1263,21 +1263,21 @@ SQL;
             ->disableOriginalConstructor()
             ->getMock();
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('getError')
             ->willReturn('err');
 
         $tableObj = $this->getMockBuilder(Table::class)
             ->disableOriginalConstructor()
             ->getMock();
-        $tableObj->expects($this->once())
+        $tableObj->expects(self::once())
             ->method('isMerge')
             ->willReturn(false);
-        $tableObj->expects($this->once())
+        $tableObj->expects(self::once())
             ->method('isView')
             ->willReturn(false);
 
-        $dbi->expects($this->any())
+        $dbi->expects(self::any())
             ->method('getTable')
             ->willReturn($tableObj);
 
@@ -1287,14 +1287,14 @@ SQL;
         $GLOBALS['sql_include_comments'] = true;
 
         ob_start();
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportData('db', 'table', 'err.com', 'SELECT'),
         );
         $result = ob_get_clean();
 
-        $this->assertIsString($result);
+        self::assertIsString($result);
 
-        $this->assertStringContainsString('-- Error reading data for table db.table: err', $result);
+        self::assertStringContainsString('-- Error reading data for table db.table: err', $result);
     }
 
     public function testMakeCreateTableMSSQLCompatible(): void
@@ -1319,7 +1319,7 @@ SQL;
         $method = new ReflectionMethod(ExportSql::class, 'makeCreateTableMSSQLCompatible');
         $result = $method->invoke($this->object, $query);
 
-        $this->assertEquals(
+        self::assertEquals(
             "CREATE TABLE (\" datetime DEFAULT NULL,\n" .
             "\" datetime DEFAULT NULL\n" .
             "\" datetime NOT NULL,\n" .
@@ -1355,22 +1355,22 @@ SQL;
         $table = null;
 
         $this->object->initAlias($aliases, $db, $table);
-        $this->assertEquals('aliastest', $db);
-        $this->assertNull($table);
+        self::assertEquals('aliastest', $db);
+        self::assertNull($table);
 
         $db = 'foo';
         $table = 'qwerty';
 
         $this->object->initAlias($aliases, $db, $table);
-        $this->assertEquals('foo', $db);
-        $this->assertEquals('qwerty', $table);
+        self::assertEquals('foo', $db);
+        self::assertEquals('qwerty', $table);
 
         $db = 'a';
         $table = 'foo';
 
         $this->object->initAlias($aliases, $db, $table);
-        $this->assertEquals('aliastest', $db);
-        $this->assertEquals('qwerty', $table);
+        self::assertEquals('aliastest', $db);
+        self::assertEquals('qwerty', $table);
     }
 
     public function testGetAlias(): void
@@ -1385,22 +1385,22 @@ SQL;
             ],
         ];
 
-        $this->assertEquals(
+        self::assertEquals(
             'f',
             $this->object->getAlias($aliases, 'bar'),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'aliastest',
             $this->object->getAlias($aliases, 'a'),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'pphymdain',
             $this->object->getAlias($aliases, 'pqr'),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             '',
             $this->object->getAlias($aliases, 'abc'),
         );
@@ -1431,7 +1431,7 @@ SQL;
             . "latin1_general_ci COMMENT='List' AUTO_INCREMENT=5";
         $result = $this->object->replaceWithAliases(null, $sqlQuery, $aliases, $db);
 
-        $this->assertEquals(
+        self::assertEquals(
             "CREATE TABLE IF NOT EXISTS `bartest` (\n" .
             "  `p` tinyint(3) UNSIGNED NOT NULL COMMENT 'Primary Key',\n" .
             "  `xyz` varchar(255) COLLATE latin1_general_ci NOT NULL COMMENT 'xyz',\n" .
@@ -1443,7 +1443,7 @@ SQL;
 
         $result = $this->object->replaceWithAliases(null, $sqlQuery, [], '');
 
-        $this->assertEquals(
+        self::assertEquals(
             "CREATE TABLE IF NOT EXISTS foo (\n" .
             "  `baz` tinyint(3) UNSIGNED NOT NULL COMMENT 'Primary Key',\n" .
             "  `xyz` varchar(255) COLLATE latin1_general_ci NOT NULL COMMENT 'xyz',\n" .
@@ -1464,7 +1464,7 @@ SQL;
             . 'END IF; END';
         $result = $this->object->replaceWithAliases('$$', $sqlQuery, $aliases, $db);
 
-        $this->assertEquals(
+        self::assertEquals(
             'CREATE TRIGGER `BEFORE_bar_INSERT` BEFORE INSERT ON `f` FOR EACH ROW BEGIN ' .
             'SET @cnt=(SELECT count(*) FROM `f` WHERE `n`=NEW.`n` AND id=NEW.id AND abc=NEW.`n` LIMIT 1); ' .
             'IF @cnt<>0 THEN ' .
@@ -1519,6 +1519,6 @@ RETURN TextString ;
 END
 SQL;
 
-        $this->assertEquals($expectedQuery, $result);
+        self::assertEquals($expectedQuery, $result);
     }
 }
diff --git a/tests/classes/Plugins/Export/ExportTexytextTest.php b/tests/classes/Plugins/Export/ExportTexytextTest.php
index ca6fe08432..45ac83e8c4 100644
--- a/tests/classes/Plugins/Export/ExportTexytextTest.php
+++ b/tests/classes/Plugins/Export/ExportTexytextTest.php
@@ -93,28 +93,28 @@ class ExportTexytextTest extends AbstractTestCase
         $attrProperties = new ReflectionProperty(ExportTexytext::class, 'properties');
         $properties = $attrProperties->getValue($this->object);
 
-        $this->assertInstanceOf(ExportPluginProperties::class, $properties);
+        self::assertInstanceOf(ExportPluginProperties::class, $properties);
 
-        $this->assertEquals(
+        self::assertEquals(
             'Texy! text',
             $properties->getText(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'txt',
             $properties->getExtension(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'text/plain',
             $properties->getMimeType(),
         );
 
         $options = $properties->getOptions();
 
-        $this->assertInstanceOf(OptionsPropertyRootGroup::class, $options);
+        self::assertInstanceOf(OptionsPropertyRootGroup::class, $options);
 
-        $this->assertEquals(
+        self::assertEquals(
             'Format Specific Options',
             $options->getName(),
         );
@@ -124,14 +124,14 @@ class ExportTexytextTest extends AbstractTestCase
         $generalOptions = $generalOptionsArray->current();
         $generalOptionsArray->next();
 
-        $this->assertInstanceOf(OptionsPropertyMainGroup::class, $generalOptions);
+        self::assertInstanceOf(OptionsPropertyMainGroup::class, $generalOptions);
 
-        $this->assertEquals(
+        self::assertEquals(
             'general_opts',
             $generalOptions->getName(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'Dump table',
             $generalOptions->getText(),
         );
@@ -140,13 +140,13 @@ class ExportTexytextTest extends AbstractTestCase
 
         $property = $generalProperties->current();
 
-        $this->assertInstanceOf(RadioPropertyItem::class, $property);
+        self::assertInstanceOf(RadioPropertyItem::class, $property);
 
         $generalOptions = $generalOptionsArray->current();
 
-        $this->assertInstanceOf(OptionsPropertyMainGroup::class, $generalOptions);
+        self::assertInstanceOf(OptionsPropertyMainGroup::class, $generalOptions);
 
-        $this->assertEquals(
+        self::assertEquals(
             'data',
             $generalOptions->getName(),
         );
@@ -156,18 +156,18 @@ class ExportTexytextTest extends AbstractTestCase
         $property = $generalProperties->current();
         $generalProperties->next();
 
-        $this->assertInstanceOf(BoolPropertyItem::class, $property);
+        self::assertInstanceOf(BoolPropertyItem::class, $property);
 
-        $this->assertEquals(
+        self::assertEquals(
             'columns',
             $property->getName(),
         );
 
         $property = $generalProperties->current();
 
-        $this->assertInstanceOf(TextPropertyItem::class, $property);
+        self::assertInstanceOf(TextPropertyItem::class, $property);
 
-        $this->assertEquals(
+        self::assertEquals(
             'null',
             $property->getName(),
         );
@@ -175,14 +175,14 @@ class ExportTexytextTest extends AbstractTestCase
 
     public function testExportHeader(): void
     {
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportHeader(),
         );
     }
 
     public function testExportFooter(): void
     {
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportFooter(),
         );
     }
@@ -190,21 +190,21 @@ class ExportTexytextTest extends AbstractTestCase
     public function testExportDBHeader(): void
     {
         $this->expectOutputString("===Database testDb\n\n");
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportDBHeader('testDb'),
         );
     }
 
     public function testExportDBFooter(): void
     {
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportDBFooter('testDB'),
         );
     }
 
     public function testExportDBCreate(): void
     {
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportDBCreate('testDB', 'database'),
         );
     }
@@ -216,7 +216,7 @@ class ExportTexytextTest extends AbstractTestCase
         $GLOBALS['foo_null'] = '>';
 
         ob_start();
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportData(
                 'test_db',
                 'test_table',
@@ -226,8 +226,8 @@ class ExportTexytextTest extends AbstractTestCase
         );
         $result = ob_get_clean();
 
-        $this->assertIsString($result);
-        $this->assertEquals(
+        self::assertIsString($result);
+        self::assertEquals(
             '== Dumping data for table test_table' . "\n\n"
                 . '|------' . "\n"
                 . '|id|name|datetimefield' . "\n"
@@ -245,7 +245,7 @@ class ExportTexytextTest extends AbstractTestCase
         $result = $this->object->getTableDefStandIn('test_db', 'test_table');
         $this->dummyDbi->assertAllSelectsConsumed();
 
-        $this->assertEquals(
+        self::assertEquals(
             '|------' . "\n"
             . '|Column|Type|Null|Default' . "\n"
             . '|------' . "\n"
@@ -271,26 +271,26 @@ class ExportTexytextTest extends AbstractTestCase
 
         $keys = [['Non_unique' => 0, 'Column_name' => 'cname'], ['Non_unique' => 1, 'Column_name' => 'cname2']];
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('getTableIndexes')
             ->with('db', 'table')
             ->willReturn($keys);
 
-        $dbi->expects($this->exactly(2))
+        $dbi->expects(self::exactly(2))
             ->method('fetchResult')
             ->willReturn(
                 ['fname' => ['foreign_table' => '<ftable', 'foreign_field' => 'ffield>']],
                 ['fname' => ['values' => 'test-', 'transformation' => 'testfoo', 'mimetype' => 'test<']],
             );
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('fetchValue')
             ->willReturn('SELECT a FROM b');
 
         $column = new Column('fname', '', false, '', null, '');
         $columnFull = new ColumnFull('fname', '', null, false, '', null, '', '', 'comm');
 
-        $dbi->expects($this->exactly(2))
+        $dbi->expects(self::exactly(2))
             ->method('getColumns')
             ->willReturnMap([
                 ['db', 'table', false, ConnectionType::User, [$column]],
@@ -300,7 +300,7 @@ class ExportTexytextTest extends AbstractTestCase
         DatabaseInterface::$instance = $dbi;
         $this->object->relation = new Relation($dbi);
 
-        $this->object->expects($this->exactly(1))
+        $this->object->expects(self::exactly(1))
             ->method('formatOneColumnDefinition')
             ->with($column, ['cname'])
             ->willReturn('1');
@@ -317,7 +317,7 @@ class ExportTexytextTest extends AbstractTestCase
 
         $result = $this->object->getTableDef('db', 'table', true, true, true);
 
-        $this->assertStringContainsString('1|&lt;ftable (ffield&gt;)|comm|Test&lt;', $result);
+        self::assertStringContainsString('1|&lt;ftable (ffield&gt;)|comm|Test&lt;', $result);
     }
 
     public function testGetTriggers(): void
@@ -335,9 +335,9 @@ class ExportTexytextTest extends AbstractTestCase
 
         $result = $this->object->getTriggers($triggers);
 
-        $this->assertStringContainsString('|tna"me|BEFORE|DELETE|def', $result);
+        self::assertStringContainsString('|tna"me|BEFORE|DELETE|def', $result);
 
-        $this->assertStringContainsString('|Name|Time|Event|Definition', $result);
+        self::assertStringContainsString('|Name|Time|Event|Definition', $result);
     }
 
     public function testExportStructure(): void
@@ -345,7 +345,7 @@ class ExportTexytextTest extends AbstractTestCase
         // case 1
         ob_start();
         $this->dummyDbi->addSelectDb('test_db');
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportStructure(
                 'test_db',
                 'test_table',
@@ -356,8 +356,8 @@ class ExportTexytextTest extends AbstractTestCase
         $this->dummyDbi->assertAllSelectsConsumed();
         $result = ob_get_clean();
 
-        $this->assertIsString($result);
-        $this->assertEquals(
+        self::assertIsString($result);
+        self::assertEquals(
             '== Table structure for table test_table' . "\n\n"
             . '|------' . "\n"
             . '|Column|Type|Null|Default' . "\n"
@@ -370,7 +370,7 @@ class ExportTexytextTest extends AbstractTestCase
 
         // case 2
         ob_start();
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportStructure(
                 'test_db',
                 'test_table',
@@ -380,7 +380,7 @@ class ExportTexytextTest extends AbstractTestCase
         );
         $result = ob_get_clean();
 
-        $this->assertEquals(
+        self::assertEquals(
             '== Triggers test_table' . "\n\n"
             . '|------' . "\n"
             . '|Name|Time|Event|Definition' . "\n"
@@ -392,7 +392,7 @@ class ExportTexytextTest extends AbstractTestCase
         // case 3
         ob_start();
         $this->dummyDbi->addSelectDb('test_db');
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportStructure(
                 'test_db',
                 'test_table',
@@ -403,7 +403,7 @@ class ExportTexytextTest extends AbstractTestCase
         $this->dummyDbi->assertAllSelectsConsumed();
         $result = ob_get_clean();
 
-        $this->assertEquals(
+        self::assertEquals(
             '== Structure for view test_table' . "\n\n"
             . '|------' . "\n"
             . '|Column|Type|Null|Default' . "\n"
@@ -417,7 +417,7 @@ class ExportTexytextTest extends AbstractTestCase
         // case 4
         ob_start();
         $this->dummyDbi->addSelectDb('test_db');
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportStructure(
                 'test_db',
                 'test_table',
@@ -428,7 +428,7 @@ class ExportTexytextTest extends AbstractTestCase
         $this->dummyDbi->assertAllSelectsConsumed();
         $result = ob_get_clean();
 
-        $this->assertEquals(
+        self::assertEquals(
             '== Stand-in structure for view test_table' . "\n\n"
             . '|------' . "\n"
             . '|Column|Type|Null|Default' . "\n"
@@ -446,7 +446,7 @@ class ExportTexytextTest extends AbstractTestCase
 
         $uniqueKeys = ['field'];
 
-        $this->assertEquals(
+        self::assertEquals(
             '|//**field**//|set(abc)|Yes|NULL',
             $this->object->formatOneColumnDefinition($cols, $uniqueKeys),
         );
@@ -455,7 +455,7 @@ class ExportTexytextTest extends AbstractTestCase
 
         $uniqueKeys = ['field'];
 
-        $this->assertEquals(
+        self::assertEquals(
             '|fields|&amp;nbsp;|No|def',
             $this->object->formatOneColumnDefinition($cols, $uniqueKeys),
         );
diff --git a/tests/classes/Plugins/Export/ExportXmlTest.php b/tests/classes/Plugins/Export/ExportXmlTest.php
index bbf6f056e3..94634b49ce 100644
--- a/tests/classes/Plugins/Export/ExportXmlTest.php
+++ b/tests/classes/Plugins/Export/ExportXmlTest.php
@@ -77,28 +77,28 @@ class ExportXmlTest extends AbstractTestCase
         $attrProperties = new ReflectionProperty(ExportXml::class, 'properties');
         $properties = $attrProperties->getValue($this->object);
 
-        $this->assertInstanceOf(ExportPluginProperties::class, $properties);
+        self::assertInstanceOf(ExportPluginProperties::class, $properties);
 
-        $this->assertEquals(
+        self::assertEquals(
             'XML',
             $properties->getText(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'xml',
             $properties->getExtension(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'text/xml',
             $properties->getMimeType(),
         );
 
         $options = $properties->getOptions();
 
-        $this->assertInstanceOf(OptionsPropertyRootGroup::class, $options);
+        self::assertInstanceOf(OptionsPropertyRootGroup::class, $options);
 
-        $this->assertEquals(
+        self::assertEquals(
             'Format Specific Options',
             $options->getName(),
         );
@@ -108,9 +108,9 @@ class ExportXmlTest extends AbstractTestCase
         $generalOptions = $generalOptionsArray->current();
         $generalOptionsArray->next();
 
-        $this->assertInstanceOf(OptionsPropertyMainGroup::class, $generalOptions);
+        self::assertInstanceOf(OptionsPropertyMainGroup::class, $generalOptions);
 
-        $this->assertEquals(
+        self::assertEquals(
             'general_opts',
             $generalOptions->getName(),
         );
@@ -119,14 +119,14 @@ class ExportXmlTest extends AbstractTestCase
 
         $property = $generalProperties->current();
 
-        $this->assertInstanceOf(HiddenPropertyItem::class, $property);
+        self::assertInstanceOf(HiddenPropertyItem::class, $property);
 
         $generalOptions = $generalOptionsArray->current();
         $generalOptionsArray->next();
 
-        $this->assertInstanceOf(OptionsPropertyMainGroup::class, $generalOptions);
+        self::assertInstanceOf(OptionsPropertyMainGroup::class, $generalOptions);
 
-        $this->assertEquals(
+        self::assertEquals(
             'structure',
             $generalOptions->getName(),
         );
@@ -135,29 +135,29 @@ class ExportXmlTest extends AbstractTestCase
 
         $property = $generalProperties->current();
 
-        $this->assertInstanceOf(BoolPropertyItem::class, $property);
+        self::assertInstanceOf(BoolPropertyItem::class, $property);
 
         $property = $generalProperties->current();
 
-        $this->assertInstanceOf(BoolPropertyItem::class, $property);
+        self::assertInstanceOf(BoolPropertyItem::class, $property);
 
         $property = $generalProperties->current();
 
-        $this->assertInstanceOf(BoolPropertyItem::class, $property);
+        self::assertInstanceOf(BoolPropertyItem::class, $property);
 
         $property = $generalProperties->current();
 
-        $this->assertInstanceOf(BoolPropertyItem::class, $property);
+        self::assertInstanceOf(BoolPropertyItem::class, $property);
 
         $property = $generalProperties->current();
 
-        $this->assertInstanceOf(BoolPropertyItem::class, $property);
+        self::assertInstanceOf(BoolPropertyItem::class, $property);
 
         $generalOptions = $generalOptionsArray->current();
 
-        $this->assertInstanceOf(OptionsPropertyMainGroup::class, $generalOptions);
+        self::assertInstanceOf(OptionsPropertyMainGroup::class, $generalOptions);
 
-        $this->assertEquals(
+        self::assertEquals(
             'data',
             $generalOptions->getName(),
         );
@@ -166,7 +166,7 @@ class ExportXmlTest extends AbstractTestCase
 
         $property = $generalProperties->current();
 
-        $this->assertInstanceOf(BoolPropertyItem::class, $property);
+        self::assertInstanceOf(BoolPropertyItem::class, $property);
     }
 
     #[Group('medium')]
@@ -209,15 +209,15 @@ class ExportXmlTest extends AbstractTestCase
         $functions = [['Db' => 'd<"b', 'Name' => 'fn', 'Type' => 'FUNCTION']];
         $procedures = [['Db' => 'd<"b', 'Name' => 'pr', 'Type' => 'PROCEDURE']];
 
-        $dbi->expects($this->exactly(5))
+        $dbi->expects(self::exactly(5))
             ->method('fetchResult')
             ->willReturn($result, $result, $triggers, $functions, $procedures);
 
-        $dbi->expects($this->exactly(3))
+        $dbi->expects(self::exactly(3))
             ->method('fetchValue')
             ->willReturn(false, 'fndef', 'prdef');
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('getTable')
             ->willReturn(new Table('table', 'd<"b', $dbi));
 
@@ -227,20 +227,20 @@ class ExportXmlTest extends AbstractTestCase
         Current::$table = 'table';
 
         ob_start();
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportHeader(),
         );
         $result = ob_get_clean();
 
-        $this->assertIsString($result);
+        self::assertIsString($result);
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             '&lt;pma_xml_export version=&quot;1.0&quot; xmlns:pma=&quot;' .
             'https://www.phpmyadmin.net/some_doc_url/&quot;&gt;',
             $result,
         );
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             '&lt;pma:structure_schemas&gt;' . "\n" .
             '        &lt;pma:database name=&quot;d&amp;lt;&amp;quot;b&quot; collat' .
             'ion=&quot;utf8_general_ci&quot; charset=&quot;utf-8&quot;&gt;' . "\n" .
@@ -280,15 +280,15 @@ class ExportXmlTest extends AbstractTestCase
 
         $result3 = ['t2' => [null, '"tbl"']];
 
-        $dbi->expects($this->exactly(3))
+        $dbi->expects(self::exactly(3))
             ->method('fetchResult')
             ->willReturn($result1, $result2, $result3);
 
-        $dbi->expects($this->exactly(2))
+        $dbi->expects(self::exactly(2))
             ->method('fetchValue')
             ->willReturn('table', false);
 
-        $dbi->expects($this->any())
+        $dbi->expects(self::any())
             ->method('getTable')
             ->willReturn(new Table('table', 'd<"b', $dbi));
 
@@ -297,14 +297,14 @@ class ExportXmlTest extends AbstractTestCase
         $GLOBALS['tables'] = ['t1', 't2'];
 
         ob_start();
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportHeader(),
         );
         $result = ob_get_clean();
 
-        $this->assertIsString($result);
+        self::assertIsString($result);
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             '&lt;pma:structure_schemas&gt;' . "\n" .
             '        &lt;pma:database name=&quot;d&amp;lt;&amp;quot;b&quot; collat' .
             'ion=&quot;utf8_general_ci&quot; charset=&quot;utf-8&quot;&gt;' . "\n" .
@@ -317,7 +317,7 @@ class ExportXmlTest extends AbstractTestCase
     public function testExportFooter(): void
     {
         $this->expectOutputString('&lt;/pma_xml_export&gt;');
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportFooter(),
         );
     }
@@ -327,18 +327,18 @@ class ExportXmlTest extends AbstractTestCase
         $GLOBALS['xml_export_contents'] = true;
 
         ob_start();
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportDBHeader('&db'),
         );
         $result = ob_get_clean();
 
-        $this->assertIsString($result);
+        self::assertIsString($result);
 
-        $this->assertStringContainsString('&lt;database name=&quot;&amp;amp;db&quot;&gt;', $result);
+        self::assertStringContainsString('&lt;database name=&quot;&amp;amp;db&quot;&gt;', $result);
 
         $GLOBALS['xml_export_contents'] = false;
 
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportDBHeader('&db'),
         );
     }
@@ -348,25 +348,25 @@ class ExportXmlTest extends AbstractTestCase
         $GLOBALS['xml_export_contents'] = true;
 
         ob_start();
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportDBFooter('&db'),
         );
         $result = ob_get_clean();
 
-        $this->assertIsString($result);
+        self::assertIsString($result);
 
-        $this->assertStringContainsString('&lt;/database&gt;', $result);
+        self::assertStringContainsString('&lt;/database&gt;', $result);
 
         $GLOBALS['xml_export_contents'] = false;
 
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportDBFooter('&db'),
         );
     }
 
     public function testExportDBCreate(): void
     {
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportDBCreate('testDB', 'database'),
         );
     }
@@ -378,7 +378,7 @@ class ExportXmlTest extends AbstractTestCase
         $GLOBALS['output_charset_conversion'] = false;
 
         ob_start();
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportData(
                 'test_db',
                 'test_table',
@@ -388,8 +388,8 @@ class ExportXmlTest extends AbstractTestCase
         );
         $result = ob_get_clean();
 
-        $this->assertIsString($result);
-        $this->assertEquals(
+        self::assertIsString($result);
+        self::assertEquals(
             '        <!-- Table test_table -->' . "\n"
             . '        <table name="test_table">' . "\n"
             . '            <column name="id">1</column>' . "\n"
diff --git a/tests/classes/Plugins/Export/ExportYamlTest.php b/tests/classes/Plugins/Export/ExportYamlTest.php
index d85bde2b42..4106c6f984 100644
--- a/tests/classes/Plugins/Export/ExportYamlTest.php
+++ b/tests/classes/Plugins/Export/ExportYamlTest.php
@@ -70,28 +70,28 @@ class ExportYamlTest extends AbstractTestCase
         $attrProperties = new ReflectionProperty(ExportYaml::class, 'properties');
         $properties = $attrProperties->getValue($this->object);
 
-        $this->assertInstanceOf(ExportPluginProperties::class, $properties);
+        self::assertInstanceOf(ExportPluginProperties::class, $properties);
 
-        $this->assertEquals(
+        self::assertEquals(
             'YAML',
             $properties->getText(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'yml',
             $properties->getExtension(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'text/yaml',
             $properties->getMimeType(),
         );
 
         $options = $properties->getOptions();
 
-        $this->assertInstanceOf(OptionsPropertyRootGroup::class, $options);
+        self::assertInstanceOf(OptionsPropertyRootGroup::class, $options);
 
-        $this->assertEquals(
+        self::assertEquals(
             'Format Specific Options',
             $options->getName(),
         );
@@ -100,9 +100,9 @@ class ExportYamlTest extends AbstractTestCase
 
         $generalOptions = $generalOptionsArray->current();
 
-        $this->assertInstanceOf(OptionsPropertyMainGroup::class, $generalOptions);
+        self::assertInstanceOf(OptionsPropertyMainGroup::class, $generalOptions);
 
-        $this->assertEquals(
+        self::assertEquals(
             'general_opts',
             $generalOptions->getName(),
         );
@@ -111,47 +111,47 @@ class ExportYamlTest extends AbstractTestCase
 
         $property = $generalProperties->current();
 
-        $this->assertInstanceOf(HiddenPropertyItem::class, $property);
+        self::assertInstanceOf(HiddenPropertyItem::class, $property);
     }
 
     public function testExportHeader(): void
     {
         ob_start();
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportHeader(),
         );
         $result = ob_get_clean();
 
-        $this->assertIsString($result);
+        self::assertIsString($result);
 
-        $this->assertStringContainsString("%YAML 1.1\n---\n", $result);
+        self::assertStringContainsString("%YAML 1.1\n---\n", $result);
     }
 
     public function testExportFooter(): void
     {
         $this->expectOutputString("...\n");
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportFooter(),
         );
     }
 
     public function testExportDBHeader(): void
     {
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportDBHeader('&db'),
         );
     }
 
     public function testExportDBFooter(): void
     {
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportDBFooter('&db'),
         );
     }
 
     public function testExportDBCreate(): void
     {
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportDBCreate('testDB', 'database'),
         );
     }
@@ -159,7 +159,7 @@ class ExportYamlTest extends AbstractTestCase
     public function testExportData(): void
     {
         ob_start();
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->exportData(
                 'test_db',
                 'test_table',
@@ -169,7 +169,7 @@ class ExportYamlTest extends AbstractTestCase
         );
         $result = ob_get_clean();
 
-        $this->assertEquals(
+        self::assertEquals(
             '# test_db.test_table' . "\n" .
             '-' . "\n" .
             '  id: 1' . "\n" .
diff --git a/tests/classes/Plugins/Export/Helpers/TablePropertyTest.php b/tests/classes/Plugins/Export/Helpers/TablePropertyTest.php
index f557a6bc1a..ee887d8c0e 100644
--- a/tests/classes/Plugins/Export/Helpers/TablePropertyTest.php
+++ b/tests/classes/Plugins/Export/Helpers/TablePropertyTest.php
@@ -37,31 +37,31 @@ class TablePropertyTest extends AbstractTestCase
 
     public function testConstructor(): void
     {
-        $this->assertEquals('name', $this->object->name);
+        self::assertEquals('name', $this->object->name);
 
-        $this->assertEquals('int', $this->object->type);
+        self::assertEquals('int', $this->object->type);
 
-        $this->assertEquals(1, $this->object->nullable);
+        self::assertEquals(1, $this->object->nullable);
 
-        $this->assertEquals('PRI', $this->object->key);
+        self::assertEquals('PRI', $this->object->key);
 
-        $this->assertEquals('0', $this->object->defaultValue);
+        self::assertEquals('0', $this->object->defaultValue);
 
-        $this->assertEquals('mysql', $this->object->ext);
+        self::assertEquals('mysql', $this->object->ext);
     }
 
     public function testGetPureType(): void
     {
         $this->object->type = 'int(10)';
 
-        $this->assertEquals(
+        self::assertEquals(
             'int',
             $this->object->getPureType(),
         );
 
         $this->object->type = 'char';
 
-        $this->assertEquals(
+        self::assertEquals(
             'char',
             $this->object->getPureType(),
         );
@@ -76,7 +76,7 @@ class TablePropertyTest extends AbstractTestCase
     {
         $this->object->nullable = $nullable;
 
-        $this->assertEquals(
+        self::assertEquals(
             $expected,
             $this->object->isNotNull(),
         );
@@ -101,7 +101,7 @@ class TablePropertyTest extends AbstractTestCase
     {
         $this->object->key = $key;
 
-        $this->assertEquals(
+        self::assertEquals(
             $expected,
             $this->object->isUnique(),
         );
@@ -126,7 +126,7 @@ class TablePropertyTest extends AbstractTestCase
     {
         $this->object->type = $type;
 
-        $this->assertEquals(
+        self::assertEquals(
             $expected,
             $this->object->getDotNetPrimitiveType(),
         );
@@ -163,7 +163,7 @@ class TablePropertyTest extends AbstractTestCase
     {
         $this->object->type = $type;
 
-        $this->assertEquals(
+        self::assertEquals(
             $expected,
             $this->object->getDotNetObjectType(),
         );
@@ -196,14 +196,14 @@ class TablePropertyTest extends AbstractTestCase
         $this->object->name = "ä'7<ab>";
         $this->object->key = 'PRI';
 
-        $this->assertEquals(
+        self::assertEquals(
             "index=\"ä'7&lt;ab&gt;\"",
             $this->object->getIndexName(),
         );
 
         $this->object->key = '';
 
-        $this->assertEquals(
+        self::assertEquals(
             '',
             $this->object->getIndexName(),
         );
@@ -213,13 +213,13 @@ class TablePropertyTest extends AbstractTestCase
     {
         $this->object->key = 'PRI';
 
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->isPK(),
         );
 
         $this->object->key = '';
 
-        $this->assertFalse(
+        self::assertFalse(
             $this->object->isPK(),
         );
     }
@@ -228,7 +228,7 @@ class TablePropertyTest extends AbstractTestCase
     {
         $this->object->name = 'Name#name#123';
 
-        $this->assertEquals(
+        self::assertEquals(
             'text123Namename',
             $this->object->formatCs('text123#name#'),
         );
@@ -238,7 +238,7 @@ class TablePropertyTest extends AbstractTestCase
     {
         $this->object->name = '"a\'';
 
-        $this->assertEquals(
+        self::assertEquals(
             '&quot;a\'index="&quot;a\'"',
             $this->object->formatXml('#name##indexName#'),
         );
@@ -246,7 +246,7 @@ class TablePropertyTest extends AbstractTestCase
 
     public function testFormat(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             'NameintInt32intfalsetrue',
             $this->object->format(
                 '#ucfirstName##dotNetPrimitiveType##dotNetObjectType##type##notNull##unique#',
diff --git a/tests/classes/Plugins/Import/ImportCsvTest.php b/tests/classes/Plugins/Import/ImportCsvTest.php
index 38b4cda753..99ff810b3e 100644
--- a/tests/classes/Plugins/Import/ImportCsvTest.php
+++ b/tests/classes/Plugins/Import/ImportCsvTest.php
@@ -102,11 +102,11 @@ class ImportCsvTest extends AbstractTestCase
     public function testGetProperties(): void
     {
         $properties = $this->object->getProperties();
-        $this->assertEquals(
+        self::assertEquals(
             __('CSV'),
             $properties->getText(),
         );
-        $this->assertEquals(
+        self::assertEquals(
             'csv',
             $properties->getExtension(),
         );
@@ -129,16 +129,16 @@ class ImportCsvTest extends AbstractTestCase
         $this->object->doImport($importHandle);
 
         //asset that all sql are executed
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             'CREATE DATABASE IF NOT EXISTS `CSV_DB 1` DEFAULT CHARACTER',
             $GLOBALS['sql_query'],
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             'CREATE TABLE IF NOT EXISTS `CSV_DB 1`.`' . $GLOBALS['import_file_name'] . '`',
             $GLOBALS['sql_query'],
         );
 
-        $this->assertTrue($GLOBALS['finished']);
+        self::assertTrue($GLOBALS['finished']);
     }
 
     /**
@@ -163,16 +163,16 @@ class ImportCsvTest extends AbstractTestCase
         $this->object->doImport($importHandle);
 
         //asset that all sql are executed
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             'CREATE DATABASE IF NOT EXISTS `ImportTestDb` DEFAULT CHARACTER',
             $GLOBALS['sql_query'],
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             'CREATE TABLE IF NOT EXISTS `ImportTestDb`.`ImportTestTable`',
             $GLOBALS['sql_query'],
         );
 
-        $this->assertTrue($GLOBALS['finished']);
+        self::assertTrue($GLOBALS['finished']);
 
         unset($_REQUEST['csv_new_tbl_name']);
         unset($_REQUEST['csv_new_db_name']);
@@ -188,11 +188,11 @@ class ImportCsvTest extends AbstractTestCase
         $GLOBALS['plugin_param'] = 'table';
         $this->object = new ImportCsv();
         $properties = $this->object->getProperties();
-        $this->assertEquals(
+        self::assertEquals(
             __('CSV'),
             $properties->getText(),
         );
-        $this->assertEquals(
+        self::assertEquals(
             'csv',
             $properties->getExtension(),
         );
@@ -215,17 +215,17 @@ class ImportCsvTest extends AbstractTestCase
         $this->object->doImport($importHandle);
 
         //asset that all sql are executed
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             'CREATE DATABASE IF NOT EXISTS `CSV_DB 1` DEFAULT CHARACTER',
             $GLOBALS['sql_query'],
         );
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             'CREATE TABLE IF NOT EXISTS `CSV_DB 1`.`' . $GLOBALS['import_file_name'] . '`',
             $GLOBALS['sql_query'],
         );
 
-        $this->assertTrue($GLOBALS['finished']);
+        self::assertTrue($GLOBALS['finished']);
     }
 
     /**
@@ -259,7 +259,7 @@ class ImportCsvTest extends AbstractTestCase
 
         $this->object->doImport();
 
-        $this->assertSame(
+        self::assertSame(
             'CREATE DATABASE IF NOT EXISTS `CSV_DB 1` DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci;;'
             . 'CREATE TABLE IF NOT EXISTS `CSV_DB 1`.`db_test` (`COL 1` varchar(5), `COL 2` varchar(5))'
             . ' DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci;;INSERT INTO `CSV_DB 1`.`db_test`'
@@ -267,7 +267,7 @@ class ImportCsvTest extends AbstractTestCase
             $GLOBALS['sql_query'],
         );
 
-        $this->assertTrue($GLOBALS['finished']);
+        self::assertTrue($GLOBALS['finished']);
         $this->dummyDbi->assertAllQueriesConsumed();
     }
 
@@ -304,7 +304,7 @@ class ImportCsvTest extends AbstractTestCase
 
         $this->object->doImport();
 
-        $this->assertSame(
+        self::assertSame(
             'CREATE DATABASE IF NOT EXISTS `CSV_DB 1` DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci;;'
             . 'CREATE TABLE IF NOT EXISTS `CSV_DB 1`.`db_test` (`Row 1` int(3), `Row 2` int(3))'
             . ' DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci;;INSERT INTO `CSV_DB 1`.`db_test`'
@@ -312,7 +312,7 @@ class ImportCsvTest extends AbstractTestCase
             $GLOBALS['sql_query'],
         );
 
-        $this->assertTrue($GLOBALS['finished']);
+        self::assertTrue($GLOBALS['finished']);
         $this->dummyDbi->assertAllQueriesConsumed();
     }
 }
diff --git a/tests/classes/Plugins/Import/ImportLdiTest.php b/tests/classes/Plugins/Import/ImportLdiTest.php
index 37b7f0974a..e6b1c18681 100644
--- a/tests/classes/Plugins/Import/ImportLdiTest.php
+++ b/tests/classes/Plugins/Import/ImportLdiTest.php
@@ -72,11 +72,11 @@ class ImportLdiTest extends AbstractTestCase
     public function testGetProperties(): void
     {
         $properties = (new ImportLdi())->getProperties();
-        $this->assertEquals(
+        self::assertEquals(
             __('CSV using LOAD DATA'),
             $properties->getText(),
         );
-        $this->assertEquals(
+        self::assertEquals(
             'ldi',
             $properties->getExtension(),
         );
@@ -88,29 +88,29 @@ class ImportLdiTest extends AbstractTestCase
     #[Group('medium')]
     public function testGetPropertiesAutoLdi(): void
     {
-        $dbi = $this->createMock(DatabaseInterface::class);
+        $dbi = self::createMock(DatabaseInterface::class);
         DatabaseInterface::$instance = $dbi;
 
-        $resultStub = $this->createMock(DummyResult::class);
+        $resultStub = self::createMock(DummyResult::class);
 
-        $dbi->expects($this->any())->method('tryQuery')
+        $dbi->expects(self::any())->method('tryQuery')
             ->willReturn($resultStub);
 
-        $resultStub->expects($this->any())->method('numRows')
+        $resultStub->expects(self::any())->method('numRows')
             ->willReturn(10);
 
-        $resultStub->expects($this->any())->method('fetchValue')
+        $resultStub->expects(self::any())->method('fetchValue')
             ->willReturn('ON');
 
         $config = Config::getInstance();
         $config->settings['Import']['ldi_local_option'] = 'auto';
         $properties = (new ImportLdi())->getProperties();
-        $this->assertTrue($config->settings['Import']['ldi_local_option']);
-        $this->assertEquals(
+        self::assertTrue($config->settings['Import']['ldi_local_option']);
+        self::assertEquals(
             __('CSV using LOAD DATA'),
             $properties->getText(),
         );
-        $this->assertEquals(
+        self::assertEquals(
             'ldi',
             $properties->getExtension(),
         );
@@ -125,8 +125,8 @@ class ImportLdiTest extends AbstractTestCase
         //$sql_query_disabled will show the import SQL detail
 
         $GLOBALS['sql_query_disabled'] = false;
-        $dbi = $this->createMock(DatabaseInterface::class);
-        $dbi->expects($this->any())->method('quoteString')
+        $dbi = self::createMock(DatabaseInterface::class);
+        $dbi->expects(self::any())->method('quoteString')
             ->willReturnCallback(static fn (string $string): string => "'" . $string . "'");
         DatabaseInterface::$instance = $dbi;
 
@@ -137,12 +137,12 @@ class ImportLdiTest extends AbstractTestCase
         (new ImportLdi())->doImport($importHandle);
 
         //asset that all sql are executed
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             'LOAD DATA INFILE \'tests/test_data/db_test_ldi.csv\' INTO TABLE `phpmyadmintest`',
             $GLOBALS['sql_query'],
         );
 
-        $this->assertTrue($GLOBALS['finished']);
+        self::assertTrue($GLOBALS['finished']);
     }
 
     /**
@@ -157,12 +157,12 @@ class ImportLdiTest extends AbstractTestCase
         (new ImportLdi())->doImport();
 
         // We handle only some kind of data!
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             __('This plugin does not support compressed imports!'),
             $GLOBALS['message']->__toString(),
         );
 
-        $this->assertTrue($GLOBALS['error']);
+        self::assertTrue($GLOBALS['error']);
     }
 
     /**
@@ -174,8 +174,8 @@ class ImportLdiTest extends AbstractTestCase
         //$sql_query_disabled will show the import SQL detail
 
         $GLOBALS['sql_query_disabled'] = false;
-        $dbi = $this->createMock(DatabaseInterface::class);
-        $dbi->expects($this->any())->method('quoteString')
+        $dbi = self::createMock(DatabaseInterface::class);
+        $dbi->expects(self::any())->method('quoteString')
             ->willReturnCallback(static fn (string $string): string => "'" . $string . "'");
         DatabaseInterface::$instance = $dbi;
 
@@ -195,20 +195,20 @@ class ImportLdiTest extends AbstractTestCase
 
         //asset that all sql are executed
         //replace
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             'LOAD DATA LOCAL INFILE \'tests/test_data/db_test_ldi.csv\' REPLACE INTO TABLE `phpmyadmintest`',
             $GLOBALS['sql_query'],
         );
 
         //FIELDS TERMINATED
-        $this->assertStringContainsString("FIELDS TERMINATED BY ','", $GLOBALS['sql_query']);
+        self::assertStringContainsString("FIELDS TERMINATED BY ','", $GLOBALS['sql_query']);
 
         //LINES TERMINATED
-        $this->assertStringContainsString("LINES TERMINATED BY 'newline_mark'", $GLOBALS['sql_query']);
+        self::assertStringContainsString("LINES TERMINATED BY 'newline_mark'", $GLOBALS['sql_query']);
 
         //IGNORE
-        $this->assertStringContainsString('IGNORE 1 LINES', $GLOBALS['sql_query']);
+        self::assertStringContainsString('IGNORE 1 LINES', $GLOBALS['sql_query']);
 
-        $this->assertTrue($GLOBALS['finished']);
+        self::assertTrue($GLOBALS['finished']);
     }
 }
diff --git a/tests/classes/Plugins/Import/ImportMediawikiTest.php b/tests/classes/Plugins/Import/ImportMediawikiTest.php
index b701e1b4b8..0ed3f4cd6b 100644
--- a/tests/classes/Plugins/Import/ImportMediawikiTest.php
+++ b/tests/classes/Plugins/Import/ImportMediawikiTest.php
@@ -74,20 +74,20 @@ class ImportMediawikiTest extends AbstractTestCase
     public function testGetProperties(): void
     {
         $properties = $this->object->getProperties();
-        $this->assertEquals(
+        self::assertEquals(
             __('MediaWiki Table'),
             $properties->getText(),
         );
-        $this->assertEquals(
+        self::assertEquals(
             'txt',
             $properties->getExtension(),
         );
-        $this->assertEquals(
+        self::assertEquals(
             'text/plain',
             $properties->getMimeType(),
         );
-        $this->assertNull($properties->getOptions());
-        $this->assertEquals(
+        self::assertNull($properties->getOptions());
+        self::assertEquals(
             __('Options'),
             $properties->getOptionsText(),
         );
@@ -127,14 +127,14 @@ class ImportMediawikiTest extends AbstractTestCase
         */
 
         //asset that all databases and tables are imported
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             'The following structures have either been created or altered.',
             $GLOBALS['import_notice'],
         );
-        $this->assertStringContainsString('Go to database: `mediawiki_DB`', $GLOBALS['import_notice']);
-        $this->assertStringContainsString('Edit settings for `mediawiki_DB`', $GLOBALS['import_notice']);
-        $this->assertStringContainsString('Go to table: `pma_bookmarktest`', $GLOBALS['import_notice']);
-        $this->assertStringContainsString('Edit settings for `pma_bookmarktest`', $GLOBALS['import_notice']);
-        $this->assertTrue($GLOBALS['finished']);
+        self::assertStringContainsString('Go to database: `mediawiki_DB`', $GLOBALS['import_notice']);
+        self::assertStringContainsString('Edit settings for `mediawiki_DB`', $GLOBALS['import_notice']);
+        self::assertStringContainsString('Go to table: `pma_bookmarktest`', $GLOBALS['import_notice']);
+        self::assertStringContainsString('Edit settings for `pma_bookmarktest`', $GLOBALS['import_notice']);
+        self::assertTrue($GLOBALS['finished']);
     }
 }
diff --git a/tests/classes/Plugins/Import/ImportOdsTest.php b/tests/classes/Plugins/Import/ImportOdsTest.php
index a269da65ce..cc3934cbb4 100644
--- a/tests/classes/Plugins/Import/ImportOdsTest.php
+++ b/tests/classes/Plugins/Import/ImportOdsTest.php
@@ -87,15 +87,15 @@ class ImportOdsTest extends AbstractTestCase
     public function testGetProperties(): void
     {
         $properties = $this->object->getProperties();
-        $this->assertEquals(
+        self::assertEquals(
             __('OpenDocument Spreadsheet'),
             $properties->getText(),
         );
-        $this->assertEquals(
+        self::assertEquals(
             'ods',
             $properties->getExtension(),
         );
-        $this->assertEquals(
+        self::assertEquals(
             __('Options'),
             $properties->getOptionsText(),
         );
@@ -126,28 +126,28 @@ class ImportOdsTest extends AbstractTestCase
         //Test function called
         $this->object->doImport($importHandle);
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             'CREATE DATABASE IF NOT EXISTS `ODS_DB` DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci',
             $GLOBALS['sql_query'],
         );
-        $this->assertStringContainsString('CREATE TABLE IF NOT EXISTS `ODS_DB`.`pma_bookmark`', $GLOBALS['sql_query']);
-        $this->assertStringContainsString(
+        self::assertStringContainsString('CREATE TABLE IF NOT EXISTS `ODS_DB`.`pma_bookmark`', $GLOBALS['sql_query']);
+        self::assertStringContainsString(
             'INSERT INTO `ODS_DB`.`pma_bookmark` (`A`, `B`, `C`, `D`) VALUES (1, \'dbbase\', NULL, \'ddd\');',
             $GLOBALS['sql_query'],
         );
 
         //asset that all databases and tables are imported
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             'The following structures have either been created or altered.',
             $GLOBALS['import_notice'],
         );
-        $this->assertStringContainsString('Go to database: `ODS_DB`', $GLOBALS['import_notice']);
-        $this->assertStringContainsString('Edit settings for `ODS_DB`', $GLOBALS['import_notice']);
-        $this->assertStringContainsString('Go to table: `pma_bookmark`', $GLOBALS['import_notice']);
-        $this->assertStringContainsString('Edit settings for `pma_bookmark`', $GLOBALS['import_notice']);
+        self::assertStringContainsString('Go to database: `ODS_DB`', $GLOBALS['import_notice']);
+        self::assertStringContainsString('Edit settings for `ODS_DB`', $GLOBALS['import_notice']);
+        self::assertStringContainsString('Go to table: `pma_bookmark`', $GLOBALS['import_notice']);
+        self::assertStringContainsString('Edit settings for `pma_bookmark`', $GLOBALS['import_notice']);
 
         //asset that the import process is finished
-        $this->assertTrue($GLOBALS['finished']);
+        self::assertTrue($GLOBALS['finished']);
     }
 
     /** @return mixed[] */
@@ -194,7 +194,7 @@ class ImportOdsTest extends AbstractTestCase
         //Test function called
         $this->object->doImport($importHandle);
 
-        $this->assertSame(
+        self::assertSame(
             'CREATE DATABASE IF NOT EXISTS `ODS_DB` DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci;;'
             . 'CREATE TABLE IF NOT EXISTS `ODS_DB`.`Shop` ('
             . '`Artikelnummer` varchar(7), `Name` varchar(41), `keywords` varchar(15), `EK_Preis` varchar(21),'
@@ -251,16 +251,16 @@ class ImportOdsTest extends AbstractTestCase
         );
 
         //asset that all databases and tables are imported
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             'The following structures have either been created or altered.',
             $GLOBALS['import_notice'],
         );
-        $this->assertStringContainsString('Go to database: `ODS_DB`', $GLOBALS['import_notice']);
-        $this->assertStringContainsString('Edit settings for `ODS_DB`', $GLOBALS['import_notice']);
-        $this->assertStringContainsString('Go to table: `Shop`', $GLOBALS['import_notice']);
-        $this->assertStringContainsString('Edit settings for `Shop`', $GLOBALS['import_notice']);
+        self::assertStringContainsString('Go to database: `ODS_DB`', $GLOBALS['import_notice']);
+        self::assertStringContainsString('Edit settings for `ODS_DB`', $GLOBALS['import_notice']);
+        self::assertStringContainsString('Go to table: `Shop`', $GLOBALS['import_notice']);
+        self::assertStringContainsString('Edit settings for `Shop`', $GLOBALS['import_notice']);
 
         //asset that the import process is finished
-        $this->assertTrue($GLOBALS['finished']);
+        self::assertTrue($GLOBALS['finished']);
     }
 }
diff --git a/tests/classes/Plugins/Import/ImportShpTest.php b/tests/classes/Plugins/Import/ImportShpTest.php
index 40fcb3a43f..e000d791b5 100644
--- a/tests/classes/Plugins/Import/ImportShpTest.php
+++ b/tests/classes/Plugins/Import/ImportShpTest.php
@@ -82,8 +82,8 @@ class ImportShpTest extends AbstractTestCase
         $GLOBALS['message'] = '';
         $GLOBALS['error'] = false;
         $this->object->doImport($importHandle);
-        $this->assertEquals('', $GLOBALS['message']);
-        $this->assertFalse($GLOBALS['error']);
+        self::assertEquals('', $GLOBALS['message']);
+        self::assertFalse($GLOBALS['error']);
     }
 
     /**
@@ -104,16 +104,16 @@ class ImportShpTest extends AbstractTestCase
     public function testGetProperties(): void
     {
         $properties = $this->object->getProperties();
-        $this->assertEquals(
+        self::assertEquals(
             __('ESRI Shape File'),
             $properties->getText(),
         );
-        $this->assertEquals(
+        self::assertEquals(
             'shp',
             $properties->getExtension(),
         );
-        $this->assertNull($properties->getOptions());
-        $this->assertEquals(
+        self::assertNull($properties->getOptions());
+        self::assertEquals(
             __('Options'),
             $properties->getOptionsText(),
         );
@@ -143,7 +143,7 @@ class ImportShpTest extends AbstractTestCase
             $endsWith = "13.737122 51.0542065)))'),";
         }
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             "(GeomFromText('MULTIPOLYGON((("
             . '13.737122 51.0542065,'
             . '13.7373039 51.0541298,'
@@ -171,37 +171,37 @@ class ImportShpTest extends AbstractTestCase
         $this->runImport('tests/test_data/timezone.shp.zip');
 
         // asset that all sql are executed
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             'CREATE DATABASE IF NOT EXISTS `SHP_DB` DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci',
             $GLOBALS['sql_query'],
         );
 
         // dbase extension will generate different sql statement
         if (extension_loaded('dbase')) {
-            $this->assertStringContainsString(
+            self::assertStringContainsString(
                 'CREATE TABLE IF NOT EXISTS `SHP_DB`.`TBL_NAME` '
                 . '(`SPATIAL` geometry, `ID` int(2), `AUTHORITY` varchar(25), `NAME` varchar(42)) '
                 . 'DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci;',
                 $GLOBALS['sql_query'],
             );
 
-            $this->assertStringContainsString(
+            self::assertStringContainsString(
                 'INSERT INTO `SHP_DB`.`TBL_NAME` (`SPATIAL`, `ID`, `AUTHORITY`, `NAME`) VALUES',
                 $GLOBALS['sql_query'],
             );
         } else {
-            $this->assertStringContainsString(
+            self::assertStringContainsString(
                 'CREATE TABLE IF NOT EXISTS `SHP_DB`.`TBL_NAME` (`SPATIAL` geometry)',
                 $GLOBALS['sql_query'],
             );
 
-            $this->assertStringContainsString(
+            self::assertStringContainsString(
                 'INSERT INTO `SHP_DB`.`TBL_NAME` (`SPATIAL`) VALUES',
                 $GLOBALS['sql_query'],
             );
         }
 
-        $this->assertStringContainsString("GeomFromText('POINT(1294523.1759236", $GLOBALS['sql_query']);
+        self::assertStringContainsString("GeomFromText('POINT(1294523.1759236", $GLOBALS['sql_query']);
 
         //asset that all databases and tables are imported
         $this->assertMessages($GLOBALS['import_notice']);
@@ -214,16 +214,16 @@ class ImportShpTest extends AbstractTestCase
      */
     protected function assertMessages(string $importNotice): void
     {
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             'The following structures have either been created or altered.',
             $importNotice,
         );
-        $this->assertStringContainsString('Go to database: `SHP_DB`', $importNotice);
-        $this->assertStringContainsString('Edit settings for `SHP_DB`', $importNotice);
-        $this->assertStringContainsString('Go to table: `TBL_NAME`', $importNotice);
-        $this->assertStringContainsString('Edit settings for `TBL_NAME`', $importNotice);
+        self::assertStringContainsString('Go to database: `SHP_DB`', $importNotice);
+        self::assertStringContainsString('Edit settings for `SHP_DB`', $importNotice);
+        self::assertStringContainsString('Go to table: `TBL_NAME`', $importNotice);
+        self::assertStringContainsString('Edit settings for `TBL_NAME`', $importNotice);
 
         //asset that the import process is finished
-        $this->assertTrue($GLOBALS['finished']);
+        self::assertTrue($GLOBALS['finished']);
     }
 }
diff --git a/tests/classes/Plugins/Import/ImportSqlTest.php b/tests/classes/Plugins/Import/ImportSqlTest.php
index 584716b050..1922a2a79b 100644
--- a/tests/classes/Plugins/Import/ImportSqlTest.php
+++ b/tests/classes/Plugins/Import/ImportSqlTest.php
@@ -86,13 +86,13 @@ class ImportSqlTest extends AbstractTestCase
         $this->object->doImport($importHandle);
 
         //asset that all sql are executed
-        $this->assertStringContainsString('SET SQL_MODE = "NO_AUTO_VALUE_ON_ZERO"', $GLOBALS['sql_query']);
-        $this->assertStringContainsString('CREATE TABLE IF NOT EXISTS `pma_bookmark`', $GLOBALS['sql_query']);
-        $this->assertStringContainsString(
+        self::assertStringContainsString('SET SQL_MODE = "NO_AUTO_VALUE_ON_ZERO"', $GLOBALS['sql_query']);
+        self::assertStringContainsString('CREATE TABLE IF NOT EXISTS `pma_bookmark`', $GLOBALS['sql_query']);
+        self::assertStringContainsString(
             'INSERT INTO `pma_bookmark` (`id`, `dbase`, `user`, `label`, `query`) VALUES',
             $GLOBALS['sql_query'],
         );
 
-        $this->assertTrue($GLOBALS['finished']);
+        self::assertTrue($GLOBALS['finished']);
     }
 }
diff --git a/tests/classes/Plugins/Import/ImportXmlTest.php b/tests/classes/Plugins/Import/ImportXmlTest.php
index 510c4dfa6e..29070c4e6b 100644
--- a/tests/classes/Plugins/Import/ImportXmlTest.php
+++ b/tests/classes/Plugins/Import/ImportXmlTest.php
@@ -78,20 +78,20 @@ class ImportXmlTest extends AbstractTestCase
     public function testGetProperties(): void
     {
         $properties = $this->object->getProperties();
-        $this->assertEquals(
+        self::assertEquals(
             __('XML'),
             $properties->getText(),
         );
-        $this->assertEquals(
+        self::assertEquals(
             'xml',
             $properties->getExtension(),
         );
-        $this->assertEquals(
+        self::assertEquals(
             'text/xml',
             $properties->getMimeType(),
         );
-        $this->assertNull($properties->getOptions());
-        $this->assertEquals(
+        self::assertNull($properties->getOptions());
+        self::assertEquals(
             __('Options'),
             $properties->getOptionsText(),
         );
@@ -132,14 +132,14 @@ class ImportXmlTest extends AbstractTestCase
         */
 
         //asset that all databases and tables are imported
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             'The following structures have either been created or altered.',
             $GLOBALS['import_notice'],
         );
-        $this->assertStringContainsString('Go to database: `phpmyadmintest`', $GLOBALS['import_notice']);
-        $this->assertStringContainsString('Edit settings for `phpmyadmintest`', $GLOBALS['import_notice']);
-        $this->assertStringContainsString('Go to table: `pma_bookmarktest`', $GLOBALS['import_notice']);
-        $this->assertStringContainsString('Edit settings for `pma_bookmarktest`', $GLOBALS['import_notice']);
-        $this->assertTrue($GLOBALS['finished']);
+        self::assertStringContainsString('Go to database: `phpmyadmintest`', $GLOBALS['import_notice']);
+        self::assertStringContainsString('Edit settings for `phpmyadmintest`', $GLOBALS['import_notice']);
+        self::assertStringContainsString('Go to table: `pma_bookmarktest`', $GLOBALS['import_notice']);
+        self::assertStringContainsString('Edit settings for `pma_bookmarktest`', $GLOBALS['import_notice']);
+        self::assertTrue($GLOBALS['finished']);
     }
 }
diff --git a/tests/classes/Plugins/Schema/DiaRelationSchemaTest.php b/tests/classes/Plugins/Schema/DiaRelationSchemaTest.php
index 3983acc19d..5f75cddbb2 100644
--- a/tests/classes/Plugins/Schema/DiaRelationSchemaTest.php
+++ b/tests/classes/Plugins/Schema/DiaRelationSchemaTest.php
@@ -66,10 +66,10 @@ class DiaRelationSchemaTest extends AbstractTestCase
     #[Group('medium')]
     public function testSetProperty(): void
     {
-        $this->assertEquals(33, $this->object->getPageNumber());
-        $this->assertTrue($this->object->isShowColor());
-        $this->assertTrue($this->object->isShowKeys());
-        $this->assertEquals('L', $this->object->getOrientation());
-        $this->assertEquals('paper', $this->object->getPaper());
+        self::assertEquals(33, $this->object->getPageNumber());
+        self::assertTrue($this->object->isShowColor());
+        self::assertTrue($this->object->isShowKeys());
+        self::assertEquals('L', $this->object->getOrientation());
+        self::assertEquals('paper', $this->object->getPaper());
     }
 }
diff --git a/tests/classes/Plugins/Schema/EpsRelationSchemaTest.php b/tests/classes/Plugins/Schema/EpsRelationSchemaTest.php
index 120bdef8cd..78aee8dd20 100644
--- a/tests/classes/Plugins/Schema/EpsRelationSchemaTest.php
+++ b/tests/classes/Plugins/Schema/EpsRelationSchemaTest.php
@@ -65,12 +65,12 @@ class EpsRelationSchemaTest extends AbstractTestCase
     #[Group('medium')]
     public function testConstructor(): void
     {
-        $this->assertEquals(33, $this->object->getPageNumber());
-        $this->assertTrue($this->object->isShowColor());
-        $this->assertTrue($this->object->isShowKeys());
-        $this->assertTrue($this->object->isTableDimension());
-        $this->assertTrue($this->object->isAllTableSameWidth());
-        $this->assertEquals('L', $this->object->getOrientation());
+        self::assertEquals(33, $this->object->getPageNumber());
+        self::assertTrue($this->object->isShowColor());
+        self::assertTrue($this->object->isShowKeys());
+        self::assertTrue($this->object->isTableDimension());
+        self::assertTrue($this->object->isAllTableSameWidth());
+        self::assertEquals('L', $this->object->getOrientation());
     }
 
     /**
@@ -80,6 +80,6 @@ class EpsRelationSchemaTest extends AbstractTestCase
     public function testSetPageNumber(): void
     {
         $this->object->setPageNumber(33);
-        $this->assertEquals(33, $this->object->getPageNumber());
+        self::assertEquals(33, $this->object->getPageNumber());
     }
 }
diff --git a/tests/classes/Plugins/Schema/ExportRelationSchemaTest.php b/tests/classes/Plugins/Schema/ExportRelationSchemaTest.php
index 98b5474f7e..316603b46d 100644
--- a/tests/classes/Plugins/Schema/ExportRelationSchemaTest.php
+++ b/tests/classes/Plugins/Schema/ExportRelationSchemaTest.php
@@ -49,7 +49,7 @@ class ExportRelationSchemaTest extends AbstractTestCase
     public function testSetPageNumber(): void
     {
         $this->object->setPageNumber(33);
-        $this->assertEquals(
+        self::assertEquals(
             33,
             $this->object->getPageNumber(),
         );
@@ -62,11 +62,11 @@ class ExportRelationSchemaTest extends AbstractTestCase
     public function testSetShowColor(): void
     {
         $this->object->setShowColor(true);
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->isShowColor(),
         );
         $this->object->setShowColor(false);
-        $this->assertFalse(
+        self::assertFalse(
             $this->object->isShowColor(),
         );
     }
@@ -78,12 +78,12 @@ class ExportRelationSchemaTest extends AbstractTestCase
     public function testSetOrientation(): void
     {
         $this->object->setOrientation('P');
-        $this->assertEquals(
+        self::assertEquals(
             'P',
             $this->object->getOrientation(),
         );
         $this->object->setOrientation('A');
-        $this->assertEquals(
+        self::assertEquals(
             'L',
             $this->object->getOrientation(),
         );
@@ -96,11 +96,11 @@ class ExportRelationSchemaTest extends AbstractTestCase
     public function testSetTableDimension(): void
     {
         $this->object->setTableDimension(true);
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->isTableDimension(),
         );
         $this->object->setTableDimension(false);
-        $this->assertFalse(
+        self::assertFalse(
             $this->object->isTableDimension(),
         );
     }
@@ -112,12 +112,12 @@ class ExportRelationSchemaTest extends AbstractTestCase
     public function testSetPaper(): void
     {
         $this->object->setPaper('A5');
-        $this->assertEquals(
+        self::assertEquals(
             'A5',
             $this->object->getPaper(),
         );
         $this->object->setPaper('A4');
-        $this->assertEquals(
+        self::assertEquals(
             'A4',
             $this->object->getPaper(),
         );
@@ -130,11 +130,11 @@ class ExportRelationSchemaTest extends AbstractTestCase
     public function testSetAllTablesSameWidth(): void
     {
         $this->object->setAllTablesSameWidth(true);
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->isAllTableSameWidth(),
         );
         $this->object->setAllTablesSameWidth(false);
-        $this->assertFalse(
+        self::assertFalse(
             $this->object->isAllTableSameWidth(),
         );
     }
@@ -146,11 +146,11 @@ class ExportRelationSchemaTest extends AbstractTestCase
     public function testSetShowKeys(): void
     {
         $this->object->setShowKeys(true);
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->isShowKeys(),
         );
         $this->object->setShowKeys(false);
-        $this->assertFalse(
+        self::assertFalse(
             $this->object->isShowKeys(),
         );
     }
diff --git a/tests/classes/Plugins/Schema/PdfRelationSchemaTest.php b/tests/classes/Plugins/Schema/PdfRelationSchemaTest.php
index 1265955567..95db427721 100644
--- a/tests/classes/Plugins/Schema/PdfRelationSchemaTest.php
+++ b/tests/classes/Plugins/Schema/PdfRelationSchemaTest.php
@@ -68,13 +68,13 @@ class PdfRelationSchemaTest extends AbstractTestCase
     #[Group('large')]
     public function testConstructor(): void
     {
-        $this->assertEquals(33, $this->object->getPageNumber());
-        $this->assertTrue($this->object->isShowGrid());
-        $this->assertTrue($this->object->isShowColor());
-        $this->assertTrue($this->object->isShowKeys());
-        $this->assertTrue($this->object->isTableDimension());
-        $this->assertTrue($this->object->isAllTableSameWidth());
-        $this->assertEquals('L', $this->object->getOrientation());
-        $this->assertEquals('paper', $this->object->getPaper());
+        self::assertEquals(33, $this->object->getPageNumber());
+        self::assertTrue($this->object->isShowGrid());
+        self::assertTrue($this->object->isShowColor());
+        self::assertTrue($this->object->isShowKeys());
+        self::assertTrue($this->object->isTableDimension());
+        self::assertTrue($this->object->isAllTableSameWidth());
+        self::assertEquals('L', $this->object->getOrientation());
+        self::assertEquals('paper', $this->object->getPaper());
     }
 }
diff --git a/tests/classes/Plugins/Schema/SvgRelationSchemaTest.php b/tests/classes/Plugins/Schema/SvgRelationSchemaTest.php
index 814ce5c457..7cedb8f041 100644
--- a/tests/classes/Plugins/Schema/SvgRelationSchemaTest.php
+++ b/tests/classes/Plugins/Schema/SvgRelationSchemaTest.php
@@ -68,10 +68,10 @@ class SvgRelationSchemaTest extends AbstractTestCase
     #[Group('medium')]
     public function testConstructor(): void
     {
-        $this->assertEquals(33, $this->object->getPageNumber());
-        $this->assertTrue($this->object->isShowColor());
-        $this->assertTrue($this->object->isShowKeys());
-        $this->assertTrue($this->object->isTableDimension());
-        $this->assertTrue($this->object->isAllTableSameWidth());
+        self::assertEquals(33, $this->object->getPageNumber());
+        self::assertTrue($this->object->isShowColor());
+        self::assertTrue($this->object->isShowKeys());
+        self::assertTrue($this->object->isTableDimension());
+        self::assertTrue($this->object->isAllTableSameWidth());
     }
 }
diff --git a/tests/classes/Plugins/Transformations/TransformationPluginsTest.php b/tests/classes/Plugins/Transformations/TransformationPluginsTest.php
index 463c0aff79..5dac1daddc 100644
--- a/tests/classes/Plugins/Transformations/TransformationPluginsTest.php
+++ b/tests/classes/Plugins/Transformations/TransformationPluginsTest.php
@@ -417,7 +417,7 @@ class TransformationPluginsTest extends AbstractTestCase
         }
 
         $reflectionMethod = new ReflectionMethod($object, $method);
-        $this->assertEquals(
+        self::assertEquals(
             $expected,
             $reflectionMethod->invokeArgs($object, $args),
         );
@@ -667,11 +667,11 @@ class TransformationPluginsTest extends AbstractTestCase
         string $error = '',
     ): void {
         $actual = $object->applyTransformation(...$applyArgs);
-        $this->assertEquals($transformed, $actual);
+        self::assertEquals($transformed, $actual);
 
         // For output transformation plugins, this method may not exist
         if (method_exists($object, 'isSuccess')) {
-            $this->assertEquals(
+            self::assertEquals(
                 $success,
                 $object->isSuccess(),
             );
@@ -682,7 +682,7 @@ class TransformationPluginsTest extends AbstractTestCase
             return;
         }
 
-        $this->assertEquals(
+        self::assertEquals(
             $error,
             $object->getError(),
         );
diff --git a/tests/classes/Plugins/TwoFactor/KeyTest.php b/tests/classes/Plugins/TwoFactor/KeyTest.php
index 593cf7a788..da143caa50 100644
--- a/tests/classes/Plugins/TwoFactor/KeyTest.php
+++ b/tests/classes/Plugins/TwoFactor/KeyTest.php
@@ -14,7 +14,7 @@ class KeyTest extends AbstractTestCase
 {
     public function testGetRegistrations(): void
     {
-        $twoFactor = $this->createStub(TwoFactor::class);
+        $twoFactor = self::createStub(TwoFactor::class);
         $twoFactor->config = [
             'backend' => 'key',
             'settings' => [
@@ -39,6 +39,6 @@ class KeyTest extends AbstractTestCase
                 'index' => 0,
             ],
         ];
-        $this->assertEquals($expected, $actual);
+        self::assertEquals($expected, $actual);
     }
 }
diff --git a/tests/classes/Plugins/TwoFactor/WebAuthnTest.php b/tests/classes/Plugins/TwoFactor/WebAuthnTest.php
index adced9e646..5d2e3476f7 100644
--- a/tests/classes/Plugins/TwoFactor/WebAuthnTest.php
+++ b/tests/classes/Plugins/TwoFactor/WebAuthnTest.php
@@ -28,9 +28,9 @@ class WebAuthnTest extends AbstractTestCase
 {
     public function testIdNameAndDescription(): void
     {
-        $this->assertSame('WebAuthn', WebAuthn::$id);
-        $this->assertSame('Hardware Security Key (WebAuthn/FIDO2)', WebAuthn::getName());
-        $this->assertSame(
+        self::assertSame('WebAuthn', WebAuthn::$id);
+        self::assertSame('Hardware Security Key (WebAuthn/FIDO2)', WebAuthn::getName());
+        self::assertSame(
             'Provides authentication using hardware security tokens supporting the WebAuthn/FIDO2 protocol,'
             . ' such as a YubiKey.',
             WebAuthn::getDescription(),
@@ -45,12 +45,12 @@ class WebAuthnTest extends AbstractTestCase
         $GLOBALS['lang'] = 'en';
         DatabaseInterface::$instance = $this->createDatabaseInterface();
 
-        $uri = $this->createStub(UriInterface::class);
+        $uri = self::createStub(UriInterface::class);
         $uri->method('getHost')->willReturn('test.localhost');
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('getUri')->willReturn($uri);
 
-        $twoFactor = $this->createStub(TwoFactor::class);
+        $twoFactor = self::createStub(TwoFactor::class);
         $twoFactor->user = 'test_user';
         $twoFactor->config = [
             'backend' => 'WebAuthn',
@@ -73,12 +73,12 @@ class WebAuthnTest extends AbstractTestCase
             'allowCredentials' => [['type' => 'public-key', 'id' => 'cHVibGljS2V5Q3JlZGVudGlhbElkMQ']],
             'timeout' => 60000,
         ];
-        $server = $this->createMock(Server::class);
-        $server->expects($this->once())->method('getCredentialRequestOptions')->with(
-            $this->equalTo('test_user'),
-            $this->anything(),
-            $this->equalTo('test.localhost'),
-            $this->equalTo([['type' => 'public-key', 'id' => 'cHVibGljS2V5Q3JlZGVudGlhbElkMQ']]),
+        $server = self::createMock(Server::class);
+        $server->expects(self::once())->method('getCredentialRequestOptions')->with(
+            self::equalTo('test_user'),
+            self::anything(),
+            self::equalTo('test.localhost'),
+            self::equalTo([['type' => 'public-key', 'id' => 'cHVibGljS2V5Q3JlZGVudGlhbElkMQ']]),
         )->willReturn($expectedRequestOptions);
 
         $webAuthn = new WebAuthn($twoFactor);
@@ -86,18 +86,18 @@ class WebAuthnTest extends AbstractTestCase
         $actual = $webAuthn->render($request);
 
         $optionsFromSession = $_SESSION['WebAuthnCredentialRequestOptions'] ?? null;
-        $this->assertIsString($optionsFromSession);
-        $this->assertJson($optionsFromSession);
-        $this->assertEquals($expectedRequestOptions, json_decode($optionsFromSession, true));
+        self::assertIsString($optionsFromSession);
+        self::assertJson($optionsFromSession);
+        self::assertEquals($expectedRequestOptions, json_decode($optionsFromSession, true));
 
-        $this->assertStringContainsString('id="webauthn_request_response"', $actual);
-        $this->assertStringContainsString('name="webauthn_request_response"', $actual);
-        $this->assertStringContainsString('value=""', $actual);
-        $this->assertStringContainsString('data-request-options="', $actual);
-        $this->assertSame('', $webAuthn->getError());
+        self::assertStringContainsString('id="webauthn_request_response"', $actual);
+        self::assertStringContainsString('name="webauthn_request_response"', $actual);
+        self::assertStringContainsString('value=""', $actual);
+        self::assertStringContainsString('data-request-options="', $actual);
+        self::assertSame('', $webAuthn->getError());
 
         $files = ResponseRenderer::getInstance()->getHeader()->getScripts()->getFiles();
-        $this->assertContains('webauthn.js', array_column($files, 'name'));
+        self::assertContains('webauthn.js', array_column($files, 'name'));
     }
 
     #[BackupStaticProperties(true)]
@@ -108,12 +108,12 @@ class WebAuthnTest extends AbstractTestCase
         $GLOBALS['lang'] = 'en';
         DatabaseInterface::$instance = $this->createDatabaseInterface();
 
-        $uri = $this->createStub(UriInterface::class);
+        $uri = self::createStub(UriInterface::class);
         $uri->method('getHost')->willReturn('test.localhost');
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('getUri')->willReturn($uri);
 
-        $twoFactor = $this->createStub(TwoFactor::class);
+        $twoFactor = self::createStub(TwoFactor::class);
         $twoFactor->user = 'test_user';
 
         $expectedCreationOptions = [
@@ -125,11 +125,11 @@ class WebAuthnTest extends AbstractTestCase
             'timeout' => 60000,
             'attestation' => 'none',
         ];
-        $server = $this->createMock(Server::class);
-        $server->expects($this->once())->method('getCredentialCreationOptions')->with(
-            $this->equalTo('test_user'),
-            $this->anything(),
-            $this->equalTo('test.localhost'),
+        $server = self::createMock(Server::class);
+        $server->expects(self::once())->method('getCredentialCreationOptions')->with(
+            self::equalTo('test_user'),
+            self::anything(),
+            self::equalTo('test.localhost'),
         )->willReturn($expectedCreationOptions);
 
         $webAuthn = new WebAuthn($twoFactor);
@@ -137,80 +137,80 @@ class WebAuthnTest extends AbstractTestCase
         $actual = $webAuthn->setup($request);
 
         $optionsFromSession = $_SESSION['WebAuthnCredentialCreationOptions'] ?? null;
-        $this->assertIsString($optionsFromSession);
-        $this->assertJson($optionsFromSession);
-        $this->assertEquals($expectedCreationOptions, json_decode($optionsFromSession, true));
+        self::assertIsString($optionsFromSession);
+        self::assertJson($optionsFromSession);
+        self::assertEquals($expectedCreationOptions, json_decode($optionsFromSession, true));
 
-        $this->assertStringContainsString('id="webauthn_creation_response"', $actual);
-        $this->assertStringContainsString('name="webauthn_creation_response"', $actual);
-        $this->assertStringContainsString('value=""', $actual);
-        $this->assertStringContainsString('data-creation-options="', $actual);
-        $this->assertSame('', $webAuthn->getError());
+        self::assertStringContainsString('id="webauthn_creation_response"', $actual);
+        self::assertStringContainsString('name="webauthn_creation_response"', $actual);
+        self::assertStringContainsString('value=""', $actual);
+        self::assertStringContainsString('data-creation-options="', $actual);
+        self::assertSame('', $webAuthn->getError());
 
         $files = ResponseRenderer::getInstance()->getHeader()->getScripts()->getFiles();
-        $this->assertContains('webauthn.js', array_column($files, 'name'));
+        self::assertContains('webauthn.js', array_column($files, 'name'));
     }
 
     public function testConfigure(): void
     {
         $_SESSION = [];
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('getParsedBodyParam')->willReturnMap([['webauthn_creation_response', '', '']]);
-        $webAuthn = new WebAuthn($this->createStub(TwoFactor::class));
-        $this->assertFalse($webAuthn->configure($request));
-        $this->assertSame('', $webAuthn->getError());
+        $webAuthn = new WebAuthn(self::createStub(TwoFactor::class));
+        self::assertFalse($webAuthn->configure($request));
+        self::assertSame('', $webAuthn->getError());
     }
 
     public function testConfigure2(): void
     {
         $_SESSION['WebAuthnCredentialCreationOptions'] = '';
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('getParsedBodyParam')->willReturnMap([['webauthn_creation_response', '', '{}']]);
-        $webAuthn = new WebAuthn($this->createStub(TwoFactor::class));
-        $this->assertFalse($webAuthn->configure($request));
-        $this->assertStringContainsString('Two-factor authentication failed:', $webAuthn->getError());
+        $webAuthn = new WebAuthn(self::createStub(TwoFactor::class));
+        self::assertFalse($webAuthn->configure($request));
+        self::assertStringContainsString('Two-factor authentication failed:', $webAuthn->getError());
     }
 
     public function testConfigure3(): void
     {
         $_SESSION['WebAuthnCredentialCreationOptions'] = '{}';
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('getParsedBodyParam')->willReturnMap([['webauthn_creation_response', '', '{}']]);
 
-        $server = $this->createMock(Server::class);
-        $server->expects($this->once())->method('parseAndValidateAttestationResponse')
+        $server = self::createMock(Server::class);
+        $server->expects(self::once())->method('parseAndValidateAttestationResponse')
             ->willThrowException(new WebAuthnException());
 
-        $webAuthn = new WebAuthn($this->createStub(TwoFactor::class));
+        $webAuthn = new WebAuthn(self::createStub(TwoFactor::class));
         $webAuthn->setServer($server);
-        $this->assertFalse($webAuthn->configure($request));
-        $this->assertStringContainsString('Two-factor authentication failed.', $webAuthn->getError());
+        self::assertFalse($webAuthn->configure($request));
+        self::assertStringContainsString('Two-factor authentication failed.', $webAuthn->getError());
     }
 
     public function testConfigure4(): void
     {
         $_SESSION['WebAuthnCredentialCreationOptions'] = '{}';
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('getParsedBodyParam')->willReturnMap([['webauthn_creation_response', '', '{}']]);
 
-        $twoFactor = $this->createStub(TwoFactor::class);
+        $twoFactor = self::createStub(TwoFactor::class);
         $twoFactor->config = ['backend' => '', 'settings' => []];
 
         // base64url of publicKeyCredentialId1
         $credential = ['publicKeyCredentialId' => 'cHVibGljS2V5Q3JlZGVudGlhbElkMQ', 'userHandle' => 'userHandle'];
-        $server = $this->createMock(Server::class);
-        $server->expects($this->once())->method('parseAndValidateAttestationResponse')->with(
-            $this->equalTo('{}'),
-            $this->equalTo('{}'),
-            $this->equalTo($request),
+        $server = self::createMock(Server::class);
+        $server->expects(self::once())->method('parseAndValidateAttestationResponse')->with(
+            self::equalTo('{}'),
+            self::equalTo('{}'),
+            self::equalTo($request),
         )->willReturn($credential);
 
         $webAuthn = new WebAuthn($twoFactor);
         $webAuthn->setServer($server);
-        $this->assertTrue($webAuthn->configure($request));
+        self::assertTrue($webAuthn->configure($request));
         /** @psalm-var array{backend: string, settings: mixed[]} $config */
         $config = $twoFactor->config;
-        $this->assertSame(
+        self::assertSame(
             [
                 'backend' => '',
                 'settings' => [
@@ -225,46 +225,46 @@ class WebAuthnTest extends AbstractTestCase
     public function testCheck(): void
     {
         $_SESSION = [];
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('getParsedBodyParam')->willReturnMap([['webauthn_request_response', '', '']]);
-        $webAuthn = new WebAuthn($this->createStub(TwoFactor::class));
-        $this->assertFalse($webAuthn->check($request));
-        $this->assertSame('', $webAuthn->getError());
+        $webAuthn = new WebAuthn(self::createStub(TwoFactor::class));
+        self::assertFalse($webAuthn->check($request));
+        self::assertSame('', $webAuthn->getError());
     }
 
     public function testCheck2(): void
     {
         $_SESSION['WebAuthnCredentialRequestOptions'] = '';
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('getParsedBodyParam')->willReturnMap([['webauthn_request_response', '', '{}']]);
-        $webAuthn = new WebAuthn($this->createStub(TwoFactor::class));
-        $this->assertFalse($webAuthn->check($request));
-        $this->assertStringContainsString('Two-factor authentication failed:', $webAuthn->getError());
+        $webAuthn = new WebAuthn(self::createStub(TwoFactor::class));
+        self::assertFalse($webAuthn->check($request));
+        self::assertStringContainsString('Two-factor authentication failed:', $webAuthn->getError());
     }
 
     public function testCheck3(): void
     {
         $_SESSION['WebAuthnCredentialRequestOptions'] = '{"challenge":"challenge"}';
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('getParsedBodyParam')->willReturnMap([['webauthn_request_response', '', '{}']]);
 
-        $server = $this->createMock(Server::class);
-        $server->expects($this->once())->method('parseAndValidateAssertionResponse')
+        $server = self::createMock(Server::class);
+        $server->expects(self::once())->method('parseAndValidateAssertionResponse')
             ->willThrowException(new WebAuthnException());
 
-        $webAuthn = new WebAuthn($this->createStub(TwoFactor::class));
+        $webAuthn = new WebAuthn(self::createStub(TwoFactor::class));
         $webAuthn->setServer($server);
-        $this->assertFalse($webAuthn->check($request));
-        $this->assertStringContainsString('Two-factor authentication failed.', $webAuthn->getError());
+        self::assertFalse($webAuthn->check($request));
+        self::assertStringContainsString('Two-factor authentication failed.', $webAuthn->getError());
     }
 
     public function testCheck4(): void
     {
         $_SESSION['WebAuthnCredentialRequestOptions'] = '{"challenge":"challenge"}';
-        $request = $this->createStub(ServerRequest::class);
+        $request = self::createStub(ServerRequest::class);
         $request->method('getParsedBodyParam')->willReturnMap([['webauthn_request_response', '', '{}']]);
 
-        $twoFactor = $this->createStub(TwoFactor::class);
+        $twoFactor = self::createStub(TwoFactor::class);
         $twoFactor->config = [
             'backend' => 'WebAuthn',
             'settings' => [
@@ -279,16 +279,16 @@ class WebAuthnTest extends AbstractTestCase
             ],
         ];
 
-        $server = $this->createMock(Server::class);
-        $server->expects($this->once())->method('parseAndValidateAssertionResponse')->with(
-            $this->equalTo('{}'),
-            $this->equalTo([['type' => 'public-key', 'id' => 'cHVibGljS2V5Q3JlZGVudGlhbElkMQ']]),
-            $this->equalTo('challenge'),
-            $this->equalTo($request),
+        $server = self::createMock(Server::class);
+        $server->expects(self::once())->method('parseAndValidateAssertionResponse')->with(
+            self::equalTo('{}'),
+            self::equalTo([['type' => 'public-key', 'id' => 'cHVibGljS2V5Q3JlZGVudGlhbElkMQ']]),
+            self::equalTo('challenge'),
+            self::equalTo($request),
         );
 
         $webAuthn = new WebAuthn($twoFactor);
         $webAuthn->setServer($server);
-        $this->assertTrue($webAuthn->check($request));
+        self::assertTrue($webAuthn->check($request));
     }
 }
diff --git a/tests/classes/PluginsTest.php b/tests/classes/PluginsTest.php
index 0aaa2e2f56..460c84b82b 100644
--- a/tests/classes/PluginsTest.php
+++ b/tests/classes/PluginsTest.php
@@ -26,27 +26,27 @@ class PluginsTest extends AbstractTestCase
     public function testGetExport(): void
     {
         $plugins = Plugins::getExport('database', false);
-        $this->assertEquals(['export_type' => 'database', 'single_table' => false], $GLOBALS['plugin_param']);
-        $this->assertIsArray($plugins);
-        $this->assertCount(14, $plugins);
-        $this->assertContainsOnlyInstancesOf(Plugins\ExportPlugin::class, $plugins);
+        self::assertEquals(['export_type' => 'database', 'single_table' => false], $GLOBALS['plugin_param']);
+        self::assertIsArray($plugins);
+        self::assertCount(14, $plugins);
+        self::assertContainsOnlyInstancesOf(Plugins\ExportPlugin::class, $plugins);
     }
 
     public function testGetImport(): void
     {
         $plugins = Plugins::getImport('database');
-        $this->assertEquals('database', $GLOBALS['plugin_param']);
-        $this->assertIsArray($plugins);
-        $this->assertCount(6, $plugins);
-        $this->assertContainsOnlyInstancesOf(Plugins\ImportPlugin::class, $plugins);
+        self::assertEquals('database', $GLOBALS['plugin_param']);
+        self::assertIsArray($plugins);
+        self::assertCount(6, $plugins);
+        self::assertContainsOnlyInstancesOf(Plugins\ImportPlugin::class, $plugins);
     }
 
     public function testGetSchema(): void
     {
         $plugins = Plugins::getSchema();
-        $this->assertIsArray($plugins);
-        $this->assertCount(4, $plugins);
-        $this->assertContainsOnlyInstancesOf(Plugins\SchemaPlugin::class, $plugins);
+        self::assertIsArray($plugins);
+        self::assertCount(4, $plugins);
+        self::assertContainsOnlyInstancesOf(Plugins\SchemaPlugin::class, $plugins);
     }
 
     /** @psalm-param 'Export'|'Import'|'Schema' $section */
@@ -73,7 +73,7 @@ class PluginsTest extends AbstractTestCase
         /** @psalm-suppress InvalidArrayOffset, PossiblyInvalidArrayAssignment */
         Config::getInstance()->settings[$section][$option] = $actualConfig;
         $default = Plugins::getDefault($section, $option);
-        $this->assertSame($expected, $default);
+        self::assertSame($expected, $default);
     }
 
     /**
@@ -134,6 +134,6 @@ class PluginsTest extends AbstractTestCase
             ['name' => 'sql', 'text' => 'SQL', 'is_selected' => false, 'is_binary' => false],
             ['name' => 'xml', 'text' => 'XML', 'is_selected' => true, 'is_binary' => false],
         ];
-        $this->assertEquals($expected, $actual);
+        self::assertEquals($expected, $actual);
     }
 }
diff --git a/tests/classes/ProfilingTest.php b/tests/classes/ProfilingTest.php
index b056e4d3df..1d697aae60 100644
--- a/tests/classes/ProfilingTest.php
+++ b/tests/classes/ProfilingTest.php
@@ -19,10 +19,10 @@ class ProfilingTest extends AbstractTestCase
 
         SessionCache::set('profiling_supported', true);
         $condition = Profiling::isSupported($dbi);
-        $this->assertTrue($condition);
+        self::assertTrue($condition);
 
         SessionCache::set('profiling_supported', false);
         $condition = Profiling::isSupported($dbi);
-        $this->assertFalse($condition);
+        self::assertFalse($condition);
     }
 }
diff --git a/tests/classes/Properties/Options/Groups/OptionsPropertyMainGroupTest.php b/tests/classes/Properties/Options/Groups/OptionsPropertyMainGroupTest.php
index de8c0eb17f..029bbe7796 100644
--- a/tests/classes/Properties/Options/Groups/OptionsPropertyMainGroupTest.php
+++ b/tests/classes/Properties/Options/Groups/OptionsPropertyMainGroupTest.php
@@ -35,7 +35,7 @@ class OptionsPropertyMainGroupTest extends AbstractTestCase
 
     public function testGetItemType(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             'main',
             $this->object->getItemType(),
         );
diff --git a/tests/classes/Properties/Options/Groups/OptionsPropertyRootGroupTest.php b/tests/classes/Properties/Options/Groups/OptionsPropertyRootGroupTest.php
index 99bbacaecd..e769db3356 100644
--- a/tests/classes/Properties/Options/Groups/OptionsPropertyRootGroupTest.php
+++ b/tests/classes/Properties/Options/Groups/OptionsPropertyRootGroupTest.php
@@ -35,7 +35,7 @@ class OptionsPropertyRootGroupTest extends AbstractTestCase
 
     public function testGetItemType(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             'root',
             $this->object->getItemType(),
         );
@@ -46,6 +46,6 @@ class OptionsPropertyRootGroupTest extends AbstractTestCase
      */
     public function testCountable(): void
     {
-        $this->assertCount(0, $this->object);
+        self::assertCount(0, $this->object);
     }
 }
diff --git a/tests/classes/Properties/Options/Groups/OptionsPropertySubgroupTest.php b/tests/classes/Properties/Options/Groups/OptionsPropertySubgroupTest.php
index 6163c206d4..8ccb13d0f8 100644
--- a/tests/classes/Properties/Options/Groups/OptionsPropertySubgroupTest.php
+++ b/tests/classes/Properties/Options/Groups/OptionsPropertySubgroupTest.php
@@ -35,7 +35,7 @@ class OptionsPropertySubgroupTest extends AbstractTestCase
 
     public function testGetItemType(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             'subgroup',
             $this->object->getItemType(),
         );
@@ -51,7 +51,7 @@ class OptionsPropertySubgroupTest extends AbstractTestCase
         $propertyItem = new OptionsPropertySubgroup();
         $this->object->setSubgroupHeader($propertyItem);
 
-        $this->assertEquals(
+        self::assertEquals(
             $propertyItem,
             $this->object->getSubgroupHeader(),
         );
diff --git a/tests/classes/Properties/Options/Items/PropertyItemsTest.php b/tests/classes/Properties/Options/Items/PropertyItemsTest.php
index 49e42d2f24..50d6ad570e 100644
--- a/tests/classes/Properties/Options/Items/PropertyItemsTest.php
+++ b/tests/classes/Properties/Options/Items/PropertyItemsTest.php
@@ -21,14 +21,14 @@ class PropertyItemsTest extends AbstractTestCase
     {
         $object = new BoolPropertyItem(null, 'Text');
 
-        $this->assertEquals(
+        self::assertEquals(
             'Text',
             $object->getText(),
         );
 
         $object->setText('xtext2');
 
-        $this->assertEquals(
+        self::assertEquals(
             'xtext2',
             $object->getText(),
         );
@@ -38,14 +38,14 @@ class PropertyItemsTest extends AbstractTestCase
     {
         $object = new BoolPropertyItem('xname');
 
-        $this->assertEquals(
+        self::assertEquals(
             'xname',
             $object->getName(),
         );
 
         $object->setName('xname2');
 
-        $this->assertEquals(
+        self::assertEquals(
             'xname2',
             $object->getName(),
         );
@@ -55,7 +55,7 @@ class PropertyItemsTest extends AbstractTestCase
     {
         $object = new BoolPropertyItem();
 
-        $this->assertEquals(
+        self::assertEquals(
             'bool',
             $object->getItemType(),
         );
@@ -65,7 +65,7 @@ class PropertyItemsTest extends AbstractTestCase
     {
         $object = new DocPropertyItem();
 
-        $this->assertEquals(
+        self::assertEquals(
             'doc',
             $object->getItemType(),
         );
@@ -75,7 +75,7 @@ class PropertyItemsTest extends AbstractTestCase
     {
         $object = new HiddenPropertyItem();
 
-        $this->assertEquals(
+        self::assertEquals(
             'hidden',
             $object->getItemType(),
         );
@@ -85,7 +85,7 @@ class PropertyItemsTest extends AbstractTestCase
     {
         $object = new MessageOnlyPropertyItem();
 
-        $this->assertEquals(
+        self::assertEquals(
             'messageOnly',
             $object->getItemType(),
         );
@@ -95,7 +95,7 @@ class PropertyItemsTest extends AbstractTestCase
     {
         $object = new RadioPropertyItem();
 
-        $this->assertEquals(
+        self::assertEquals(
             'radio',
             $object->getItemType(),
         );
@@ -105,7 +105,7 @@ class PropertyItemsTest extends AbstractTestCase
     {
         $object = new SelectPropertyItem();
 
-        $this->assertEquals(
+        self::assertEquals(
             'select',
             $object->getItemType(),
         );
@@ -115,7 +115,7 @@ class PropertyItemsTest extends AbstractTestCase
     {
         $object = new TextPropertyItem();
 
-        $this->assertEquals(
+        self::assertEquals(
             'text',
             $object->getItemType(),
         );
diff --git a/tests/classes/Properties/Options/OptionsPropertyGroupTest.php b/tests/classes/Properties/Options/OptionsPropertyGroupTest.php
index 65c1e2f09e..7376360326 100644
--- a/tests/classes/Properties/Options/OptionsPropertyGroupTest.php
+++ b/tests/classes/Properties/Options/OptionsPropertyGroupTest.php
@@ -41,10 +41,10 @@ class OptionsPropertyGroupTest extends AbstractTestCase
         $this->stub->addProperty($propertyItem);
         $this->stub->addProperty($propertyItem);
 
-        $this->assertTrue(
+        self::assertTrue(
             $this->stub->getProperties()->contains($propertyItem),
         );
-        $this->assertEquals(
+        self::assertEquals(
             1,
             $this->stub->getNrOfProperties(),
         );
@@ -55,19 +55,19 @@ class OptionsPropertyGroupTest extends AbstractTestCase
         $propertyItem = new BoolPropertyItem();
 
         $this->stub->addProperty($propertyItem);
-        $this->assertTrue(
+        self::assertTrue(
             $this->stub->getProperties()->contains($propertyItem),
         );
 
         $this->stub->removeProperty($propertyItem);
-        $this->assertFalse(
+        self::assertFalse(
             $this->stub->getProperties()->contains($propertyItem),
         );
     }
 
     public function testGetGroup(): void
     {
-        $this->assertInstanceOf(
+        self::assertInstanceOf(
             OptionsPropertyGroup::class,
             $this->stub->getGroup(),
         );
@@ -78,7 +78,7 @@ class OptionsPropertyGroupTest extends AbstractTestCase
         $propertyItem = new BoolPropertyItem();
         $this->stub->addProperty($propertyItem);
 
-        $this->assertTrue(
+        self::assertTrue(
             $this->stub->getProperties()->contains($propertyItem),
         );
     }
@@ -90,7 +90,7 @@ class OptionsPropertyGroupTest extends AbstractTestCase
         $this->stub->addProperty($propertyItem);
         $propertyItem2 = new BoolPropertyItem();
         $this->stub->addProperty($propertyItem2);
-        $this->assertEquals(
+        self::assertEquals(
             2,
             $this->stub->getNrOfProperties(),
         );
diff --git a/tests/classes/Properties/Options/OptionsPropertyItemTest.php b/tests/classes/Properties/Options/OptionsPropertyItemTest.php
index ca999e43b3..c1d18f1688 100644
--- a/tests/classes/Properties/Options/OptionsPropertyItemTest.php
+++ b/tests/classes/Properties/Options/OptionsPropertyItemTest.php
@@ -43,7 +43,7 @@ class OptionsPropertyItemTest extends AbstractTestCase
     {
         $this->stub->setName('name123');
 
-        $this->assertEquals(
+        self::assertEquals(
             'name123',
             $this->stub->getName(),
         );
@@ -58,7 +58,7 @@ class OptionsPropertyItemTest extends AbstractTestCase
     {
         $this->stub->setText('text123');
 
-        $this->assertEquals(
+        self::assertEquals(
             'text123',
             $this->stub->getText(),
         );
@@ -73,7 +73,7 @@ class OptionsPropertyItemTest extends AbstractTestCase
     {
         $this->stub->setForce('force123');
 
-        $this->assertEquals(
+        self::assertEquals(
             'force123',
             $this->stub->getForce(),
         );
@@ -81,7 +81,7 @@ class OptionsPropertyItemTest extends AbstractTestCase
 
     public function testGetPropertyType(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             'options',
             $this->stub->getPropertyType(),
         );
diff --git a/tests/classes/Properties/Options/OptionsPropertyOneItemTest.php b/tests/classes/Properties/Options/OptionsPropertyOneItemTest.php
index b4e9fd6f69..6467d6d3ed 100644
--- a/tests/classes/Properties/Options/OptionsPropertyOneItemTest.php
+++ b/tests/classes/Properties/Options/OptionsPropertyOneItemTest.php
@@ -43,7 +43,7 @@ class OptionsPropertyOneItemTest extends AbstractTestCase
     {
         $this->stub->setValues([1, 2]);
 
-        $this->assertEquals(
+        self::assertEquals(
             [1, 2],
             $this->stub->getValues(),
         );
@@ -58,7 +58,7 @@ class OptionsPropertyOneItemTest extends AbstractTestCase
     {
         $this->stub->setLen(12);
 
-        $this->assertEquals(
+        self::assertEquals(
             12,
             $this->stub->getLen(),
         );
@@ -73,7 +73,7 @@ class OptionsPropertyOneItemTest extends AbstractTestCase
     {
         $this->stub->setForce('force123');
 
-        $this->assertEquals(
+        self::assertEquals(
             'force123',
             $this->stub->getForce(),
         );
@@ -88,7 +88,7 @@ class OptionsPropertyOneItemTest extends AbstractTestCase
     {
         $this->stub->setDoc('doc123');
 
-        $this->assertEquals(
+        self::assertEquals(
             'doc123',
             $this->stub->getDoc(),
         );
@@ -103,7 +103,7 @@ class OptionsPropertyOneItemTest extends AbstractTestCase
     {
         $this->stub->setSize(22);
 
-        $this->assertEquals(
+        self::assertEquals(
             22,
             $this->stub->getSize(),
         );
diff --git a/tests/classes/Properties/Plugins/ExportPluginPropertiesTest.php b/tests/classes/Properties/Plugins/ExportPluginPropertiesTest.php
index dbfc93837a..c96486f832 100644
--- a/tests/classes/Properties/Plugins/ExportPluginPropertiesTest.php
+++ b/tests/classes/Properties/Plugins/ExportPluginPropertiesTest.php
@@ -35,7 +35,7 @@ class ExportPluginPropertiesTest extends AbstractTestCase
 
     public function testGetItemType(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             'export',
             $this->object->getItemType(),
         );
@@ -50,7 +50,7 @@ class ExportPluginPropertiesTest extends AbstractTestCase
     {
         $this->object->setForceFile(true);
 
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->getForceFile(),
         );
     }
diff --git a/tests/classes/Properties/Plugins/ImportPluginPropertiesTest.php b/tests/classes/Properties/Plugins/ImportPluginPropertiesTest.php
index ac671c223f..c5785ab2c5 100644
--- a/tests/classes/Properties/Plugins/ImportPluginPropertiesTest.php
+++ b/tests/classes/Properties/Plugins/ImportPluginPropertiesTest.php
@@ -35,7 +35,7 @@ class ImportPluginPropertiesTest extends AbstractTestCase
 
     public function testGetItemType(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             'import',
             $this->object->getItemType(),
         );
@@ -50,7 +50,7 @@ class ImportPluginPropertiesTest extends AbstractTestCase
     {
         $this->object->setOptionsText('options123');
 
-        $this->assertEquals(
+        self::assertEquals(
             'options123',
             $this->object->getOptionsText(),
         );
@@ -65,7 +65,7 @@ class ImportPluginPropertiesTest extends AbstractTestCase
     {
         $this->object->setMimeType('mime123');
 
-        $this->assertEquals(
+        self::assertEquals(
             'mime123',
             $this->object->getMimeType(),
         );
diff --git a/tests/classes/Properties/Plugins/PluginPropertyItemTest.php b/tests/classes/Properties/Plugins/PluginPropertyItemTest.php
index d471da2c1c..d627667f2b 100644
--- a/tests/classes/Properties/Plugins/PluginPropertyItemTest.php
+++ b/tests/classes/Properties/Plugins/PluginPropertyItemTest.php
@@ -35,7 +35,7 @@ class PluginPropertyItemTest extends AbstractTestCase
 
     public function testGetPropertyType(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             'plugin',
             $this->stub->getPropertyType(),
         );
diff --git a/tests/classes/Properties/PropertyItemTest.php b/tests/classes/Properties/PropertyItemTest.php
index 03b0b50d6c..721f9753cc 100644
--- a/tests/classes/Properties/PropertyItemTest.php
+++ b/tests/classes/Properties/PropertyItemTest.php
@@ -36,7 +36,7 @@ class PropertyItemTest extends AbstractTestCase
 
     public function testGetGroup(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             null,
             $this->stub->getGroup(),
         );
diff --git a/tests/classes/Query/CompatibilityTest.php b/tests/classes/Query/CompatibilityTest.php
index ec7e840c85..4398a10ff1 100644
--- a/tests/classes/Query/CompatibilityTest.php
+++ b/tests/classes/Query/CompatibilityTest.php
@@ -16,7 +16,7 @@ class CompatibilityTest extends TestCase
     #[DataProvider('providerForTestHasAccountLocking')]
     public function testHasAccountLocking(bool $expected, bool $isMariaDb, int $version): void
     {
-        $this->assertSame($expected, Compatibility::hasAccountLocking($isMariaDb, $version));
+        self::assertSame($expected, Compatibility::hasAccountLocking($isMariaDb, $version));
     }
 
     /**
@@ -38,12 +38,12 @@ class CompatibilityTest extends TestCase
     #[DataProvider('providerForTestIsUUIDSupported')]
     public function testIsUUIDSupported(bool $expected, bool $isMariaDb, int $version): void
     {
-        $dbiStub = $this->createStub(DatabaseInterface::class);
+        $dbiStub = self::createStub(DatabaseInterface::class);
 
         $dbiStub->method('isMariaDB')->willReturn($isMariaDb);
         $dbiStub->method('getVersion')->willReturn($version);
 
-        $this->assertSame($expected, Compatibility::isUUIDSupported($dbiStub));
+        self::assertSame($expected, Compatibility::isUUIDSupported($dbiStub));
     }
 
     /**
diff --git a/tests/classes/Query/GeneratorTest.php b/tests/classes/Query/GeneratorTest.php
index cee325e98b..1b0e34f23a 100644
--- a/tests/classes/Query/GeneratorTest.php
+++ b/tests/classes/Query/GeneratorTest.php
@@ -13,14 +13,14 @@ class GeneratorTest extends AbstractTestCase
 {
     public function testGetColumnsSql(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             'SHOW  COLUMNS FROM `mydb`.`mytable`',
             Generator::getColumnsSql(
                 'mydb',
                 'mytable',
             ),
         );
-        $this->assertEquals(
+        self::assertEquals(
             'SHOW  COLUMNS FROM `mydb`.`mytable` LIKE \'_idcolumn\'',
             Generator::getColumnsSql(
                 'mydb',
@@ -28,7 +28,7 @@ class GeneratorTest extends AbstractTestCase
                 "'_idcolumn'",
             ),
         );
-        $this->assertEquals(
+        self::assertEquals(
             'SHOW FULL COLUMNS FROM `mydb`.`mytable`',
             Generator::getColumnsSql(
                 'mydb',
@@ -37,7 +37,7 @@ class GeneratorTest extends AbstractTestCase
                 true,
             ),
         );
-        $this->assertEquals(
+        self::assertEquals(
             'SHOW FULL COLUMNS FROM `mydb`.`mytable` LIKE \'_idcolumn\'',
             Generator::getColumnsSql(
                 'mydb',
@@ -50,14 +50,14 @@ class GeneratorTest extends AbstractTestCase
 
     public function testGetTableIndexesSql(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             'SHOW INDEXES FROM `mydb`.`mytable`',
             Generator::getTableIndexesSql(
                 'mydb',
                 'mytable',
             ),
         );
-        $this->assertEquals(
+        self::assertEquals(
             'SHOW INDEXES FROM `mydb`.`mytable` WHERE (1)',
             Generator::getTableIndexesSql(
                 'mydb',
@@ -69,7 +69,7 @@ class GeneratorTest extends AbstractTestCase
 
     public function testGetSqlQueryForIndexRename(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             'ALTER TABLE `mydb`.`mytable` RENAME INDEX `oldIndexName` TO `newIndexName`;',
             Generator::getSqlQueryForIndexRename(
                 'mydb',
@@ -82,7 +82,7 @@ class GeneratorTest extends AbstractTestCase
 
     public function testGetQueryForReorderingTable(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             'ALTER TABLE `mytable` ORDER BY `myOrderField` ASC;',
             Generator::getQueryForReorderingTable(
                 'mytable',
@@ -90,7 +90,7 @@ class GeneratorTest extends AbstractTestCase
                 '',
             ),
         );
-        $this->assertEquals(
+        self::assertEquals(
             'ALTER TABLE `mytable` ORDER BY `myOrderField` ASC;',
             Generator::getQueryForReorderingTable(
                 'mytable',
@@ -98,7 +98,7 @@ class GeneratorTest extends AbstractTestCase
                 'S',
             ),
         );
-        $this->assertEquals(
+        self::assertEquals(
             'ALTER TABLE `mytable` ORDER BY `myOrderField` ASC;',
             Generator::getQueryForReorderingTable(
                 'mytable',
@@ -106,7 +106,7 @@ class GeneratorTest extends AbstractTestCase
                 'DESC',
             ),
         );
-        $this->assertEquals(
+        self::assertEquals(
             'ALTER TABLE `mytable` ORDER BY `myOrderField` DESC;',
             Generator::getQueryForReorderingTable(
                 'mytable',
@@ -114,7 +114,7 @@ class GeneratorTest extends AbstractTestCase
                 'desc',
             ),
         );
-        $this->assertEquals(
+        self::assertEquals(
             'ALTER TABLE `mytable` ORDER BY `myOrderField` ASC;',
             Generator::getQueryForReorderingTable(
                 'mytable',
@@ -126,7 +126,7 @@ class GeneratorTest extends AbstractTestCase
 
     public function testGetQueryForPartitioningTable(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             'ALTER TABLE `mytable`  PARTITION ;',
             Generator::getQueryForPartitioningTable(
                 'mytable',
@@ -134,7 +134,7 @@ class GeneratorTest extends AbstractTestCase
                 [],
             ),
         );
-        $this->assertEquals(
+        self::assertEquals(
             'ALTER TABLE `mytable`  PARTITION p1;',
             Generator::getQueryForPartitioningTable(
                 'mytable',
@@ -142,7 +142,7 @@ class GeneratorTest extends AbstractTestCase
                 ['p1'],
             ),
         );
-        $this->assertEquals(
+        self::assertEquals(
             'ALTER TABLE `mytable`  PARTITION p1, p2;',
             Generator::getQueryForPartitioningTable(
                 'mytable',
@@ -150,7 +150,7 @@ class GeneratorTest extends AbstractTestCase
                 ['p1', 'p2'],
             ),
         );
-        $this->assertEquals(
+        self::assertEquals(
             'ALTER TABLE `mytable` COALESCE PARTITION 2',
             Generator::getQueryForPartitioningTable(
                 'mytable',
@@ -168,12 +168,12 @@ class GeneratorTest extends AbstractTestCase
         $queryFields = ['a', 'b'];
         $valueSets = ['1', '2'];
 
-        $this->assertEquals(
+        self::assertEquals(
             'INSERT IGNORE INTO `table` (a, b) VALUES (1), (2)',
             Generator::buildInsertSqlQuery('table', true, $queryFields, $valueSets),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'INSERT INTO `table` (a, b) VALUES (1), (2)',
             Generator::buildInsertSqlQuery('table', false, $queryFields, $valueSets),
         );
diff --git a/tests/classes/Replication/ReplicationGuiTest.php b/tests/classes/Replication/ReplicationGuiTest.php
index 9f268bf005..7a5ab71736 100644
--- a/tests/classes/Replication/ReplicationGuiTest.php
+++ b/tests/classes/Replication/ReplicationGuiTest.php
@@ -59,35 +59,35 @@ class ReplicationGuiTest extends AbstractTestCase
         $html = $this->replicationGui->getHtmlForPrimaryReplication(null, false, 'primary_add_user', null, null);
 
         //validate 1: Primary replication
-        $this->assertStringContainsString('<div class="card-header">Primary replication</div>', $html);
-        $this->assertStringContainsString('This server is configured as primary in a replication process.', $html);
+        self::assertStringContainsString('<div class="card-header">Primary replication</div>', $html);
+        self::assertStringContainsString('This server is configured as primary in a replication process.', $html);
 
         //validate 2: getHtmlForReplicationStatusTable
-        $this->assertStringContainsString('<div id="replication_primary_section"', $html);
+        self::assertStringContainsString('<div id="replication_primary_section"', $html);
 
-        $this->assertStringContainsString('Binlog_Do_DB', $html);
-        $this->assertStringContainsString('Binlog_Ignore_DB', $html);
+        self::assertStringContainsString('Binlog_Do_DB', $html);
+        self::assertStringContainsString('Binlog_Ignore_DB', $html);
 
-        $this->assertStringContainsString('primary-bin.000030', $html);
+        self::assertStringContainsString('primary-bin.000030', $html);
 
         //validate 3: getHtmlForReplicationReplicasTable
-        $this->assertStringContainsString('replication_replicas_section', $html);
-        $this->assertStringContainsString('<th>Server ID</th>', $html);
-        $this->assertStringContainsString('<th>Host</th>', $html);
+        self::assertStringContainsString('replication_replicas_section', $html);
+        self::assertStringContainsString('<th>Server ID</th>', $html);
+        self::assertStringContainsString('<th>Host</th>', $html);
         //replica host
-        $this->assertStringContainsString('<td class="text-end font-monospace">Server_id1</td>', $html);
-        $this->assertStringContainsString('<td class="text-end font-monospace">Server_id2</td>', $html);
-        $this->assertStringContainsString('<td class="text-end font-monospace">Host1</td>', $html);
-        $this->assertStringContainsString('<td class="text-end font-monospace">Host2</td>', $html);
+        self::assertStringContainsString('<td class="text-end font-monospace">Server_id1</td>', $html);
+        self::assertStringContainsString('<td class="text-end font-monospace">Server_id2</td>', $html);
+        self::assertStringContainsString('<td class="text-end font-monospace">Host1</td>', $html);
+        self::assertStringContainsString('<td class="text-end font-monospace">Host2</td>', $html);
         //Notice
-        $this->assertStringContainsString('Only replicas started with the', $html);
+        self::assertStringContainsString('Only replicas started with the', $html);
 
         //validate 4: navigation URL
-        $this->assertStringContainsString('<a href="index.php?route=/server/replication', $html);
-        $this->assertStringContainsString('Add replica replication user', $html);
+        self::assertStringContainsString('<a href="index.php?route=/server/replication', $html);
+        self::assertStringContainsString('Add replica replication user', $html);
 
         //validate 5: 'Add replication replica user' form
-        $this->assertStringContainsString('<div id="primary_addreplicauser_gui">', $html);
+        self::assertStringContainsString('<div id="primary_addreplicauser_gui">', $html);
     }
 
     public function testGetHtmlForReplicaConfiguration(): void
@@ -104,17 +104,17 @@ class ReplicationGuiTest extends AbstractTestCase
         );
 
         //legend
-        $this->assertStringContainsString('<div class="card-header">Replica replication</div>', $html);
-        $this->assertStringContainsString('<div id="replica_configuration_gui">', $html);
+        self::assertStringContainsString('<div class="card-header">Replica replication</div>', $html);
+        self::assertStringContainsString('<div id="replica_configuration_gui">', $html);
         //notice
-        $this->assertStringContainsString('Server is configured as replica in a replication process.', $html);
+        self::assertStringContainsString('Server is configured as replica in a replication process.', $html);
         //replica session
-        $this->assertStringContainsString('<div id="replication_replica_section"', $html);
+        self::assertStringContainsString('<div id="replication_replica_section"', $html);
         //variable
-        $this->assertStringContainsString('Master_SSL_CA_Path', $html);
-        $this->assertStringContainsString('Master_SSL_Cert', $html);
-        $this->assertStringContainsString('Master_SSL_Cipher', $html);
-        $this->assertStringContainsString('Seconds_Behind_Master', $html);
+        self::assertStringContainsString('Master_SSL_CA_Path', $html);
+        self::assertStringContainsString('Master_SSL_Cert', $html);
+        self::assertStringContainsString('Master_SSL_Cipher', $html);
+        self::assertStringContainsString('Seconds_Behind_Master', $html);
     }
 
     public function testGetHtmlForReplicationChangePrimary(): void
@@ -122,10 +122,10 @@ class ReplicationGuiTest extends AbstractTestCase
         //Call the test function
         $html = $this->replicationGui->getHtmlForReplicationChangePrimary('replica_changeprimary');
 
-        $this->assertStringContainsString('<form method="post" action="index.php?route=/server/replication', $html);
-        $this->assertStringContainsString('Replica configuration', $html);
-        $this->assertStringContainsString('Change or reconfigure primary server', $html);
+        self::assertStringContainsString('<form method="post" action="index.php?route=/server/replication', $html);
+        self::assertStringContainsString('Replica configuration', $html);
+        self::assertStringContainsString('Change or reconfigure primary server', $html);
         $notice = 'Make sure you have a unique server-id in your configuration file (my.cnf)';
-        $this->assertStringContainsString($notice, $html);
+        self::assertStringContainsString($notice, $html);
     }
 }
diff --git a/tests/classes/ResponseRendererTest.php b/tests/classes/ResponseRendererTest.php
index 496c56caf0..7266523a42 100644
--- a/tests/classes/ResponseRendererTest.php
+++ b/tests/classes/ResponseRendererTest.php
@@ -33,22 +33,22 @@ class ResponseRendererTest extends AbstractTestCase
         $response = ResponseRenderer::getInstance();
         $header = $response->getHeader();
         $footer = (new ReflectionProperty(ResponseRenderer::class, 'footer'))->getValue($response);
-        $this->assertInstanceOf(Footer::class, $footer);
+        self::assertInstanceOf(Footer::class, $footer);
         $headerIsAjax = new ReflectionProperty(Header::class, 'isAjax');
         $footerIsAjax = new ReflectionProperty(Footer::class, 'isAjax');
 
-        $this->assertFalse($response->isAjax());
-        $this->assertFalse($headerIsAjax->getValue($header));
-        $this->assertFalse($footerIsAjax->getValue($footer));
+        self::assertFalse($response->isAjax());
+        self::assertFalse($headerIsAjax->getValue($header));
+        self::assertFalse($footerIsAjax->getValue($footer));
 
         $response->setAjax(true);
-        $this->assertTrue($response->isAjax());
-        $this->assertTrue($headerIsAjax->getValue($header));
-        $this->assertTrue($footerIsAjax->getValue($footer));
+        self::assertTrue($response->isAjax());
+        self::assertTrue($headerIsAjax->getValue($header));
+        self::assertTrue($footerIsAjax->getValue($footer));
 
         $response->setAjax(false);
-        $this->assertFalse($response->isAjax());
-        $this->assertFalse($headerIsAjax->getValue($header));
-        $this->assertFalse($footerIsAjax->getValue($footer));
+        self::assertFalse($response->isAjax());
+        self::assertFalse($headerIsAjax->getValue($header));
+        self::assertFalse($footerIsAjax->getValue($footer));
     }
 }
diff --git a/tests/classes/Routing/RoutesTest.php b/tests/classes/Routing/RoutesTest.php
index a15fd37f72..f3f3f96330 100644
--- a/tests/classes/Routing/RoutesTest.php
+++ b/tests/classes/Routing/RoutesTest.php
@@ -351,7 +351,7 @@ final class RoutesTest extends TestCase
 
         $routeCollector = new RouteCollector(new RouteParserStd(), new DataGeneratorGroupCountBased());
         Routes::collect($routeCollector);
-        $this->assertSame(
+        self::assertSame(
             [
                 ['GET' => $expectedGetRoutes, 'POST' => $expectedPostRoutes],
                 ['GET' => $expectedRegexGetRoutes, 'POST' => $expectedRegexPostRoutes],
diff --git a/tests/classes/Routing/RoutingTest.php b/tests/classes/Routing/RoutingTest.php
index 10409cb05b..fc18456a24 100644
--- a/tests/classes/Routing/RoutingTest.php
+++ b/tests/classes/Routing/RoutingTest.php
@@ -33,33 +33,33 @@ class RoutingTest extends AbstractTestCase
         $config = Config::getInstance();
         $config->settings['environment'] = null;
 
-        $this->assertDirectoryIsWritable(CACHE_DIR);
+        self::assertDirectoryIsWritable(CACHE_DIR);
 
         // Valid cache file.
-        $this->assertTrue(copy($validCacheFilename, $cacheFilename));
+        self::assertTrue(copy($validCacheFilename, $cacheFilename));
         $dispatcher = Routing::getDispatcher();
-        $this->assertSame($expected, $dispatcher->dispatch('GET', '/'));
-        $this->assertFileEquals($validCacheFilename, $cacheFilename);
+        self::assertSame($expected, $dispatcher->dispatch('GET', '/'));
+        self::assertFileEquals($validCacheFilename, $cacheFilename);
 
         // Invalid cache file.
-        $this->assertTrue(copy($invalidCacheFilename, $cacheFilename));
+        self::assertTrue(copy($invalidCacheFilename, $cacheFilename));
         $dispatcher = Routing::getDispatcher();
-        $this->assertSame($expected, $dispatcher->dispatch('GET', '/'));
-        $this->assertFileNotEquals($invalidCacheFilename, $cacheFilename);
+        self::assertSame($expected, $dispatcher->dispatch('GET', '/'));
+        self::assertFileNotEquals($invalidCacheFilename, $cacheFilename);
 
         // Create new cache file.
-        $this->assertTrue(unlink($cacheFilename));
+        self::assertTrue(unlink($cacheFilename));
 
-        $this->assertFileDoesNotExist($cacheFilename);
+        self::assertFileDoesNotExist($cacheFilename);
 
         $dispatcher = Routing::getDispatcher();
-        $this->assertSame($expected, $dispatcher->dispatch('GET', '/'));
-        $this->assertFileExists($cacheFilename);
+        self::assertSame($expected, $dispatcher->dispatch('GET', '/'));
+        self::assertFileExists($cacheFilename);
 
         // Without a cache file.
         $config->settings['environment'] = 'development';
         $dispatcher = Routing::getDispatcher();
-        $this->assertSame($expected, $dispatcher->dispatch('GET', '/'));
+        self::assertSame($expected, $dispatcher->dispatch('GET', '/'));
     }
 
     /**
@@ -75,7 +75,7 @@ class RoutingTest extends AbstractTestCase
         $_SERVER['REQUEST_URI'] = $request;
         $_SERVER['PATH_INFO'] = $pathInfo;
         $actual = Routing::getCleanPathInfo();
-        $this->assertEquals($expected, $actual);
+        self::assertEquals($expected, $actual);
     }
 
     /** @return array<array{string, string, string, string}> */
diff --git a/tests/classes/SanitizeTest.php b/tests/classes/SanitizeTest.php
index 203fcfb636..3e65048025 100644
--- a/tests/classes/SanitizeTest.php
+++ b/tests/classes/SanitizeTest.php
@@ -27,7 +27,7 @@ class SanitizeTest extends AbstractTestCase
      */
     public function testXssInHref(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             '[a@javascript:alert(&#039;XSS&#039;);@target]link</a>',
             Sanitize::convertBBCode('[a@javascript:alert(\'XSS\');@target]link[/a]'),
         );
@@ -41,7 +41,7 @@ class SanitizeTest extends AbstractTestCase
         $lang = $GLOBALS['lang'];
 
         unset($GLOBALS['lang']);
-        $this->assertEquals(
+        self::assertEquals(
             '<a href="index.php?route=/url&url=https%3A%2F%2Fwww.phpmyadmin.net%2F" target="target">link</a>',
             Sanitize::convertBBCode('[a@https://www.phpmyadmin.net/@target]link[/a]'),
         );
@@ -58,7 +58,7 @@ class SanitizeTest extends AbstractTestCase
     #[DataProvider('docLinks')]
     public function testDoc(string $link, string $expected): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             '<a href="index.php?route=/url&url=https%3A%2F%2Fdocs.phpmyadmin.net%2Fen%2Flatest%2F'
                 . $expected . '" target="documentation">doclink</a>',
             Sanitize::convertBBCode('[doc@' . $link . ']doclink[/doc]'),
@@ -85,7 +85,7 @@ class SanitizeTest extends AbstractTestCase
      */
     public function testInvalidTarget(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             '[a@./Documentation.html@INVALID9]doc</a>',
             Sanitize::convertBBCode('[a@./Documentation.html@INVALID9]doc[/a]'),
         );
@@ -96,7 +96,7 @@ class SanitizeTest extends AbstractTestCase
      */
     public function testLinkDocXss(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             '[a@./Documentation.html&quot; onmouseover=&quot;alert(foo)&quot;]doc</a>',
             Sanitize::convertBBCode('[a@./Documentation.html" onmouseover="alert(foo)"]doc[/a]'),
         );
@@ -107,7 +107,7 @@ class SanitizeTest extends AbstractTestCase
      */
     public function testLinkAndXssInHref(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             '<a href="index.php?route=/url&url=https%3A%2F%2Fdocs.phpmyadmin.net%2F">doc</a>'
                 . '[a@javascript:alert(&#039;XSS&#039;);@target]link</a>',
             Sanitize::convertBBCode(
@@ -121,7 +121,7 @@ class SanitizeTest extends AbstractTestCase
      */
     public function testHtmlTags(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             '&lt;div onclick=&quot;&quot;&gt;',
             Sanitize::convertBBCode('<div onclick="">'),
         );
@@ -132,7 +132,7 @@ class SanitizeTest extends AbstractTestCase
      */
     public function testBBCode(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             '<strong>strong</strong>',
             Sanitize::convertBBCode('[strong]strong[/strong]'),
         );
@@ -143,7 +143,7 @@ class SanitizeTest extends AbstractTestCase
      */
     public function testSanitizeFilename(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             'File_name_123',
             Sanitize::sanitizeFilename('File_name 123'),
         );
@@ -159,7 +159,7 @@ class SanitizeTest extends AbstractTestCase
     #[DataProvider('variables')]
     public function testGetJsValue(string $key, string|bool|int|array $value, string $expected): void
     {
-        $this->assertEquals($expected, Sanitize::getJsValue($key, $value));
+        self::assertEquals($expected, Sanitize::getJsValue($key, $value));
     }
 
     /**
@@ -193,9 +193,9 @@ class SanitizeTest extends AbstractTestCase
         $_REQUEST['second'] = 1;
         $allowList = ['allow', 'second'];
         Sanitize::removeRequestVars($allowList);
-        $this->assertArrayNotHasKey('foo', $_REQUEST);
-        $this->assertArrayNotHasKey('second', $_REQUEST);
-        $this->assertArrayHasKey('allow', $_REQUEST);
+        self::assertArrayNotHasKey('foo', $_REQUEST);
+        self::assertArrayNotHasKey('second', $_REQUEST);
+        self::assertArrayHasKey('allow', $_REQUEST);
     }
 
     /**
@@ -235,7 +235,7 @@ class SanitizeTest extends AbstractTestCase
     #[DataProvider('dataProviderCheckLinks')]
     public function testCheckLink(bool $expected, string $url, bool $http, bool $other): void
     {
-        $this->assertSame(
+        self::assertSame(
             $expected,
             Sanitize::checkLink($url, $http, $other),
         );
diff --git a/tests/classes/ScriptsTest.php b/tests/classes/ScriptsTest.php
index efaeff2b80..029a3980ae 100644
--- a/tests/classes/ScriptsTest.php
+++ b/tests/classes/ScriptsTest.php
@@ -49,17 +49,17 @@ class ScriptsTest extends AbstractTestCase
 
         $actual = $this->object->getDisplay();
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             'src="js/dist/common.js?v=' . rawurlencode(Version::VERSION) . '"',
             $actual,
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             'window.AJAX.scriptHandler.add(\'vendor\/codemirror\/lib\/codemirror.js\', false);',
             $actual,
         );
-        $this->assertStringContainsString('window.AJAX.scriptHandler.add(\'common.js\', true);', $actual);
-        $this->assertStringContainsString('window.AJAX.fireOnload(\'common.js\')', $actual);
-        $this->assertStringNotContainsString(
+        self::assertStringContainsString('window.AJAX.scriptHandler.add(\'common.js\', true);', $actual);
+        self::assertStringContainsString('window.AJAX.fireOnload(\'common.js\')', $actual);
+        self::assertStringNotContainsString(
             'window.AJAX.fireOnload(\'vendor\/codemirror\/lib\/codemirror.js\')',
             $actual,
         );
@@ -74,7 +74,7 @@ class ScriptsTest extends AbstractTestCase
 
         $actual = $this->object->getDisplay();
 
-        $this->assertStringContainsString('alert(\'CodeAdded\');', $actual);
+        self::assertStringContainsString('alert(\'CodeAdded\');', $actual);
     }
 
     /**
@@ -86,7 +86,7 @@ class ScriptsTest extends AbstractTestCase
         $this->object->addFile('vendor/codemirror/lib/codemirror.js');
 
         $this->object->addFile('common.js');
-        $this->assertEquals(
+        self::assertEquals(
             [['name' => 'vendor/codemirror/lib/codemirror.js', 'fire' => 0], ['name' => 'common.js', 'fire' => 1]],
             $this->object->getFiles(),
         );
@@ -101,14 +101,14 @@ class ScriptsTest extends AbstractTestCase
 
         // Assert empty _files property of
         // Scripts
-        $this->assertEquals([], $reflection->getValue($this->object));
+        self::assertEquals([], $reflection->getValue($this->object));
 
         // Add one script file
         $file = 'common.js';
         $hash = 'd7716810d825f4b55d18727c3ccb24e6';
         $files = [$hash => ['has_onload' => 1, 'filename' => 'common.js', 'params' => []]];
         $this->object->addFile($file);
-        $this->assertEquals($files, $reflection->getValue($this->object));
+        self::assertEquals($files, $reflection->getValue($this->object));
     }
 
     /**
@@ -124,6 +124,6 @@ class ScriptsTest extends AbstractTestCase
             '347a57484fcd6ea6d8a125e6e1d31f78' => ['has_onload' => 1, 'filename' => 'sql.js', 'params' => []],
         ];
         $this->object->addFiles($filenames);
-        $this->assertEquals($files, $reflection->getValue($this->object));
+        self::assertEquals($files, $reflection->getValue($this->object));
     }
 }
diff --git a/tests/classes/Server/PluginTest.php b/tests/classes/Server/PluginTest.php
index eac80709ac..a8dcb78c0f 100644
--- a/tests/classes/Server/PluginTest.php
+++ b/tests/classes/Server/PluginTest.php
@@ -30,20 +30,20 @@ class PluginTest extends AbstractTestCase
             'authVersion' => '1.0',
         ]);
 
-        $this->assertInstanceOf(Plugin::class, $plugin);
-        $this->assertSame('BLACKHOLE', $plugin->getName());
-        $this->assertSame('1.0', $plugin->getVersion());
-        $this->assertSame('ACTIVE', $plugin->getStatus());
-        $this->assertSame('STORAGE ENGINE', $plugin->getType());
-        $this->assertSame('100316.0', $plugin->getTypeVersion());
-        $this->assertSame('ha_blackhole.so', $plugin->getLibrary());
-        $this->assertSame('1.13', $plugin->getLibraryVersion());
-        $this->assertSame('MySQL AB', $plugin->getAuthor());
-        $this->assertSame('GPL', $plugin->getLicense());
-        $this->assertSame('ON', $plugin->getLoadOption());
-        $this->assertSame('Stable', $plugin->getMaturity());
-        $this->assertSame('1.0', $plugin->getAuthVersion());
-        $this->assertSame(
+        self::assertInstanceOf(Plugin::class, $plugin);
+        self::assertSame('BLACKHOLE', $plugin->getName());
+        self::assertSame('1.0', $plugin->getVersion());
+        self::assertSame('ACTIVE', $plugin->getStatus());
+        self::assertSame('STORAGE ENGINE', $plugin->getType());
+        self::assertSame('100316.0', $plugin->getTypeVersion());
+        self::assertSame('ha_blackhole.so', $plugin->getLibrary());
+        self::assertSame('1.13', $plugin->getLibraryVersion());
+        self::assertSame('MySQL AB', $plugin->getAuthor());
+        self::assertSame('GPL', $plugin->getLicense());
+        self::assertSame('ON', $plugin->getLoadOption());
+        self::assertSame('Stable', $plugin->getMaturity());
+        self::assertSame('1.0', $plugin->getAuthVersion());
+        self::assertSame(
             '/dev/null storage engine (anything you write to it disappears)',
             $plugin->getDescription(),
         );
@@ -54,7 +54,7 @@ class PluginTest extends AbstractTestCase
     #[Depends('testFromState')]
     public function testToArray(Plugin $plugin): void
     {
-        $this->assertSame([
+        self::assertSame([
             'name' => 'BLACKHOLE',
             'version' => '1.0',
             'status' => 'ACTIVE',
diff --git a/tests/classes/Server/PluginsTest.php b/tests/classes/Server/PluginsTest.php
index d75ba3452a..80d6c1763f 100644
--- a/tests/classes/Server/PluginsTest.php
+++ b/tests/classes/Server/PluginsTest.php
@@ -35,13 +35,13 @@ class PluginsTest extends AbstractTestCase
 
         $plugins = $this->plugins->getAll();
 
-        $this->assertIsArray($plugins);
-        $this->assertNotEmpty($plugins);
+        self::assertIsArray($plugins);
+        self::assertNotEmpty($plugins);
 
         $plugin = $plugins[0];
 
-        $this->assertInstanceOf(Plugin::class, $plugin);
-        $this->assertSame([
+        self::assertInstanceOf(Plugin::class, $plugin);
+        self::assertSame([
             'name' => 'BLACKHOLE',
             'version' => '1.0',
             'status' => 'ACTIVE',
@@ -68,13 +68,13 @@ class PluginsTest extends AbstractTestCase
 
         $plugins = $this->plugins->getAll();
 
-        $this->assertIsArray($plugins);
-        $this->assertNotEmpty($plugins);
+        self::assertIsArray($plugins);
+        self::assertNotEmpty($plugins);
 
         $plugin = $plugins[0];
 
-        $this->assertInstanceOf(Plugin::class, $plugin);
-        $this->assertSame([
+        self::assertInstanceOf(Plugin::class, $plugin);
+        self::assertSame([
             'name' => 'partition',
             'version' => null,
             'status' => 'ACTIVE',
@@ -95,9 +95,9 @@ class PluginsTest extends AbstractTestCase
     {
         $this->plugins = new Plugins(DatabaseInterface::getInstance());
         $plugins = $this->plugins->getAuthentication();
-        $this->assertIsArray($plugins);
-        $this->assertNotEmpty($plugins);
-        $this->assertEquals(
+        self::assertIsArray($plugins);
+        self::assertNotEmpty($plugins);
+        self::assertEquals(
             [
                 'mysql_old_password' => __('Old MySQL-4.0 authentication'),
                 'mysql_native_password' => __('Native MySQL authentication'),
diff --git a/tests/classes/Server/Privileges/AccountLockingTest.php b/tests/classes/Server/Privileges/AccountLockingTest.php
index d379853011..d784735110 100644
--- a/tests/classes/Server/Privileges/AccountLockingTest.php
+++ b/tests/classes/Server/Privileges/AccountLockingTest.php
@@ -16,16 +16,16 @@ class AccountLockingTest extends TestCase
 {
     public function testLockWithValidAccount(): void
     {
-        $dbi = $this->createMock(DatabaseInterface::class);
-        $dbi->expects($this->once())->method('isMariaDB')->willReturn(true);
-        $dbi->expects($this->once())->method('getVersion')->willReturn(100402);
-        $dbi->expects($this->exactly(2))->method('quoteString')
+        $dbi = self::createMock(DatabaseInterface::class);
+        $dbi->expects(self::once())->method('isMariaDB')->willReturn(true);
+        $dbi->expects(self::once())->method('getVersion')->willReturn(100402);
+        $dbi->expects(self::exactly(2))->method('quoteString')
             ->willReturnCallback(static fn (string $string): string => "'" . $string . "'");
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('tryQuery')
-            ->with($this->equalTo('ALTER USER \'test.user\'@\'test.host\' ACCOUNT LOCK;'))
-            ->willReturn($this->createStub(DummyResult::class));
-        $dbi->expects($this->never())->method('getError');
+            ->with(self::equalTo('ALTER USER \'test.user\'@\'test.host\' ACCOUNT LOCK;'))
+            ->willReturn(self::createStub(DummyResult::class));
+        $dbi->expects(self::never())->method('getError');
 
         $accountLocking = new AccountLocking($dbi);
         $accountLocking->lock('test.user', 'test.host');
@@ -33,16 +33,16 @@ class AccountLockingTest extends TestCase
 
     public function testLockWithInvalidAccount(): void
     {
-        $dbi = $this->createMock(DatabaseInterface::class);
-        $dbi->expects($this->once())->method('isMariaDB')->willReturn(true);
-        $dbi->expects($this->once())->method('getVersion')->willReturn(100402);
-        $dbi->expects($this->exactly(2))->method('quoteString')
+        $dbi = self::createMock(DatabaseInterface::class);
+        $dbi->expects(self::once())->method('isMariaDB')->willReturn(true);
+        $dbi->expects(self::once())->method('getVersion')->willReturn(100402);
+        $dbi->expects(self::exactly(2))->method('quoteString')
             ->willReturnCallback(static fn (string $string): string => "'" . $string . "'");
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('tryQuery')
-            ->with($this->equalTo('ALTER USER \'test.user\'@\'test.host\' ACCOUNT LOCK;'))
+            ->with(self::equalTo('ALTER USER \'test.user\'@\'test.host\' ACCOUNT LOCK;'))
             ->willReturn(false);
-        $dbi->expects($this->once())->method('getError')->willReturn('Invalid account.');
+        $dbi->expects(self::once())->method('getError')->willReturn('Invalid account.');
 
         $accountLocking = new AccountLocking($dbi);
 
@@ -54,12 +54,12 @@ class AccountLockingTest extends TestCase
 
     public function testLockWithUnsupportedServer(): void
     {
-        $dbi = $this->createMock(DatabaseInterface::class);
-        $dbi->expects($this->once())->method('isMariaDB')->willReturn(true);
-        $dbi->expects($this->once())->method('getVersion')->willReturn(100401);
-        $dbi->expects($this->never())->method('quoteString');
-        $dbi->expects($this->never())->method('tryQuery');
-        $dbi->expects($this->never())->method('getError');
+        $dbi = self::createMock(DatabaseInterface::class);
+        $dbi->expects(self::once())->method('isMariaDB')->willReturn(true);
+        $dbi->expects(self::once())->method('getVersion')->willReturn(100401);
+        $dbi->expects(self::never())->method('quoteString');
+        $dbi->expects(self::never())->method('tryQuery');
+        $dbi->expects(self::never())->method('getError');
 
         $accountLocking = new AccountLocking($dbi);
 
@@ -71,16 +71,16 @@ class AccountLockingTest extends TestCase
 
     public function testUnlockWithValidAccount(): void
     {
-        $dbi = $this->createMock(DatabaseInterface::class);
-        $dbi->expects($this->once())->method('isMariaDB')->willReturn(true);
-        $dbi->expects($this->once())->method('getVersion')->willReturn(100402);
-        $dbi->expects($this->exactly(2))->method('quoteString')
+        $dbi = self::createMock(DatabaseInterface::class);
+        $dbi->expects(self::once())->method('isMariaDB')->willReturn(true);
+        $dbi->expects(self::once())->method('getVersion')->willReturn(100402);
+        $dbi->expects(self::exactly(2))->method('quoteString')
             ->willReturnCallback(static fn (string $string): string => "'" . $string . "'");
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('tryQuery')
-            ->with($this->equalTo('ALTER USER \'test.user\'@\'test.host\' ACCOUNT UNLOCK;'))
-            ->willReturn($this->createStub(DummyResult::class));
-        $dbi->expects($this->never())->method('getError');
+            ->with(self::equalTo('ALTER USER \'test.user\'@\'test.host\' ACCOUNT UNLOCK;'))
+            ->willReturn(self::createStub(DummyResult::class));
+        $dbi->expects(self::never())->method('getError');
 
         $accountLocking = new AccountLocking($dbi);
         $accountLocking->unlock('test.user', 'test.host');
@@ -88,16 +88,16 @@ class AccountLockingTest extends TestCase
 
     public function testUnlockWithInvalidAccount(): void
     {
-        $dbi = $this->createMock(DatabaseInterface::class);
-        $dbi->expects($this->once())->method('isMariaDB')->willReturn(true);
-        $dbi->expects($this->once())->method('getVersion')->willReturn(100402);
-        $dbi->expects($this->exactly(2))->method('quoteString')
+        $dbi = self::createMock(DatabaseInterface::class);
+        $dbi->expects(self::once())->method('isMariaDB')->willReturn(true);
+        $dbi->expects(self::once())->method('getVersion')->willReturn(100402);
+        $dbi->expects(self::exactly(2))->method('quoteString')
             ->willReturnCallback(static fn (string $string): string => "'" . $string . "'");
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('tryQuery')
-            ->with($this->equalTo('ALTER USER \'test.user\'@\'test.host\' ACCOUNT UNLOCK;'))
+            ->with(self::equalTo('ALTER USER \'test.user\'@\'test.host\' ACCOUNT UNLOCK;'))
             ->willReturn(false);
-        $dbi->expects($this->once())->method('getError')->willReturn('Invalid account.');
+        $dbi->expects(self::once())->method('getError')->willReturn('Invalid account.');
 
         $accountLocking = new AccountLocking($dbi);
 
@@ -109,12 +109,12 @@ class AccountLockingTest extends TestCase
 
     public function testUnlockWithUnsupportedServer(): void
     {
-        $dbi = $this->createMock(DatabaseInterface::class);
-        $dbi->expects($this->once())->method('isMariaDB')->willReturn(false);
-        $dbi->expects($this->once())->method('getVersion')->willReturn(50705);
-        $dbi->expects($this->never())->method('quoteString');
-        $dbi->expects($this->never())->method('tryQuery');
-        $dbi->expects($this->never())->method('getError');
+        $dbi = self::createMock(DatabaseInterface::class);
+        $dbi->expects(self::once())->method('isMariaDB')->willReturn(false);
+        $dbi->expects(self::once())->method('getVersion')->willReturn(50705);
+        $dbi->expects(self::never())->method('quoteString');
+        $dbi->expects(self::never())->method('tryQuery');
+        $dbi->expects(self::never())->method('getError');
 
         $accountLocking = new AccountLocking($dbi);
 
diff --git a/tests/classes/Server/PrivilegesTest.php b/tests/classes/Server/PrivilegesTest.php
index cd831a2c7d..1150a92ce4 100644
--- a/tests/classes/Server/PrivilegesTest.php
+++ b/tests/classes/Server/PrivilegesTest.php
@@ -68,43 +68,43 @@ class PrivilegesTest extends AbstractTestCase
             $routinename,
             $dbnameIsWildcard,
         ] = $serverPrivileges->getDataForDBInfo();
-        $this->assertEquals('PMA_username', $username);
-        $this->assertEquals('PMA_hostname', $hostname);
-        $this->assertEquals('PMA_dbname', $dbname);
-        $this->assertEquals('PMA_tablename', $tablename);
-        $this->assertTrue($dbnameIsWildcard);
+        self::assertEquals('PMA_username', $username);
+        self::assertEquals('PMA_hostname', $hostname);
+        self::assertEquals('PMA_dbname', $dbname);
+        self::assertEquals('PMA_tablename', $tablename);
+        self::assertTrue($dbnameIsWildcard);
 
         //pre variable have been defined
         $_POST['pred_tablename'] = 'PMA_pred__tablename';
         $_POST['pred_dbname'] = ['PMA_pred_dbname'];
         [, , $dbname, $tablename, $routinename, $dbnameIsWildcard] = $serverPrivileges->getDataForDBInfo();
-        $this->assertEquals('PMA_pred_dbname', $dbname);
-        $this->assertEquals('PMA_pred__tablename', $tablename);
-        $this->assertTrue($dbnameIsWildcard);
+        self::assertEquals('PMA_pred_dbname', $dbname);
+        self::assertEquals('PMA_pred__tablename', $tablename);
+        self::assertTrue($dbnameIsWildcard);
 
         // Escaped database
         $_POST['pred_tablename'] = 'PMA_pred__tablename';
         $_POST['pred_dbname'] = ['PMA\_pred\_dbname'];
         [, , $dbname, $tablename, $routinename, $dbnameIsWildcard] = $serverPrivileges->getDataForDBInfo();
-        $this->assertEquals('PMA\_pred\_dbname', $dbname);
-        $this->assertEquals('PMA_pred__tablename', $tablename);
-        $this->assertFalse($dbnameIsWildcard);
+        self::assertEquals('PMA\_pred\_dbname', $dbname);
+        self::assertEquals('PMA_pred__tablename', $tablename);
+        self::assertFalse($dbnameIsWildcard);
 
         // Multiselect database - pred
         unset($_POST['pred_tablename'], $_REQUEST['tablename'], $_REQUEST['dbname']);
         $_POST['pred_dbname'] = ['PMA\_pred\_dbname', 'PMADbname2'];
         [, , $dbname, $tablename, , $dbnameIsWildcard] = $serverPrivileges->getDataForDBInfo();
-        $this->assertEquals(['PMA\_pred\_dbname', 'PMADbname2'], $dbname);
-        $this->assertEquals(null, $tablename);
-        $this->assertFalse($dbnameIsWildcard);
+        self::assertEquals(['PMA\_pred\_dbname', 'PMADbname2'], $dbname);
+        self::assertEquals(null, $tablename);
+        self::assertFalse($dbnameIsWildcard);
 
         // Multiselect database
         unset($_POST['pred_tablename'], $_REQUEST['tablename'], $_POST['pred_dbname']);
         $_REQUEST['dbname'] = ['PMA\_dbname', 'PMADbname2'];
         [, , $dbname, $tablename, , $dbnameIsWildcard] = $serverPrivileges->getDataForDBInfo();
-        $this->assertEquals(['PMA\_dbname', 'PMADbname2'], $dbname);
-        $this->assertEquals(null, $tablename);
-        $this->assertFalse($dbnameIsWildcard);
+        self::assertEquals(['PMA\_dbname', 'PMADbname2'], $dbname);
+        self::assertEquals(null, $tablename);
+        self::assertFalse($dbnameIsWildcard);
     }
 
     public function testWildcardEscapeForGrant(): void
@@ -114,17 +114,17 @@ class PrivilegesTest extends AbstractTestCase
         $dbname = '';
         $tablename = '';
         $dbAndTable = $serverPrivileges->wildcardEscapeForGrant($dbname, $tablename);
-        $this->assertEquals('*.*', $dbAndTable);
+        self::assertEquals('*.*', $dbAndTable);
 
         $dbname = 'dbname';
         $tablename = '';
         $dbAndTable = $serverPrivileges->wildcardEscapeForGrant($dbname, $tablename);
-        $this->assertEquals('`dbname`.*', $dbAndTable);
+        self::assertEquals('`dbname`.*', $dbAndTable);
 
         $dbname = 'dbname';
         $tablename = 'tablename';
         $dbAndTable = $serverPrivileges->wildcardEscapeForGrant($dbname, $tablename);
-        $this->assertEquals('`dbname`.`tablename`', $dbAndTable);
+        self::assertEquals('`dbname`.`tablename`', $dbAndTable);
     }
 
     public function testRangeOfUsers(): void
@@ -132,16 +132,16 @@ class PrivilegesTest extends AbstractTestCase
         $serverPrivileges = $this->getPrivileges($this->createDatabaseInterface());
 
         $ret = $serverPrivileges->rangeOfUsers('INIT');
-        $this->assertEquals('WHERE `User` LIKE \'INIT%\' OR `User` LIKE \'init%\'', $ret);
+        self::assertEquals('WHERE `User` LIKE \'INIT%\' OR `User` LIKE \'init%\'', $ret);
 
         $ret = $serverPrivileges->rangeOfUsers('%');
-        $this->assertEquals('WHERE `User` LIKE \'\\\\%%\' OR `User` LIKE \'\\\\%%\'', $ret);
+        self::assertEquals('WHERE `User` LIKE \'\\\\%%\' OR `User` LIKE \'\\\\%%\'', $ret);
 
         $ret = $serverPrivileges->rangeOfUsers('');
-        $this->assertEquals("WHERE `User` = ''", $ret);
+        self::assertEquals("WHERE `User` = ''", $ret);
 
         $ret = $serverPrivileges->rangeOfUsers();
-        $this->assertEquals('', $ret);
+        self::assertEquals('', $ret);
     }
 
     public function testGetTableGrantsArray(): void
@@ -149,11 +149,11 @@ class PrivilegesTest extends AbstractTestCase
         $serverPrivileges = $this->getPrivileges($this->createDatabaseInterface());
 
         $ret = $serverPrivileges->getTableGrantsArray();
-        $this->assertEquals(
+        self::assertEquals(
             ['Delete', 'DELETE', __('Allows deleting data.')],
             $ret[0],
         );
-        $this->assertEquals(
+        self::assertEquals(
             ['Create', 'CREATE', __('Allows creating new tables.')],
             $ret[1],
         );
@@ -164,11 +164,11 @@ class PrivilegesTest extends AbstractTestCase
         $serverPrivileges = $this->getPrivileges($this->createDatabaseInterface());
 
         $ret = $serverPrivileges->getGrantsArray();
-        $this->assertEquals(
+        self::assertEquals(
             ['Select_priv', 'SELECT', __('Allows reading data.')],
             $ret[0],
         );
-        $this->assertEquals(
+        self::assertEquals(
             ['Insert_priv', 'INSERT', __('Allows inserting and replacing data.')],
             $ret[1],
         );
@@ -189,7 +189,7 @@ class PrivilegesTest extends AbstractTestCase
         $sql = 'SELECT * FROM `mysql`.`user`'
             . ' WHERE `User` = ' . $dbi->quoteString($username)
             . ' AND `Host` = ' . $dbi->quoteString($hostname) . ';';
-        $this->assertEquals($sql, $ret);
+        self::assertEquals($sql, $ret);
 
         //$table == '*'
         $db = 'pma_db';
@@ -200,7 +200,7 @@ class PrivilegesTest extends AbstractTestCase
             . ' AND `Host` = ' . $dbi->quoteString($hostname)
             . ' AND `Db` = \'' . $db . '\'';
 
-        $this->assertEquals($sql, $ret);
+        self::assertEquals($sql, $ret);
 
         //$table == 'pma_table'
         $db = 'pma_db';
@@ -212,13 +212,13 @@ class PrivilegesTest extends AbstractTestCase
             . ' AND `Host` = ' . $dbi->quoteString($hostname)
             . " AND `Db` = '" . $serverPrivileges->unescapeGrantWildcards($db) . "'"
             . ' AND `Table_name` = ' . $dbi->quoteString($table) . ';';
-        $this->assertEquals($sql, $ret);
+        self::assertEquals($sql, $ret);
 
         // SQL escaping
         $db = "db' AND";
         $table = 'pma_table';
         $ret = $serverPrivileges->getSqlQueryForDisplayPrivTable($db, $table, $username, $hostname);
-        $this->assertEquals(
+        self::assertEquals(
             'SELECT `Table_priv` FROM `mysql`.`tables_priv` '
             . "WHERE `User` = 'pma_username' AND "
             . "`Host` = 'pma_hostname' AND `Db` = 'db\' AND' AND "
@@ -250,7 +250,7 @@ class PrivilegesTest extends AbstractTestCase
         //$_POST['change_copy'] is set
         $_POST['change_copy'] = true;
         $password = $serverPrivileges->getDataForChangeOrCopyUser('PMA_old_username', 'PMA_old_hostname');
-        $this->assertEquals('pma_password', $password);
+        self::assertEquals('pma_password', $password);
         unset($_POST['change_copy']);
     }
 
@@ -269,9 +269,9 @@ class PrivilegesTest extends AbstractTestCase
 
         $export = $serverPrivileges->getExportUserDefinitionTextarea($username, $hostname, null);
 
-        $this->assertStringContainsString('grant user2 delete', $export);
-        $this->assertStringContainsString('grant user1 select', $export);
-        $this->assertStringContainsString('<textarea class="export"', $export);
+        self::assertStringContainsString('grant user2 delete', $export);
+        self::assertStringContainsString('grant user1 select', $export);
+        self::assertStringContainsString('<textarea class="export"', $export);
     }
 
     public function testAddUser(): void
@@ -311,17 +311,17 @@ class PrivilegesTest extends AbstractTestCase
             $sqlQuery,
             $addUserError,
         ] = $serverPrivileges->addUser($dbname, $username, $hostname, $dbname, true);
-        $this->assertEquals(
+        self::assertEquals(
             'You have added a new user.',
             $retMessage->getMessage(),
         );
-        $this->assertEquals(
+        self::assertEquals(
             "CREATE USER ''@'localhost' IDENTIFIED WITH mysql_native_password AS '***';"
             . "GRANT USAGE ON *.* TO ''@'localhost' REQUIRE NONE;"
             . "GRANT ALL PRIVILEGES ON `pma_dbname`.* TO ''@'localhost';",
             $sqlQuery,
         );
-        $this->assertFalse($addUserError);
+        self::assertFalse($addUserError);
     }
 
     public function testAddUserOld(): void
@@ -361,18 +361,18 @@ class PrivilegesTest extends AbstractTestCase
             $addUserError,
         ] = $serverPrivileges->addUser($dbname, $username, $hostname, $dbname, true);
 
-        $this->assertEquals(
+        self::assertEquals(
             'You have added a new user.',
             $retMessage->getMessage(),
         );
-        $this->assertEquals(
+        self::assertEquals(
             "CREATE USER ''@'localhost';"
             . "GRANT USAGE ON *.* TO ''@'localhost' REQUIRE NONE;"
             . "SET PASSWORD FOR ''@'localhost' = '***';"
             . "GRANT ALL PRIVILEGES ON `pma_dbname`.* TO ''@'localhost';",
             $sqlQuery,
         );
-        $this->assertFalse($addUserError);
+        self::assertFalse($addUserError);
     }
 
     public function testUpdatePassword(): void
@@ -393,7 +393,7 @@ class PrivilegesTest extends AbstractTestCase
 
         $message = $serverPrivileges->updatePassword($errUrl, $username, $hostname);
 
-        $this->assertEquals(
+        self::assertEquals(
             'The password for \'pma_username\'@\'pma_hostname\' was changed successfully.',
             $message->getMessage(),
         );
@@ -431,11 +431,11 @@ class PrivilegesTest extends AbstractTestCase
             '',
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             "You have revoked the privileges for 'pma_username'@'pma_hostname'.",
             $message->getMessage(),
         );
-        $this->assertEquals(
+        self::assertEquals(
             'REVOKE ALL PRIVILEGES ON  `pma_dbname`.`pma_tablename` '
             . "FROM 'pma_username'@'pma_hostname'; "
             . 'REVOKE GRANT OPTION ON  `pma_dbname`.`pma_tablename` '
@@ -465,11 +465,11 @@ class PrivilegesTest extends AbstractTestCase
         $_POST['max_questions'] = 1000;
         [$sqlQuery, $message] = $serverPrivileges->updatePrivileges($username, $hostname, $tablename, $dbname, '');
 
-        $this->assertEquals(
+        self::assertEquals(
             "You have updated the privileges for 'pma_username'@'pma_hostname'.",
             $message->getMessage(),
         );
-        $this->assertEquals(
+        self::assertEquals(
             'REVOKE ALL PRIVILEGES ON  `pma_dbname`.`pma_tablename` FROM \'pma_username\'@\'pma_hostname\';   ',
             $sqlQuery,
         );
@@ -498,9 +498,9 @@ class PrivilegesTest extends AbstractTestCase
             ->disableOriginalConstructor()
             ->getMock();
 
-        $dbi->expects($this->any())->method('getVersion')
+        $dbi->expects(self::any())->method('getVersion')
             ->willReturn(8003);
-        $dbi->expects($this->any())
+        $dbi->expects(self::any())
             ->method('quoteString')
             ->willReturnCallback(static fn (string $string): string => "'" . $string . "'");
 
@@ -508,11 +508,11 @@ class PrivilegesTest extends AbstractTestCase
 
         [$sqlQuery, $message] = $serverPrivileges->updatePrivileges($username, $hostname, $tablename, $dbname, '');
 
-        $this->assertEquals(
+        self::assertEquals(
             "You have updated the privileges for 'pma_username'@'pma_hostname'.",
             $message->getMessage(),
         );
-        $this->assertEquals(
+        self::assertEquals(
             '  GRANT USAGE ON  *.* TO \'pma_username\'@\'pma_hostname\' REQUIRE NONE'
             . ' WITH GRANT OPTION MAX_QUERIES_PER_HOUR 1000 MAX_CONNECTIONS_PER_HOUR 20'
             . ' MAX_UPDATES_PER_HOUR 30 MAX_USER_CONNECTIONS 40; ',
@@ -542,9 +542,9 @@ class PrivilegesTest extends AbstractTestCase
             ->disableOriginalConstructor()
             ->getMock();
 
-        $dbi->expects($this->any())->method('getVersion')
+        $dbi->expects(self::any())->method('getVersion')
             ->willReturn(80011);
-        $dbi->expects($this->any())
+        $dbi->expects(self::any())
             ->method('quoteString')
             ->willReturnCallback(static fn (string $string): string => "'" . $string . "'");
 
@@ -552,11 +552,11 @@ class PrivilegesTest extends AbstractTestCase
 
         [$sqlQuery, $message] = $serverPrivileges->updatePrivileges($username, $hostname, $tablename, $dbname, '');
 
-        $this->assertEquals(
+        self::assertEquals(
             "You have updated the privileges for 'pma_username'@'pma_hostname'.",
             $message->getMessage(),
         );
-        $this->assertEquals(
+        self::assertEquals(
             '  GRANT USAGE ON  *.* TO \'pma_username\'@\'pma_hostname\';'
             . ' ALTER USER \'pma_username\'@\'pma_hostname\'  REQUIRE NONE'
             . ' WITH MAX_QUERIES_PER_HOUR 1000 MAX_CONNECTIONS_PER_HOUR'
@@ -577,68 +577,68 @@ class PrivilegesTest extends AbstractTestCase
         $GLOBALS['username'] = 'username';
 
         //validate 2: button
-        $this->assertStringContainsString('Update user privileges', $html);
+        self::assertStringContainsString('Update user privileges', $html);
 
         //validate 3: getHtmlForGlobalOrDbSpecificPrivs
-        $this->assertStringContainsString('<div class="card">', $html);
-        $this->assertStringContainsString(
+        self::assertStringContainsString('<div class="card">', $html);
+        self::assertStringContainsString(
             '<div class="card-header js-submenu-label" data-submenu-label="' . __('Global') . '">',
             $html,
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             __('Global privileges'),
             $html,
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             __('Check all'),
             $html,
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             __('Note: MySQL privilege names are expressed in English'),
             $html,
         );
 
         //validate 4: getHtmlForGlobalPrivTableWithCheckboxes items
         //Select_priv
-        $this->assertStringContainsString('<input type="checkbox" class="checkall" name="Select_priv"', $html);
+        self::assertStringContainsString('<input type="checkbox" class="checkall" name="Select_priv"', $html);
         //Create_user_priv
-        $this->assertStringContainsString('<input type="checkbox" class="checkall" name="Create_user_priv"', $html);
+        self::assertStringContainsString('<input type="checkbox" class="checkall" name="Create_user_priv"', $html);
         //Insert_priv
-        $this->assertStringContainsString('<input type="checkbox" class="checkall" name="Insert_priv"', $html);
+        self::assertStringContainsString('<input type="checkbox" class="checkall" name="Insert_priv"', $html);
         //Update_priv
-        $this->assertStringContainsString('<input type="checkbox" class="checkall" name="Update_priv"', $html);
+        self::assertStringContainsString('<input type="checkbox" class="checkall" name="Update_priv"', $html);
         //Create_priv
-        $this->assertStringContainsString('<input type="checkbox" class="checkall" name="Create_priv"', $html);
+        self::assertStringContainsString('<input type="checkbox" class="checkall" name="Create_priv"', $html);
         //Create_routine_priv
-        $this->assertStringContainsString('<input type="checkbox" class="checkall" name="Create_routine_priv"', $html);
+        self::assertStringContainsString('<input type="checkbox" class="checkall" name="Create_routine_priv"', $html);
         //Execute_priv
-        $this->assertStringContainsString('<input type="checkbox" class="checkall" name="Execute_priv"', $html);
+        self::assertStringContainsString('<input type="checkbox" class="checkall" name="Execute_priv"', $html);
 
         //validate 5: getHtmlForResourceLimits
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             '<div class="card-header">' . __('Resource limits') . '</div>',
             $html,
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             __('Note: Setting these options to 0 (zero) removes the limit.'),
             $html,
         );
-        $this->assertStringContainsString('MAX QUERIES PER HOUR', $html);
-        $this->assertStringContainsString('id="text_max_updates" value="0"', $html);
-        $this->assertStringContainsString(
+        self::assertStringContainsString('MAX QUERIES PER HOUR', $html);
+        self::assertStringContainsString('id="text_max_updates" value="0"', $html);
+        self::assertStringContainsString(
             __('Limits the number of new connections the user may open per hour.'),
             $html,
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             __('Limits the number of simultaneous connections the user may have.'),
             $html,
         );
 
-        $this->assertStringContainsString('<div class="card-header">SSL</div>', $html);
-        $this->assertStringContainsString('value="NONE"', $html);
-        $this->assertStringContainsString('value="ANY"', $html);
-        $this->assertStringContainsString('value="X509"', $html);
-        $this->assertStringContainsString('value="SPECIFIED"', $html);
+        self::assertStringContainsString('<div class="card-header">SSL</div>', $html);
+        self::assertStringContainsString('value="NONE"', $html);
+        self::assertStringContainsString('value="ANY"', $html);
+        self::assertStringContainsString('value="X509"', $html);
+        self::assertStringContainsString('value="SPECIFIED"', $html);
     }
 
     public function testGetSqlQueriesForDisplayAndAddUserMySql8011(): void
@@ -665,13 +665,13 @@ class PrivilegesTest extends AbstractTestCase
         ] = $serverPrivileges->getSqlQueriesForDisplayAndAddUser($username, $hostname, $password);
 
         //validate 1: $create_user_real
-        $this->assertEquals(
+        self::assertEquals(
             'CREATE USER \'PMA_username\'@\'PMA_hostname\' IDENTIFIED WITH mysql_native_password BY \'pma_password\';',
             $createUserReal,
         );
 
         //validate 2: $create_user_show
-        $this->assertEquals(
+        self::assertEquals(
             'CREATE USER \'PMA_username\'@\'PMA_hostname\' IDENTIFIED WITH mysql_native_password BY \'***\';',
             $createUserShow,
         );
@@ -698,13 +698,13 @@ class PrivilegesTest extends AbstractTestCase
         ] = $serverPrivileges->getSqlQueriesForDisplayAndAddUser($username, $hostname, $password);
 
         //validate 1: $createUserReal
-        $this->assertEquals(
+        self::assertEquals(
             'CREATE USER \'PMA_username\'@\'PMA_hostname\' IDENTIFIED BY \'pma_password\';',
             $createUserReal,
         );
 
         //validate 2: $createUserShow
-        $this->assertEquals('CREATE USER \'PMA_username\'@\'PMA_hostname\' IDENTIFIED BY \'***\';', $createUserShow);
+        self::assertEquals('CREATE USER \'PMA_username\'@\'PMA_hostname\' IDENTIFIED BY \'***\';', $createUserShow);
     }
 
     public function testGetSqlQueriesForDisplayAndAddUser(): void
@@ -738,26 +738,26 @@ class PrivilegesTest extends AbstractTestCase
         ] = $serverPrivileges->getSqlQueriesForDisplayAndAddUser($username, $hostname, $password);
 
         //validate 1: $createUserReal
-        $this->assertEquals(
+        self::assertEquals(
             'CREATE USER \'PMA_username\'@\'PMA_hostname\' IDENTIFIED WITH mysql_native_password AS \'pma_password\';',
             $createUserReal,
         );
 
         //validate 2: $createUserShow
-        $this->assertEquals(
+        self::assertEquals(
             'CREATE USER \'PMA_username\'@\'PMA_hostname\' IDENTIFIED WITH mysql_native_password AS \'***\';',
             $createUserShow,
         );
 
         //validate 3:$realSqlQuery
-        $this->assertEquals('GRANT USAGE ON *.* TO \'PMA_username\'@\'PMA_hostname\' REQUIRE NONE;', $realSqlQuery);
+        self::assertEquals('GRANT USAGE ON *.* TO \'PMA_username\'@\'PMA_hostname\' REQUIRE NONE;', $realSqlQuery);
 
         //validate 4:$sqlQuery
-        $this->assertEquals('GRANT USAGE ON *.* TO \'PMA_username\'@\'PMA_hostname\' REQUIRE NONE;', $sqlQuery);
+        self::assertEquals('GRANT USAGE ON *.* TO \'PMA_username\'@\'PMA_hostname\' REQUIRE NONE;', $sqlQuery);
 
-        $this->assertSame('', $alterRealSqlQuery);
+        self::assertSame('', $alterRealSqlQuery);
 
-        $this->assertSame('', $alterSqlQuery);
+        self::assertSame('', $alterSqlQuery);
 
         //Test for addUserAndCreateDatabase
         [$sqlQuery, $message] = $serverPrivileges->addUserAndCreateDatabase(
@@ -775,12 +775,12 @@ class PrivilegesTest extends AbstractTestCase
         );
 
         //validate 5: $sqlQuery
-        $this->assertEquals('GRANT USAGE ON *.* TO \'PMA_username\'@\'PMA_hostname\' REQUIRE NONE;', $sqlQuery);
+        self::assertEquals('GRANT USAGE ON *.* TO \'PMA_username\'@\'PMA_hostname\' REQUIRE NONE;', $sqlQuery);
 
-        $this->assertInstanceOf(Message::class, $message);
+        self::assertInstanceOf(Message::class, $message);
 
         //validate 6: $message
-        $this->assertEquals(
+        self::assertEquals(
             'You have added a new user.',
             $message->getMessage(),
         );
@@ -798,32 +798,32 @@ class PrivilegesTest extends AbstractTestCase
         $GLOBALS['hostname'] = 'PMA_hostname';
         $html = $serverPrivileges->getHtmlToDisplayPrivilegesTable('PMA_db', 'PMA_table');
 
-        $this->assertStringContainsString('checkbox_Update_priv_none', $html);
-        $this->assertStringContainsString('<dfn title="Allows changing data.">UPDATE</dfn>', $html);
-        $this->assertStringContainsString('checkbox_Insert_priv_none', $html);
-        $this->assertStringContainsString(
+        self::assertStringContainsString('checkbox_Update_priv_none', $html);
+        self::assertStringContainsString('<dfn title="Allows changing data.">UPDATE</dfn>', $html);
+        self::assertStringContainsString('checkbox_Insert_priv_none', $html);
+        self::assertStringContainsString(
             __('Allows reading data.'),
             $html,
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             __('Allows inserting and replacing data'),
             $html,
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             __('Allows changing data.'),
             $html,
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             __('Has no effect in this MySQL version.'),
             $html,
         );
 
-        $this->assertStringContainsString('title="Allows performing SHOW CREATE VIEW queries." checked>', $html);
-        $this->assertStringContainsString('<dfn title="Allows creating new views.">', $html);
-        $this->assertStringContainsString('CREATE VIEW', $html);
-        $this->assertStringContainsString('Create_view_priv', $html);
-        $this->assertStringContainsString('Show_view_priv', $html);
-        $this->assertStringContainsString(
+        self::assertStringContainsString('title="Allows performing SHOW CREATE VIEW queries." checked>', $html);
+        self::assertStringContainsString('<dfn title="Allows creating new views.">', $html);
+        self::assertStringContainsString('CREATE VIEW', $html);
+        self::assertStringContainsString('Create_view_priv', $html);
+        self::assertStringContainsString('Show_view_priv', $html);
+        self::assertStringContainsString(
             _pgettext('None privileges', 'None'),
             $html,
         );
@@ -843,9 +843,9 @@ class PrivilegesTest extends AbstractTestCase
             ['COLUMN_NAME' => 'Host', 'CHARACTER_MAXIMUM_LENGTH' => 80],
             ['COLUMN_NAME' => 'User', 'CHARACTER_MAXIMUM_LENGTH' => 40],
         ];
-        $dbi->expects($this->any())->method('fetchResult')
+        $dbi->expects(self::any())->method('fetchResult')
             ->willReturn($fieldsInfo);
-        $dbi->expects($this->any())
+        $dbi->expects(self::any())
             ->method('quoteString')
             ->willReturnCallback(static fn (string $string): string => "'" . $string . "'");
 
@@ -854,19 +854,19 @@ class PrivilegesTest extends AbstractTestCase
         $html = $serverPrivileges->getHtmlForLoginInformationFields();
 
         //validate 1: __('Login Information')
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             __('Login Information'),
             $html,
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             __('User name:'),
             $html,
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             __('Any user'),
             $html,
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             __('Use text field'),
             $html,
         );
@@ -876,7 +876,7 @@ class PrivilegesTest extends AbstractTestCase
                 'When Host table is used, this field is ignored and values stored in Host table are used instead.',
             ),
         );
-        $this->assertStringContainsString($output, $html);
+        self::assertStringContainsString($output, $html);
     }
 
     public function testGetWithClauseForAddUserAndUpdatePrivs(): void
@@ -893,7 +893,7 @@ class PrivilegesTest extends AbstractTestCase
         $expect = 'WITH GRANT OPTION MAX_QUERIES_PER_HOUR 10 '
             . 'MAX_CONNECTIONS_PER_HOUR 20'
             . ' MAX_UPDATES_PER_HOUR 30 MAX_USER_CONNECTIONS 40';
-        $this->assertStringContainsString($expect, $sqlQuery);
+        self::assertStringContainsString($expect, $sqlQuery);
     }
 
     #[Group('medium')]
@@ -909,12 +909,12 @@ class PrivilegesTest extends AbstractTestCase
             ['COLUMN_NAME' => 'Host', 'CHARACTER_MAXIMUM_LENGTH' => 80],
             ['COLUMN_NAME' => 'User', 'CHARACTER_MAXIMUM_LENGTH' => 40],
         ];
-        $dbi->expects($this->any())->method('fetchResult')
+        $dbi->expects(self::any())->method('fetchResult')
             ->willReturn($fieldsInfo);
-        $dbi->expects($this->any())
+        $dbi->expects(self::any())
             ->method('quoteString')
             ->willReturnCallback(static fn (string $string): string => "'" . $string . "'");
-        $dbi->expects($this->any())->method('isGrantUser')
+        $dbi->expects(self::any())->method('isGrantUser')
             ->willReturn(true);
 
         $serverPrivileges->dbi = $dbi;
@@ -924,37 +924,37 @@ class PrivilegesTest extends AbstractTestCase
         $html = $serverPrivileges->getHtmlForAddUser($dbname);
 
         //validate 1: Url::getHiddenInputs
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             Url::getHiddenInputs('', ''),
             $html,
         );
 
         //validate 2: getHtmlForLoginInformationFields
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             $serverPrivileges->getHtmlForLoginInformationFields(),
             $html,
         );
 
         //validate 3: Database for user
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             __('Database for user'),
             $html,
         );
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             __('Grant all privileges on wildcard name (username\\_%).'),
             $html,
         );
-        $this->assertStringContainsString('<input type="checkbox" name="createdb-2" id="createdb-2">', $html);
+        self::assertStringContainsString('<input type="checkbox" name="createdb-2" id="createdb-2">', $html);
 
         //validate 4: getHtmlToDisplayPrivilegesTable
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             $serverPrivileges->getHtmlToDisplayPrivilegesTable('*', '*', false),
             $html,
         );
 
         //validate 5: button
-        $this->assertStringContainsString('Create user', $html);
+        self::assertStringContainsString('Create user', $html);
     }
 
     public function testGetUserLink(): void
@@ -976,8 +976,8 @@ class PrivilegesTest extends AbstractTestCase
             'tablename' => $tablename,
             'routinename' => '',
         ], '');
-        $this->assertStringContainsString($urlHtml, $html);
-        $this->assertStringContainsString(
+        self::assertStringContainsString($urlHtml, $html);
+        self::assertStringContainsString(
             __('Edit privileges'),
             $html,
         );
@@ -997,8 +997,8 @@ class PrivilegesTest extends AbstractTestCase
             ],
             '',
         );
-        $this->assertStringContainsString($urlHtml, $html);
-        $this->assertStringContainsString(
+        self::assertStringContainsString($urlHtml, $html);
+        self::assertStringContainsString(
             __('Revoke'),
             $html,
         );
@@ -1011,8 +1011,8 @@ class PrivilegesTest extends AbstractTestCase
             'initial' => '',
             'export' => 1,
         ], '');
-        $this->assertStringContainsString($urlHtml, $html);
-        $this->assertStringContainsString(
+        self::assertStringContainsString($urlHtml, $html);
+        self::assertStringContainsString(
             __('Export'),
             $html,
         );
@@ -1037,8 +1037,8 @@ class PrivilegesTest extends AbstractTestCase
             'tablename' => $tablename,
             'routinename' => '',
         ], '');
-        $this->assertStringContainsString($urlHtml, $html);
-        $this->assertStringContainsString(
+        self::assertStringContainsString($urlHtml, $html);
+        self::assertStringContainsString(
             __('Edit privileges'),
             $html,
         );
@@ -1058,8 +1058,8 @@ class PrivilegesTest extends AbstractTestCase
             ],
             '',
         );
-        $this->assertStringContainsString($urlHtml, $html);
-        $this->assertStringContainsString(
+        self::assertStringContainsString($urlHtml, $html);
+        self::assertStringContainsString(
             __('Revoke'),
             $html,
         );
@@ -1072,8 +1072,8 @@ class PrivilegesTest extends AbstractTestCase
             'initial' => '',
             'export' => 1,
         ], '');
-        $this->assertStringContainsString($urlHtml, $html);
-        $this->assertStringContainsString(
+        self::assertStringContainsString($urlHtml, $html);
+        self::assertStringContainsString(
             __('Export'),
             $html,
         );
@@ -1103,37 +1103,37 @@ class PrivilegesTest extends AbstractTestCase
         $extraData = $serverPrivileges->getExtraDataForAjaxBehavior($password, $sqlQuery, $hostname, $username);
 
         //user_exists
-        $this->assertFalse($extraData['user_exists']);
+        self::assertFalse($extraData['user_exists']);
 
         //db_wildcard_privs
-        $this->assertTrue($extraData['db_wildcard_privs']);
+        self::assertTrue($extraData['db_wildcard_privs']);
 
         //user_exists
-        $this->assertFalse($extraData['db_specific_privs']);
+        self::assertFalse($extraData['db_specific_privs']);
 
         //new_user_initial
-        $this->assertEquals('P', $extraData['new_user_initial']);
+        self::assertEquals('P', $extraData['new_user_initial']);
 
         //sql_query
-        $this->assertEquals(
+        self::assertEquals(
             Generator::getMessage('', $sqlQuery),
             $extraData['sql_query'],
         );
 
         //new_user_string
-        $this->assertIsString($extraData['new_user_string']);
-        $this->assertStringContainsString(
+        self::assertIsString($extraData['new_user_string']);
+        self::assertStringContainsString(
             htmlspecialchars($hostname),
             $extraData['new_user_string'],
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             htmlspecialchars($username),
             $extraData['new_user_string'],
         );
 
         //new_privileges
-        $this->assertIsString($extraData['new_privileges']);
-        $this->assertStringContainsString(
+        self::assertIsString($extraData['new_privileges']);
+        self::assertStringContainsString(
             implode(', ', $serverPrivileges->extractPrivInfo(null, true)),
             $extraData['new_privileges'],
         );
@@ -1157,7 +1157,7 @@ class PrivilegesTest extends AbstractTestCase
 
         $serverPrivileges = $this->getPrivileges($this->createDatabaseInterface($dummyDbi));
 
-        $this->assertEquals('pma_usergroup', $serverPrivileges->getUserGroupForUser('pma_username'));
+        self::assertEquals('pma_usergroup', $serverPrivileges->getUserGroupForUser('pma_username'));
     }
 
     public function testGetUsersOverview(): void
@@ -1187,31 +1187,31 @@ class PrivilegesTest extends AbstractTestCase
         $html = $serverPrivileges->getUsersOverview($resultStub, $dbRights, $textDir);
 
         //Url::getHiddenInputs
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             Url::getHiddenInputs('', ''),
             $html,
         );
 
         //items
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             __('User'),
             $html,
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             __('Host'),
             $html,
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             __('Password'),
             $html,
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             __('Global privileges'),
             $html,
         );
 
         //Util::showHint
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             Generator::showHint(
                 __('Note: MySQL privilege names are expressed in English.'),
             ),
@@ -1219,41 +1219,41 @@ class PrivilegesTest extends AbstractTestCase
         );
 
         //__('User group')
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             __('User group'),
             $html,
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             __('Grant'),
             $html,
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             __('Action'),
             $html,
         );
 
         //$text_dir
-        $this->assertStringContainsString($textDir, $html);
+        self::assertStringContainsString($textDir, $html);
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             Url::getCommon(['adduser' => 1], ''),
             $html,
         );
 
         //labels
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             __('Add user account'),
             $html,
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             __('Remove selected user accounts'),
             $html,
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             __('Drop the databases that have the same names as the users.'),
             $html,
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             __('Drop the databases that have the same names as the users.'),
             $html,
         );
@@ -1274,7 +1274,7 @@ class PrivilegesTest extends AbstractTestCase
         $ret = $serverPrivileges->getDataForDeleteUsers($queries);
 
         $item = ["# Deleting 'old_username'@'old_hostname' ...", "DROP USER 'old_username'@'old_hostname';"];
-        $this->assertEquals($item, $ret);
+        self::assertEquals($item, $ret);
     }
 
     public function testGetHtmlHeaderForUserProperties(): void
@@ -1307,11 +1307,11 @@ class PrivilegesTest extends AbstractTestCase
         );
 
         //title
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             __('Edit privileges:'),
             $html,
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             __('User account'),
             $html,
         );
@@ -1323,26 +1323,26 @@ class PrivilegesTest extends AbstractTestCase
             'dbname' => '',
             'tablename' => '',
         ], '');
-        $this->assertStringContainsString($item, $html);
+        self::assertStringContainsString($item, $html);
 
         //$username & $hostname
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             htmlspecialchars($username),
             $html,
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             htmlspecialchars($hostname),
             $html,
         );
 
         //$dbnameIsWildcard = true
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             __('Databases'),
             $html,
         );
 
         //$dbnameIsWildcard = true
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             __('Databases'),
             $html,
         );
@@ -1354,8 +1354,8 @@ class PrivilegesTest extends AbstractTestCase
             'dbname' => $urlDbname,
             'tablename' => '',
         ], '');
-        $this->assertStringContainsString($item, $html);
-        $this->assertStringContainsString($dbname, $html);
+        self::assertStringContainsString($item, $html);
+        self::assertStringContainsString($dbname, $html);
     }
 
     public function testGetHtmlForUserProperties(): void
@@ -1402,36 +1402,36 @@ class PrivilegesTest extends AbstractTestCase
             'actor',
             '/server/privileges',
         );
-        $this->assertStringContainsString('addUsersForm', $actual);
-        $this->assertStringContainsString('SELECT', $actual);
-        $this->assertStringContainsString('Allows reading data.', $actual);
-        $this->assertStringContainsString('INSERT', $actual);
-        $this->assertStringContainsString('Allows inserting and replacing data.', $actual);
-        $this->assertStringContainsString('UPDATE', $actual);
-        $this->assertStringContainsString('Allows changing data.', $actual);
-        $this->assertStringContainsString('DELETE', $actual);
-        $this->assertStringContainsString('Allows deleting data.', $actual);
-        $this->assertStringContainsString('CREATE', $actual);
-        $this->assertStringContainsString('Allows creating new tables.', $actual);
+        self::assertStringContainsString('addUsersForm', $actual);
+        self::assertStringContainsString('SELECT', $actual);
+        self::assertStringContainsString('Allows reading data.', $actual);
+        self::assertStringContainsString('INSERT', $actual);
+        self::assertStringContainsString('Allows inserting and replacing data.', $actual);
+        self::assertStringContainsString('UPDATE', $actual);
+        self::assertStringContainsString('Allows changing data.', $actual);
+        self::assertStringContainsString('DELETE', $actual);
+        self::assertStringContainsString('Allows deleting data.', $actual);
+        self::assertStringContainsString('CREATE', $actual);
+        self::assertStringContainsString('Allows creating new tables.', $actual);
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             Url::getHiddenInputs(),
             $actual,
         );
 
         //$username & $hostname
-        $this->assertStringContainsString('user', $actual);
-        $this->assertStringContainsString('host', $actual);
+        self::assertStringContainsString('user', $actual);
+        self::assertStringContainsString('host', $actual);
 
         //Create a new user with the same privileges
-        $this->assertStringContainsString('Create a new user account with the same privileges', $actual);
+        self::assertStringContainsString('Create a new user account with the same privileges', $actual);
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             __('Database'),
             $actual,
         );
         $config = Config::getInstance();
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             Util::getScriptNameForOption(
                 $config->settings['DefaultTabDatabase'],
                 'database',
@@ -1439,15 +1439,15 @@ class PrivilegesTest extends AbstractTestCase
             $actual,
         );
         $item = Url::getCommon(['db' => 'sakila', 'reload' => 1], '');
-        $this->assertStringContainsString($item, $actual);
-        $this->assertStringContainsString('sakila', $actual);
+        self::assertStringContainsString($item, $actual);
+        self::assertStringContainsString('sakila', $actual);
 
         //$tablename
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             __('Table'),
             $actual,
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             Util::getScriptNameForOption(
                 $config->settings['DefaultTabTable'],
                 'table',
@@ -1455,10 +1455,10 @@ class PrivilegesTest extends AbstractTestCase
             $actual,
         );
         $item = Url::getCommon(['db' => 'sakila', 'table' => 'actor', 'reload' => 1], '');
-        $this->assertStringContainsString($item, $actual);
-        $this->assertStringContainsString('table', $actual);
+        self::assertStringContainsString($item, $actual);
+        self::assertStringContainsString('table', $actual);
         $item = Util::getTitleForTarget($config->settings['DefaultTabTable']);
-        $this->assertStringContainsString((string) $item, $actual);
+        self::assertStringContainsString((string) $item, $actual);
     }
 
     public function testGetHtmlForUserOverview(): void
@@ -1494,8 +1494,8 @@ class PrivilegesTest extends AbstractTestCase
 
         $_REQUEST = ['ajax_page_request' => '1'];
         $actual = $serverPrivileges->getHtmlForUserOverview('ltr', null);
-        $this->assertStringContainsString('Note: MySQL privilege names are expressed in English.', $actual);
-        $this->assertStringContainsString(
+        self::assertStringContainsString('Note: MySQL privilege names are expressed in English.', $actual);
+        self::assertStringContainsString(
             'Note: phpMyAdmin gets the users’ privileges directly from MySQL’s privilege tables.',
             $actual,
         );
@@ -1515,15 +1515,15 @@ class PrivilegesTest extends AbstractTestCase
         $serverPrivileges = $this->getPrivileges($this->createDatabaseInterface($dummyDbi));
         $html = $serverPrivileges->getHtmlForUserOverview('ltr', null);
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             Url::getCommon(['adduser' => 1], ''),
             $html,
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             Generator::getIcon('b_usradd', 'Add user account'),
             $html,
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             __('Add user'),
             $html,
         );
@@ -1543,7 +1543,7 @@ class PrivilegesTest extends AbstractTestCase
         $serverPrivileges = $this->getPrivileges($this->createDatabaseInterface($dummyDbi));
         $actual = $serverPrivileges->getHtmlForUserOverview('ltr', null);
 
-        $this->assertStringContainsString('Your privilege table structure seems to be older than'
+        self::assertStringContainsString('Your privilege table structure seems to be older than'
             . ' this MySQL version!<br>'
             . 'Please run the <code>mysql_upgrade</code> command'
             . ' that should be included in your MySQL server distribution'
@@ -1592,13 +1592,13 @@ class PrivilegesTest extends AbstractTestCase
 
         // Test case 1
         $actual = $serverPrivileges->getHtmlForAllTableSpecificRights('pma', 'host', 'table', 'pmadb');
-        $this->assertStringContainsString('<input type="hidden" name="username" value="pma">', $actual);
-        $this->assertStringContainsString('<input type="hidden" name="hostname" value="host">', $actual);
-        $this->assertStringContainsString(
+        self::assertStringContainsString('<input type="hidden" name="username" value="pma">', $actual);
+        self::assertStringContainsString('<input type="hidden" name="hostname" value="host">', $actual);
+        self::assertStringContainsString(
             '<div class="card-header js-submenu-label" data-submenu-label="Table">',
             $actual,
         );
-        $this->assertStringContainsString('Table-specific privileges', $actual);
+        self::assertStringContainsString('Table-specific privileges', $actual);
 
         // Test case 2
         $config = Config::getInstance();
@@ -1610,11 +1610,11 @@ class PrivilegesTest extends AbstractTestCase
             ['SCHEMA_NAME'],
         );
         $actual = $serverPrivileges->getHtmlForAllTableSpecificRights('pma2', 'host2', 'database', '');
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             '<div class="card-header js-submenu-label" data-submenu-label="Database">',
             $actual,
         );
-        $this->assertStringContainsString('Database-specific privileges', $actual);
+        self::assertStringContainsString('Database-specific privileges', $actual);
     }
 
     public function testGetHtmlForInitials(): void
@@ -1632,41 +1632,41 @@ class PrivilegesTest extends AbstractTestCase
         $serverPrivileges = $this->getPrivileges($dbi);
 
         $actual = $serverPrivileges->getHtmlForInitials();
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             '<a class="page-link" href="#" tabindex="-1" aria-disabled="true">A</a>',
             $actual,
         );
-        $this->assertMatchesRegularExpression(
+        self::assertMatchesRegularExpression(
             '/<a class="page-link" href="index.php\?route=\/server\/privileges&initial=C&lang=en">\s*C\s*<\/a>/',
             $actual,
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             '<a class="page-link" href="#" tabindex="-1" aria-disabled="true">Z</a>',
             $actual,
         );
-        $this->assertMatchesRegularExpression(
+        self::assertMatchesRegularExpression(
             '/<a class="page-link" href="index.php\?route=\/server\/privileges&initial=-&lang=en">\s*-\s*<\/a>/',
             $actual,
         );
-        $this->assertMatchesRegularExpression(
+        self::assertMatchesRegularExpression(
             '/<a class="page-link" href="index.php\?route=\/server\/privileges&initial=%22&lang=en">\s*&quot;\s*<\/a>/',
             $actual,
         );
-        $this->assertMatchesRegularExpression(
+        self::assertMatchesRegularExpression(
             '/<a class="page-link" href="index.php\?route=\/server\/privileges&initial=%25&lang=en">\s*%\s*<\/a>/',
             $actual,
         );
-        $this->assertMatchesRegularExpression(
+        self::assertMatchesRegularExpression(
             '/<a class="page-link" href="index.php\?route=\/server\/privileges&initial=%5C&lang=en">\s*\\\\\s*<\/a>/',
             $actual,
         );
-        $this->assertMatchesRegularExpression(
+        self::assertMatchesRegularExpression(
             '/<a class="page-link" href="index.php\?route=\/server\/privileges&initial=&lang=en">\s*' .
                 '<span class="text-danger text-nowrap">' . preg_quote(__('Any')) . '<\/span>' .
                 '\s*<\/a>/',
             $actual,
         );
-        $this->assertStringContainsString('Show all', $actual);
+        self::assertStringContainsString('Show all', $actual);
     }
 
     public function testGetDbRightsForUserOverview(): void
@@ -1680,16 +1680,16 @@ class PrivilegesTest extends AbstractTestCase
         $dbi = $this->getMockBuilder(DatabaseInterface::class)
             ->disableOriginalConstructor()
             ->getMock();
-        $dbi->expects($this->any())
+        $dbi->expects(self::any())
             ->method('query')
             ->willReturn($resultStub);
-        $dbi->expects($this->any())
+        $dbi->expects(self::any())
             ->method('fetchResult')
             ->willReturn(['db', 'columns_priv']);
-        $resultStub->expects($this->any())
+        $resultStub->expects(self::any())
             ->method('fetchAssoc')
             ->willReturn(['User' => 'pmauser', 'Host' => 'local'], []);
-        $dbi->expects($this->any())
+        $dbi->expects(self::any())
             ->method('quoteString')
             ->willReturnCallback(static fn (string $string): string => "'" . $string . "'");
 
@@ -1707,7 +1707,7 @@ class PrivilegesTest extends AbstractTestCase
             ],
         ];
         $actual = $serverPrivileges->getDbRightsForUserOverview('A');
-        $this->assertEquals($expected, $actual);
+        self::assertEquals($expected, $actual);
     }
 
     public function testDeleteUser(): void
@@ -1721,13 +1721,13 @@ class PrivilegesTest extends AbstractTestCase
         $dbi = $this->getMockBuilder(DatabaseInterface::class)
             ->disableOriginalConstructor()
             ->getMock();
-        $dbi->expects($this->any())
+        $dbi->expects(self::any())
             ->method('tryQuery')
             ->willReturn($resultStub, $resultStub, false);
-        $dbi->expects($this->any())
+        $dbi->expects(self::any())
             ->method('getError')
             ->willReturn('Some error occurred!');
-        $dbi->expects($this->any())
+        $dbi->expects(self::any())
             ->method('quoteString')
             ->willReturnCallback(static fn (string $string): string => "'" . $string . "'");
 
@@ -1736,10 +1736,10 @@ class PrivilegesTest extends AbstractTestCase
         // Test case 1 : empty queries
         $queries = [];
         $actual = $serverPrivileges->deleteUser($queries);
-        $this->assertArrayHasKey(0, $actual);
-        $this->assertArrayHasKey(1, $actual);
-        $this->assertEquals('', $actual[0]);
-        $this->assertEquals(
+        self::assertArrayHasKey(0, $actual);
+        self::assertArrayHasKey(1, $actual);
+        self::assertEquals('', $actual[0]);
+        self::assertEquals(
             'No users selected for deleting!',
             $actual[1]->getMessage(),
         );
@@ -1748,10 +1748,10 @@ class PrivilegesTest extends AbstractTestCase
         $_POST['mode'] = 3;
         $queries = ['foo'];
         $actual = $serverPrivileges->deleteUser($queries);
-        $this->assertArrayHasKey(0, $actual);
-        $this->assertArrayHasKey(1, $actual);
-        $this->assertEquals("foo\n# Reloading the privileges …\nFLUSH PRIVILEGES;", $actual[0]);
-        $this->assertEquals(
+        self::assertArrayHasKey(0, $actual);
+        self::assertArrayHasKey(1, $actual);
+        self::assertEquals("foo\n# Reloading the privileges …\nFLUSH PRIVILEGES;", $actual[0]);
+        self::assertEquals(
             'The selected users have been deleted successfully.',
             $actual[1]->getMessage(),
         );
@@ -1760,10 +1760,10 @@ class PrivilegesTest extends AbstractTestCase
         $_POST['mode'] = 1;
         $queries = ['bar'];
         $actual = $serverPrivileges->deleteUser($queries);
-        $this->assertArrayHasKey(0, $actual);
-        $this->assertArrayHasKey(1, $actual);
-        $this->assertEquals('bar', $actual[0]);
-        $this->assertEquals(
+        self::assertArrayHasKey(0, $actual);
+        self::assertArrayHasKey(1, $actual);
+        self::assertEquals('bar', $actual[0]);
+        self::assertEquals(
             'Some error occurred!' . "\n",
             $actual[1]->getMessage(),
         );
@@ -1778,38 +1778,38 @@ class PrivilegesTest extends AbstractTestCase
 
         $html = $serverPrivileges->getFormForChangePassword($username, $hostname, false, '/server/privileges');
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             Url::getFromRoute('/server/privileges'),
             $html,
         );
 
         //Url::getHiddenInputs
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             Url::getHiddenInputs(),
             $html,
         );
 
         //$username & $hostname
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             htmlspecialchars($username),
             $html,
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             htmlspecialchars($hostname),
             $html,
         );
 
         //labels
-        $this->assertStringContainsString('change_password_form', $html);
-        $this->assertStringContainsString(
+        self::assertStringContainsString('change_password_form', $html);
+        self::assertStringContainsString(
             __('No Password'),
             $html,
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             __('Password:'),
             $html,
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             __('Password:'),
             $html,
         );
@@ -1819,20 +1819,20 @@ class PrivilegesTest extends AbstractTestCase
     {
         $mysqliResultStub = $this->createMock(ResultInterface::class);
         $mysqliStmtStub = $this->createMock(Statement::class);
-        $mysqliStmtStub->expects($this->exactly(2))->method('execute')->willReturn(true);
-        $mysqliStmtStub->expects($this->exactly(2))->method('getResult')->willReturn($mysqliResultStub);
+        $mysqliStmtStub->expects(self::exactly(2))->method('execute')->willReturn(true);
+        $mysqliStmtStub->expects(self::exactly(2))->method('getResult')->willReturn($mysqliResultStub);
 
         $dbi = $this->createMock(DatabaseInterface::class);
-        $dbi->expects($this->once())->method('isMariaDB')->willReturn(true);
+        $dbi->expects(self::once())->method('isMariaDB')->willReturn(true);
 
         $userQuery = 'SELECT * FROM `mysql`.`user` WHERE `User` = ? AND `Host` = ?;';
         $globalPrivQuery = 'SELECT * FROM `mysql`.`global_priv` WHERE `User` = ? AND `Host` = ?;';
-        $dbi->expects($this->exactly(2))->method('prepare')->willReturnMap([
+        $dbi->expects(self::exactly(2))->method('prepare')->willReturnMap([
             [$userQuery, ConnectionType::User, $mysqliStmtStub],
             [$globalPrivQuery, ConnectionType::User, $mysqliStmtStub],
         ]);
 
-        $mysqliResultStub->expects($this->exactly(2))
+        $mysqliResultStub->expects(self::exactly(2))
             ->method('fetchAssoc')
             ->willReturn(
                 ['Host' => 'test.host', 'User' => 'test.user'],
@@ -1852,7 +1852,7 @@ class PrivilegesTest extends AbstractTestCase
         /** @var array|null $actual */
         $actual = $method->invokeArgs($serverPrivileges, ['test.user', 'test.host', true]);
 
-        $this->assertEquals(['Host' => 'test.host', 'User' => 'test.user', 'account_locked' => 'Y'], $actual);
+        self::assertEquals(['Host' => 'test.host', 'User' => 'test.user', 'account_locked' => 'Y'], $actual);
     }
 
     private function getPrivileges(DatabaseInterface $dbi): Privileges
@@ -1890,7 +1890,7 @@ class PrivilegesTest extends AbstractTestCase
     {
         $dbi = $this->createDatabaseInterface();
         $serverPrivileges = $this->getPrivileges($dbi);
-        $this->assertEquals(
+        self::assertEquals(
             $a,
             $serverPrivileges->escapeGrantWildcards($b),
         );
@@ -1905,7 +1905,7 @@ class PrivilegesTest extends AbstractTestCase
     {
         $dbi = $this->createDatabaseInterface();
         $serverPrivileges = $this->getPrivileges($dbi);
-        $this->assertEquals(
+        self::assertEquals(
             $b,
             $serverPrivileges->unescapeGrantWildcards($a),
         );
diff --git a/tests/classes/Server/SelectTest.php b/tests/classes/Server/SelectTest.php
index 64793c8ffb..051516611c 100644
--- a/tests/classes/Server/SelectTest.php
+++ b/tests/classes/Server/SelectTest.php
@@ -77,7 +77,7 @@ class SelectTest extends AbstractTestCase
         $server = $config->settings['Servers']['0'];
 
         if ($notOnlyOptions) {
-            $this->assertStringContainsString(
+            self::assertStringContainsString(
                 Util::getScriptNameForOption(
                     $config->settings['DefaultTabServer'],
                     'server',
@@ -85,21 +85,21 @@ class SelectTest extends AbstractTestCase
                 $html,
             );
 
-            $this->assertStringContainsString(
+            self::assertStringContainsString(
                 __('Current server:'),
                 $html,
             );
-            $this->assertStringContainsString(
+            self::assertStringContainsString(
                 '(' . __('Servers') . ')',
                 $html,
             );
         }
 
         //server items
-        $this->assertStringContainsString($server['host'], $html);
-        $this->assertStringContainsString($server['port'], $html);
-        $this->assertStringContainsString($server['only_db'], $html);
-        $this->assertStringContainsString($server['user'], $html);
+        self::assertStringContainsString($server['host'], $html);
+        self::assertStringContainsString($server['port'], $html);
+        self::assertStringContainsString($server['only_db'], $html);
+        self::assertStringContainsString($server['user'], $html);
     }
 
     /** @return mixed[][] */
diff --git a/tests/classes/Server/SysInfo/SysInfoTest.php b/tests/classes/Server/SysInfo/SysInfoTest.php
index 42974c7ef0..c097c4de19 100644
--- a/tests/classes/Server/SysInfo/SysInfoTest.php
+++ b/tests/classes/Server/SysInfo/SysInfoTest.php
@@ -22,7 +22,7 @@ class SysInfoTest extends AbstractTestCase
     #[DataProvider('sysInfoOsProvider')]
     public function testGetSysInfoOs(string $os, string $expected): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             $expected,
             SysInfo::getOs($os),
         );
@@ -43,7 +43,7 @@ class SysInfoTest extends AbstractTestCase
      */
     public function testGetSysInfo(): void
     {
-        $this->assertInstanceOf(Base::class, SysInfo::get());
+        self::assertInstanceOf(Base::class, SysInfo::get());
     }
 
     /**
@@ -51,6 +51,6 @@ class SysInfoTest extends AbstractTestCase
      */
     public function testGetSysInfoSupported(): void
     {
-        $this->assertTrue(SysInfo::get()::isSupported());
+        self::assertTrue(SysInfo::get()::isSupported());
     }
 }
diff --git a/tests/classes/Setup/ConfigGeneratorTest.php b/tests/classes/Setup/ConfigGeneratorTest.php
index 3352e6359e..a175903b98 100644
--- a/tests/classes/Setup/ConfigGeneratorTest.php
+++ b/tests/classes/Setup/ConfigGeneratorTest.php
@@ -42,7 +42,7 @@ class ConfigGeneratorTest extends AbstractTestCase
 
         $result = ConfigGenerator::getConfigFile($cf);
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             "<?php\n" .
             "/**\n" .
             " * Generated configuration file\n" .
@@ -50,7 +50,7 @@ class ConfigGeneratorTest extends AbstractTestCase
             $result,
         );
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             "/* Servers configuration */\n" .
             '$i = 0;' . "\n\n" .
             "/* Server: localhost [0] */\n" .
@@ -71,18 +71,18 @@ class ConfigGeneratorTest extends AbstractTestCase
         $reflection = new ReflectionClass(ConfigGenerator::class);
         $method = $reflection->getMethod('getVarExport');
 
-        $this->assertEquals(
+        self::assertEquals(
             '$cfg[\'var_name\'] = 1;' . "\n",
             $method->invoke(null, 'var_name', 1, "\n"),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             '$cfg[\'var_name\'] = array (' .
             "\n);\n",
             $method->invoke(null, 'var_name', [], "\n"),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             '$cfg[\'var_name\'] = [1, 2, 3];' . "\n",
             $method->invoke(
                 null,
@@ -92,7 +92,7 @@ class ConfigGeneratorTest extends AbstractTestCase
             ),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             '$cfg[\'var_name\'][\'1a\'] = \'foo\';' . "\n" .
             '$cfg[\'var_name\'][\'b\'] = \'bar\';' . "\n",
             $method->invoke(
@@ -109,7 +109,7 @@ class ConfigGeneratorTest extends AbstractTestCase
         $reflection = new ReflectionClass(ConfigGenerator::class);
         $method = $reflection->getMethod('getVarExport');
 
-        $this->assertEquals(
+        self::assertEquals(
             '$cfg[\'blowfish_secret\'] = \sodium_hex2bin(\''
             . '6161616161616161616161616161616161616161616161616161616161616161\');' . "\n",
             $method->invoke(null, 'blowfish_secret', str_repeat('a', SODIUM_CRYPTO_SECRETBOX_KEYBYTES), "\n"),
@@ -117,13 +117,13 @@ class ConfigGeneratorTest extends AbstractTestCase
 
         /** @var string $actual */
         $actual = $method->invoke(null, 'blowfish_secret', 'invalid secret', "\n");
-        $this->assertStringStartsWith('$cfg[\'blowfish_secret\'] = \sodium_hex2bin(\'', $actual);
-        $this->assertStringEndsWith('\');' . "\n", $actual);
+        self::assertStringStartsWith('$cfg[\'blowfish_secret\'] = \sodium_hex2bin(\'', $actual);
+        self::assertStringEndsWith('\');' . "\n", $actual);
         $pieces = explode('\'', $actual);
-        $this->assertCount(5, $pieces);
+        self::assertCount(5, $pieces);
         $binaryString = hex2bin($pieces[3]);
-        $this->assertIsString($binaryString);
-        $this->assertSame(SODIUM_CRYPTO_SECRETBOX_KEYBYTES, mb_strlen($binaryString, '8bit'));
+        self::assertIsString($binaryString);
+        self::assertSame(SODIUM_CRYPTO_SECRETBOX_KEYBYTES, mb_strlen($binaryString, '8bit'));
     }
 
     /**
@@ -134,28 +134,28 @@ class ConfigGeneratorTest extends AbstractTestCase
         $reflection = new ReflectionClass(ConfigGenerator::class);
         $method = $reflection->getMethod('isZeroBasedArray');
 
-        $this->assertFalse(
+        self::assertFalse(
             $method->invoke(
                 null,
                 ['a' => 1, 'b' => 2],
             ),
         );
 
-        $this->assertFalse(
+        self::assertFalse(
             $method->invoke(
                 null,
                 [0 => 1, 1 => 2, 3 => 3],
             ),
         );
 
-        $this->assertTrue(
+        self::assertTrue(
             $method->invoke(
                 null,
                 [],
             ),
         );
 
-        $this->assertTrue(
+        self::assertTrue(
             $method->invoke(
                 null,
                 [1, 2, 3],
@@ -175,13 +175,13 @@ class ConfigGeneratorTest extends AbstractTestCase
 
         $result = $method->invoke(null, $arr, "\n");
 
-        $this->assertEquals('[1, 2, 3, 4]', $result);
+        self::assertEquals('[1, 2, 3, 4]', $result);
 
         $arr = [1, 2, 3, 4, 7, 'foo'];
 
         $result = $method->invoke(null, $arr, "\n");
 
-        $this->assertEquals(
+        self::assertEquals(
             '[' . "\n" .
             '    1,' . "\n" .
             '    2,' . "\n" .
diff --git a/tests/classes/Setup/FormProcessingTest.php b/tests/classes/Setup/FormProcessingTest.php
index 0bcb34a00a..1ec4cb14a5 100644
--- a/tests/classes/Setup/FormProcessingTest.php
+++ b/tests/classes/Setup/FormProcessingTest.php
@@ -54,12 +54,12 @@ class FormProcessingTest extends AbstractTestCase
             ->onlyMethods(['process', 'getDisplay'])
             ->getMock();
 
-        $formDisplay->expects($this->once())
+        $formDisplay->expects(self::once())
             ->method('process')
             ->with(false)
             ->willReturn(false);
 
-        $formDisplay->expects($this->once())
+        $formDisplay->expects(self::once())
             ->method('getDisplay');
 
         FormProcessing::process($formDisplay);
@@ -70,12 +70,12 @@ class FormProcessingTest extends AbstractTestCase
             ->onlyMethods(['process', 'hasErrors', 'displayErrors'])
             ->getMock();
 
-        $formDisplay->expects($this->once())
+        $formDisplay->expects(self::once())
             ->method('process')
             ->with(false)
             ->willReturn(true);
 
-        $formDisplay->expects($this->once())
+        $formDisplay->expects(self::once())
             ->method('hasErrors')
             ->with()
             ->willReturn(true);
@@ -84,15 +84,15 @@ class FormProcessingTest extends AbstractTestCase
         FormProcessing::process($formDisplay);
         $result = ob_get_clean();
 
-        $this->assertIsString($result);
+        self::assertIsString($result);
 
-        $this->assertStringContainsString('<div class="error">', $result);
+        self::assertStringContainsString('<div class="error">', $result);
 
-        $this->assertStringContainsString('mode=revert', $result);
+        self::assertStringContainsString('mode=revert', $result);
 
-        $this->assertStringContainsString('<a class="btn" href="../setup/index.php?route=/setup&', $result);
+        self::assertStringContainsString('<a class="btn" href="../setup/index.php?route=/setup&', $result);
 
-        $this->assertStringContainsString('mode=edit', $result);
+        self::assertStringContainsString('mode=edit', $result);
 
         // case 3
         $formDisplay = $this->getMockBuilder(FormDisplay::class)
@@ -100,12 +100,12 @@ class FormProcessingTest extends AbstractTestCase
             ->onlyMethods(['process', 'hasErrors'])
             ->getMock();
 
-        $formDisplay->expects($this->once())
+        $formDisplay->expects(self::once())
             ->method('process')
             ->with(false)
             ->willReturn(true);
 
-        $formDisplay->expects($this->once())
+        $formDisplay->expects(self::once())
             ->method('hasErrors')
             ->with()
             ->willReturn(false);
@@ -115,9 +115,9 @@ class FormProcessingTest extends AbstractTestCase
         } catch (Throwable $throwable) {
         }
 
-        $this->assertInstanceOf(ExitException::class, $throwable ?? null);
+        self::assertInstanceOf(ExitException::class, $throwable ?? null);
         $response = $responseStub->getResponse();
-        $this->assertSame(['../setup/index.php?route=%2Fsetup&lang=en'], $response->getHeader('Location'));
-        $this->assertSame(303, $response->getStatusCode());
+        self::assertSame(['../setup/index.php?route=%2Fsetup&lang=en'], $response->getHeader('Location'));
+        self::assertSame(303, $response->getStatusCode());
     }
 }
diff --git a/tests/classes/Setup/IndexTest.php b/tests/classes/Setup/IndexTest.php
index 8eb6b8bfde..4cd4127b2d 100644
--- a/tests/classes/Setup/IndexTest.php
+++ b/tests/classes/Setup/IndexTest.php
@@ -31,7 +31,7 @@ class IndexTest extends AbstractTestCase
 
         SetupIndex::messagesBegin();
 
-        $this->assertEquals(
+        self::assertEquals(
             [[[0 => 'foo', 'fresh' => false, 'active' => false], [0 => 'bar', 'fresh' => false, 'active' => false]]],
             $_SESSION['messages'],
         );
@@ -40,7 +40,7 @@ class IndexTest extends AbstractTestCase
 
         unset($_SESSION['messages']);
         SetupIndex::messagesBegin();
-        $this->assertEquals(
+        self::assertEquals(
             ['error' => [], 'notice' => []],
             $_SESSION['messages'],
         );
@@ -53,7 +53,7 @@ class IndexTest extends AbstractTestCase
     {
         SetupIndex::messagesSet('type', '123', 'testTitle', 'msg');
 
-        $this->assertEquals(
+        self::assertEquals(
             ['fresh' => true, 'active' => true, 'title' => 'testTitle', 'message' => 'msg'],
             $_SESSION['messages']['type']['123'],
         );
@@ -68,7 +68,7 @@ class IndexTest extends AbstractTestCase
 
         SetupIndex::messagesEnd();
 
-        $this->assertEquals(
+        self::assertEquals(
             [['1' => ['msg' => 'bar', 'active' => 1]]],
             $_SESSION['messages'],
         );
@@ -91,6 +91,6 @@ class IndexTest extends AbstractTestCase
             ['id' => 1, 'title' => 'bar', 'type' => 'type', 'message' => '321', 'is_hidden' => false],
         ];
 
-        $this->assertEquals($expected, SetupIndex::messagesShowHtml());
+        self::assertEquals($expected, SetupIndex::messagesShowHtml());
     }
 }
diff --git a/tests/classes/ShowGrantsTest.php b/tests/classes/ShowGrantsTest.php
index 932d22a288..06cfebe8c1 100644
--- a/tests/classes/ShowGrantsTest.php
+++ b/tests/classes/ShowGrantsTest.php
@@ -13,17 +13,17 @@ class ShowGrantsTest extends AbstractTestCase
     public function test1(): void
     {
         $showGrants = new ShowGrants('GRANT ALL PRIVILEGES ON *.* TO \'root\'@\'localhost\' WITH GRANT OPTION');
-        $this->assertEquals('ALL PRIVILEGES', $showGrants->grants);
-        $this->assertEquals('*', $showGrants->dbName);
-        $this->assertEquals('*', $showGrants->tableName);
+        self::assertEquals('ALL PRIVILEGES', $showGrants->grants);
+        self::assertEquals('*', $showGrants->dbName);
+        self::assertEquals('*', $showGrants->tableName);
     }
 
     public function test2(): void
     {
         $showGrants = new ShowGrants('GRANT ALL PRIVILEGES ON `mysql`.* TO \'root\'@\'localhost\' WITH GRANT OPTION');
-        $this->assertEquals('ALL PRIVILEGES', $showGrants->grants);
-        $this->assertEquals('mysql', $showGrants->dbName);
-        $this->assertEquals('*', $showGrants->tableName);
+        self::assertEquals('ALL PRIVILEGES', $showGrants->grants);
+        self::assertEquals('mysql', $showGrants->dbName);
+        self::assertEquals('*', $showGrants->tableName);
     }
 
     public function test3(): void
@@ -31,20 +31,20 @@ class ShowGrantsTest extends AbstractTestCase
         $showGrants = new ShowGrants(
             'GRANT SELECT, INSERT, UPDATE, DELETE ON `mysql`.`columns_priv` TO \'root\'@\'localhost\'',
         );
-        $this->assertEquals('SELECT, INSERT, UPDATE, DELETE', $showGrants->grants);
-        $this->assertEquals('mysql', $showGrants->dbName);
-        $this->assertEquals('columns_priv', $showGrants->tableName);
+        self::assertEquals('SELECT, INSERT, UPDATE, DELETE', $showGrants->grants);
+        self::assertEquals('mysql', $showGrants->dbName);
+        self::assertEquals('columns_priv', $showGrants->tableName);
     }
 
     public function test4(): void
     {
         $showGrants = new ShowGrants('GRANT ALL PRIVILEGES ON `cptest\_.`.* TO \'cptest\'@\'localhost\'');
-        $this->assertEquals('cptest\_.', $showGrants->dbName);
+        self::assertEquals('cptest\_.', $showGrants->dbName);
 
         $showGrants = new ShowGrants(
             'GRANT ALL PRIVILEGES ON `cptest\_.a.b.c.d.e.f.g.h.i.j.k.'
                 . 'l.m.n.o.p.q.r.s.t.u.v.w.x.y.z`.* TO \'cptest\'@\'localhost\'',
         );
-        $this->assertEquals('cptest\_.a.b.c.d.e.f.g.h.i.j.k.l.m.n.o.p.q.r.s.t.u.v.w.x.y.z', $showGrants->dbName);
+        self::assertEquals('cptest\_.a.b.c.d.e.f.g.h.i.j.k.l.m.n.o.p.q.r.s.t.u.v.w.x.y.z', $showGrants->dbName);
     }
 }
diff --git a/tests/classes/SqlQueryFormTest.php b/tests/classes/SqlQueryFormTest.php
index ed2b63d7b2..6c90ff9b0b 100644
--- a/tests/classes/SqlQueryFormTest.php
+++ b/tests/classes/SqlQueryFormTest.php
@@ -102,31 +102,31 @@ class SqlQueryFormTest extends AbstractTestCase
         $html = $this->sqlQueryForm->getHtml('PMA_db', 'PMA_table', $query);
 
         //validate 1: query
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             htmlspecialchars($query),
             $html,
         );
 
         //validate 2: enable auto select text in textarea
         $autoSel = ' data-textarea-auto-select="true"';
-        $this->assertStringContainsString($autoSel, $html);
+        self::assertStringContainsString($autoSel, $html);
 
         //validate 3: MySQLDocumentation::show
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             MySQLDocumentation::show('SELECT'),
             $html,
         );
 
         //validate 4: $fields_list
-        $this->assertStringContainsString('<input type="button" value="DELETE" id="delete"', $html);
-        $this->assertStringContainsString('<input type="button" value="UPDATE" id="update"', $html);
-        $this->assertStringContainsString('<input type="button" value="INSERT" id="insert"', $html);
-        $this->assertStringContainsString('<input type="button" value="SELECT" id="select"', $html);
-        $this->assertStringContainsString('<input type="button" value="SELECT *" id="selectall"', $html);
+        self::assertStringContainsString('<input type="button" value="DELETE" id="delete"', $html);
+        self::assertStringContainsString('<input type="button" value="UPDATE" id="update"', $html);
+        self::assertStringContainsString('<input type="button" value="INSERT" id="insert"', $html);
+        self::assertStringContainsString('<input type="button" value="SELECT" id="select"', $html);
+        self::assertStringContainsString('<input type="button" value="SELECT *" id="selectall"', $html);
 
         //validate 5: Clear button
-        $this->assertStringContainsString('<input type="button" value="DELETE" id="delete"', $html);
-        $this->assertStringContainsString(
+        self::assertStringContainsString('<input type="button" value="DELETE" id="delete"', $html);
+        self::assertStringContainsString(
             __('Clear'),
             $html,
         );
@@ -143,35 +143,35 @@ class SqlQueryFormTest extends AbstractTestCase
         $html = $this->sqlQueryForm->getHtml('PMA_db', 'PMA_table', $query);
 
         //validate 1: query
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             htmlspecialchars($query),
             $html,
         );
 
         //validate 2: $enctype
         $enctype = ' enctype="multipart/form-data">';
-        $this->assertStringContainsString($enctype, $html);
+        self::assertStringContainsString($enctype, $html);
 
         //validate 3: sqlqueryform
-        $this->assertStringContainsString('id="sqlqueryform" name="sqlform"', $html);
+        self::assertStringContainsString('id="sqlqueryform" name="sqlform"', $html);
 
         //validate 4: $db, $table
         $table = Current::$table;
         $db = Current::$database;
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             Url::getHiddenInputs($db, $table),
             $html,
         );
 
         //validate 5: $goto
         $goto = empty($GLOBALS['goto']) ? Url::getFromRoute('/table/sql') : $GLOBALS['goto'];
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             htmlspecialchars($goto),
             $html,
         );
 
         //validate 6: Kanji encoding form
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             Encoding::kanjiEncodingForm(),
             $html,
         );
diff --git a/tests/classes/SqlTest.php b/tests/classes/SqlTest.php
index 2f7ca3c8fa..0392016d02 100644
--- a/tests/classes/SqlTest.php
+++ b/tests/classes/SqlTest.php
@@ -83,7 +83,7 @@ class SqlTest extends AbstractTestCase
         $GLOBALS['_SESSION']['tmpval']['pos'] = 1;
         $GLOBALS['_SESSION']['tmpval']['max_rows'] = 2;
 
-        $this->assertEquals('SELECT * FROM test LIMIT 1, 2 ', $this->callFunction(
+        self::assertEquals('SELECT * FROM test LIMIT 1, 2 ', $this->callFunction(
             $this->sql,
             Sql::class,
             'getSqlWithLimitClause',
@@ -99,31 +99,31 @@ class SqlTest extends AbstractTestCase
         // Test environment.
         Config::getInstance()->settings['RememberSorting'] = true;
 
-        $this->assertTrue(
+        self::assertTrue(
             $this->callFunction($this->sql, Sql::class, 'isRememberSortingOrder', [
                 ParseAnalyze::sqlQuery('SELECT * FROM tbl', Current::$database)[0],
             ]),
         );
 
-        $this->assertFalse(
+        self::assertFalse(
             $this->callFunction($this->sql, Sql::class, 'isRememberSortingOrder', [
                 ParseAnalyze::sqlQuery('SELECT col FROM tbl', Current::$database)[0],
             ]),
         );
 
-        $this->assertFalse(
+        self::assertFalse(
             $this->callFunction($this->sql, Sql::class, 'isRememberSortingOrder', [
                 ParseAnalyze::sqlQuery('SELECT 1', Current::$database)[0],
             ]),
         );
 
-        $this->assertFalse(
+        self::assertFalse(
             $this->callFunction($this->sql, Sql::class, 'isRememberSortingOrder', [
                 ParseAnalyze::sqlQuery('SELECT col1, col2 FROM tbl', Current::$database)[0],
             ]),
         );
 
-        $this->assertFalse(
+        self::assertFalse(
             $this->callFunction($this->sql, Sql::class, 'isRememberSortingOrder', [
                 ParseAnalyze::sqlQuery('SELECT COUNT(*) from tbl', Current::$database)[0],
             ]),
@@ -138,13 +138,13 @@ class SqlTest extends AbstractTestCase
         // Test environment.
         $GLOBALS['_SESSION']['tmpval']['max_rows'] = 10;
 
-        $this->assertTrue(
+        self::assertTrue(
             $this->callFunction($this->sql, Sql::class, 'isAppendLimitClause', [
                 ParseAnalyze::sqlQuery('SELECT * FROM tbl', Current::$database)[0],
             ]),
         );
 
-        $this->assertFalse(
+        self::assertFalse(
             $this->callFunction($this->sql, Sql::class, 'isAppendLimitClause', [
                 ParseAnalyze::sqlQuery('SELECT * from tbl LIMIT 0, 10', Current::$database)[0],
             ]),
@@ -156,15 +156,15 @@ class SqlTest extends AbstractTestCase
         // Test environment.
         $GLOBALS['_SESSION']['tmpval']['max_rows'] = 10;
 
-        $this->assertTrue(Sql::isJustBrowsing(
+        self::assertTrue(Sql::isJustBrowsing(
             ParseAnalyze::sqlQuery('SELECT * FROM db.tbl', Current::$database)[0],
         ));
 
-        $this->assertTrue(Sql::isJustBrowsing(
+        self::assertTrue(Sql::isJustBrowsing(
             ParseAnalyze::sqlQuery('SELECT * FROM tbl WHERE 1', Current::$database)[0],
         ));
 
-        $this->assertFalse(Sql::isJustBrowsing(
+        self::assertFalse(Sql::isJustBrowsing(
             ParseAnalyze::sqlQuery('SELECT * from tbl1, tbl2 LIMIT 0, 10', Current::$database)[0],
         ));
     }
@@ -174,19 +174,19 @@ class SqlTest extends AbstractTestCase
      */
     public function testIsDeleteTransformationInfo(): void
     {
-        $this->assertTrue(
+        self::assertTrue(
             $this->callFunction($this->sql, Sql::class, 'isDeleteTransformationInfo', [
                 ParseAnalyze::sqlQuery('ALTER TABLE tbl DROP COLUMN col', Current::$database)[0],
             ]),
         );
 
-        $this->assertTrue(
+        self::assertTrue(
             $this->callFunction($this->sql, Sql::class, 'isDeleteTransformationInfo', [
                 ParseAnalyze::sqlQuery('DROP TABLE tbl', Current::$database)[0],
             ]),
         );
 
-        $this->assertFalse(
+        self::assertFalse(
             $this->callFunction($this->sql, Sql::class, 'isDeleteTransformationInfo', [
                 ParseAnalyze::sqlQuery('SELECT * from tbl', Current::$database)[0],
             ]),
@@ -198,7 +198,7 @@ class SqlTest extends AbstractTestCase
      */
     public function testHasNoRightsToDropDatabase(): void
     {
-        $this->assertTrue(
+        self::assertTrue(
             $this->sql->hasNoRightsToDropDatabase(
                 ParseAnalyze::sqlQuery('DROP DATABASE db', Current::$database)[0],
                 false,
@@ -206,7 +206,7 @@ class SqlTest extends AbstractTestCase
             ),
         );
 
-        $this->assertFalse(
+        self::assertFalse(
             $this->sql->hasNoRightsToDropDatabase(
                 ParseAnalyze::sqlQuery('DROP TABLE tbl', Current::$database)[0],
                 false,
@@ -214,7 +214,7 @@ class SqlTest extends AbstractTestCase
             ),
         );
 
-        $this->assertFalse(
+        self::assertFalse(
             $this->sql->hasNoRightsToDropDatabase(
                 ParseAnalyze::sqlQuery('SELECT * from tbl', Current::$database)[0],
                 false,
@@ -236,18 +236,18 @@ class SqlTest extends AbstractTestCase
         $col3->table = 'table3';
 
         $fieldsMeta = [$col1, $col2, $col3];
-        $this->assertFalse(
+        self::assertFalse(
             $this->callFunction($this->sql, Sql::class, 'resultSetHasJustOneTable', [$fieldsMeta]),
         );
 
         // should not matter on where the odd column occurs
         $fieldsMeta = [$col2, $col3, $col1];
-        $this->assertFalse(
+        self::assertFalse(
             $this->callFunction($this->sql, Sql::class, 'resultSetHasJustOneTable', [$fieldsMeta]),
         );
 
         $fieldsMeta = [$col3, $col1, $col2];
-        $this->assertFalse(
+        self::assertFalse(
             $this->callFunction($this->sql, Sql::class, 'resultSetHasJustOneTable', [$fieldsMeta]),
         );
     }
@@ -265,7 +265,7 @@ class SqlTest extends AbstractTestCase
         $col3->table = 'table1';
         $fieldsMeta = [$col1, $col2, $col3];
 
-        $this->assertTrue(
+        self::assertTrue(
             $this->callFunction($this->sql, Sql::class, 'resultSetHasJustOneTable', [$fieldsMeta]),
         );
     }
@@ -284,18 +284,18 @@ class SqlTest extends AbstractTestCase
         $col3->table = 'table1';
 
         $fieldsMeta = [$col1, $col2, $col3];
-        $this->assertTrue(
+        self::assertTrue(
             $this->callFunction($this->sql, Sql::class, 'resultSetHasJustOneTable', [$fieldsMeta]),
         );
 
         // should not matter on where the function column occurs
         $fieldsMeta = [$col2, $col3, $col1];
-        $this->assertTrue(
+        self::assertTrue(
             $this->callFunction($this->sql, Sql::class, 'resultSetHasJustOneTable', [$fieldsMeta]),
         );
 
         $fieldsMeta = [$col3, $col1, $col2];
-        $this->assertTrue(
+        self::assertTrue(
             $this->callFunction($this->sql, Sql::class, 'resultSetHasJustOneTable', [$fieldsMeta]),
         );
     }
@@ -314,7 +314,7 @@ class SqlTest extends AbstractTestCase
         $col3->table = '';
         $fieldsMeta = [$col1, $col2, $col3];
 
-        $this->assertFalse(
+        self::assertFalse(
             $this->callFunction($this->sql, Sql::class, 'resultSetHasJustOneTable', [$fieldsMeta]),
         );
     }
@@ -451,7 +451,7 @@ class SqlTest extends AbstractTestCase
                 ParseAnalyze::sqlQuery($sqlQuery ?? '', Current::$database)[0],
             ],
         );
-        $this->assertEquals($expectedNumRows, $result);
+        self::assertEquals($expectedNumRows, $result);
         $this->dummyDbi->assertAllQueriesConsumed();
     }
 
@@ -617,20 +617,20 @@ class SqlTest extends AbstractTestCase
             'SELECT * FROM `sakila`.`country` LIMIT 0, 3;',
             null,
         );
-        $this->assertStringContainsString('Showing rows 0 -  2 (3 total', $actual);
-        $this->assertStringContainsString('SELECT * FROM `sakila`.`country` LIMIT 0, 3;', $actual);
-        $this->assertStringContainsString('Afghanistan', $actual);
-        $this->assertStringContainsString('Algeria', $actual);
-        $this->assertStringContainsString('American Samoa', $actual);
-        $this->assertStringContainsString('data-type="int"', $actual);
-        $this->assertStringContainsString('data-type="string"', $actual);
-        $this->assertStringContainsString('data-type="timestamp"', $actual);
+        self::assertStringContainsString('Showing rows 0 -  2 (3 total', $actual);
+        self::assertStringContainsString('SELECT * FROM `sakila`.`country` LIMIT 0, 3;', $actual);
+        self::assertStringContainsString('Afghanistan', $actual);
+        self::assertStringContainsString('Algeria', $actual);
+        self::assertStringContainsString('American Samoa', $actual);
+        self::assertStringContainsString('data-type="int"', $actual);
+        self::assertStringContainsString('data-type="string"', $actual);
+        self::assertStringContainsString('data-type="timestamp"', $actual);
     }
 
     public function testGetDetailedProfilingStatsWithoutData(): void
     {
         $method = new ReflectionMethod($this->sql, 'getDetailedProfilingStats');
-        $this->assertSame([], $method->invoke($this->sql, []));
+        self::assertSame([], $method->invoke($this->sql, []));
     }
 
     public function testGetDetailedProfilingStatsWithZeroTotalTime(): void
@@ -640,7 +640,7 @@ class SqlTest extends AbstractTestCase
             ['Status' => 'Starting', 'Duration' => '0'],
             ['Status' => 'checking permissions', 'Duration' => '0'],
         ];
-        $this->assertSame([], $method->invoke($this->sql, $profiling));
+        self::assertSame([], $method->invoke($this->sql, $profiling));
     }
 
     public function testGetDetailedProfilingStatsWithData(): void
@@ -780,6 +780,6 @@ class SqlTest extends AbstractTestCase
                 ['status' => 'Reset For Next Command', 'duration' => '9 µ', 'duration_raw' => '0.000009'],
             ],
         ];
-        $this->assertSame($expected, $method->invoke($this->sql, $profiling));
+        self::assertSame($expected, $method->invoke($this->sql, $profiling));
     }
 }
diff --git a/tests/classes/StatementInfoTest.php b/tests/classes/StatementInfoTest.php
index dbeed08843..1664556f60 100644
--- a/tests/classes/StatementInfoTest.php
+++ b/tests/classes/StatementInfoTest.php
@@ -52,41 +52,41 @@ class StatementInfoTest extends TestCase
 
         $statementInfo = StatementInfo::fromArray($info);
 
-        $this->assertFalse($statementInfo->distinct);
-        $this->assertFalse($statementInfo->dropDatabase);
-        $this->assertFalse($statementInfo->group);
-        $this->assertFalse($statementInfo->having);
-        $this->assertFalse($statementInfo->isAffected);
-        $this->assertFalse($statementInfo->isAnalyse);
-        $this->assertFalse($statementInfo->isCount);
-        $this->assertFalse($statementInfo->isDelete);
-        $this->assertFalse($statementInfo->isExplain);
-        $this->assertFalse($statementInfo->isExport);
-        $this->assertFalse($statementInfo->isFunction);
-        $this->assertFalse($statementInfo->isGroup);
-        $this->assertFalse($statementInfo->isInsert);
-        $this->assertFalse($statementInfo->isMaint);
-        $this->assertFalse($statementInfo->isProcedure);
-        $this->assertFalse($statementInfo->isReplace);
-        $this->assertTrue($statementInfo->isSelect);
-        $this->assertFalse($statementInfo->isShow);
-        $this->assertFalse($statementInfo->isSubquery);
-        $this->assertFalse($statementInfo->join);
-        $this->assertFalse($statementInfo->limit);
-        $this->assertFalse($statementInfo->offset);
-        $this->assertFalse($statementInfo->order);
-        $this->assertSame('SELECT', $statementInfo->queryType);
-        $this->assertFalse($statementInfo->reload);
-        $this->assertTrue($statementInfo->selectFrom);
-        $this->assertFalse($statementInfo->union);
-        $this->assertNotNull($statementInfo->parser);
-        $this->assertNotNull($statementInfo->statement);
-        $this->assertNotEmpty($statementInfo->selectTables);
-        $this->assertNotEmpty($statementInfo->selectExpression);
-        $this->assertSame($info['parser'], $statementInfo->parser);
-        $this->assertSame($info['statement'], $statementInfo->statement);
-        $this->assertSame($info['select_tables'], $statementInfo->selectTables);
-        $this->assertSame($info['select_expr'], $statementInfo->selectExpression);
+        self::assertFalse($statementInfo->distinct);
+        self::assertFalse($statementInfo->dropDatabase);
+        self::assertFalse($statementInfo->group);
+        self::assertFalse($statementInfo->having);
+        self::assertFalse($statementInfo->isAffected);
+        self::assertFalse($statementInfo->isAnalyse);
+        self::assertFalse($statementInfo->isCount);
+        self::assertFalse($statementInfo->isDelete);
+        self::assertFalse($statementInfo->isExplain);
+        self::assertFalse($statementInfo->isExport);
+        self::assertFalse($statementInfo->isFunction);
+        self::assertFalse($statementInfo->isGroup);
+        self::assertFalse($statementInfo->isInsert);
+        self::assertFalse($statementInfo->isMaint);
+        self::assertFalse($statementInfo->isProcedure);
+        self::assertFalse($statementInfo->isReplace);
+        self::assertTrue($statementInfo->isSelect);
+        self::assertFalse($statementInfo->isShow);
+        self::assertFalse($statementInfo->isSubquery);
+        self::assertFalse($statementInfo->join);
+        self::assertFalse($statementInfo->limit);
+        self::assertFalse($statementInfo->offset);
+        self::assertFalse($statementInfo->order);
+        self::assertSame('SELECT', $statementInfo->queryType);
+        self::assertFalse($statementInfo->reload);
+        self::assertTrue($statementInfo->selectFrom);
+        self::assertFalse($statementInfo->union);
+        self::assertNotNull($statementInfo->parser);
+        self::assertNotNull($statementInfo->statement);
+        self::assertNotEmpty($statementInfo->selectTables);
+        self::assertNotEmpty($statementInfo->selectExpression);
+        self::assertSame($info['parser'], $statementInfo->parser);
+        self::assertSame($info['statement'], $statementInfo->statement);
+        self::assertSame($info['select_tables'], $statementInfo->selectTables);
+        self::assertSame($info['select_expr'], $statementInfo->selectExpression);
     }
 
     public function testFromArrayWithEmptyStatement(): void
@@ -123,36 +123,36 @@ class StatementInfoTest extends TestCase
 
         $statementInfo = StatementInfo::fromArray($info);
 
-        $this->assertFalse($statementInfo->distinct);
-        $this->assertFalse($statementInfo->dropDatabase);
-        $this->assertFalse($statementInfo->group);
-        $this->assertFalse($statementInfo->having);
-        $this->assertFalse($statementInfo->isAffected);
-        $this->assertFalse($statementInfo->isAnalyse);
-        $this->assertFalse($statementInfo->isCount);
-        $this->assertFalse($statementInfo->isDelete);
-        $this->assertFalse($statementInfo->isExplain);
-        $this->assertFalse($statementInfo->isExport);
-        $this->assertFalse($statementInfo->isFunction);
-        $this->assertFalse($statementInfo->isGroup);
-        $this->assertFalse($statementInfo->isInsert);
-        $this->assertFalse($statementInfo->isMaint);
-        $this->assertFalse($statementInfo->isProcedure);
-        $this->assertFalse($statementInfo->isReplace);
-        $this->assertFalse($statementInfo->isSelect);
-        $this->assertFalse($statementInfo->isShow);
-        $this->assertFalse($statementInfo->isSubquery);
-        $this->assertFalse($statementInfo->join);
-        $this->assertFalse($statementInfo->limit);
-        $this->assertFalse($statementInfo->offset);
-        $this->assertFalse($statementInfo->order);
-        $this->assertFalse($statementInfo->queryType);
-        $this->assertFalse($statementInfo->reload);
-        $this->assertFalse($statementInfo->selectFrom);
-        $this->assertFalse($statementInfo->union);
-        $this->assertNull($statementInfo->parser);
-        $this->assertNull($statementInfo->statement);
-        $this->assertEmpty($statementInfo->selectTables);
-        $this->assertEmpty($statementInfo->selectExpression);
+        self::assertFalse($statementInfo->distinct);
+        self::assertFalse($statementInfo->dropDatabase);
+        self::assertFalse($statementInfo->group);
+        self::assertFalse($statementInfo->having);
+        self::assertFalse($statementInfo->isAffected);
+        self::assertFalse($statementInfo->isAnalyse);
+        self::assertFalse($statementInfo->isCount);
+        self::assertFalse($statementInfo->isDelete);
+        self::assertFalse($statementInfo->isExplain);
+        self::assertFalse($statementInfo->isExport);
+        self::assertFalse($statementInfo->isFunction);
+        self::assertFalse($statementInfo->isGroup);
+        self::assertFalse($statementInfo->isInsert);
+        self::assertFalse($statementInfo->isMaint);
+        self::assertFalse($statementInfo->isProcedure);
+        self::assertFalse($statementInfo->isReplace);
+        self::assertFalse($statementInfo->isSelect);
+        self::assertFalse($statementInfo->isShow);
+        self::assertFalse($statementInfo->isSubquery);
+        self::assertFalse($statementInfo->join);
+        self::assertFalse($statementInfo->limit);
+        self::assertFalse($statementInfo->offset);
+        self::assertFalse($statementInfo->order);
+        self::assertFalse($statementInfo->queryType);
+        self::assertFalse($statementInfo->reload);
+        self::assertFalse($statementInfo->selectFrom);
+        self::assertFalse($statementInfo->union);
+        self::assertNull($statementInfo->parser);
+        self::assertNull($statementInfo->statement);
+        self::assertEmpty($statementInfo->selectTables);
+        self::assertEmpty($statementInfo->selectExpression);
     }
 }
diff --git a/tests/classes/StorageEngineTest.php b/tests/classes/StorageEngineTest.php
index ab68581859..9cac7e228b 100644
--- a/tests/classes/StorageEngineTest.php
+++ b/tests/classes/StorageEngineTest.php
@@ -69,7 +69,7 @@ class StorageEngineTest extends AbstractTestCase
     #[RunInSeparateProcess]
     public function testGetStorageEngines(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             [
                 'dummy' => ['Engine' => 'dummy', 'Support' => 'YES', 'Comment' => 'dummy comment'],
                 'dummy2' => ['Engine' => 'dummy2', 'Support' => 'NO', 'Comment' => 'dummy2 comment'],
@@ -88,7 +88,7 @@ class StorageEngineTest extends AbstractTestCase
     {
         $actual = $this->object->getArray();
 
-        $this->assertEquals(
+        self::assertEquals(
             ['dummy' => ['name' => 'dummy', 'comment' => 'dummy comment', 'is_default' => false]],
             $actual,
         );
@@ -105,7 +105,7 @@ class StorageEngineTest extends AbstractTestCase
     public function testGetEngine(string $expectedClass, string $engineName): void
     {
         $actual = StorageEngine::getEngine($engineName);
-        $this->assertInstanceOf($expectedClass, $actual);
+        self::assertInstanceOf($expectedClass, $actual);
     }
 
     /**
@@ -137,16 +137,16 @@ class StorageEngineTest extends AbstractTestCase
      */
     public function testIsValid(): void
     {
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->isValid('PBMS'),
         );
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->isValid('dummy'),
         );
-        $this->assertTrue(
+        self::assertTrue(
             $this->object->isValid('dummy2'),
         );
-        $this->assertFalse(
+        self::assertFalse(
             $this->object->isValid('invalid'),
         );
     }
@@ -156,7 +156,7 @@ class StorageEngineTest extends AbstractTestCase
      */
     public function testGetPage(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             '',
             $this->object->getPage('Foo'),
         );
@@ -167,7 +167,7 @@ class StorageEngineTest extends AbstractTestCase
      */
     public function testGetInfoPages(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             [],
             $this->object->getInfoPages(),
         );
@@ -178,7 +178,7 @@ class StorageEngineTest extends AbstractTestCase
      */
     public function testGetVariablesLikePattern(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             '',
             $this->object->getVariablesLikePattern(),
         );
@@ -189,7 +189,7 @@ class StorageEngineTest extends AbstractTestCase
      */
     public function testGetMysqlHelpPage(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             'dummy-storage-engine',
             $this->object->getMysqlHelpPage(),
         );
@@ -200,7 +200,7 @@ class StorageEngineTest extends AbstractTestCase
      */
     public function testGetVariables(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             [],
             $this->object->getVariables(),
         );
@@ -211,25 +211,25 @@ class StorageEngineTest extends AbstractTestCase
      */
     public function testGetSupportInformationMessage(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             'dummy is available on this MySQL server.',
             $this->object->getSupportInformationMessage(),
         );
 
         $this->object->support = 1;
-        $this->assertEquals(
+        self::assertEquals(
             'dummy has been disabled for this MySQL server.',
             $this->object->getSupportInformationMessage(),
         );
 
         $this->object->support = 2;
-        $this->assertEquals(
+        self::assertEquals(
             'dummy is available on this MySQL server.',
             $this->object->getSupportInformationMessage(),
         );
 
         $this->object->support = 3;
-        $this->assertEquals(
+        self::assertEquals(
             'dummy is the default storage engine on this MySQL server.',
             $this->object->getSupportInformationMessage(),
         );
@@ -240,7 +240,7 @@ class StorageEngineTest extends AbstractTestCase
      */
     public function testGetComment(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             'dummy comment',
             $this->object->getComment(),
         );
@@ -251,7 +251,7 @@ class StorageEngineTest extends AbstractTestCase
      */
     public function testGetTitle(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             'dummy',
             $this->object->getTitle(),
         );
@@ -262,7 +262,7 @@ class StorageEngineTest extends AbstractTestCase
      */
     public function testResolveTypeSize(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             [0 => 12, 1 => 'B'],
             $this->object->resolveTypeSize(12),
         );
@@ -275,13 +275,13 @@ class StorageEngineTest extends AbstractTestCase
                 (string) json_encode([]), // Fake result
             ],
         ]);
-        $this->assertTrue(StorageEngine::hasMroongaEngine());
-        $this->assertTrue(StorageEngine::hasMroongaEngine()); // Does not call any query
+        self::assertTrue(StorageEngine::hasMroongaEngine());
+        self::assertTrue(StorageEngine::hasMroongaEngine()); // Does not call any query
 
         Cache::remove('storage-engine.mroonga.has.mroonga_command'); // Cache clear
 
         $this->dummyDbi->addResult('SELECT mroonga_command(\'object_list\');', false);
-        $this->assertFalse(StorageEngine::hasMroongaEngine());
+        self::assertFalse(StorageEngine::hasMroongaEngine());
 
         $this->dummyDbi->assertAllQueriesConsumed();
     }
@@ -528,7 +528,7 @@ class StorageEngineTest extends AbstractTestCase
         $this->dummyDbi->addSelectDb('my_db');
         $lengths = StorageEngine::getMroongaLengths('my_db', 'idx_correo');
         $this->dummyDbi->assertAllSelectsConsumed();
-        $this->assertSame([4521984, 578126], $lengths);
+        self::assertSame([4521984, 578126], $lengths);
 
         $this->dummyDbi->assertAllQueriesConsumed();
     }
diff --git a/tests/classes/SystemDatabaseTest.php b/tests/classes/SystemDatabaseTest.php
index 93f1a0a04c..28a87463e3 100644
--- a/tests/classes/SystemDatabaseTest.php
+++ b/tests/classes/SystemDatabaseTest.php
@@ -36,17 +36,17 @@ class SystemDatabaseTest extends AbstractTestCase
          */
         Config::getInstance()->selectedServer['pmadb'] = '';
 
-        $resultStub = $this->createMock(DummyResult::class);
+        $resultStub = self::createMock(DummyResult::class);
 
         $dbi = $this->getMockBuilder(DatabaseInterface::class)
             ->disableOriginalConstructor()
             ->getMock();
 
-        $dbi->expects($this->any())
+        $dbi->expects(self::any())
             ->method('tryQuery')
             ->willReturn($resultStub);
 
-        $dbi->expects($this->any())
+        $dbi->expects(self::any())
             ->method('quoteString')
             ->willReturnCallback(static fn (string $string): string => "'" . $string . "'");
 
@@ -76,7 +76,7 @@ class SystemDatabaseTest extends AbstractTestCase
         $ret = $this->sysDb->getExistingTransformationData($db);
 
         //validate that is the same as $dbi->tryQuery
-        $this->assertInstanceOf(DummyResult::class, $ret);
+        self::assertInstanceOf(DummyResult::class, $ret);
     }
 
     /**
@@ -84,9 +84,9 @@ class SystemDatabaseTest extends AbstractTestCase
      */
     public function testPMAGetNewTransformationDataSql(): void
     {
-        $resultStub = $this->createMock(DummyResult::class);
+        $resultStub = self::createMock(DummyResult::class);
 
-        $resultStub->expects($this->any())
+        $resultStub->expects(self::any())
             ->method('fetchAssoc')
             ->willReturn([
                 'table_name' => 'table_name',
@@ -109,7 +109,7 @@ class SystemDatabaseTest extends AbstractTestCase
             . "('PMA_db', 'view_name', 'column_name', 'comment', 'mimetype', "
             . "'transformation', 'transformation_options')";
 
-        $this->assertEquals($sql, $ret);
+        self::assertEquals($sql, $ret);
     }
 
     public function testGetColumnMapFromSql(): void
@@ -141,11 +141,11 @@ class SystemDatabaseTest extends AbstractTestCase
         $systemDatabase = new SystemDatabase($dbi);
         $columnMap = $systemDatabase->getColumnMapFromSql($sqlQuery, $viewColumns);
 
-        $this->assertEquals(
+        self::assertEquals(
             new SystemColumn('meta1_table', 'meta1_name', 'view_columns1'),
             $columnMap[0],
         );
-        $this->assertEquals(
+        self::assertEquals(
             new SystemColumn('meta2_table', 'meta2_name', 'view_columns2'),
             $columnMap[1],
         );
diff --git a/tests/classes/Table/ColumnsDefinitionTest.php b/tests/classes/Table/ColumnsDefinitionTest.php
index c36f08c817..066140e697 100644
--- a/tests/classes/Table/ColumnsDefinitionTest.php
+++ b/tests/classes/Table/ColumnsDefinitionTest.php
@@ -204,7 +204,7 @@ SQL;
             'disable_is' => false,
         ];
 
-        $this->assertEquals($expected, $actual);
+        self::assertEquals($expected, $actual);
     }
 
     /**
@@ -221,7 +221,7 @@ SQL;
     ): void {
         $result = ColumnsDefinition::decorateColumnMetaDefault($type, $default, $isNull);
 
-        $this->assertEquals($expected, $result);
+        self::assertEquals($expected, $result);
     }
 
     /**
diff --git a/tests/classes/Table/IndexesTest.php b/tests/classes/Table/IndexesTest.php
index d55c2ad589..f4f61a6bae 100644
--- a/tests/classes/Table/IndexesTest.php
+++ b/tests/classes/Table/IndexesTest.php
@@ -35,7 +35,7 @@ class IndexesTest extends AbstractTestCase
     {
         $sqlQuery = 'ALTER TABLE `db`.`table` RENAME INDEX `0` TO `ABC`;';
 
-        $this->dbi->expects($this->any())->method('getVersion')
+        $this->dbi->expects(self::any())->method('getVersion')
             ->willReturn(50700);
 
         $index = new Index(['Key_name' => 'ABC']);
@@ -43,18 +43,18 @@ class IndexesTest extends AbstractTestCase
         $indexes = new Indexes($this->dbi);
 
         $sqlResult = $indexes->getSqlQueryForRename('0', $index, Current::$database, Current::$table);
-        $this->assertStringContainsString($sqlQuery, $sqlResult);
+        self::assertStringContainsString($sqlQuery, $sqlResult);
 
         // Error message
         $index->setName('NOT PRIMARY'); // Cannot rename primary so the operation should fail
         $indexes->getSqlQueryForRename('PRIMARY', $index, Current::$database, Current::$table);
         $error = $indexes->getError();
-        $this->assertInstanceOf(Message::class, $error);
+        self::assertInstanceOf(Message::class, $error);
 
         $index->setName('PRIMARY'); // The new name cannot be PRIMARY so the operation should fail
         $indexes->getSqlQueryForRename('NOT PRIMARY', $index, Current::$database, Current::$table);
         $error = $indexes->getError();
-        $this->assertInstanceOf(Message::class, $error);
+        self::assertInstanceOf(Message::class, $error);
     }
 
     public function testGetSqlQueryForIndexCreateOrEdit(): void
@@ -62,7 +62,7 @@ class IndexesTest extends AbstractTestCase
         $table = $this->getMockBuilder(Table::class)
             ->disableOriginalConstructor()
             ->getMock();
-        $this->dbi->expects($this->any())->method('getTable')
+        $this->dbi->expects(self::any())->method('getTable')
             ->willReturn($table);
         $indexes = new Indexes($this->dbi);
 
@@ -76,7 +76,7 @@ class IndexesTest extends AbstractTestCase
         $sqlQueryExpected = 'ALTER TABLE `pma_db`.`pma_table` DROP PRIMARY KEY, ADD PRIMARY KEY (`id`);';
 
         $_POST['old_index'] = 'PRIMARY';
-        $this->assertEquals(
+        self::assertEquals(
             $sqlQueryExpected,
             $indexes->getSqlQueryForIndexCreateOrEdit('PRIMARY', $index, $db, $table),
         );
@@ -84,6 +84,6 @@ class IndexesTest extends AbstractTestCase
         // Error message
         $index->setName('NOT PRIMARY'); // Cannot rename primary so the operation should fail
         $indexes->getSqlQueryForIndexCreateOrEdit('PRIMARY', $index, $db, $table);
-        $this->assertInstanceOf(Message::class, $indexes->getError());
+        self::assertInstanceOf(Message::class, $indexes->getError());
     }
 }
diff --git a/tests/classes/Table/Maintenance/MessageTest.php b/tests/classes/Table/Maintenance/MessageTest.php
index 7975eec003..c438d2623a 100644
--- a/tests/classes/Table/Maintenance/MessageTest.php
+++ b/tests/classes/Table/Maintenance/MessageTest.php
@@ -17,10 +17,10 @@ class MessageTest extends TestCase
     public function testFromArray(array $row, string $table, string $operation, string $type, string $text): void
     {
         $message = Message::fromArray($row);
-        $this->assertSame($message->table, $table);
-        $this->assertSame($message->operation, $operation);
-        $this->assertSame($message->type, $type);
-        $this->assertSame($message->text, $text);
+        self::assertSame($message->table, $table);
+        self::assertSame($message->operation, $operation);
+        self::assertSame($message->type, $type);
+        self::assertSame($message->text, $text);
     }
 
     /**
diff --git a/tests/classes/Table/SearchTest.php b/tests/classes/Table/SearchTest.php
index 1125a823ce..54e0ab63fd 100644
--- a/tests/classes/Table/SearchTest.php
+++ b/tests/classes/Table/SearchTest.php
@@ -32,14 +32,14 @@ class SearchTest extends AbstractTestCase
         $_POST['order'] = 'asc';
         $_POST['customWhereClause'] = "name='pma'";
 
-        $this->assertEquals(
+        self::assertEquals(
             'SELECT DISTINCT *  FROM `PMA` WHERE name=\'pma\' ORDER BY `name` asc',
             $this->search->buildSqlQuery(),
         );
 
         unset($_POST['customWhereClause']);
 
-        $this->assertEquals(
+        self::assertEquals(
             'SELECT DISTINCT *  FROM `PMA` ORDER BY `name` asc',
             $this->search->buildSqlQuery(),
         );
@@ -62,7 +62,7 @@ class SearchTest extends AbstractTestCase
             . ' AND `id` > value2 AND `index` IS NULL AND `index2` LIKE \'%value4%\''
             . ' AND `index3` REGEXP ^value5$ AND `index4` IN (value6) AND `index5`'
             . ' BETWEEN value7 AND value8 ORDER BY `name` asc';
-        $this->assertEquals(
+        self::assertEquals(
             $expected,
             $this->search->buildSqlQuery(),
         );
@@ -73,14 +73,14 @@ class SearchTest extends AbstractTestCase
         $_POST['zoom_submit'] = true;
         $_POST['table'] = 'PMA';
 
-        $this->assertEquals(
+        self::assertEquals(
             'SELECT *  FROM `PMA`',
             $this->search->buildSqlQuery(),
         );
 
         $_POST['customWhereClause'] = '`table` = \'WhereClause\'';
 
-        $this->assertEquals(
+        self::assertEquals(
             'SELECT *  FROM `PMA` WHERE `table` = \'WhereClause\'',
             $this->search->buildSqlQuery(),
         );
@@ -91,7 +91,7 @@ class SearchTest extends AbstractTestCase
         $_POST['criteriaValues'] = ['10', '2', '', ''];
         $_POST['criteriaColumnTypes'] = ['int(11)', 'int(11)', 'int(11)', 'int(11)'];
 
-        $this->assertEquals(
+        self::assertEquals(
             'SELECT *  FROM `PMA` WHERE `b` <= 10 AND `a` = 2 AND `c` IS NULL AND `d` IS NOT NULL',
             $this->search->buildSqlQuery(),
         );
@@ -102,14 +102,14 @@ class SearchTest extends AbstractTestCase
         $_POST['zoom_submit'] = true;
         $_POST['table'] = 'PMA';
 
-        $this->assertEquals(
+        self::assertEquals(
             'SELECT *  FROM `PMA`',
             $this->search->buildSqlQuery(),
         );
 
         $_POST['customWhereClause'] = '`table` = \'WhereClause\'';
 
-        $this->assertEquals(
+        self::assertEquals(
             'SELECT *  FROM `PMA` WHERE `table` = \'WhereClause\'',
             $this->search->buildSqlQuery(),
         );
@@ -121,7 +121,7 @@ class SearchTest extends AbstractTestCase
         $_POST['criteriaValues'] = ['1'];
         $_POST['criteriaColumnTypes'] = ['geometry'];
 
-        $this->assertEquals(
+        self::assertEquals(
             'SELECT *  FROM `PMA` WHERE Dimension(`b`) = \'1\'',
             $this->search->buildSqlQuery(),
         );
@@ -132,14 +132,14 @@ class SearchTest extends AbstractTestCase
         $_POST['zoom_submit'] = true;
         $_POST['table'] = 'PMA';
 
-        $this->assertEquals(
+        self::assertEquals(
             'SELECT *  FROM `PMA`',
             $this->search->buildSqlQuery(),
         );
 
         $_POST['customWhereClause'] = '`table` = \'WhereClause\'';
 
-        $this->assertEquals(
+        self::assertEquals(
             'SELECT *  FROM `PMA` WHERE `table` = \'WhereClause\'',
             $this->search->buildSqlQuery(),
         );
@@ -151,7 +151,7 @@ class SearchTest extends AbstractTestCase
         $_POST['criteriaValues'] = ['PG-13'];
         $_POST['criteriaColumnTypes'] = ['enum(\'G\', \'PG\', \'PG-13\', \'R\', \'NC-17\')'];
 
-        $this->assertEquals(
+        self::assertEquals(
             'SELECT *  FROM `PMA` WHERE `rating` = \'PG-13\'',
             $this->search->buildSqlQuery(),
         );
@@ -162,14 +162,14 @@ class SearchTest extends AbstractTestCase
         $_POST['zoom_submit'] = true;
         $_POST['table'] = 'PMA';
 
-        $this->assertEquals(
+        self::assertEquals(
             'SELECT *  FROM `PMA`',
             $this->search->buildSqlQuery(),
         );
 
         $_POST['customWhereClause'] = '';
 
-        $this->assertEquals(
+        self::assertEquals(
             'SELECT *  FROM `PMA`',
             $this->search->buildSqlQuery(),
         );
@@ -181,7 +181,7 @@ class SearchTest extends AbstractTestCase
         $_POST['criteriaValues'] = ['07ca1fdd-4805-11ed-a4dc-0242ac110002'];
         $_POST['criteriaColumnTypes'] = ['uuid'];
 
-        $this->assertEquals(
+        self::assertEquals(
             "SELECT *  FROM `PMA` WHERE `id` = '07ca1fdd-4805-11ed-a4dc-0242ac110002'",
             $this->search->buildSqlQuery(),
         );
@@ -201,6 +201,6 @@ class SearchTest extends AbstractTestCase
         $_POST['ajax_request'] = 'true';
         $_POST['displayAllColumns'] = 'true';
 
-        $this->assertSame('SELECT *  FROM `world_cities`', $this->search->buildSqlQuery());
+        self::assertSame('SELECT *  FROM `world_cities`', $this->search->buildSqlQuery());
     }
 }
diff --git a/tests/classes/Table/TableTest.php b/tests/classes/Table/TableTest.php
index d036bc4618..77c0d4cf65 100644
--- a/tests/classes/Table/TableTest.php
+++ b/tests/classes/Table/TableTest.php
@@ -225,18 +225,18 @@ class TableTest extends AbstractTestCase
             ->disableOriginalConstructor()
             ->getMock();
 
-        $databaseList = $this->createStub(ListDatabase::class);
+        $databaseList = self::createStub(ListDatabase::class);
         $databaseList->method('exists')->willReturn(true);
-        $dbi->expects($this->any())->method('getDatabaseList')->willReturn($databaseList);
+        $dbi->expects(self::any())->method('getDatabaseList')->willReturn($databaseList);
 
-        $dbi->expects($this->any())->method('fetchResult')
+        $dbi->expects(self::any())->method('fetchResult')
             ->willReturnMap($fetchResult);
 
-        $dbi->expects($this->any())->method('fetchValue')
+        $dbi->expects(self::any())->method('fetchValue')
             ->willReturnMap($fetchValue);
 
         $cache = new Cache();
-        $dbi->expects($this->any())->method('getCache')
+        $dbi->expects(self::any())->method('getCache')
             ->willReturn($cache);
 
         $databases = [];
@@ -248,26 +248,26 @@ class TableTest extends AbstractTestCase
         $databases[$databaseName]['SCHEMA_INDEX_LENGTH'] = 10;
         $databases[$databaseName]['SCHEMA_LENGTH'] = 10;
 
-        $dbi->expects($this->any())->method('getTablesFull')
+        $dbi->expects(self::any())->method('getTablesFull')
             ->willReturn($databases);
 
-        $dbi->expects($this->any())->method('query')
+        $dbi->expects(self::any())->method('query')
             ->willReturn($resultStub);
 
-        $dbi->expects($this->any())->method('insertId')
+        $dbi->expects(self::any())->method('insertId')
             ->willReturn(10);
 
-        $resultStub->expects($this->any())->method('fetchAssoc')
+        $resultStub->expects(self::any())->method('fetchAssoc')
             ->willReturn([]);
 
         $value = ['Auto_increment' => 'Auto_increment'];
-        $dbi->expects($this->any())->method('fetchSingleRow')
+        $dbi->expects(self::any())->method('fetchSingleRow')
             ->willReturn($value);
 
-        $resultStub->expects($this->any())->method('fetchRow')
+        $resultStub->expects(self::any())->method('fetchRow')
             ->willReturn([]);
 
-        $dbi->expects($this->any())->method('quoteString')
+        $dbi->expects(self::any())->method('quoteString')
             ->willReturnCallback(static fn (string $string): string => "'" . $string . "'");
 
         DatabaseInterface::$instance = $dbi;
@@ -287,7 +287,7 @@ class TableTest extends AbstractTestCase
     public function testCreate(): void
     {
         $table = new Table('table1', 'pma_test', $this->mockedDbi);
-        $this->assertInstanceOf(Table::class, $table);
+        self::assertInstanceOf(Table::class, $table);
     }
 
     /**
@@ -296,19 +296,19 @@ class TableTest extends AbstractTestCase
     public function testConstruct(): void
     {
         $table = new Table('PMA_BookMark', 'PMA', $this->mockedDbi);
-        $this->assertEquals(
+        self::assertEquals(
             'PMA_BookMark',
             $table->__toString(),
         );
-        $this->assertEquals(
+        self::assertEquals(
             'PMA_BookMark',
             $table->getName(),
         );
-        $this->assertEquals(
+        self::assertEquals(
             'PMA',
             $table->getDbName(),
         );
-        $this->assertEquals(
+        self::assertEquals(
             'PMA.PMA_BookMark',
             $table->getFullName(),
         );
@@ -320,19 +320,19 @@ class TableTest extends AbstractTestCase
     public function testGetName(): void
     {
         $table = new Table('table1', 'pma_test', $this->mockedDbi);
-        $this->assertEquals(
+        self::assertEquals(
             'table1',
             $table->getName(),
         );
-        $this->assertEquals(
+        self::assertEquals(
             '`table1`',
             $table->getName(true),
         );
-        $this->assertEquals(
+        self::assertEquals(
             'pma_test',
             $table->getDbName(),
         );
-        $this->assertEquals(
+        self::assertEquals(
             '`pma_test`',
             $table->getDbName(true),
         );
@@ -352,23 +352,23 @@ class TableTest extends AbstractTestCase
         $table->messages[] = 'messages2';
         $table->messages[] = 'messages3';
 
-        $this->assertEquals(
+        self::assertEquals(
             'error3',
             $table->getLastError(),
         );
-        $this->assertEquals(
+        self::assertEquals(
             'messages3',
             $table->getLastMessage(),
         );
 
         $table->errors = [];
-        $this->assertEquals(
+        self::assertEquals(
             '',
             $table->getLastError(),
         );
 
         $table->messages = [];
-        $this->assertEquals(
+        self::assertEquals(
             '',
             $table->getLastMessage(),
         );
@@ -384,7 +384,7 @@ class TableTest extends AbstractTestCase
     #[DataProvider('dataValidateName')]
     public function testValidateName(string $name, bool $result, bool $isBackquoted = false): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             $result,
             Table::isValidName($name, $isBackquoted),
         );
@@ -413,18 +413,18 @@ class TableTest extends AbstractTestCase
     public function testIsView(): void
     {
         $table = new Table('', '', $this->mockedDbi);
-        $this->assertFalse(
+        self::assertFalse(
             $table->isView(),
         );
 
         //validate that it is the same as DBI fetchResult
         $table = new Table('PMA_BookMark', 'PMA', $this->mockedDbi);
-        $this->assertTrue(
+        self::assertTrue(
             $table->isView(),
         );
 
         $table = new Table('PMA_BookMark_2', 'PMA', $this->mockedDbi);
-        $this->assertFalse(
+        self::assertFalse(
             $table->isView(),
         );
     }
@@ -464,7 +464,7 @@ class TableTest extends AbstractTestCase
             $expression,
             $moveTo,
         );
-        $this->assertEquals(
+        self::assertEquals(
             '`PMA_name` BIT(12) PMA_attribute NULL DEFAULT b\'10\' AUTO_INCREMENT COMMENT \'PMA_comment\' FIRST',
             $query,
         );
@@ -486,7 +486,7 @@ class TableTest extends AbstractTestCase
             $expression,
             $moveTo,
         );
-        $this->assertEquals(
+        self::assertEquals(
             '`PMA_name` DOUBLE(12) PMA_attribute NULL DEFAULT \'12\' AUTO_INCREMENT COMMENT \'PMA_comment\' FIRST',
             $query,
         );
@@ -508,7 +508,7 @@ class TableTest extends AbstractTestCase
             $expression,
             $moveTo,
         );
-        $this->assertEquals(
+        self::assertEquals(
             '`PMA_name` BOOLEAN PMA_attribute NULL DEFAULT TRUE AUTO_INCREMENT COMMENT \'PMA_comment\' FIRST',
             $query,
         );
@@ -530,7 +530,7 @@ class TableTest extends AbstractTestCase
             $expression,
             $moveTo,
         );
-        $this->assertEquals(
+        self::assertEquals(
             '`PMA_name` BOOLEAN PMA_attribute NULL DEFAULT NULL AUTO_INCREMENT COMMENT \'PMA_comment\' FIRST',
             $query,
         );
@@ -552,7 +552,7 @@ class TableTest extends AbstractTestCase
             $expression,
             $moveTo,
         );
-        $this->assertEquals(
+        self::assertEquals(
             '`PMA_name` BOOLEAN PMA_attribute NULL DEFAULT CURRENT_TIMESTAMP '
             . "AUTO_INCREMENT COMMENT 'PMA_comment' FIRST",
             $query,
@@ -575,7 +575,7 @@ class TableTest extends AbstractTestCase
             $expression,
             $moveTo,
         );
-        $this->assertEquals(
+        self::assertEquals(
             '`PMA_name` BOOLEAN PMA_attribute NULL DEFAULT current_timestamp() '
             . "AUTO_INCREMENT COMMENT 'PMA_comment' FIRST",
             $query,
@@ -601,7 +601,7 @@ class TableTest extends AbstractTestCase
             $expression,
             $moveTo,
         );
-        $this->assertEquals(
+        self::assertEquals(
             '`PMA_name` TIMESTAMP(3) PMA_attribute NULL DEFAULT CURRENT_TIMESTAMP(3) COMMENT \'PMA_comment\' FIRST',
             $query,
         );
@@ -626,7 +626,7 @@ class TableTest extends AbstractTestCase
             $expression,
             $moveTo,
         );
-        $this->assertEquals(
+        self::assertEquals(
             '`PMA_name` TIMESTAMP PMA_attribute NULL DEFAULT \'0000-00-00 00:00:00\' COMMENT \'PMA_comment\' FIRST',
             $query,
         );
@@ -651,7 +651,7 @@ class TableTest extends AbstractTestCase
             $expression,
             $moveTo,
         );
-        $this->assertEquals(
+        self::assertEquals(
             '`PMA_name` TIMESTAMP PMA_attribute NULL DEFAULT \'0000-00-00 00:00:00.0\' COMMENT \'PMA_comment\' FIRST',
             $query,
         );
@@ -676,7 +676,7 @@ class TableTest extends AbstractTestCase
             $expression,
             $moveTo,
         );
-        $this->assertEquals(
+        self::assertEquals(
             '`PMA_name` TIMESTAMP PMA_attribute NULL DEFAULT \'0000-00-00 00:00:00.000000\' '
             . "COMMENT 'PMA_comment' FIRST",
             $query,
@@ -701,7 +701,7 @@ class TableTest extends AbstractTestCase
             $expression,
             $moveTo,
         );
-        $this->assertEquals('`PMA_name` UUID PMA_attribute NULL DEFAULT uuid()', $query);
+        self::assertEquals('`PMA_name` UUID PMA_attribute NULL DEFAULT uuid()', $query);
 
         //$default_type is uuid()
         $type = 'UUID';
@@ -722,7 +722,7 @@ class TableTest extends AbstractTestCase
             $expression,
             $moveTo,
         );
-        $this->assertEquals('`PMA_name` UUID PMA_attribute NULL DEFAULT uuid()', $query);
+        self::assertEquals('`PMA_name` UUID PMA_attribute NULL DEFAULT uuid()', $query);
 
         //$default_type is NONE
         $type = 'BOOLEAN';
@@ -744,7 +744,7 @@ class TableTest extends AbstractTestCase
             $expression,
             $moveTo,
         );
-        $this->assertEquals('`PMA_name` BOOLEAN PMA_attribute NULL INCREMENT COMMENT \'PMA_comment\' FIRST', $query);
+        self::assertEquals('`PMA_name` BOOLEAN PMA_attribute NULL INCREMENT COMMENT \'PMA_comment\' FIRST', $query);
 
         $defaultType = 'NONE';
         $moveTo = '-first';
@@ -765,7 +765,7 @@ class TableTest extends AbstractTestCase
             ['id'],
             'id',
         );
-        $this->assertEquals('`ids` INT(11) PMA_attribute NULL AUTO_INCREMENT COMMENT \'PMA_comment\' FIRST', $query);
+        self::assertEquals('`ids` INT(11) PMA_attribute NULL AUTO_INCREMENT COMMENT \'PMA_comment\' FIRST', $query);
 
         $defaultType = 'NONE';
         $moveTo = '-first';
@@ -787,7 +787,7 @@ class TableTest extends AbstractTestCase
             'id',
         );
         // Add primary key for AUTO_INCREMENT if missing
-        $this->assertEquals(
+        self::assertEquals(
             '`ids` INT(11) PMA_attribute NULL AUTO_INCREMENT '
             . "COMMENT 'PMA_comment' FIRST, add PRIMARY KEY (`ids`)",
             $query,
@@ -813,7 +813,7 @@ class TableTest extends AbstractTestCase
             'id',
         );
         // Do not add PK
-        $this->assertEquals('`id` INT(11) PMA_attribute NULL DEF COMMENT \'PMA_comment\' FIRST', $query);
+        self::assertEquals('`id` INT(11) PMA_attribute NULL DEF COMMENT \'PMA_comment\' FIRST', $query);
 
         $defaultType = 'NONE';
         $moveTo = '-first';
@@ -835,7 +835,7 @@ class TableTest extends AbstractTestCase
             'id',
         );
         // Do not add PK
-        $this->assertEquals('`ids` INT(11) PMA_attribute NULL DEF COMMENT \'PMA_comment\' FIRST', $query);
+        self::assertEquals('`ids` INT(11) PMA_attribute NULL DEF COMMENT \'PMA_comment\' FIRST', $query);
 
         $defaultType = 'NONE';
         $moveTo = '-first';
@@ -857,7 +857,7 @@ class TableTest extends AbstractTestCase
             'id',
         );
         // Add it beaucause it is missing
-        $this->assertEquals(
+        self::assertEquals(
             '`ids` INT(11) PMA_attribute NULL DEF COMMENT \'PMA_comment\' FIRST, add PRIMARY KEY (`ids`)',
             $query,
         );
@@ -882,7 +882,7 @@ class TableTest extends AbstractTestCase
             'id',
         );
         // Do not add PK since it is not a AUTO_INCREMENT
-        $this->assertEquals(
+        self::assertEquals(
             '`ids` INT(11) PMA_attribute AS (1) VIRTUAL NULL USER_DEFINED COMMENT \'PMA_comment\' FIRST',
             $query,
         );
@@ -905,7 +905,7 @@ class TableTest extends AbstractTestCase
         (new ReflectionProperty(Relation::class, 'cache'))->setValue(null, $relationParameters);
 
         $ret = Table::duplicateInfo('relwork', 'relation', $getFields, $whereFields, $newFields);
-        $this->assertSame(-1, $ret);
+        self::assertSame(-1, $ret);
     }
 
     /**
@@ -914,18 +914,18 @@ class TableTest extends AbstractTestCase
     public function testIsUpdatableView(): void
     {
         $table = new Table('', '', $this->mockedDbi);
-        $this->assertFalse(
+        self::assertFalse(
             $table->isUpdatableView(),
         );
 
         //validate that it is the same as DBI fetchResult
         $table = new Table('PMA_BookMark', 'PMA', $this->mockedDbi);
-        $this->assertTrue(
+        self::assertTrue(
             $table->isUpdatableView(),
         );
 
         $table = new Table('PMA_BookMark_2', 'PMA', $this->mockedDbi);
-        $this->assertFalse(
+        self::assertFalse(
             $table->isUpdatableView(),
         );
     }
@@ -936,7 +936,7 @@ class TableTest extends AbstractTestCase
     public function testIsMergeCase1(): void
     {
         $tableObj = new Table('PMA_BookMark', 'PMA', $this->mockedDbi);
-        $this->assertFalse(
+        self::assertFalse(
             $tableObj->isMerge(),
         );
     }
@@ -949,7 +949,7 @@ class TableTest extends AbstractTestCase
         $this->mockedDbi->getCache()->cacheTableValue('PMA', 'PMA_BookMark', 'ENGINE', 'MERGE');
 
         $tableObj = new Table('PMA_BookMark', 'PMA', $this->mockedDbi);
-        $this->assertTrue(
+        self::assertTrue(
             $tableObj->isMerge(),
         );
     }
@@ -962,7 +962,7 @@ class TableTest extends AbstractTestCase
         $this->mockedDbi->getCache()->cacheTableValue('PMA', 'PMA_BookMark', 'ENGINE', 'MRG_MYISAM');
 
         $tableObj = new Table('PMA_BookMark', 'PMA', $this->mockedDbi);
-        $this->assertTrue(
+        self::assertTrue(
             $tableObj->isMerge(),
         );
     }
@@ -973,7 +973,7 @@ class TableTest extends AbstractTestCase
     public function testIsMergeCase4(): void
     {
         $tableObj = new Table('PMA_BookMark', 'PMA', $this->mockedDbi);
-        $this->assertFalse(
+        self::assertFalse(
             $tableObj->isMerge(),
         );
     }
@@ -1020,7 +1020,7 @@ class TableTest extends AbstractTestCase
             . "charset1 NULL DEFAULT 'VARCHAR' "
             . "AUTO_INCREMENT COMMENT 'PMA comment' AFTER `new_name`";
 
-        $this->assertEquals($expect, $result);
+        self::assertEquals($expect, $result);
     }
 
     /**
@@ -1033,31 +1033,31 @@ class TableTest extends AbstractTestCase
         $table = 'PMA_BookMark';
         $db = 'PMA';
 
-        $this->mockedDbi->expects($this->any())->method('tryQuery')->willReturn($this->createMock(DummyResult::class));
+        $this->mockedDbi->expects(self::any())->method('tryQuery')->willReturn($this->createMock(DummyResult::class));
 
         $table = new Table($table, $db, $this->mockedDbi);
 
         //rename to same name
         $tableNew = 'PMA_BookMark';
         $result = $table->rename($tableNew);
-        $this->assertTrue($result);
+        self::assertTrue($result);
 
         //isValidName
         //space in table name
         $tableNew = 'PMA_BookMark ';
         $result = $table->rename($tableNew);
-        $this->assertFalse($result);
+        self::assertFalse($result);
         //empty name
         $tableNew = '';
         $result = $table->rename($tableNew);
-        $this->assertFalse($result);
+        self::assertFalse($result);
         //dot in table name
         $tableNew = 'PMA_.BookMark';
         $result = $table->rename($tableNew);
-        $this->assertTrue($result);
+        self::assertTrue($result);
 
         //message
-        $this->assertEquals(
+        self::assertEquals(
             'Table PMA_BookMark has been renamed to PMA_.BookMark.',
             $table->getLastMessage(),
         );
@@ -1065,9 +1065,9 @@ class TableTest extends AbstractTestCase
         $tableNew = 'PMA_BookMark_new';
         $dbNew = 'PMA_new';
         $result = $table->rename($tableNew, $dbNew);
-        $this->assertTrue($result);
+        self::assertTrue($result);
         //message
-        $this->assertEquals(
+        self::assertEquals(
             'Table PMA_.BookMark has been renamed to PMA_BookMark_new.',
             $table->getLastMessage(),
         );
@@ -1084,7 +1084,7 @@ class TableTest extends AbstractTestCase
         $table = new Table($table, $db, $this->mockedDbi);
         $return = $table->getUniqueColumns();
         $expect = ['`PMA`.`PMA_BookMark`.`index1`', '`PMA`.`PMA_BookMark`.`index3`', '`PMA`.`PMA_BookMark`.`index5`'];
-        $this->assertEquals($expect, $return);
+        self::assertEquals($expect, $return);
     }
 
     /**
@@ -1105,7 +1105,7 @@ class TableTest extends AbstractTestCase
             '`PMA`.`PMA_BookMark`.`ADD`',
             '`PMA`.`PMA_BookMark`.`ALL`',
         ];
-        $this->assertEquals($expect, $return);
+        self::assertEquals($expect, $return);
     }
 
     /**
@@ -1119,12 +1119,12 @@ class TableTest extends AbstractTestCase
 
         $resultStub = $this->createMock(DummyResult::class);
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('tryQuery')
             ->with('SELECT * FROM `db`.`table` LIMIT 1')
             ->willReturn($resultStub);
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('getFieldsMeta')
             ->with($resultStub)
             ->willReturn(['aNonValidExampleToRefactor']);
@@ -1133,7 +1133,7 @@ class TableTest extends AbstractTestCase
 
         $tableObj = new Table('table', 'db', $dbi);
 
-        $this->assertEquals(
+        self::assertEquals(
             $tableObj->getColumnsMeta(),
             ['aNonValidExampleToRefactor'],
         );
@@ -1161,7 +1161,7 @@ class TableTest extends AbstractTestCase
         $sqlExcepted = 'ALTER TABLE `PMA_table` ADD  '
             . 'FOREIGN KEY (`PMA_field1`, `PMA_field2`) REFERENCES '
             . '`foreignDb`.`foreignTable`(`foreignField1`, `foreignField2`);';
-        $this->assertEquals($sqlExcepted, $sql);
+        self::assertEquals($sqlExcepted, $sql);
 
         // Exclude db name when relations are made between table in the same db
         $sql = $this->callFunction(
@@ -1173,7 +1173,7 @@ class TableTest extends AbstractTestCase
         $sqlExcepted = 'ALTER TABLE `PMA_table` ADD  '
             . 'FOREIGN KEY (`PMA_field1`, `PMA_field2`) REFERENCES '
             . '`foreignTable`(`foreignField1`, `foreignField2`);';
-        $this->assertEquals($sqlExcepted, $sql);
+        self::assertEquals($sqlExcepted, $sql);
     }
 
     /**
@@ -1195,11 +1195,11 @@ class TableTest extends AbstractTestCase
             '`PMA`.`PMA_BookMark`.`ADD`',
             '`PMA`.`PMA_BookMark`.`ALL`',
         ];
-        $this->assertEquals($expect, $return);
+        self::assertEquals($expect, $return);
 
         $return = $table->getReservedColumnNames();
         $expect = ['ACCESSIBLE', 'ADD', 'ALL'];
-        $this->assertEquals($expect, $return);
+        self::assertEquals($expect, $return);
     }
 
     /**
@@ -1214,13 +1214,13 @@ class TableTest extends AbstractTestCase
         $dbi = $this->getMockBuilder(DatabaseInterface::class)
             ->disableOriginalConstructor()
             ->getMock();
-        $dbi->expects($this->any())
+        $dbi->expects(self::any())
             ->method('tryQuery')
             ->willReturn($resultStub);
-        $resultStub->expects($this->any())
+        $resultStub->expects(self::any())
             ->method('numRows')
             ->willReturn(0, 10, 200);
-        $dbi->expects($this->any())
+        $dbi->expects(self::any())
             ->method('fetchResult')
             ->willReturn(
                 [['`one_pk`']],
@@ -1239,17 +1239,17 @@ class TableTest extends AbstractTestCase
         // Case 1 : Check if table is non-empty
         $return = $tableObj->checkIfMinRecordsExist();
         $expect = true;
-        $this->assertEquals($expect, $return);
+        self::assertEquals($expect, $return);
 
         // Case 2 : Check if table contains at least 100
         $return = $tableObj->checkIfMinRecordsExist(100);
         $expect = false;
-        $this->assertEquals($expect, $return);
+        self::assertEquals($expect, $return);
 
         // Case 3 : Check if table contains at least 100
         $return = $tableObj->checkIfMinRecordsExist(100);
         $expect = true;
-        $this->assertEquals($expect, $return);
+        self::assertEquals($expect, $return);
 
         DatabaseInterface::$instance = $oldDbi;
     }
@@ -1260,19 +1260,19 @@ class TableTest extends AbstractTestCase
     public function testCountRecords(): void
     {
         $resultStub = $this->createMock(DummyResult::class);
-        $resultStub->expects($this->any())
+        $resultStub->expects(self::any())
             ->method('numRows')
             ->willReturn(20);
 
         $dbi = clone $this->mockedDbi;
-        $dbi->expects($this->any())->method('tryQuery')
+        $dbi->expects(self::any())->method('tryQuery')
             ->willReturn($resultStub);
 
         $table = 'PMA_BookMark';
         $db = 'PMA';
         $tableObj = new Table($table, $db, $dbi);
 
-        $this->assertEquals(
+        self::assertEquals(
             20,
             $tableObj->countRecords(true),
         );
@@ -1294,16 +1294,16 @@ class TableTest extends AbstractTestCase
         $table->setUiProp($property, $value, $tableCreateTime);
 
         //set UI prop successfully
-        $this->assertEquals($value, $table->uiprefs[$property]);
+        self::assertEquals($value, $table->uiprefs[$property]);
 
         //removeUiProp
         $table->removeUiProp($property);
         $isDefineProperty = isset($table->uiprefs[$property]);
-        $this->assertFalse($isDefineProperty);
+        self::assertFalse($isDefineProperty);
 
         //getUiProp after removeUiProp
         $isDefineProperty = $table->getUiProp($property);
-        $this->assertFalse($isDefineProperty);
+        self::assertFalse($isDefineProperty);
     }
 
     /**
@@ -1326,36 +1326,36 @@ class TableTest extends AbstractTestCase
             ['aa', 'ad', new Table('ad', 'aa', $this->mockedDbi)],
         ];
 
-        $this->mockedDbi->expects($this->any())->method('getTable')
+        $this->mockedDbi->expects(self::any())->method('getTable')
             ->willReturnMap($getTableMap);
 
         $return = Table::moveCopy($sourceDb, $sourceTable, $targetDb, $targetTable, $what, $move, $mode, true);
 
         //successfully
         $expect = true;
-        $this->assertEquals($expect, $return);
+        self::assertEquals($expect, $return);
         $sqlQuery = 'INSERT INTO `PMA_new`.`PMA_BookMark_new`(`COLUMN_NAME1`)'
             . ' SELECT `COLUMN_NAME1` FROM '
             . '`PMA`.`PMA_BookMark`';
-        $this->assertStringContainsString($sqlQuery, $GLOBALS['sql_query']);
+        self::assertStringContainsString($sqlQuery, $GLOBALS['sql_query']);
         $sqlQuery = 'DROP VIEW `PMA`.`PMA_BookMark`';
-        $this->assertStringContainsString($sqlQuery, $GLOBALS['sql_query']);
+        self::assertStringContainsString($sqlQuery, $GLOBALS['sql_query']);
 
         $return = Table::moveCopy($sourceDb, $sourceTable, $targetDb, $targetTable, $what, false, $mode, true);
 
         //successfully
         $expect = true;
-        $this->assertEquals($expect, $return);
+        self::assertEquals($expect, $return);
         $sqlQuery = 'INSERT INTO `PMA_new`.`PMA_BookMark_new`(`COLUMN_NAME1`)'
             . ' SELECT `COLUMN_NAME1` FROM '
             . '`PMA`.`PMA_BookMark`';
-        $this->assertStringContainsString($sqlQuery, $GLOBALS['sql_query']);
+        self::assertStringContainsString($sqlQuery, $GLOBALS['sql_query']);
         $sqlQuery = 'DROP VIEW `PMA`.`PMA_BookMark`';
-        $this->assertStringNotContainsString($sqlQuery, $GLOBALS['sql_query']);
+        self::assertStringNotContainsString($sqlQuery, $GLOBALS['sql_query']);
 
         // Renaming DB with a view bug
         $resultStub = $this->createMock(DummyResult::class);
-        $this->mockedDbi->expects($this->any())->method('tryQuery')
+        $this->mockedDbi->expects(self::any())->method('tryQuery')
             ->willReturnMap([
                 [
                     'SHOW CREATE TABLE `aa`.`ad`',
@@ -1373,7 +1373,7 @@ class TableTest extends AbstractTestCase
                 ],
                 ['USE `aa`', ConnectionType::User, DatabaseInterface::QUERY_BUFFERED, true, $resultStub],
             ]);
-        $resultStub->expects($this->any())
+        $resultStub->expects(self::any())
             ->method('fetchRow')
             ->willReturn([
                 'ad',
@@ -1385,14 +1385,14 @@ class TableTest extends AbstractTestCase
 
         $GLOBALS['sql_query'] = '';
         $return = Table::moveCopy('aa', 'ad', 'bb', 'ad', 'structure', true, 'db_copy', true);
-        $this->assertTrue($return);
-        $this->assertStringContainsString('DROP TABLE IF EXISTS `bb`.`ad`;', $GLOBALS['sql_query']);
-        $this->assertStringContainsString(
+        self::assertTrue($return);
+        self::assertStringContainsString('DROP TABLE IF EXISTS `bb`.`ad`;', $GLOBALS['sql_query']);
+        self::assertStringContainsString(
             'CREATE ALGORITHM=UNDEFINED DEFINER=`root`@`localhost`' .
             ' SQL SECURITY DEFINER VIEW `bb`.`ad`  AS SELECT `bb`.`ac` AS `ac` FROM `bb` ;',
             $GLOBALS['sql_query'],
         );
-        $this->assertStringContainsString('DROP VIEW `aa`.`ad`;', $GLOBALS['sql_query']);
+        self::assertStringContainsString('DROP VIEW `aa`.`ad`;', $GLOBALS['sql_query']);
     }
 
     /**
@@ -1408,7 +1408,7 @@ class TableTest extends AbstractTestCase
         $tblObject->getStatusInfo(null);
         $expect = 'DBIDUMMY';
         $tblStorageEngine = $dbi->getTable($targetDb, $targetTable)->getStorageEngine();
-        $this->assertEquals($expect, $tblStorageEngine);
+        self::assertEquals($expect, $tblStorageEngine);
     }
 
     /**
@@ -1424,7 +1424,7 @@ class TableTest extends AbstractTestCase
         $tblObject->getStatusInfo(null);
         $expect = 'Test comment for "table1" in \'pma_test\'';
         $showComment = $dbi->getTable($targetDb, $targetTable)->getComment();
-        $this->assertEquals($expect, $showComment);
+        self::assertEquals($expect, $showComment);
     }
 
     /**
@@ -1440,7 +1440,7 @@ class TableTest extends AbstractTestCase
         $tblObject->getStatusInfo(null);
         $expect = 'utf8mb4_general_ci';
         $tblCollation = $dbi->getTable($targetDb, $targetTable)->getCollation();
-        $this->assertEquals($expect, $tblCollation);
+        self::assertEquals($expect, $tblCollation);
     }
 
     /**
@@ -1456,7 +1456,7 @@ class TableTest extends AbstractTestCase
         $tblObject->getStatusInfo(null);
         $expect = 'Redundant';
         $rowFormat = $dbi->getTable($targetDb, $targetTable)->getRowFormat();
-        $this->assertEquals($expect, $rowFormat);
+        self::assertEquals($expect, $rowFormat);
     }
 
     /**
@@ -1472,7 +1472,7 @@ class TableTest extends AbstractTestCase
         $tblObject->getStatusInfo(null);
         $expect = '5';
         $autoIncrement = $dbi->getTable($targetDb, $targetTable)->getAutoIncrement();
-        $this->assertEquals($expect, $autoIncrement);
+        self::assertEquals($expect, $autoIncrement);
     }
 
     /**
@@ -1488,6 +1488,6 @@ class TableTest extends AbstractTestCase
         $tblObject->getStatusInfo(null);
         $expect = ['pack_keys' => 'DEFAULT', 'row_format' => 'REDUNDANT'];
         $createOptions = $dbi->getTable($targetDb, $targetTable)->getCreateOptions();
-        $this->assertEquals($expect, $createOptions);
+        self::assertEquals($expect, $createOptions);
     }
 }
diff --git a/tests/classes/TemplateTest.php b/tests/classes/TemplateTest.php
index e826cf5975..d69893f2cd 100644
--- a/tests/classes/TemplateTest.php
+++ b/tests/classes/TemplateTest.php
@@ -38,12 +38,12 @@ class TemplateTest extends AbstractTestCase
     public function testGetTwigEnvironment(): void
     {
         $twig = Template::getTwigEnvironment(null, false);
-        $this->assertFalse($twig->isDebug());
-        $this->assertFalse(TransNode::$enableAddDebugInfo);
+        self::assertFalse($twig->isDebug());
+        self::assertFalse(TransNode::$enableAddDebugInfo);
 
         $twig = Template::getTwigEnvironment(null, true);
-        $this->assertTrue($twig->isDebug());
-        $this->assertTrue(TransNode::$enableAddDebugInfo);
+        self::assertTrue($twig->isDebug());
+        self::assertTrue(TransNode::$enableAddDebugInfo);
     }
 
     /**
@@ -55,8 +55,8 @@ class TemplateTest extends AbstractTestCase
     public function testSet(string $data): void
     {
         $result = $this->template->render($data, ['variable1' => 'value1', 'variable2' => 'value2']);
-        $this->assertStringContainsString('value1', $result);
-        $this->assertStringContainsString('value2', $result);
+        self::assertStringContainsString('value1', $result);
+        self::assertStringContainsString('value2', $result);
     }
 
     /**
@@ -79,7 +79,7 @@ class TemplateTest extends AbstractTestCase
     #[DataProvider('providerTestDynamicRender')]
     public function testDynamicRender(string $templateFile, string $key, string $value): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             $value,
             $this->template->render($templateFile, [$key => $value]),
         );
@@ -113,7 +113,7 @@ class TemplateTest extends AbstractTestCase
     #[DataProvider('providerTestRender')]
     public function testRender(string $templateFile, string $expectedResult): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             $expectedResult,
             $this->template->render($templateFile),
         );
@@ -139,7 +139,7 @@ class TemplateTest extends AbstractTestCase
     #[DataProvider('providerTestRenderGettext')]
     public function testRenderGettext(string $templateFile, array $renderParams, string $expectedResult): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             $expectedResult,
             $this->template->render($templateFile, $renderParams),
         );
@@ -170,26 +170,26 @@ class TemplateTest extends AbstractTestCase
         $twigEnvCacheProperty = new ReflectionProperty(Template::class, 'twig');
         $twigEnvCacheProperty->setValue(null, null);
         $template = new Template();
-        $this->assertSame("static content\n", $template->render('test/static'));
+        self::assertSame("static content\n", $template->render('test/static'));
         $twigEnv = $twigEnvCacheProperty->getValue();
-        $this->assertInstanceOf(Environment::class, $twigEnv);
+        self::assertInstanceOf(Environment::class, $twigEnv);
         $template2 = new Template();
-        $this->assertSame("static content\n", $template2->render('test/static'));
-        $this->assertSame($twigEnv, $twigEnvCacheProperty->getValue());
+        self::assertSame("static content\n", $template2->render('test/static'));
+        self::assertSame($twigEnv, $twigEnvCacheProperty->getValue());
     }
 
     public function testDisableCache(): void
     {
         (new ReflectionProperty(Template::class, 'twig'))->setValue(null, null);
-        $template = new Template($this->createStub(Config::class));
+        $template = new Template(self::createStub(Config::class));
         $template->disableCache();
         $twig = (new ReflectionProperty(Template::class, 'twig'))->getValue();
-        $this->assertInstanceOf(Environment::class, $twig);
-        $this->assertFalse($twig->getCache());
-        $twig->setCache($this->createStub(CacheInterface::class));
-        $this->assertNotFalse($twig->getCache());
+        self::assertInstanceOf(Environment::class, $twig);
+        self::assertFalse($twig->getCache());
+        $twig->setCache(self::createStub(CacheInterface::class));
+        self::assertNotFalse($twig->getCache());
         $template->disableCache();
-        $this->assertFalse($twig->getCache());
+        self::assertFalse($twig->getCache());
         (new ReflectionProperty(Template::class, 'twig'))->setValue(null, null);
     }
 }
diff --git a/tests/classes/Theme/ThemeManagerTest.php b/tests/classes/Theme/ThemeManagerTest.php
index 1ad3a99c5c..de69261dfd 100644
--- a/tests/classes/Theme/ThemeManagerTest.php
+++ b/tests/classes/Theme/ThemeManagerTest.php
@@ -35,7 +35,7 @@ class ThemeManagerTest extends AbstractTestCase
     public function testCookieName(): void
     {
         $tm = new ThemeManager();
-        $this->assertEquals('pma_theme', $tm->getThemeCookieName());
+        self::assertEquals('pma_theme', $tm->getThemeCookieName());
     }
 
     /**
@@ -45,7 +45,7 @@ class ThemeManagerTest extends AbstractTestCase
     {
         $tm = new ThemeManager();
         $tm->setThemePerServer(true);
-        $this->assertEquals('pma_theme-99', $tm->getThemeCookieName());
+        self::assertEquals('pma_theme-99', $tm->getThemeCookieName());
     }
 
     public function testGetThemesArray(): void
@@ -53,13 +53,13 @@ class ThemeManagerTest extends AbstractTestCase
         $tm = new ThemeManager();
         $tm->initializeTheme();
         $themes = $tm->getThemesArray();
-        $this->assertIsArray($themes);
-        $this->assertArrayHasKey(0, $themes);
-        $this->assertIsArray($themes[0]);
-        $this->assertArrayHasKey('id', $themes[0]);
-        $this->assertArrayHasKey('name', $themes[0]);
-        $this->assertArrayHasKey('version', $themes[0]);
-        $this->assertArrayHasKey('is_active', $themes[0]);
+        self::assertIsArray($themes);
+        self::assertArrayHasKey(0, $themes);
+        self::assertIsArray($themes[0]);
+        self::assertArrayHasKey('id', $themes[0]);
+        self::assertArrayHasKey('name', $themes[0]);
+        self::assertArrayHasKey('version', $themes[0]);
+        self::assertArrayHasKey('is_active', $themes[0]);
     }
 
     /**
@@ -68,7 +68,7 @@ class ThemeManagerTest extends AbstractTestCase
     public function testSetThemeCookie(): void
     {
         $tm = new ThemeManager();
-        $this->assertTrue(
+        self::assertTrue(
             $tm->setThemeCookie(),
         );
     }
diff --git a/tests/classes/Theme/ThemeTest.php b/tests/classes/Theme/ThemeTest.php
index a2077d39e4..e8d8cb2150 100644
--- a/tests/classes/Theme/ThemeTest.php
+++ b/tests/classes/Theme/ThemeTest.php
@@ -43,7 +43,7 @@ class ThemeTest extends AbstractTestCase
     public function testCheckImgPathNotExisted(): void
     {
         $this->object->setPath('path/to/nowhere');
-        $this->assertFalse($this->object->loadInfo());
+        self::assertFalse($this->object->loadInfo());
     }
 
     /**
@@ -52,7 +52,7 @@ class ThemeTest extends AbstractTestCase
     public function testCheckImgPathIncorrect(): void
     {
         $this->object->setPath(TEST_PATH . 'tests/classes/_data/incorrect_theme');
-        $this->assertFalse(
+        self::assertFalse(
             $this->object->loadInfo(),
             'Theme name is not properly set',
         );
@@ -64,9 +64,9 @@ class ThemeTest extends AbstractTestCase
     public function testCheckImgPathFull(): void
     {
         $this->object->setFsPath(TEST_PATH . 'tests/classes/_data/gen_version_info/');
-        $this->assertTrue($this->object->loadInfo());
-        $this->assertEquals('Test Theme', $this->object->getName());
-        $this->assertEquals('6.0', $this->object->getVersion());
+        self::assertTrue($this->object->loadInfo());
+        self::assertEquals('Test Theme', $this->object->getName());
+        self::assertEquals('6.0', $this->object->getVersion());
     }
 
     /**
@@ -76,17 +76,17 @@ class ThemeTest extends AbstractTestCase
     {
         $this->object->setFsPath(ROOT_PATH . 'public/themes/original/');
         $infofile = $this->object->getFsPath() . 'theme.json';
-        $this->assertTrue($this->object->loadInfo());
+        self::assertTrue($this->object->loadInfo());
 
-        $this->assertEquals(
+        self::assertEquals(
             filemtime($infofile),
             $this->object->mtimeInfo,
         );
 
         $this->object->setPath(ROOT_PATH . 'public/themes/original');
         $this->object->mtimeInfo = (int) filemtime($infofile);
-        $this->assertTrue($this->object->loadInfo());
-        $this->assertEquals('Original', $this->object->getName());
+        self::assertTrue($this->object->loadInfo());
+        self::assertEquals('Original', $this->object->getName());
     }
 
     /**
@@ -99,8 +99,8 @@ class ThemeTest extends AbstractTestCase
             ThemeManager::getThemesFsDir() . 'original' . DIRECTORY_SEPARATOR,
             'original',
         );
-        $this->assertNotNull($newTheme);
-        $this->assertInstanceOf(Theme::class, $newTheme);
+        self::assertNotNull($newTheme);
+        self::assertInstanceOf(Theme::class, $newTheme);
     }
 
     /**
@@ -108,7 +108,7 @@ class ThemeTest extends AbstractTestCase
      */
     public function testLoadNonExistent(): void
     {
-        $this->assertNull(
+        self::assertNull(
             Theme::load(
                 ThemeManager::getThemesDir() . 'nonexistent',
                 ThemeManager::getThemesFsDir() . 'nonexistent' . DIRECTORY_SEPARATOR,
@@ -123,7 +123,7 @@ class ThemeTest extends AbstractTestCase
     public function testCheckImgPathFallback(): void
     {
         $this->object->setPath('path/to/nowhere');
-        $this->assertTrue($this->object->checkImgPath());
+        self::assertTrue($this->object->checkImgPath());
     }
 
     /**
@@ -132,7 +132,7 @@ class ThemeTest extends AbstractTestCase
     public function testCheckImgPath(): void
     {
         $this->object->setPath(ROOT_PATH . 'themes/original');
-        $this->assertTrue($this->object->checkImgPath());
+        self::assertTrue($this->object->checkImgPath());
     }
 
     /**
@@ -140,10 +140,10 @@ class ThemeTest extends AbstractTestCase
      */
     public function testGetSetPath(): void
     {
-        $this->assertEmpty($this->object->getPath());
+        self::assertEmpty($this->object->getPath());
         $this->object->setPath(ROOT_PATH . 'themes/original');
 
-        $this->assertEquals(ROOT_PATH . 'themes/original', $this->object->getPath());
+        self::assertEquals(ROOT_PATH . 'themes/original', $this->object->getPath());
     }
 
     /**
@@ -152,17 +152,17 @@ class ThemeTest extends AbstractTestCase
     #[Depends('testLoadInfo')]
     public function testGetSetCheckVersion(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             '0.0.0.0',
             $this->object->getVersion(),
             'Version 0.0.0.0 by default',
         );
 
         $this->object->setVersion('1.2.3.4');
-        $this->assertEquals('1.2.3.4', $this->object->getVersion());
+        self::assertEquals('1.2.3.4', $this->object->getVersion());
 
-        $this->assertFalse($this->object->checkVersion('0.0.1.1'));
-        $this->assertTrue($this->object->checkVersion('2.0.1.1'));
+        self::assertFalse($this->object->checkVersion('0.0.1.1'));
+        self::assertTrue($this->object->checkVersion('2.0.1.1'));
     }
 
     /**
@@ -170,10 +170,10 @@ class ThemeTest extends AbstractTestCase
      */
     public function testGetSetName(): void
     {
-        $this->assertEmpty($this->object->getName(), 'Name is empty by default');
+        self::assertEmpty($this->object->getName(), 'Name is empty by default');
         $this->object->setName('New Theme Name');
 
-        $this->assertEquals('New Theme Name', $this->object->getName());
+        self::assertEquals('New Theme Name', $this->object->getName());
     }
 
     /**
@@ -181,10 +181,10 @@ class ThemeTest extends AbstractTestCase
      */
     public function testGetSetId(): void
     {
-        $this->assertEmpty($this->object->getId(), 'ID is empty by default');
+        self::assertEmpty($this->object->getId(), 'ID is empty by default');
         $this->object->setId('NewID');
 
-        $this->assertEquals('NewID', $this->object->getId());
+        self::assertEquals('NewID', $this->object->getId());
     }
 
     /**
@@ -192,13 +192,13 @@ class ThemeTest extends AbstractTestCase
      */
     public function testGetSetImgPath(): void
     {
-        $this->assertEmpty(
+        self::assertEmpty(
             $this->object->getImgPath(),
             'ImgPath is empty by default',
         );
         $this->object->setImgPath('/new/path');
 
-        $this->assertEquals('/new/path', $this->object->getImgPath());
+        self::assertEquals('/new/path', $this->object->getImgPath());
     }
 
     /**
@@ -211,7 +211,7 @@ class ThemeTest extends AbstractTestCase
     #[DataProvider('providerForGetImgPath')]
     public function testGetImgPath(string|null $file, string|null $fallback, string $output): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             $this->object->getImgPath($file, $fallback),
             $output,
         );
diff --git a/tests/classes/Tracking/TrackerTest.php b/tests/classes/Tracking/TrackerTest.php
index 513a042ff7..93ac5cfd9f 100644
--- a/tests/classes/Tracking/TrackerTest.php
+++ b/tests/classes/Tracking/TrackerTest.php
@@ -57,11 +57,11 @@ class TrackerTest extends AbstractTestCase
      */
     public function testEnabled(): void
     {
-        $this->assertFalse(Tracker::isEnabled());
+        self::assertFalse(Tracker::isEnabled());
         Tracker::enable();
-        $this->assertTrue(Tracker::isEnabled());
+        self::assertTrue(Tracker::isEnabled());
         Tracker::disable();
-        $this->assertFalse(Tracker::isEnabled());
+        self::assertFalse(Tracker::isEnabled());
     }
 
     /**
@@ -69,9 +69,9 @@ class TrackerTest extends AbstractTestCase
      */
     public function testIsActive(): void
     {
-        $this->assertFalse(Tracker::isEnabled());
+        self::assertFalse(Tracker::isEnabled());
 
-        $this->assertFalse(
+        self::assertFalse(
             Tracker::isActive(),
         );
 
@@ -80,7 +80,7 @@ class TrackerTest extends AbstractTestCase
         $relationParameters = RelationParameters::fromArray([]);
         (new ReflectionProperty(Relation::class, 'cache'))->setValue(null, $relationParameters);
 
-        $this->assertFalse(
+        self::assertFalse(
             Tracker::isActive(),
         );
 
@@ -91,7 +91,7 @@ class TrackerTest extends AbstractTestCase
         ]);
         (new ReflectionProperty(Relation::class, 'cache'))->setValue(null, $relationParameters);
 
-        $this->assertTrue(
+        self::assertTrue(
             Tracker::isActive(),
         );
     }
@@ -101,9 +101,9 @@ class TrackerTest extends AbstractTestCase
      */
     public function testIsTracked(): void
     {
-        $this->assertFalse(Tracker::isEnabled());
+        self::assertFalse(Tracker::isEnabled());
 
-        $this->assertFalse(
+        self::assertFalse(
             Tracker::isTracked('', ''),
         );
 
@@ -112,7 +112,7 @@ class TrackerTest extends AbstractTestCase
         $relationParameters = RelationParameters::fromArray([]);
         (new ReflectionProperty(Relation::class, 'cache'))->setValue(null, $relationParameters);
 
-        $this->assertFalse(
+        self::assertFalse(
             Tracker::isTracked('', ''),
         );
 
@@ -123,11 +123,11 @@ class TrackerTest extends AbstractTestCase
         ]);
         (new ReflectionProperty(Relation::class, 'cache'))->setValue(null, $relationParameters);
 
-        $this->assertTrue(
+        self::assertTrue(
             Tracker::isTracked('pma_test_db', 'pma_test_table'),
         );
 
-        $this->assertFalse(
+        self::assertFalse(
             Tracker::isTracked('pma_test_db', 'pma_test_table2'),
         );
     }
@@ -140,7 +140,7 @@ class TrackerTest extends AbstractTestCase
         $date = Util::date('Y-m-d H:i:s');
         Config::getInstance()->selectedServer['user'] = 'pma_test_user';
 
-        $this->assertEquals(
+        self::assertEquals(
             '# log ' . $date . " pma_test_user\n",
             Tracker::getLogComment(),
         );
@@ -172,34 +172,34 @@ class TrackerTest extends AbstractTestCase
             new ColumnFull('field1', 'int(11)', null, false, 'PRI', null, '', '', ''),
             new ColumnFull('field2', 'text', null, false, '', null, '', '', ''),
         ];
-        $dbi->expects($this->once())->method('getColumns')
+        $dbi->expects(self::once())->method('getColumns')
             ->with('pma_test', 'pma_tbl')
             ->willReturn($getColumnsResult);
 
         $getIndexesResult = [['Table' => 'pma_tbl', 'Field' => 'field1', 'Key' => 'PRIMARY']];
-        $dbi->expects($this->once())->method('getTableIndexes')
+        $dbi->expects(self::once())->method('getTableIndexes')
             ->with('pma_test', 'pma_tbl')
             ->willReturn($getIndexesResult);
 
         $showTableStatusQuery = 'SHOW TABLE STATUS FROM `pma_test` WHERE Name = \'pma_tbl\'';
         $useStatement = 'USE `pma_test`';
         $showCreateTableQuery = 'SHOW CREATE TABLE `pma_test`.`pma_tbl`';
-        $dbi->expects($this->exactly(3))->method('tryQuery')->willReturnMap([
+        $dbi->expects(self::exactly(3))->method('tryQuery')->willReturnMap([
             [$showTableStatusQuery, ConnectionType::User, DatabaseInterface::QUERY_BUFFERED, true, $resultStub],
             [$useStatement, ConnectionType::User, DatabaseInterface::QUERY_BUFFERED, true, $resultStub],
             [$showCreateTableQuery, ConnectionType::User, DatabaseInterface::QUERY_BUFFERED, true, $resultStub],
         ]);
 
-        $dbi->expects($this->any())->method('query')
+        $dbi->expects(self::any())->method('query')
             ->willReturn($resultStub);
 
-        $dbi->expects($this->any())->method('getCompatibilities')
+        $dbi->expects(self::any())->method('getCompatibilities')
             ->willReturn([]);
-        $dbi->expects($this->any())->method('quoteString')
+        $dbi->expects(self::any())->method('quoteString')
             ->willReturnCallback(static fn (string $string): string => "'" . $string . "'");
 
         DatabaseInterface::$instance = $dbi;
-        $this->assertTrue(Tracker::createVersion('pma_test', 'pma_tbl', '1', '11', true));
+        self::assertTrue(Tracker::createVersion('pma_test', 'pma_tbl', '1', '11', true));
     }
 
     /**
@@ -224,16 +224,16 @@ class TrackerTest extends AbstractTestCase
             . ' \'\', \'# log %d-%d-%d %d:%d:%d pma_test_user' . "\n" . 'SHOW DATABASES\', \'' . "\n"
             . '\', \'CREATE DATABASE,ALTER DATABASE,DROP DATABASE\')';
 
-        $dbi->expects($this->exactly(1))
+        $dbi->expects(self::exactly(1))
             ->method('queryAsControlUser')
-            ->with($this->matches($expectedMainQuery))
+            ->with(self::matches($expectedMainQuery))
             ->willReturn($resultStub);
 
-        $dbi->expects($this->any())->method('quoteString')
+        $dbi->expects(self::any())->method('quoteString')
             ->willReturnCallback(static fn (string $string): string => "'" . $string . "'");
 
         DatabaseInterface::$instance = $dbi;
-        $this->assertTrue(Tracker::createDatabaseVersion('pma_test', '1', 'SHOW DATABASES'));
+        self::assertTrue(Tracker::createDatabaseVersion('pma_test', '1', 'SHOW DATABASES'));
     }
 
     /**
@@ -264,12 +264,12 @@ class TrackerTest extends AbstractTestCase
         " AND `table_name` = '" . $tablename . "'" .
         " AND `version` = '" . $version . "'";
 
-        $dbi->expects($this->exactly(1))
+        $dbi->expects(self::exactly(1))
             ->method('queryAsControlUser')
             ->with($sqlQuery)
             ->willReturn($resultStub);
 
-        $dbi->expects($this->any())->method('quoteString')
+        $dbi->expects(self::any())->method('quoteString')
             ->willReturnCallback(static fn (string $string): string => "'" . $string . "'");
 
         DatabaseInterface::$instance = $dbi;
@@ -323,21 +323,21 @@ class TrackerTest extends AbstractTestCase
     ): void {
         $result = Tracker::parseQuery($query);
 
-        $this->assertEquals($type, $result['type']);
+        self::assertEquals($type, $result['type']);
 
-        $this->assertEquals($identifier, $result['identifier']);
+        self::assertEquals($identifier, $result['identifier']);
 
-        $this->assertEquals($tableName, $result['tablename']);
+        self::assertEquals($tableName, $result['tablename']);
 
         if ($db !== null && $db !== '') {
-            $this->assertEquals($db, Current::$database);
+            self::assertEquals($db, Current::$database);
         }
 
         if ($tableNameAfterRename === null || $tableNameAfterRename === '') {
             return;
         }
 
-        $this->assertEquals($result['tablename_after_rename'], $tableNameAfterRename);
+        self::assertEquals($result['tablename_after_rename'], $tableNameAfterRename);
     }
 
     /**
diff --git a/tests/classes/Tracking/TrackingCheckerTest.php b/tests/classes/Tracking/TrackingCheckerTest.php
index bbd83483a9..88ea9c9018 100644
--- a/tests/classes/Tracking/TrackingCheckerTest.php
+++ b/tests/classes/Tracking/TrackingCheckerTest.php
@@ -45,10 +45,10 @@ class TrackingCheckerTest extends AbstractTestCase
 
     public function testGetTrackedTables(): void
     {
-        $this->assertFalse(Tracker::isEnabled());
+        self::assertFalse(Tracker::isEnabled());
 
         $actual = $this->trackingChecker->getTrackedTables('dummyDb');
-        $this->assertEquals([], $actual);
+        self::assertEquals([], $actual);
 
         Tracker::enable();
 
@@ -59,21 +59,21 @@ class TrackingCheckerTest extends AbstractTestCase
 
         $actual = $this->trackingChecker->getTrackedTables('dummyDb');
 
-        $this->assertEquals($expectation, $actual);
+        self::assertEquals($expectation, $actual);
     }
 
     public function testGetUntrackedTableNames(): void
     {
-        $this->assertFalse(Tracker::isEnabled());
+        self::assertFalse(Tracker::isEnabled());
 
         $expectation = ['0', 'actor', 'untrackedTable'];
         $actual = $this->trackingChecker->getUntrackedTableNames('dummyDb');
-        $this->assertEquals($expectation, $actual);
+        self::assertEquals($expectation, $actual);
 
         Tracker::enable();
 
         $expectation = ['untrackedTable'];
         $actual = $this->trackingChecker->getUntrackedTableNames('dummyDb');
-        $this->assertEquals($expectation, $actual);
+        self::assertEquals($expectation, $actual);
     }
 }
diff --git a/tests/classes/Tracking/TrackingTest.php b/tests/classes/Tracking/TrackingTest.php
index ca2547af1a..c239bd1e81 100644
--- a/tests/classes/Tracking/TrackingTest.php
+++ b/tests/classes/Tracking/TrackingTest.php
@@ -71,7 +71,7 @@ class TrackingTest extends AbstractTestCase
             $template,
             $relation,
             $dbi,
-            $this->createStub(TrackingChecker::class),
+            self::createStub(TrackingChecker::class),
         );
     }
 
@@ -93,23 +93,23 @@ class TrackingTest extends AbstractTestCase
             new DateTimeImmutable('2020-01-01 12:34:56'),
         );
 
-        $this->assertEquals('username1', $ret[0]['username']);
-        $this->assertEquals('statement1', $ret[0]['statement']);
+        self::assertEquals('username1', $ret[0]['username']);
+        self::assertEquals('statement1', $ret[0]['statement']);
     }
 
     public function testGetHtmlForMain(): void
     {
         $html = $this->tracking->getHtmlForMainPage('PMA_db', 'PMA_table', [], 'ltr');
 
-        $this->assertStringContainsString('PMA_db.PMA_table', $html);
-        $this->assertStringContainsString('<td>date_created</td>', $html);
-        $this->assertStringContainsString(__('Delete version'), $html);
-        $this->assertStringContainsString('<div class="card mt-3">', $html);
-        $this->assertStringContainsString('<div class="card-header">', $html);
-        $this->assertStringContainsString('<div class="card-body">', $html);
-        $this->assertStringContainsString('<div class="card-footer">', $html);
-        $this->assertStringContainsString(Url::getHiddenInputs(Current::$database), $html);
-        $this->assertStringContainsString(
+        self::assertStringContainsString('PMA_db.PMA_table', $html);
+        self::assertStringContainsString('<td>date_created</td>', $html);
+        self::assertStringContainsString(__('Delete version'), $html);
+        self::assertStringContainsString('<div class="card mt-3">', $html);
+        self::assertStringContainsString('<div class="card-header">', $html);
+        self::assertStringContainsString('<div class="card-body">', $html);
+        self::assertStringContainsString('<div class="card-footer">', $html);
+        self::assertStringContainsString(Url::getHiddenInputs(Current::$database), $html);
+        self::assertStringContainsString(
             sprintf(
                 __('Create version %1$s of %2$s'),
                 2,
@@ -117,13 +117,13 @@ class TrackingTest extends AbstractTestCase
             ),
             $html,
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             '<input type="checkbox" name="delete" value="true"'
                 . ' checked="checked">' . "\n" . '            DELETE<br>',
             $html,
         );
-        $this->assertStringContainsString(__('Create version'), $html);
-        $this->assertStringContainsString('Deactivate now', $html);
+        self::assertStringContainsString(__('Create version'), $html);
+        self::assertStringContainsString('Deactivate now', $html);
     }
 
     /**
@@ -132,10 +132,10 @@ class TrackingTest extends AbstractTestCase
     public function testGetTableLastVersionNumber(): void
     {
         $sqlResult = $this->tracking->getListOfVersionsOfTable('PMA_db', 'PMA_table');
-        $this->assertNotFalse($sqlResult);
+        self::assertNotFalse($sqlResult);
 
         $lastVersion = $this->tracking->getTableLastVersionNumber($sqlResult);
-        $this->assertSame(1, $lastVersion);
+        self::assertSame(1, $lastVersion);
     }
 
     /**
@@ -166,66 +166,66 @@ class TrackingTest extends AbstractTestCase
 
         $html = $this->tracking->getHtmlForColumns($columns);
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             __('Column'),
             $html,
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             __('Type'),
             $html,
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             __('Collation'),
             $html,
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             __('Default'),
             $html,
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             __('Comment'),
             $html,
         );
 
         //column1
         $item1 = $columns[0];
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             htmlspecialchars($item1['Field']),
             $html,
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             htmlspecialchars($item1['Type']),
             $html,
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             htmlspecialchars($item1['Collation']),
             $html,
         );
-        $this->assertStringContainsString('<em>NULL</em>', $html);
-        $this->assertStringContainsString(
+        self::assertStringContainsString('<em>NULL</em>', $html);
+        self::assertStringContainsString(
             htmlspecialchars($item1['Comment']),
             $html,
         );
 
         //column2
         $item1 = $columns[1];
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             htmlspecialchars($item1['Field']),
             $html,
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             htmlspecialchars($item1['Type']),
             $html,
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             htmlspecialchars($item1['Collation']),
             $html,
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             _pgettext('None for default', 'None'),
             $html,
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             htmlspecialchars($item1['Comment']),
             $html,
         );
@@ -238,7 +238,7 @@ class TrackingTest extends AbstractTestCase
     {
         $ret = $this->tracking->getListOfVersionsOfTable('PMA_db', 'PMA_table');
 
-        $this->assertNotFalse($ret);
+        self::assertNotFalse($ret);
     }
 
     /**
@@ -268,42 +268,42 @@ class TrackingTest extends AbstractTestCase
             'users',
         );
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             __('Tracking report'),
             $html,
         );
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             __('Tracking statements'),
             $html,
         );
 
-        $this->assertStringContainsString($data->tracking, $html);
+        self::assertStringContainsString($data->tracking, $html);
 
         $version = Url::getHiddenInputs($urlParams + ['report' => 'true', 'version' => '10']);
 
-        $this->assertStringContainsString($version, $html);
+        self::assertStringContainsString($version, $html);
 
-        $this->assertStringContainsString($version, $html);
+        self::assertStringContainsString($version, $html);
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             __('Structure only'),
             $html,
         );
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             __('Data only'),
             $html,
         );
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             __('Structure and data'),
             $html,
         );
 
-        $this->assertStringContainsString('2022-11-03 22:15:24', $html);
-        $this->assertStringContainsString('2022-11-04 22:15:24', $html);
-        $this->assertStringContainsString('users', $html);
+        self::assertStringContainsString('2022-11-03 22:15:24', $html);
+        self::assertStringContainsString('2022-11-04 22:15:24', $html);
+        self::assertStringContainsString('users', $html);
     }
 
     /**
@@ -335,24 +335,24 @@ class TrackingTest extends AbstractTestCase
             new DateTimeImmutable('2020-01-01 12:34:56'),
         );
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             __('Date'),
             $html,
         );
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             __('Username'),
             $html,
         );
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             __('Data manipulation statement'),
             $html,
         );
 
-        $this->assertStringContainsString($data->dmlog[0]['date'], $html);
+        self::assertStringContainsString($data->dmlog[0]['date'], $html);
 
-        $this->assertStringContainsString($data->dmlog[0]['username'], $html);
+        self::assertStringContainsString($data->dmlog[0]['username'], $html);
     }
 
     /**
@@ -382,33 +382,33 @@ class TrackingTest extends AbstractTestCase
             new DateTimeImmutable('2020-01-01 12:34:56'),
         );
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             __('Date'),
             $html,
         );
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             __('Username'),
             $html,
         );
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             __('Data definition statement'),
             $html,
         );
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             __('Action'),
             $html,
         );
 
         //PMA_getHtmlForDataDefinitionStatement
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             htmlspecialchars($data->ddlog[0]['username']),
             $html,
         );
 
-        $this->assertEquals(2, $count);
+        self::assertEquals(2, $count);
     }
 
     /**
@@ -432,52 +432,52 @@ class TrackingTest extends AbstractTestCase
 
         $html = $this->tracking->getHtmlForIndexes($indexs);
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             __('Indexes'),
             $html,
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             __('Keyname'),
             $html,
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             __('Type'),
             $html,
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             __('Unique'),
             $html,
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             __('Packed'),
             $html,
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             __('Column'),
             $html,
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             __('Cardinality'),
             $html,
         );
         // items
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             htmlspecialchars($indexs[0]['Key_name']),
             $html,
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             htmlspecialchars($indexs[0]['Index_type']),
             $html,
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             htmlspecialchars($indexs[0]['Column_name']),
             $html,
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             htmlspecialchars($indexs[0]['Cardinality']),
             $html,
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             htmlspecialchars($indexs[0]['Collation']),
             $html,
         );
@@ -500,7 +500,7 @@ class TrackingTest extends AbstractTestCase
         $_POST['truncate'] = true;
 
         $trackingSet = $this->tracking->getTrackingSet();
-        $this->assertEquals('RENAME TABLE,CREATE TABLE,DROP TABLE,DROP INDEX,INSERT,DELETE,TRUNCATE', $trackingSet);
+        self::assertEquals('RENAME TABLE,CREATE TABLE,DROP TABLE,DROP INDEX,INSERT,DELETE,TRUNCATE', $trackingSet);
 
         //other set to true
         $_POST['alter_table'] = true;
@@ -515,7 +515,7 @@ class TrackingTest extends AbstractTestCase
         $_POST['truncate'] = false;
 
         $trackingSet = $this->tracking->getTrackingSet();
-        $this->assertEquals('ALTER TABLE,CREATE INDEX,UPDATE', $trackingSet);
+        self::assertEquals('ALTER TABLE,CREATE INDEX,UPDATE', $trackingSet);
     }
 
     /**
@@ -540,18 +540,18 @@ class TrackingTest extends AbstractTestCase
             new DateTimeImmutable('2010-01-01 12:34:56'),
             new DateTimeImmutable('2020-01-01 12:34:56'),
         );
-        $this->assertEquals('username3', $entries[0]['username']);
-        $this->assertEquals('statement1', $entries[0]['statement']);
+        self::assertEquals('username3', $entries[0]['username']);
+        self::assertEquals('statement1', $entries[0]['statement']);
     }
 
     public function testGetDownloadInfoForExport(): void
     {
         $tracking = new Tracking(
-            $this->createStub(SqlQueryForm::class),
-            $this->createStub(Template::class),
-            $this->createStub(Relation::class),
-            $this->createStub(DatabaseInterface::class),
-            $this->createStub(TrackingChecker::class),
+            self::createStub(SqlQueryForm::class),
+            self::createStub(Template::class),
+            self::createStub(Relation::class),
+            self::createStub(DatabaseInterface::class),
+            self::createStub(TrackingChecker::class),
         );
         ini_set('url_rewriter.tags', 'a=href,area=href,frame=src,form=,fieldset=');
         $entries = [['statement' => 'first statement'], ['statement' => 'second statement']];
@@ -559,9 +559,9 @@ class TrackingTest extends AbstractTestCase
             . '# ' . date('Y-m-d H:i:sP') . "\n"
             . 'first statementsecond statement';
         $actual = $tracking->getDownloadInfoForExport('test>  table', $entries);
-        $this->assertSame('log_test&gt; table.sql', $actual['filename']);
-        $this->assertSame($expectedDump, $actual['dump']);
-        $this->assertSame('', ini_get('url_rewriter.tags'));
+        self::assertSame('log_test&gt; table.sql', $actual['filename']);
+        self::assertSame($expectedDump, $actual['dump']);
+        self::assertSame('', ini_get('url_rewriter.tags'));
         ini_restore('url_rewriter.tags');
     }
 
@@ -570,7 +570,7 @@ class TrackingTest extends AbstractTestCase
      */
     public function testDeleteTracking(): void
     {
-        $resultStub = $this->createMock(DummyResult::class);
+        $resultStub = self::createMock(DummyResult::class);
 
         $dbi = $this->getMockBuilder(DatabaseInterface::class)
             ->disableOriginalConstructor()
@@ -581,21 +581,21 @@ class TrackingTest extends AbstractTestCase
             . " WHERE `db_name` = 'testdb'"
             . " AND `table_name` = 'testtable'";
 
-        $dbi->expects($this->exactly(1))
+        $dbi->expects(self::exactly(1))
             ->method('queryAsControlUser')
             ->with($sqlQuery)
             ->willReturn($resultStub);
-        $dbi->expects($this->any())->method('quoteString')
+        $dbi->expects(self::any())->method('quoteString')
             ->willReturnCallback(static fn (string $string): string => "'" . $string . "'");
 
         $tracking = new Tracking(
-            $this->createStub(SqlQueryForm::class),
-            $this->createStub(Template::class),
+            self::createStub(SqlQueryForm::class),
+            self::createStub(Template::class),
             new Relation(DatabaseInterface::getInstance()),
             $dbi,
-            $this->createStub(TrackingChecker::class),
+            self::createStub(TrackingChecker::class),
         );
-        $this->assertTrue($tracking->deleteTracking('testdb', 'testtable'));
+        self::assertTrue($tracking->deleteTracking('testdb', 'testtable'));
     }
 
     /**
@@ -627,24 +627,24 @@ class TrackingTest extends AbstractTestCase
         " AND `table_name` = 'pma_table'" .
         " AND `version` = '1.0'";
 
-        $resultStub1 = $this->createMock(DummyResult::class);
-        $resultStub2 = $this->createMock(DummyResult::class);
+        $resultStub1 = self::createMock(DummyResult::class);
+        $resultStub2 = self::createMock(DummyResult::class);
 
         $dbi->method('queryAsControlUser')
             ->willReturnMap([[$sqlQuery1, $resultStub1], [$sqlQuery2, $resultStub2]]);
 
-        $dbi->expects($this->any())->method('quoteString')
+        $dbi->expects(self::any())->method('quoteString')
             ->willReturnCallback(static fn (string $string): string => "'" . $string . "'");
 
         $tracking = new Tracking(
-            $this->createStub(SqlQueryForm::class),
-            $this->createStub(Template::class),
+            self::createStub(SqlQueryForm::class),
+            self::createStub(Template::class),
             new Relation(DatabaseInterface::getInstance()),
             $dbi,
-            $this->createStub(TrackingChecker::class),
+            self::createStub(TrackingChecker::class),
         );
 
-        $this->assertTrue(
+        self::assertTrue(
             $tracking->changeTrackingData(
                 'pma_db',
                 'pma_table',
@@ -664,31 +664,31 @@ class TrackingTest extends AbstractTestCase
     #[DataProvider('getTrackedDataProvider')]
     public function testGetTrackedData(array $fetchArrayReturn, TrackedData $expected): void
     {
-        $resultStub = $this->createMock(DummyResult::class);
+        $resultStub = self::createMock(DummyResult::class);
 
         $dbi = $this->getMockBuilder(DatabaseInterface::class)
             ->disableOriginalConstructor()
             ->getMock();
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('queryAsControlUser')
             ->willReturn($resultStub);
 
-        $resultStub->expects($this->once())
+        $resultStub->expects(self::once())
             ->method('fetchAssoc')
             ->willReturn($fetchArrayReturn);
 
         $tracking = new Tracking(
-            $this->createStub(SqlQueryForm::class),
-            $this->createStub(Template::class),
+            self::createStub(SqlQueryForm::class),
+            self::createStub(Template::class),
             new Relation(DatabaseInterface::getInstance()),
             $dbi,
-            $this->createStub(TrackingChecker::class),
+            self::createStub(TrackingChecker::class),
         );
 
         $result = $tracking->getTrackedData("pma'db", "pma'table", '1.0');
 
-        $this->assertEquals($expected, $result);
+        self::assertEquals($expected, $result);
     }
 
     /**
diff --git a/tests/classes/TransformationsTest.php b/tests/classes/TransformationsTest.php
index 42b43c992a..a050c9524f 100644
--- a/tests/classes/TransformationsTest.php
+++ b/tests/classes/TransformationsTest.php
@@ -55,7 +55,7 @@ class TransformationsTest extends AbstractTestCase
     #[DataProvider('getOptionsData')]
     public function testGetOptions(string $input, array $expected): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             $expected,
             $this->transformations->getOptions($input),
         );
@@ -81,7 +81,7 @@ class TransformationsTest extends AbstractTestCase
     #[RunInSeparateProcess]
     public function testGetTypes(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             [
                 'mimetype' => [
                     'Application/Octetstream' => 'Application/Octetstream',
@@ -177,7 +177,7 @@ class TransformationsTest extends AbstractTestCase
             'column_info' => 'column_info',
         ]);
         (new ReflectionProperty(Relation::class, 'cache'))->setValue(null, $relationParameters);
-        $this->assertEquals(
+        self::assertEquals(
             [
                 'o' => [
                     'column_name' => 'o',
@@ -209,16 +209,16 @@ class TransformationsTest extends AbstractTestCase
         $dbi = $this->getMockBuilder(DatabaseInterface::class)
             ->disableOriginalConstructor()
             ->getMock();
-        $dbi->expects($this->any())
+        $dbi->expects(self::any())
             ->method('tryQuery')
-            ->willReturn($this->createStub(DummyResult::class));
+            ->willReturn(self::createStub(DummyResult::class));
         DatabaseInterface::$instance = $dbi;
 
         (new ReflectionProperty(Relation::class, 'cache'))->setValue(null, null);
 
         // Case 1 : no configuration storage
         $actual = $this->transformations->clear('db');
-        $this->assertFalse($actual);
+        self::assertFalse($actual);
 
         $relationParameters = RelationParameters::fromArray([
             'db' => 'pmadb',
@@ -229,15 +229,15 @@ class TransformationsTest extends AbstractTestCase
 
         // Case 2 : database delete
         $actual = $this->transformations->clear('db');
-        $this->assertTrue($actual);
+        self::assertTrue($actual);
 
         // Case 3 : table delete
         $actual = $this->transformations->clear('db', 'table');
-        $this->assertTrue($actual);
+        self::assertTrue($actual);
 
         // Case 4 : column delete
         $actual = $this->transformations->clear('db', 'table', 'col');
-        $this->assertTrue($actual);
+        self::assertTrue($actual);
     }
 
     /**
@@ -247,7 +247,7 @@ class TransformationsTest extends AbstractTestCase
     #[DataProvider('fixupData')]
     public function testFixup(string $value, string $expected): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             $expected,
             $this->transformations->fixUpMime($value),
         );
@@ -274,7 +274,7 @@ class TransformationsTest extends AbstractTestCase
     #[DataProvider('providerGetDescription')]
     public function testGetDescription(string $file, string $expectedDescription): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             $expectedDescription,
             $this->transformations->getDescription($file),
         );
@@ -299,7 +299,7 @@ class TransformationsTest extends AbstractTestCase
     #[DataProvider('providerGetName')]
     public function testGetName(string $file, string $expectedName): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             $expectedName,
             $this->transformations->getName($file),
         );
diff --git a/tests/classes/Triggers/TriggerTest.php b/tests/classes/Triggers/TriggerTest.php
index 32304c9714..21afb3bf86 100644
--- a/tests/classes/Triggers/TriggerTest.php
+++ b/tests/classes/Triggers/TriggerTest.php
@@ -16,7 +16,7 @@ class TriggerTest extends TestCase
 {
     public function testTryFromArrayWithEmptyArray(): void
     {
-        $this->assertNull(Trigger::tryFromArray([]));
+        self::assertNull(Trigger::tryFromArray([]));
     }
 
     /** @param mixed[] $trigger */
@@ -24,13 +24,13 @@ class TriggerTest extends TestCase
     public function testTryFromArrayWithValidValues(array $trigger): void
     {
         $actual = Trigger::tryFromArray($trigger);
-        $this->assertNotNull($actual);
-        $this->assertSame('trigger_name', $actual->name->getName());
-        $this->assertSame(Timing::Before, $actual->timing);
-        $this->assertSame(Event::Update, $actual->event);
-        $this->assertSame('test_table', $actual->table->getName());
-        $this->assertSame('BEGIN END', $actual->statement);
-        $this->assertSame('definer@localhost', $actual->definer);
+        self::assertNotNull($actual);
+        self::assertSame('trigger_name', $actual->name->getName());
+        self::assertSame(Timing::Before, $actual->timing);
+        self::assertSame(Event::Update, $actual->event);
+        self::assertSame('test_table', $actual->table->getName());
+        self::assertSame('BEGIN END', $actual->statement);
+        self::assertSame('definer@localhost', $actual->definer);
     }
 
     /** @return iterable<array-key, array{mixed[]}> */
@@ -63,7 +63,7 @@ class TriggerTest extends TestCase
     #[DataProvider('arrayWithInvalidValuesProvider')]
     public function testTryFromArrayWithInvalidValues(array $trigger): void
     {
-        $this->assertNull(Trigger::tryFromArray($trigger));
+        self::assertNull(Trigger::tryFromArray($trigger));
     }
 
     /** @return iterable<array-key, array{mixed[]}> */
@@ -103,19 +103,19 @@ class TriggerTest extends TestCase
             'Definer' => 'definer@localhost',
         ]);
 
-        $this->assertNotNull($testTrigger);
+        self::assertNotNull($testTrigger);
 
-        $this->assertSame(
+        self::assertSame(
             'DROP TRIGGER IF EXISTS `a_trigger`',
             $testTrigger->getDropSql(),
         );
 
-        $this->assertSame(
+        self::assertSame(
             "CREATE TRIGGER `a_trigger` BEFORE UPDATE ON `test_table2`\n FOR EACH ROW BEGIN END\n//\n",
             $testTrigger->getCreateSql(),
         );
 
-        $this->assertSame(
+        self::assertSame(
             "CREATE TRIGGER `a_trigger` BEFORE UPDATE ON `test_table2`\n FOR EACH ROW BEGIN END\n$$\n",
             $testTrigger->getCreateSql('$$'),
         );
diff --git a/tests/classes/Triggers/TriggersTest.php b/tests/classes/Triggers/TriggersTest.php
index 333e221b2f..3c84cd9c67 100644
--- a/tests/classes/Triggers/TriggersTest.php
+++ b/tests/classes/Triggers/TriggersTest.php
@@ -70,8 +70,8 @@ class TriggersTest extends AbstractTestCase
         $_POST['item_table'] = $table;
         $_POST['item_definition'] = $definition;
 
-        $this->assertEquals($query, $this->triggers->getQueryFromRequest());
-        $this->assertCount($numErr, $GLOBALS['errors']);
+        self::assertEquals($query, $this->triggers->getQueryFromRequest());
+        self::assertCount($numErr, $GLOBALS['errors']);
     }
 
     /**
@@ -150,7 +150,7 @@ class TriggersTest extends AbstractTestCase
                 'Definer' => 'definer@localhost',
             ]),
         ];
-        $this->assertEquals($expected, $triggers);
+        self::assertEquals($expected, $triggers);
     }
 
     public function testGetDetails2(): void
@@ -174,7 +174,7 @@ class TriggersTest extends AbstractTestCase
                 'Definer' => 'definer2@localhost',
             ]),
         ];
-        $this->assertEquals($expected, $triggers);
+        self::assertEquals($expected, $triggers);
     }
 
     public function testGetDetails3(): void
@@ -200,7 +200,7 @@ class TriggersTest extends AbstractTestCase
                 'Definer' => 'definer@localhost',
             ]),
         ];
-        $this->assertEquals($expected, $triggers);
+        self::assertEquals($expected, $triggers);
     }
 
     public function testGetDetails4(): void
@@ -226,6 +226,6 @@ class TriggersTest extends AbstractTestCase
                 'Definer' => 'definer@localhost',
             ]),
         ];
-        $this->assertEquals($expected, $triggers);
+        self::assertEquals($expected, $triggers);
     }
 }
diff --git a/tests/classes/TwoFactorTest.php b/tests/classes/TwoFactorTest.php
index d189926d83..dfcb18c6e7 100644
--- a/tests/classes/TwoFactorTest.php
+++ b/tests/classes/TwoFactorTest.php
@@ -151,58 +151,58 @@ class TwoFactorTest extends AbstractTestCase
 
     public function testNone(): void
     {
-        $request = new ServerRequest($this->createStub(ServerRequestInterface::class));
+        $request = new ServerRequest(self::createStub(ServerRequestInterface::class));
         $object = $this->getTwoFactorAndLoadConfig('user', ['type' => 'db']);
         $backend = $object->getBackend();
-        $this->assertEquals('', $backend::$id);
+        self::assertEquals('', $backend::$id);
         // Is always valid
-        $this->assertTrue($object->check($request, true));
+        self::assertTrue($object->check($request, true));
         // Test session persistence
-        $this->assertTrue($object->check($request));
-        $this->assertTrue($object->check($request));
-        $this->assertEquals('', $object->render($request));
+        self::assertTrue($object->check($request));
+        self::assertTrue($object->check($request));
+        self::assertEquals('', $object->render($request));
 
         $this->dummyDbi->assertAllQueriesConsumed();
 
         $this->loadResultForConfig(['type' => 'db']);
         $this->loadQueriesForConfigure('');
 
-        $this->assertTrue($object->configure($request, ''));
-        $this->assertEquals('', $object->setup($request));
+        self::assertTrue($object->configure($request, ''));
+        self::assertEquals('', $object->setup($request));
     }
 
     public function testSimple(): void
     {
-        $request = new ServerRequest($this->createStub(ServerRequestInterface::class));
+        $request = new ServerRequest(self::createStub(ServerRequestInterface::class));
         $config = Config::getInstance();
         $config->settings['DBG']['simple2fa'] = true;
         $object = $this->getTwoFactorAndLoadConfig('user', ['type' => 'db', 'backend' => 'simple']);
         $backend = $object->getBackend();
-        $this->assertEquals('simple', $backend::$id);
+        self::assertEquals('simple', $backend::$id);
         $config->settings['DBG']['simple2fa'] = false;
 
         unset($_POST['2fa_confirm']);
-        $this->assertFalse($object->check($request, true));
+        self::assertFalse($object->check($request, true));
 
         $_POST['2fa_confirm'] = 1;
-        $this->assertTrue($object->check($request, true));
+        self::assertTrue($object->check($request, true));
         unset($_POST['2fa_confirm']);
 
         /* Test rendering */
-        $this->assertNotEquals('', $object->render($request));
-        $this->assertEquals('', $object->setup($request));
+        self::assertNotEquals('', $object->render($request));
+        self::assertEquals('', $object->setup($request));
     }
 
     public function testLoad(): void
     {
         $object = $this->getTwoFactorAndLoadConfig('user', null);
         $backend = $object->getBackend();
-        $this->assertEquals('', $backend::$id);
+        self::assertEquals('', $backend::$id);
     }
 
     public function testConfigureSimple(): void
     {
-        $request = new ServerRequest($this->createStub(ServerRequestInterface::class));
+        $request = new ServerRequest(self::createStub(ServerRequestInterface::class));
         $config = Config::getInstance();
         $config->settings['DBG']['simple2fa'] = true;
         $object = $this->getTwoFactorAndLoadConfig('user', null);
@@ -212,18 +212,18 @@ class TwoFactorTest extends AbstractTestCase
         $this->loadResultForConfig([]);
         $this->loadQueriesForConfigure('simple');
 
-        $this->assertTrue($object->configure($request, 'simple'));
+        self::assertTrue($object->configure($request, 'simple'));
         $backend = $object->getBackend();
-        $this->assertEquals('simple', $backend::$id);
+        self::assertEquals('simple', $backend::$id);
 
         $this->dummyDbi->assertAllQueriesConsumed();
 
         $this->loadResultForConfig([]);
         $this->loadQueriesForConfigure('');
 
-        $this->assertTrue($object->configure($request, ''));
+        self::assertTrue($object->configure($request, ''));
         $backend = $object->getBackend();
-        $this->assertEquals('', $backend::$id);
+        self::assertEquals('', $backend::$id);
 
         $this->dummyDbi->assertAllQueriesConsumed();
 
@@ -231,7 +231,7 @@ class TwoFactorTest extends AbstractTestCase
 
         $config->settings['DBG']['simple2fa'] = false;
         $object = $this->getTwoFactorAndLoadConfig('user', null);
-        $this->assertFalse($object->configure($request, 'simple'));
+        self::assertFalse($object->configure($request, 'simple'));
         $this->dummyDbi->assertAllQueriesConsumed();
     }
 
@@ -242,20 +242,20 @@ class TwoFactorTest extends AbstractTestCase
     {
         parent::setLanguage();
 
-        $request = new ServerRequest($this->createStub(ServerRequestInterface::class));
+        $request = new ServerRequest(self::createStub(ServerRequestInterface::class));
 
         $object = $this->getTwoFactorAndLoadConfig('user', null);
         if (! in_array('application', $object->getAvailable(), true)) {
-            $this->markTestSkipped('google2fa not available');
+            self::markTestSkipped('google2fa not available');
         }
 
         /* Without providing code this should fail */
         unset($_POST['2fa_code']);
-        $this->assertFalse($object->configure($request, 'application'));
+        self::assertFalse($object->configure($request, 'application'));
 
         /* Invalid code */
         $_POST['2fa_code'] = 'invalid';
-        $this->assertFalse($object->configure($request, 'application'));
+        self::assertFalse($object->configure($request, 'application'));
 
         /* Generate valid code */
         /** @var Application $app */
@@ -270,67 +270,67 @@ class TwoFactorTest extends AbstractTestCase
         $this->loadResultForConfig([]);
         $this->loadQueriesForConfigure('application', ['secret' => $object->config['settings']['secret']]);
 
-        $this->assertTrue($object->configure($request, 'application'));
+        self::assertTrue($object->configure($request, 'application'));
 
         $this->dummyDbi->assertAllQueriesConsumed();
         unset($_POST['2fa_code']);
 
         /* Check code */
         unset($_POST['2fa_code']);
-        $this->assertFalse($object->check($request, true));
+        self::assertFalse($object->check($request, true));
         $_POST['2fa_code'] = 'invalid';
-        $this->assertFalse($object->check($request, true));
+        self::assertFalse($object->check($request, true));
         $_POST['2fa_code'] = $google2fa->oathTotp(
             $object->config['settings']['secret'],
             $google2fa->getTimestamp(),
         );
-        $this->assertTrue($object->check($request, true));
+        self::assertTrue($object->check($request, true));
         unset($_POST['2fa_code']);
 
         /* Test rendering */
-        $this->assertNotEquals('', $object->render($request));
-        $this->assertNotEquals('', $object->setup($request));
+        self::assertNotEquals('', $object->render($request));
+        self::assertNotEquals('', $object->setup($request));
     }
 
     public function testKey(): void
     {
         parent::setLanguage();
 
-        $request = new ServerRequest($this->createStub(ServerRequestInterface::class));
+        $request = new ServerRequest(self::createStub(ServerRequestInterface::class));
 
         $object = $this->getTwoFactorAndLoadConfig('user', null);
         if (! in_array('key', $object->getAvailable(), true)) {
-            $this->markTestSkipped('u2f-php-server not available');
+            self::markTestSkipped('u2f-php-server not available');
         }
 
         $_SESSION['registrationRequest'] = null;
         /* Without providing code this should fail */
         unset($_POST['u2f_registration_response']);
-        $this->assertFalse($object->configure($request, 'key'));
+        self::assertFalse($object->configure($request, 'key'));
 
         /* Invalid code */
         $_POST['u2f_registration_response'] = 'invalid';
-        $this->assertFalse($object->configure($request, 'key'));
+        self::assertFalse($object->configure($request, 'key'));
 
         /* Invalid code */
         $_POST['u2f_registration_response'] = '[]';
-        $this->assertFalse($object->configure($request, 'key'));
+        self::assertFalse($object->configure($request, 'key'));
 
         /* Without providing code this should fail */
         unset($_POST['u2f_authentication_response']);
-        $this->assertFalse($object->check($request, true));
+        self::assertFalse($object->check($request, true));
 
         /* Invalid code */
         $_POST['u2f_authentication_response'] = 'invalid';
-        $this->assertFalse($object->check($request, true));
+        self::assertFalse($object->check($request, true));
 
         /* Invalid code */
         $_POST['u2f_authentication_response'] = '[]';
-        $this->assertFalse($object->check($request, true));
+        self::assertFalse($object->check($request, true));
 
         /* Test rendering */
-        $this->assertNotEquals('', $object->render($request));
-        $this->assertNotEquals('', $object->setup($request));
+        self::assertNotEquals('', $object->render($request));
+        self::assertNotEquals('', $object->setup($request));
     }
 
     /**
@@ -341,19 +341,19 @@ class TwoFactorTest extends AbstractTestCase
         $config = Config::getInstance();
         $object = $this->getTwoFactorAndLoadConfig('user', null);
         $config->set('PmaAbsoluteUri', 'http://demo.example.com');
-        $this->assertEquals('http://demo.example.com', $object->getBackend()->getAppId(true));
-        $this->assertEquals('demo.example.com', $object->getBackend()->getAppId(false));
+        self::assertEquals('http://demo.example.com', $object->getBackend()->getAppId(true));
+        self::assertEquals('demo.example.com', $object->getBackend()->getAppId(false));
         $config->set('PmaAbsoluteUri', 'https://demo.example.com:123');
-        $this->assertEquals('https://demo.example.com:123', $object->getBackend()->getAppId(true));
-        $this->assertEquals('demo.example.com', $object->getBackend()->getAppId(false));
+        self::assertEquals('https://demo.example.com:123', $object->getBackend()->getAppId(true));
+        self::assertEquals('demo.example.com', $object->getBackend()->getAppId(false));
         $config->set('PmaAbsoluteUri', '');
         $config->set('is_https', true);
         $_SERVER['HTTP_HOST'] = 'pma.example.com';
-        $this->assertEquals('https://pma.example.com', $object->getBackend()->getAppId(true));
-        $this->assertEquals('pma.example.com', $object->getBackend()->getAppId(false));
+        self::assertEquals('https://pma.example.com', $object->getBackend()->getAppId(true));
+        self::assertEquals('pma.example.com', $object->getBackend()->getAppId(false));
         $config->set('is_https', false);
-        $this->assertEquals('http://pma.example.com', $object->getBackend()->getAppId(true));
-        $this->assertEquals('pma.example.com', $object->getBackend()->getAppId(false));
+        self::assertEquals('http://pma.example.com', $object->getBackend()->getAppId(true));
+        self::assertEquals('pma.example.com', $object->getBackend()->getAppId(false));
     }
 
     /**
@@ -362,11 +362,11 @@ class TwoFactorTest extends AbstractTestCase
      */
     public function testKeyAuthentication(): void
     {
-        $request = new ServerRequest($this->createStub(ServerRequestInterface::class));
+        $request = new ServerRequest(self::createStub(ServerRequestInterface::class));
 
         $object = $this->getTwoFactorAndLoadConfig('user', null);
         if (! in_array('key', $object->getAvailable(), true)) {
-            $this->markTestSkipped('u2f-php-server not available');
+            self::markTestSkipped('u2f-php-server not available');
         }
 
         $_SESSION['registrationRequest'] = new RegistrationRequest(
@@ -374,10 +374,10 @@ class TwoFactorTest extends AbstractTestCase
             'http://demo.example.com',
         );
         unset($_POST['u2f_registration_response']);
-        $this->assertFalse($object->configure($request, 'key'));
+        self::assertFalse($object->configure($request, 'key'));
 
         $_POST['u2f_registration_response'] = '';
-        $this->assertFalse($object->configure($request, 'key'));
+        self::assertFalse($object->configure($request, 'key'));
 
         $_POST['u2f_registration_response'] = '{ "registrationData": "BQQtEmhWVgvbh-8GpjsHbj_d5F'
             . 'B9iNoRL8mNEq34-ANufKWUpVdIj6BSB_m3eMoZ3GqnaDy3RA5eWP8mhTkT1Ht3QAk1GsmaPIQgXgvrBk'
@@ -426,13 +426,13 @@ class TwoFactorTest extends AbstractTestCase
             ],
         ]);
 
-        $this->assertTrue($object->configure($request, 'key'));
+        self::assertTrue($object->configure($request, 'key'));
 
         unset($_POST['u2f_authentication_response']);
-        $this->assertFalse($object->check($request, true));
+        self::assertFalse($object->check($request, true));
 
         $_POST['u2f_authentication_response'] = '';
-        $this->assertFalse($object->check($request, true));
+        self::assertFalse($object->check($request, true));
 
         $_SESSION['authenticationRequest'] = [
             new SignRequest([
@@ -441,7 +441,7 @@ class TwoFactorTest extends AbstractTestCase
                 'appId' => 'http://demo.example.com',
             ]),
         ];
-        $this->assertFalse($object->check($request, true));
+        self::assertFalse($object->check($request, true));
         $_POST['u2f_authentication_response'] = '{ "signatureData": "AQAAAAQwRQIhAI6FSrMD3KUUtkpiP0'
             . 'jpIEakql-HNhwWFngyw553pS1CAiAKLjACPOhxzZXuZsVO8im-HStEcYGC50PKhsGp_SUAng==", '
             . '"clientData": "eyAiY2hhbGxlbmdlIjogImZFbmM5b1Y3OUVhQmdLNUJvTkVSVTVnUEtNMlhHWVd'
@@ -474,7 +474,7 @@ class TwoFactorTest extends AbstractTestCase
                 ],
             ],
         ]);
-        $this->assertTrue($object->check($request, true));
+        self::assertTrue($object->check($request, true));
         $this->dummyDbi->assertAllQueriesConsumed();
     }
 
@@ -487,7 +487,7 @@ class TwoFactorTest extends AbstractTestCase
         $config->settings['DBG']['simple2fa'] = true;
         $object = $this->getTwoFactorAndLoadConfig('user', null);
         $backends = $object->getAllBackends();
-        $this->assertCount(
+        self::assertCount(
             count($object->getAvailable()) + 1,
             $backends,
         );
diff --git a/tests/classes/TypesByDatabaseVersionTest.php b/tests/classes/TypesByDatabaseVersionTest.php
index 118a8d71cb..4738c4a18b 100644
--- a/tests/classes/TypesByDatabaseVersionTest.php
+++ b/tests/classes/TypesByDatabaseVersionTest.php
@@ -25,7 +25,7 @@ class TypesByDatabaseVersionTest extends AbstractTestCase
     {
         parent::setUp();
 
-        $this->dbiStub = $this->createStub(DatabaseInterface::class);
+        $this->dbiStub = self::createStub(DatabaseInterface::class);
     }
 
     /**
@@ -62,7 +62,7 @@ class TypesByDatabaseVersionTest extends AbstractTestCase
         $result = $this->object->getFunctionsClass($class);
 
         foreach ($includes as $value) {
-            $this->assertContains($value, $result);
+            self::assertContains($value, $result);
         }
 
         if ($excludes === []) {
@@ -70,7 +70,7 @@ class TypesByDatabaseVersionTest extends AbstractTestCase
         }
 
         foreach ($excludes as $value) {
-            $this->assertNotContains($value, $result);
+            self::assertNotContains($value, $result);
         }
     }
 
@@ -279,7 +279,7 @@ class TypesByDatabaseVersionTest extends AbstractTestCase
         $result = $this->object->getFunctions('enum');
 
         foreach ($includes as $value) {
-            $this->assertContains($value, $result);
+            self::assertContains($value, $result);
         }
 
         if ($excludes === []) {
@@ -287,7 +287,7 @@ class TypesByDatabaseVersionTest extends AbstractTestCase
         }
 
         foreach ($excludes as $value) {
-            $this->assertNotContains($value, $result);
+            self::assertNotContains($value, $result);
         }
     }
 
@@ -352,7 +352,7 @@ class TypesByDatabaseVersionTest extends AbstractTestCase
         $result = $this->object->getAllFunctions();
 
         foreach ($includes as $value) {
-            $this->assertContains($value, $result);
+            self::assertContains($value, $result);
         }
 
         if ($excludes === []) {
@@ -360,7 +360,7 @@ class TypesByDatabaseVersionTest extends AbstractTestCase
         }
 
         foreach ($excludes as $value) {
-            $this->assertNotContains($value, $result);
+            self::assertNotContains($value, $result);
         }
     }
 
@@ -606,7 +606,7 @@ class TypesByDatabaseVersionTest extends AbstractTestCase
     {
         $this->createObject($database, $dbVersion);
 
-        $this->assertEquals($expected, $this->object->getColumns());
+        self::assertEquals($expected, $this->object->getColumns());
     }
 
     /**
diff --git a/tests/classes/TypesTest.php b/tests/classes/TypesTest.php
index a34e5b7b15..7e379b74ef 100644
--- a/tests/classes/TypesTest.php
+++ b/tests/classes/TypesTest.php
@@ -31,8 +31,8 @@ class TypesTest extends AbstractTestCase
      */
     public function testUnary(): void
     {
-        $this->assertTrue($this->object->isUnaryOperator('IS NULL'));
-        $this->assertFalse($this->object->isUnaryOperator('='));
+        self::assertTrue($this->object->isUnaryOperator('IS NULL'));
+        self::assertFalse($this->object->isUnaryOperator('='));
     }
 
     /**
@@ -40,7 +40,7 @@ class TypesTest extends AbstractTestCase
      */
     public function testGetUnaryOperators(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             ['IS NULL', 'IS NOT NULL', "= ''", "!= ''"],
             $this->object->getUnaryOperators(),
         );
@@ -51,7 +51,7 @@ class TypesTest extends AbstractTestCase
      */
     public function testGetNullOperators(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             ['IS NULL', 'IS NOT NULL'],
             $this->object->getNullOperators(),
         );
@@ -62,7 +62,7 @@ class TypesTest extends AbstractTestCase
      */
     public function testGetEnumOperators(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             ['=', '!='],
             $this->object->getEnumOperators(),
         );
@@ -73,7 +73,7 @@ class TypesTest extends AbstractTestCase
      */
     public function testgetTextOperators(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             [
                 'LIKE',
                 'LIKE %...%',
@@ -100,7 +100,7 @@ class TypesTest extends AbstractTestCase
      */
     public function testGetNumberOperators(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             [
                 '=',
                 '>',
@@ -126,7 +126,7 @@ class TypesTest extends AbstractTestCase
      */
     public function testGetUUIDOperators(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             ['=', '!=', 'LIKE', 'LIKE %...%', 'NOT LIKE', 'NOT LIKE %...%', 'IN (...)', 'NOT IN (...)'],
             $this->object->getUUIDOperators(),
         );
@@ -142,7 +142,7 @@ class TypesTest extends AbstractTestCase
     #[DataProvider('providerForGetTypeOperators')]
     public function testGetTypeOperators(string $type, bool $null, string|array $output): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             $output,
             $this->object->getTypeOperators($type, $null),
         );
@@ -239,7 +239,7 @@ class TypesTest extends AbstractTestCase
         string $selectedOperator,
         string $output,
     ): void {
-        $this->assertEquals(
+        self::assertEquals(
             $output,
             $this->object->getTypeOperatorsHtml($type, $null, $selectedOperator),
         );
@@ -265,7 +265,7 @@ class TypesTest extends AbstractTestCase
     #[DataProvider('providerForTestGetTypeDescription')]
     public function testGetTypeDescription(string $type): void
     {
-        $this->assertNotEquals(
+        self::assertNotEquals(
             '',
             $this->object->getTypeDescription($type),
         );
@@ -276,7 +276,7 @@ class TypesTest extends AbstractTestCase
      */
     public function testGetUnknownTypeDescription(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             '',
             $this->object->getTypeDescription('UNKNOWN'),
         );
@@ -342,7 +342,7 @@ class TypesTest extends AbstractTestCase
     #[DataProvider('providerFortTestGetFunctionsClass')]
     public function testGetFunctionsClass(string $class, array $output): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             $output,
             $this->object->getFunctionsClass($class),
         );
@@ -501,7 +501,7 @@ class TypesTest extends AbstractTestCase
      */
     public function testGetFunctions(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             [
                 'AES_DECRYPT',
                 'AES_ENCRYPT',
@@ -548,7 +548,7 @@ class TypesTest extends AbstractTestCase
      */
     public function testGetAllFunctions(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             [
                 'ABS',
                 'ACOS',
@@ -678,7 +678,7 @@ class TypesTest extends AbstractTestCase
      */
     public function testGetAttributes(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             ['', 'BINARY', 'UNSIGNED', 'UNSIGNED ZEROFILL', 'on update CURRENT_TIMESTAMP'],
             $this->object->getAttributes(),
         );
@@ -689,7 +689,7 @@ class TypesTest extends AbstractTestCase
      */
     public function testGetColumns(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             [
                 0 => 'INT',
                 1 => 'VARCHAR',
@@ -755,7 +755,7 @@ class TypesTest extends AbstractTestCase
     #[DataProvider('providerFortTestGetTypeClass')]
     public function testGetTypeClass(string $type, string $output): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             $output,
             $this->object->getTypeClass($type),
         );
diff --git a/tests/classes/UniqueConditionTest.php b/tests/classes/UniqueConditionTest.php
index 13865ff1e6..1208cca47f 100644
--- a/tests/classes/UniqueConditionTest.php
+++ b/tests/classes/UniqueConditionTest.php
@@ -34,14 +34,14 @@ class UniqueConditionTest extends AbstractTestCase
         Config::getInstance()->selectedServer['DisableIS'] = false;
 
         $actual = new UniqueCondition([], []);
-        $this->assertEquals(['', false, []], [
+        self::assertEquals(['', false, []], [
             $actual->getWhereClause(),
             $actual->isClauseUnique(),
             $actual->getConditionArray(),
         ]);
 
         $actual = new UniqueCondition([], [], true);
-        $this->assertEquals(['', true, []], [
+        self::assertEquals(['', true, []], [
             $actual->getWhereClause(),
             $actual->isClauseUnique(),
             $actual->getConditionArray(),
@@ -149,7 +149,7 @@ class UniqueConditionTest extends AbstractTestCase
             'value',
             0x1,
         ], false, 'table');
-        $this->assertEquals(
+        self::assertEquals(
             [
                 '`table`.`field1` IS NULL AND `table`.`field2` = \'value\\\'s\' AND `table`.`field3` = 123456'
                 . ' AND `table`.`field4` = 123.456 AND `table`.`field5` = CAST(0x76616c7565 AS BINARY)'
@@ -188,7 +188,7 @@ class UniqueConditionTest extends AbstractTestCase
         ];
 
         $actual = new UniqueCondition($meta, [str_repeat('*', 1001)]);
-        $this->assertEquals(
+        self::assertEquals(
             ['CHAR_LENGTH(`table`.`field`)  = 1001', false, ['`table`.`field`' => ' = 1001']],
             [$actual->getWhereClause(), $actual->isClauseUnique(), $actual->getConditionArray()],
         );
@@ -215,7 +215,7 @@ class UniqueConditionTest extends AbstractTestCase
         ];
 
         $actual = new UniqueCondition($meta, [1, 'value']);
-        $this->assertEquals(['`table`.`id` = 1', true, ['`table`.`id`' => '= 1']], [
+        self::assertEquals(['`table`.`id` = 1', true, ['`table`.`id`' => '= 1']], [
             $actual->getWhereClause(),
             $actual->isClauseUnique(),
             $actual->getConditionArray(),
@@ -243,7 +243,7 @@ class UniqueConditionTest extends AbstractTestCase
         ];
 
         $actual = new UniqueCondition($meta, ['unique', 'value']);
-        $this->assertEquals(['`table`.`id` = \'unique\'', true, ['`table`.`id`' => '= \'unique\'']], [
+        self::assertEquals(['`table`.`id` = \'unique\'', true, ['`table`.`id`' => '= \'unique\'']], [
             $actual->getWhereClause(),
             $actual->isClauseUnique(),
             $actual->getConditionArray(),
@@ -267,7 +267,7 @@ class UniqueConditionTest extends AbstractTestCase
 
         $actual = new UniqueCondition($meta, $row);
 
-        $this->assertEquals($expected, [
+        self::assertEquals($expected, [
             $actual->getWhereClause(),
             $actual->isClauseUnique(),
             $actual->getConditionArray(),
diff --git a/tests/classes/UrlTest.php b/tests/classes/UrlTest.php
index 5ec26a75be..b6a3391d56 100644
--- a/tests/classes/UrlTest.php
+++ b/tests/classes/UrlTest.php
@@ -51,7 +51,7 @@ class UrlTest extends AbstractTestCase
         $expected = '?db=db'
             . $separator . $expected;
 
-        $this->assertEquals($expected, Url::getCommon(['db' => 'db']));
+        self::assertEquals($expected, Url::getCommon(['db' => 'db']));
     }
 
     /**
@@ -69,7 +69,7 @@ class UrlTest extends AbstractTestCase
             . $separator . 'table=table'
             . $separator . $expected;
         $params = ['db' => 'db', 'table' => 'table'];
-        $this->assertEquals($expected, Url::getCommon($params));
+        self::assertEquals($expected, Url::getCommon($params));
     }
 
     /**
@@ -85,7 +85,7 @@ class UrlTest extends AbstractTestCase
 
         $expected = '#ABC#db=db' . $separator . 'table=table' . $separator
             . $expected;
-        $this->assertEquals(
+        self::assertEquals(
             $expected,
             Url::getCommonRaw(
                 ['db' => 'db', 'table' => 'table'],
@@ -104,7 +104,7 @@ class UrlTest extends AbstractTestCase
 
         $separator = Url::getArgSeparator();
         $expected = '?server=2' . $separator . 'lang=en';
-        $this->assertEquals($expected, Url::getCommon());
+        self::assertEquals($expected, Url::getCommon());
     }
 
     /**
@@ -118,7 +118,7 @@ class UrlTest extends AbstractTestCase
             'field' => '%1\$s',
             'change_column' => 1,
         ]);
-        $this->assertEquals(
+        self::assertEquals(
             'index.php?route=/test&db=%253%5C%24s&table=%252%5C%24s&field=%251%5C%24s&change_column=1&lang=en',
             $generatedUrl,
         );
@@ -137,9 +137,9 @@ class UrlTest extends AbstractTestCase
         ]);
         $expectedUrl = 'index.php?route=/test&db=%26test%3D_database%3D'
         . '&table=%26test%3D_database%3D&field=%26test%3D_database%3D&change_column=1&lang=en';
-        $this->assertEquals($expectedUrl, $generatedUrl);
+        self::assertEquals($expectedUrl, $generatedUrl);
 
-        $this->assertEquals(
+        self::assertEquals(
             'index.php?route=/test&db=&test=_database=&table=&'
             . 'test=_database=&field=&test=_database=&change_column=1&lang=en',
             urldecode(
@@ -161,7 +161,7 @@ class UrlTest extends AbstractTestCase
             'book' => false,
             'worm' => false,
         ]);
-        $this->assertEquals(
+        self::assertEquals(
             'index.php?route=/test&db=%3Cscript+src%3D%22https%3A%2F%2Fdomain.tld%2Fsvn'
             . '%2Ftrunk%2Fhtml5.js%22%3E%3C%2Fscript%3E&table=%3Cscript+src%3D%22'
             . 'https%3A%2F%2Fdomain.tld%2Fmaybeweshouldusegit%2Ftrunk%2Fhtml5.js%22%3E%3C%2F'
@@ -173,10 +173,10 @@ class UrlTest extends AbstractTestCase
     public function testGetHiddenFields(): void
     {
         $_SESSION = [];
-        $this->assertSame('', Url::getHiddenFields([]));
+        self::assertSame('', Url::getHiddenFields([]));
 
         $_SESSION = [' PMA_token ' => '<b>token</b>'];
-        $this->assertSame(
+        self::assertSame(
             '<input type="hidden" name="token" value="&lt;b&gt;token&lt;/b&gt;">',
             Url::getHiddenFields([]),
         );
@@ -186,7 +186,7 @@ class UrlTest extends AbstractTestCase
     {
         Config::getInstance()->set('URLQueryEncryption', false);
         $params = ['db' => 'test_db', 'table' => 'test_table', 'pos' => 0];
-        $this->assertEquals('db=test_db&table=test_table&pos=0', Url::buildHttpQuery($params));
+        self::assertEquals('db=test_db&table=test_table&pos=0', Url::buildHttpQuery($params));
     }
 
     public function testBuildHttpQueryWithUrlQueryEncryptionEnabled(): void
@@ -198,18 +198,18 @@ class UrlTest extends AbstractTestCase
 
         $params = ['db' => 'test_db', 'table' => 'test_table', 'pos' => 0];
         $query = Url::buildHttpQuery($params);
-        $this->assertStringStartsWith('pos=0&eq=', $query);
+        self::assertStringStartsWith('pos=0&eq=', $query);
         parse_str($query, $queryParams);
-        $this->assertCount(2, $queryParams);
-        $this->assertSame('0', $queryParams['pos']);
-        $this->assertTrue(is_string($queryParams['eq']));
-        $this->assertNotSame('', $queryParams['eq']);
-        $this->assertMatchesRegularExpression('/^[a-zA-Z0-9-_=]+$/', $queryParams['eq']);
+        self::assertCount(2, $queryParams);
+        self::assertSame('0', $queryParams['pos']);
+        self::assertTrue(is_string($queryParams['eq']));
+        self::assertNotSame('', $queryParams['eq']);
+        self::assertMatchesRegularExpression('/^[a-zA-Z0-9-_=]+$/', $queryParams['eq']);
 
         $decrypted = Url::decryptQuery($queryParams['eq']);
-        $this->assertNotNull($decrypted);
-        $this->assertJson($decrypted);
-        $this->assertSame('{"db":"test_db","table":"test_table"}', $decrypted);
+        self::assertNotNull($decrypted);
+        self::assertJson($decrypted);
+        self::assertSame('{"db":"test_db","table":"test_table"}', $decrypted);
     }
 
     public function testQueryEncryption(): void
@@ -221,12 +221,12 @@ class UrlTest extends AbstractTestCase
 
         $query = '{"db":"test_db","table":"test_table"}';
         $encrypted = Url::encryptQuery($query);
-        $this->assertNotSame($query, $encrypted);
-        $this->assertNotSame('', $encrypted);
-        $this->assertMatchesRegularExpression('/^[a-zA-Z0-9-_=]+$/', $encrypted);
+        self::assertNotSame($query, $encrypted);
+        self::assertNotSame('', $encrypted);
+        self::assertMatchesRegularExpression('/^[a-zA-Z0-9-_=]+$/', $encrypted);
 
         $decrypted = Url::decryptQuery($encrypted);
-        $this->assertSame($query, $decrypted);
+        self::assertSame($query, $decrypted);
     }
 
     /** @param string|false $iniValue */
diff --git a/tests/classes/UserPasswordTest.php b/tests/classes/UserPasswordTest.php
index 5ce7c0f9a2..c15208de34 100644
--- a/tests/classes/UserPasswordTest.php
+++ b/tests/classes/UserPasswordTest.php
@@ -38,7 +38,7 @@ class UserPasswordTest extends AbstractTestCase
         );
         $this->object = new UserPassword(
             $serverPrivileges,
-            $this->createStub(AuthenticationPluginFactory::class),
+            self::createStub(AuthenticationPluginFactory::class),
             $dbi,
         );
     }
@@ -51,7 +51,7 @@ class UserPasswordTest extends AbstractTestCase
         string $password,
         string $passwordConfirmation,
     ): void {
-        $this->assertEquals(
+        self::assertEquals(
             ['error' => $error, 'msg' => $message],
             $this->object->setChangePasswordMsg(
                 $password,
diff --git a/tests/classes/UserPreferencesTest.php b/tests/classes/UserPreferencesTest.php
index 0ae3d092af..24776a9eae 100644
--- a/tests/classes/UserPreferencesTest.php
+++ b/tests/classes/UserPreferencesTest.php
@@ -54,7 +54,7 @@ class UserPreferencesTest extends AbstractTestCase
         $userPreferences = new UserPreferences($dbi, new Relation($dbi), new Template());
         $userPreferences->pageInit(new ConfigFile());
 
-        $this->assertEquals(
+        self::assertEquals(
             ['Servers' => [1 => ['hide_db' => 'testval123']]],
             $_SESSION['ConfigFile' . Current::$server],
         );
@@ -74,21 +74,21 @@ class UserPreferencesTest extends AbstractTestCase
         $userPreferences = new UserPreferences($dbi1, new Relation($dbi1), new Template());
         $result = $userPreferences->load();
 
-        $this->assertCount(3, $result);
+        self::assertCount(3, $result);
 
-        $this->assertEquals(
+        self::assertEquals(
             [],
             $result['config_data'],
         );
 
-        $this->assertEqualsWithDelta(
+        self::assertEqualsWithDelta(
             time(),
             $result['mtime'],
             2,
             '',
         );
 
-        $this->assertEquals('session', $result['type']);
+        self::assertEquals('session', $result['type']);
 
         // case 2
         $relationParameters = RelationParameters::fromArray([
@@ -106,18 +106,18 @@ class UserPreferencesTest extends AbstractTestCase
         $query = 'SELECT `config_data`, UNIX_TIMESTAMP(`timevalue`) ts '
             . 'FROM `pma\'db`.`testconf` WHERE `username` = \'user\'';
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('fetchSingleRow')
             ->with($query, DatabaseInterface::FETCH_ASSOC, ConnectionType::ControlUser)
             ->willReturn(['ts' => '123', 'config_data' => json_encode([1, 2])]);
-        $dbi->expects($this->any())
+        $dbi->expects(self::any())
             ->method('quoteString')
             ->willReturnCallback(static fn (string $string): string => "'" . $string . "'");
 
         $userPreferences = new UserPreferences($dbi, new Relation($dbi), new Template());
         $result = $userPreferences->load();
 
-        $this->assertEquals(
+        self::assertEquals(
             ['config_data' => [1, 2], 'mtime' => 123, 'type' => 'db'],
             $result,
         );
@@ -138,17 +138,17 @@ class UserPreferencesTest extends AbstractTestCase
         $userPreferences = new UserPreferences($dbi1, new Relation($dbi1), new Template());
         $result = $userPreferences->save([1]);
 
-        $this->assertTrue($result);
+        self::assertTrue($result);
 
-        $this->assertCount(2, $_SESSION['userconfig']);
+        self::assertCount(2, $_SESSION['userconfig']);
 
-        $this->assertEquals(
+        self::assertEquals(
             [1],
             $_SESSION['userconfig']['db'],
         );
 
         /* TODO: This breaks sometimes as there might be time difference! */
-        $this->assertEqualsWithDelta(
+        self::assertEqualsWithDelta(
             time(),
             $_SESSION['userconfig']['ts'],
             2,
@@ -161,7 +161,7 @@ class UserPreferencesTest extends AbstractTestCase
             $assert = false;
         }
 
-        $this->assertTrue($assert);
+        self::assertTrue($assert);
 
         // case 2
         $relationParameters = RelationParameters::fromArray([
@@ -181,24 +181,24 @@ class UserPreferencesTest extends AbstractTestCase
             ->disableOriginalConstructor()
             ->getMock();
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('fetchValue')
             ->with($query1, 0, ConnectionType::ControlUser)
             ->willReturn('1');
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('tryQuery')
             ->with($query2, ConnectionType::ControlUser)
-            ->willReturn($this->createStub(DummyResult::class));
+            ->willReturn(self::createStub(DummyResult::class));
 
-        $dbi->expects($this->any())
+        $dbi->expects(self::any())
             ->method('quoteString')
             ->willReturnCallback(static fn (string $string): string => "'" . $string . "'");
 
         $userPreferences = new UserPreferences($dbi, new Relation($dbi1), new Template());
         $result = $userPreferences->save([1]);
 
-        $this->assertTrue($result);
+        self::assertTrue($result);
 
         // case 3
 
@@ -211,29 +211,29 @@ class UserPreferencesTest extends AbstractTestCase
             ->disableOriginalConstructor()
             ->getMock();
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('fetchValue')
             ->with($query1, 0, ConnectionType::ControlUser)
             ->willReturn(false);
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('tryQuery')
             ->with($query2, ConnectionType::ControlUser)
             ->willReturn(false);
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('getError')
             ->with(ConnectionType::ControlUser)
             ->willReturn('err1');
-        $dbi->expects($this->any())
+        $dbi->expects(self::any())
             ->method('quoteString')
             ->willReturnCallback(static fn (string $string): string => "'" . $string . "'");
 
         $userPreferences = new UserPreferences($dbi, new Relation($dbi1), new Template());
         $result = $userPreferences->save([1]);
 
-        $this->assertInstanceOf(Message::class, $result);
-        $this->assertEquals(
+        self::assertInstanceOf(Message::class, $result);
+        self::assertEquals(
             'Could not save configuration<br><br>err1'
             . '<br><br>The phpMyAdmin configuration storage database could not be accessed.',
             $result->getMessage(),
@@ -261,7 +261,7 @@ class UserPreferencesTest extends AbstractTestCase
             ],
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             ['Server' => ['hide_db' => 1]],
             $result,
         );
@@ -280,7 +280,7 @@ class UserPreferencesTest extends AbstractTestCase
             ['DBG/sql' => true],
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             ['DBG' => ['sql' => true]],
             $result,
         );
@@ -302,15 +302,15 @@ class UserPreferencesTest extends AbstractTestCase
 
         $dbi = DatabaseInterface::getInstance();
         $userPreferences = new UserPreferences($dbi, new Relation($dbi), new Template());
-        $this->assertTrue(
+        self::assertTrue(
             $userPreferences->persistOption('Server/hide_db', 'val', 'val'),
         );
 
-        $this->assertTrue(
+        self::assertTrue(
             $userPreferences->persistOption('Server/hide_db', 'val2', 'val'),
         );
 
-        $this->assertTrue(
+        self::assertTrue(
             $userPreferences->persistOption('Server/hide_db2', 'val', 'val'),
         );
     }
@@ -336,8 +336,8 @@ class UserPreferencesTest extends AbstractTestCase
         );
 
         $response = $responseStub->getResponse();
-        $this->assertSame(['/phpmyadmin/file.html?a=b&saved=1&server=2#h+ash'], $response->getHeader('Location'));
-        $this->assertSame(302, $response->getStatusCode());
+        self::assertSame(['/phpmyadmin/file.html?a=b&saved=1&server=2#h+ash'], $response->getHeader('Location'));
+        self::assertSame(302, $response->getStatusCode());
     }
 
     /**
@@ -350,28 +350,28 @@ class UserPreferencesTest extends AbstractTestCase
 
         $dbi = DatabaseInterface::getInstance();
         $userPreferences = new UserPreferences($dbi, new Relation($dbi), new Template());
-        $this->assertEquals(
+        self::assertEquals(
             '',
             $userPreferences->autoloadGetHeader(),
         );
 
-        $this->assertTrue($_SESSION['userprefs_autoload']);
+        self::assertTrue($_SESSION['userprefs_autoload']);
 
         $_REQUEST['prefs_autoload'] = 'nohide';
         Config::getInstance()->settings['ServerDefault'] = 1;
         $result = $userPreferences->autoloadGetHeader();
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             '<form action="' . Url::getFromRoute('/preferences/manage') . '" method="post" class="disableAjax">',
             $result,
         );
 
-        $this->assertStringContainsString('<input type="hidden" name="token" value="token"', $result);
+        self::assertStringContainsString('<input type="hidden" name="token" value="token"', $result);
 
-        $this->assertStringContainsString('<input type="hidden" name="json" value="">', $result);
+        self::assertStringContainsString('<input type="hidden" name="json" value="">', $result);
 
-        $this->assertStringContainsString('<input type="hidden" name="submit_import" value="1">', $result);
+        self::assertStringContainsString('<input type="hidden" name="submit_import" value="1">', $result);
 
-        $this->assertStringContainsString('<input type="hidden" name="return_url" value="?">', $result);
+        self::assertStringContainsString('<input type="hidden" name="return_url" value="?">', $result);
     }
 }
diff --git a/tests/classes/UtilTest.php b/tests/classes/UtilTest.php
index 82e42a979f..9d4d7c98a5 100644
--- a/tests/classes/UtilTest.php
+++ b/tests/classes/UtilTest.php
@@ -47,7 +47,7 @@ class UtilTest extends AbstractTestCase
     #[RequiresPhpExtension('sodium')]
     public function testListPHPExtensions(): void
     {
-        $this->assertSame(
+        self::assertSame(
             ['mysqli', 'curl', 'mbstring', 'sodium'],
             Util::listPHPExtensions(),
         );
@@ -58,13 +58,13 @@ class UtilTest extends AbstractTestCase
      */
     public function testPageSelector(): void
     {
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             '<select class="pageselector ajax" name="pma" >',
             Util::pageselector('pma', 3),
         );
 
         // If pageNow > nbTotalPage, show the pageNow number to avoid confusion
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             '<option selected="selected" style="font-weight: bold" value="297">100</option>',
             Util::pageselector('pma', 3, 100, 50),
         );
@@ -79,7 +79,7 @@ class UtilTest extends AbstractTestCase
     #[DataProvider('charsetQueryData')]
     public function testGenerateCharsetQueryPart(string $collation, string $expected): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             $expected,
             Util::getCharsetQueryPart($collation),
         );
@@ -100,8 +100,8 @@ class UtilTest extends AbstractTestCase
      */
     public function testGenerateRandom(): void
     {
-        $this->assertEquals(32, strlen(Util::generateRandom(32)));
-        $this->assertEquals(16, strlen(Util::generateRandom(16)));
+        self::assertEquals(32, strlen(Util::generateRandom(32)));
+        self::assertEquals(16, strlen(Util::generateRandom(16)));
     }
 
     public function testClearUserCache(): void
@@ -109,14 +109,14 @@ class UtilTest extends AbstractTestCase
         Config::getInstance()->selectedServer['user'] = null;
         Current::$server = 2;
         SessionCache::set('is_superuser', 'yes');
-        $this->assertEquals('yes', $_SESSION['cache']['server_2']['is_superuser']);
+        self::assertEquals('yes', $_SESSION['cache']['server_2']['is_superuser']);
 
         SessionCache::set('mysql_cur_user', 'mysql');
-        $this->assertEquals('mysql', $_SESSION['cache']['server_2']['mysql_cur_user']);
+        self::assertEquals('mysql', $_SESSION['cache']['server_2']['mysql_cur_user']);
 
         Util::clearUserCache();
-        $this->assertArrayNotHasKey('is_superuser', $_SESSION['cache']['server_2']);
-        $this->assertArrayNotHasKey('mysql_cur_user', $_SESSION['cache']['server_2']);
+        self::assertArrayNotHasKey('is_superuser', $_SESSION['cache']['server_2']);
+        self::assertArrayNotHasKey('mysql_cur_user', $_SESSION['cache']['server_2']);
     }
 
     /**
@@ -128,7 +128,7 @@ class UtilTest extends AbstractTestCase
     #[DataProvider('providerConvertBitDefaultValue')]
     public function testConvertBitDefaultValue(string|null $bit, string $val): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             $val,
             Util::convertBitDefaultValue($bit),
         );
@@ -170,12 +170,12 @@ class UtilTest extends AbstractTestCase
         Current::$database = 'database';
         Current::$table = 'table';
 
-        $this->assertEquals(
+        self::assertEquals(
             $out,
             Util::expandUserString($in),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             htmlspecialchars($out),
             Util::expandUserString(
                 $in,
@@ -212,7 +212,7 @@ class UtilTest extends AbstractTestCase
     {
         Config::getInstance()->settings['LimitChars'] = 1000;
 
-        $this->assertEquals(
+        self::assertEquals(
             $out,
             Util::extractColumnSpec($in),
         );
@@ -357,7 +357,7 @@ class UtilTest extends AbstractTestCase
     #[DataProvider('providerParseEnumSetValues')]
     public function testParseEnumSetValues(string $in, bool $escapeHTML, array $out): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             $out,
             Util::parseEnumSetValues($in, $escapeHTML),
         );
@@ -477,7 +477,7 @@ class UtilTest extends AbstractTestCase
     #[DataProvider('providerExtractValueFromFormattedSize')]
     public function testExtractValueFromFormattedSize(int|string $size, int|float $expected): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             $expected,
             Util::extractValueFromFormattedSize($size),
         );
@@ -505,7 +505,7 @@ class UtilTest extends AbstractTestCase
     public function testFormatByteDown(float|int|string|null $a, int $b, int $c, array|null $e): void
     {
         $result = Util::formatByteDown($a, $b, $c);
-        $this->assertSame($e, $result);
+        self::assertSame($e, $result);
     }
 
     /**
@@ -548,7 +548,7 @@ class UtilTest extends AbstractTestCase
      */
     private function assertFormatNumber(float|int|string $a, int $b, int $c, string $d): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             $d,
             Util::formatNumber(
                 $a,
@@ -650,7 +650,7 @@ class UtilTest extends AbstractTestCase
     #[DataProvider('providerGetFormattedMaximumUploadSize')]
     public function testGetFormattedMaximumUploadSize(int|float|string $size, string $unit, string $res): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             '(' . __('Max: ') . $res . $unit . ')',
             Util::getFormattedMaximumUploadSize($size),
         );
@@ -692,7 +692,7 @@ class UtilTest extends AbstractTestCase
     #[DataProvider('providerGetTitleForTarget')]
     public function testGetTitleForTarget(string $target, string $result): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             $result,
             Util::getTitleForTarget($target),
         );
@@ -728,7 +728,7 @@ class UtilTest extends AbstractTestCase
     public function testLocalisedDate(int $a, string $b, string $e, string $tz, string $locale): void
     {
         if (! is_readable(LOCALE_PATH . '/cs/LC_MESSAGES/phpmyadmin.mo')) {
-            $this->markTestSkipped('Missing compiled locales.');
+            self::markTestSkipped('Missing compiled locales.');
         }
 
         parent::setLanguage();
@@ -739,7 +739,7 @@ class UtilTest extends AbstractTestCase
         $tmpTimezone = date_default_timezone_get();
         date_default_timezone_set($tz);
 
-        $this->assertEquals(
+        self::assertEquals(
             $e,
             Util::localisedDate($a, $b),
         );
@@ -818,7 +818,7 @@ class UtilTest extends AbstractTestCase
         $tmpTimezone = date_default_timezone_get();
         date_default_timezone_set('Europe/London');
 
-        $this->assertEquals(
+        self::assertEquals(
             $e,
             Util::timespanFormat($a),
         );
@@ -849,7 +849,7 @@ class UtilTest extends AbstractTestCase
     #[DataProvider('providerPrintableBitValue')]
     public function testPrintableBitValue(int $a, int $b, string $e): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             $e,
             Util::printableBitValue($a, $b),
         );
@@ -877,7 +877,7 @@ class UtilTest extends AbstractTestCase
     #[DataProvider('providerUnQuote')]
     public function testUnQuote(string $param, string $expected): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             $expected,
             Util::unQuote($param),
         );
@@ -902,7 +902,7 @@ class UtilTest extends AbstractTestCase
     #[DataProvider('providerUnQuoteSelectedChar')]
     public function testUnQuoteSelectedChar(string $param, string $expected): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             $expected,
             Util::unQuote($param, '"'),
         );
@@ -921,11 +921,11 @@ class UtilTest extends AbstractTestCase
     #[DataProvider('providerForTestBackquote')]
     public function testBackquote(string|null $entry, string $expectedNoneOutput, string $expectedMssqlOutput): void
     {
-        $this->assertSame($expectedNoneOutput, Util::backquote($entry));
-        $this->assertEquals($entry, Util::backquoteCompat($entry, 'NONE', false));
-        $this->assertEquals($entry, Util::backquoteCompat($entry, 'MSSQL', false));
-        $this->assertSame($expectedNoneOutput, Util::backquoteCompat($entry, 'NONE'));
-        $this->assertSame($expectedMssqlOutput, Util::backquoteCompat($entry, 'MSSQL'));
+        self::assertSame($expectedNoneOutput, Util::backquote($entry));
+        self::assertEquals($entry, Util::backquoteCompat($entry, 'NONE', false));
+        self::assertEquals($entry, Util::backquoteCompat($entry, 'MSSQL', false));
+        self::assertSame($expectedNoneOutput, Util::backquoteCompat($entry, 'NONE'));
+        self::assertSame($expectedMssqlOutput, Util::backquoteCompat($entry, 'MSSQL'));
     }
 
     /** @return array<int|string, string|null>[] */
@@ -951,7 +951,7 @@ class UtilTest extends AbstractTestCase
                 $expected = '`' . $keyword . '`';
             }
 
-            $this->assertSame($expected, Util::backquoteCompat($keyword, 'NONE', false));
+            self::assertSame($expected, Util::backquoteCompat($keyword, 'NONE', false));
         }
     }
 
@@ -966,7 +966,7 @@ class UtilTest extends AbstractTestCase
     {
         Config::getInstance()->selectedServer['user'] = 'root';
 
-        $this->assertEquals($e, Util::userDir($a));
+        self::assertEquals($e, Util::userDir($a));
     }
 
     /**
@@ -988,7 +988,7 @@ class UtilTest extends AbstractTestCase
     #[DataProvider('providerDuplicateFirstNewline')]
     public function testDuplicateFirstNewline(string $a, string $e): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             $e,
             Util::duplicateFirstNewline($a),
         );
@@ -1007,7 +1007,7 @@ class UtilTest extends AbstractTestCase
     public function testUnsupportedDatatypes(): void
     {
         $noSupportTypes = [];
-        $this->assertEquals(
+        self::assertEquals(
             $noSupportTypes,
             Util::unsupportedDatatypes(),
         );
@@ -1015,10 +1015,10 @@ class UtilTest extends AbstractTestCase
 
     public function testGetPageFromPosition(): void
     {
-        $this->assertEquals(Util::getPageFromPosition(0, 1), 1);
-        $this->assertEquals(Util::getPageFromPosition(1, 1), 2);
-        $this->assertEquals(Util::getPageFromPosition(1, 2), 1);
-        $this->assertEquals(Util::getPageFromPosition(1, 6), 1);
+        self::assertEquals(Util::getPageFromPosition(0, 1), 1);
+        self::assertEquals(Util::getPageFromPosition(1, 1), 2);
+        self::assertEquals(Util::getPageFromPosition(1, 2), 1);
+        self::assertEquals(Util::getPageFromPosition(1, 6), 1);
     }
 
     /**
@@ -1031,7 +1031,7 @@ class UtilTest extends AbstractTestCase
     public function testIsInteger(bool $expected, mixed $input): void
     {
         $isInteger = Util::isInteger($input);
-        $this->assertEquals($expected, $isInteger);
+        self::assertEquals($expected, $isInteger);
     }
 
     /**
@@ -1054,7 +1054,7 @@ class UtilTest extends AbstractTestCase
     public function testGetProtoFromForwardedHeader(string $header, string $proto): void
     {
         $protocolDetected = Util::getProtoFromForwardedHeader($header);
-        $this->assertEquals($proto, $protocolDetected);
+        self::assertEquals($proto, $protocolDetected);
     }
 
     /**
@@ -1102,7 +1102,7 @@ class UtilTest extends AbstractTestCase
         $dbiDummy->addResult('SELECT CURRENT_USER();', []);
         DatabaseInterface::$instance = $this->createDatabaseInterface($dbiDummy);
 
-        $this->assertTrue(Util::currentUserHasPrivilege('EVENT'));
+        self::assertTrue(Util::currentUserHasPrivilege('EVENT'));
         $dbiDummy->assertAllQueriesConsumed();
     }
 
@@ -1118,7 +1118,7 @@ SQL;
         $dbiDummy->addResult($globalPrivilegeQuery, [['EVENT']]);
         DatabaseInterface::$instance = $this->createDatabaseInterface($dbiDummy);
 
-        $this->assertTrue(Util::currentUserHasPrivilege('EVENT'));
+        self::assertTrue(Util::currentUserHasPrivilege('EVENT'));
         $dbiDummy->assertAllQueriesConsumed();
     }
 
@@ -1134,7 +1134,7 @@ SQL;
         $dbiDummy->addResult($globalPrivilegeQuery, []);
         DatabaseInterface::$instance = $this->createDatabaseInterface($dbiDummy);
 
-        $this->assertFalse(Util::currentUserHasPrivilege('EVENT'));
+        self::assertFalse(Util::currentUserHasPrivilege('EVENT'));
         $dbiDummy->assertAllQueriesConsumed();
     }
 
@@ -1154,7 +1154,7 @@ SQL;
         $dbiDummy->addResult($databasePrivilegeQuery, [['EVENT']]);
         DatabaseInterface::$instance = $this->createDatabaseInterface($dbiDummy);
 
-        $this->assertTrue(Util::currentUserHasPrivilege('EVENT', 'my_data_base'));
+        self::assertTrue(Util::currentUserHasPrivilege('EVENT', 'my_data_base'));
         $dbiDummy->assertAllQueriesConsumed();
     }
 
@@ -1174,7 +1174,7 @@ SQL;
         $dbiDummy->addResult($databasePrivilegeQuery, []);
         DatabaseInterface::$instance = $this->createDatabaseInterface($dbiDummy);
 
-        $this->assertFalse(Util::currentUserHasPrivilege('EVENT', 'my_data_base'));
+        self::assertFalse(Util::currentUserHasPrivilege('EVENT', 'my_data_base'));
         $dbiDummy->assertAllQueriesConsumed();
     }
 
@@ -1198,7 +1198,7 @@ SQL;
         $dbiDummy->addResult($tablePrivilegeQuery, [['EVENT']]);
         DatabaseInterface::$instance = $this->createDatabaseInterface($dbiDummy);
 
-        $this->assertTrue(Util::currentUserHasPrivilege('EVENT', 'my_data_base', 'my_data_table'));
+        self::assertTrue(Util::currentUserHasPrivilege('EVENT', 'my_data_base', 'my_data_table'));
         $dbiDummy->assertAllQueriesConsumed();
     }
 
@@ -1222,7 +1222,7 @@ SQL;
         $dbiDummy->addResult($tablePrivilegeQuery, []);
         DatabaseInterface::$instance = $this->createDatabaseInterface($dbiDummy);
 
-        $this->assertFalse(Util::currentUserHasPrivilege('EVENT', 'my_data_base', 'my_data_table'));
+        self::assertFalse(Util::currentUserHasPrivilege('EVENT', 'my_data_base', 'my_data_table'));
         $dbiDummy->assertAllQueriesConsumed();
     }
 
@@ -1334,7 +1334,7 @@ SQL;
     public function testGetScriptNameForOption(string $target, string $location, string $finalLink): void
     {
         $GLOBALS['lang'] = 'en';
-        $this->assertSame(
+        self::assertSame(
             $finalLink,
             Util::getScriptNameForOption($target, $location),
         );
@@ -1344,22 +1344,22 @@ SQL;
     {
         $config = Config::getInstance();
         $config->settings['ActionLinksMode'] = 'icons';
-        $this->assertTrue(Util::showIcons('ActionLinksMode'));
+        self::assertTrue(Util::showIcons('ActionLinksMode'));
         $config->settings['ActionLinksMode'] = 'both';
-        $this->assertTrue(Util::showIcons('ActionLinksMode'));
+        self::assertTrue(Util::showIcons('ActionLinksMode'));
         $config->settings['ActionLinksMode'] = 'text';
-        $this->assertFalse(Util::showIcons('ActionLinksMode'));
+        self::assertFalse(Util::showIcons('ActionLinksMode'));
     }
 
     public function testShowText(): void
     {
         $config = Config::getInstance();
         $config->settings['ActionLinksMode'] = 'text';
-        $this->assertTrue(Util::showText('ActionLinksMode'));
+        self::assertTrue(Util::showText('ActionLinksMode'));
         $config->settings['ActionLinksMode'] = 'both';
-        $this->assertTrue(Util::showText('ActionLinksMode'));
+        self::assertTrue(Util::showText('ActionLinksMode'));
         $config->settings['ActionLinksMode'] = 'icons';
-        $this->assertFalse(Util::showText('ActionLinksMode'));
+        self::assertFalse(Util::showText('ActionLinksMode'));
     }
 
     #[DataProvider('providerForTestGetMySQLDocuURL')]
@@ -1368,7 +1368,7 @@ SQL;
         $dbi = $this->createDatabaseInterface();
         DatabaseInterface::$instance = $dbi;
         $dbi->setVersion(['@@version' => $version, '@@version_comment' => 'MySQL Community Server (GPL)']);
-        $this->assertSame($expected, Util::getMySQLDocuURL($link, $anchor));
+        self::assertSame($expected, Util::getMySQLDocuURL($link, $anchor));
     }
 
     /**
@@ -1421,15 +1421,15 @@ SQL;
         $dbi = $this->createDatabaseInterface();
         $dbi->setVersion(['@@version' => '5.5.0']);
         DatabaseInterface::$instance = $dbi;
-        $this->assertSame(
+        self::assertSame(
             'index.php?route=/url&url=https%3A%2F%2Fmariadb.com%2Fkb%2Fen%2Fdocumentation%2F',
             Util::getDocuURL(true),
         );
-        $this->assertSame(
+        self::assertSame(
             'index.php?route=/url&url=https%3A%2F%2Fdev.mysql.com%2Fdoc%2Frefman%2F5.5%2Fen%2Findex.html',
             Util::getDocuURL(false),
         );
-        $this->assertSame(
+        self::assertSame(
             'index.php?route=/url&url=https%3A%2F%2Fdev.mysql.com%2Fdoc%2Frefman%2F5.5%2Fen%2Findex.html',
             Util::getDocuURL(),
         );
@@ -1438,11 +1438,11 @@ SQL;
     public function testSplitURLQuery(): void
     {
         $actual = Util::splitURLQuery('');
-        $this->assertSame([], $actual);
+        self::assertSame([], $actual);
         $actual = Util::splitURLQuery('index.php');
-        $this->assertSame([], $actual);
+        self::assertSame([], $actual);
         $actual = Util::splitURLQuery('index.php?route=/table/structure&db=sakila&table=address');
-        $this->assertSame(['route=/table/structure', 'db=sakila', 'table=address'], $actual);
+        self::assertSame(['route=/table/structure', 'db=sakila', 'table=address'], $actual);
     }
 
     public function testGetDbInfo(): void
@@ -1497,27 +1497,27 @@ SQL;
             'TABLE_TYPE' => 'BASE TABLE',
         ];
         $expected = [['test_table' => $tableInfo], 1];
-        $actual = Util::getDbInfo($this->createStub(ServerRequest::class), 'test_db');
-        $this->assertSame($expected, $actual);
+        $actual = Util::getDbInfo(self::createStub(ServerRequest::class), 'test_db');
+        self::assertSame($expected, $actual);
     }
 
     public function testGetTableListPosition(): void
     {
         // Default 0
-        $actual = Util::getTableListPosition($this->createStub(ServerRequest::class), 'test_db');
-        $this->assertSame(0, $actual);
+        $actual = Util::getTableListPosition(self::createStub(ServerRequest::class), 'test_db');
+        self::assertSame(0, $actual);
 
         // From POST
-        $requestStub = $this->createStub(ServerRequestInterface::class);
+        $requestStub = self::createStub(ServerRequestInterface::class);
         $requestStub->method('getQueryParams')->willReturn([]);
         $requestStub->method('getParsedBody')->willReturn(['pos' => '250']);
         $request = new ServerRequest($requestStub);
         $actual = Util::getTableListPosition($request, 'test_db');
-        $this->assertSame(250, $actual);
+        self::assertSame(250, $actual);
 
         // From SESSION
-        $actual = Util::getTableListPosition($this->createStub(ServerRequest::class), 'test_db');
-        $this->assertSame(250, $actual);
+        $actual = Util::getTableListPosition(self::createStub(ServerRequest::class), 'test_db');
+        self::assertSame(250, $actual);
     }
 
     /**
@@ -1534,16 +1534,16 @@ SQL;
             ->disableOriginalConstructor()
             ->getMock();
 
-        $dbi->expects($this->any())
+        $dbi->expects(self::any())
             ->method('isMariaDB')
             ->willReturn($isMariaDB);
 
-        $dbi->expects($this->any())
+        $dbi->expects(self::any())
             ->method('getVersion')
             ->willReturn($version);
 
         DatabaseInterface::$instance = $dbi;
-        $this->assertEquals(Util::isUUIDSupported(), $expected);
+        self::assertEquals(Util::isUUIDSupported(), $expected);
         DatabaseInterface::$instance = null;
     }
 
@@ -1564,7 +1564,7 @@ SQL;
         $dbiDummy = $this->createDbiDummy();
         $dbiDummy->addResult('SELECT @@lower_case_table_names', [[$lowerCaseTableNames]], ['@@lower_case_table_names']);
         DatabaseInterface::$instance = $this->createDatabaseInterface($dbiDummy);
-        $this->assertSame($expected, Util::getCollateForIS());
+        self::assertSame($expected, Util::getCollateForIS());
         $dbiDummy->assertAllQueriesConsumed();
     }
 
@@ -1626,7 +1626,7 @@ SQL;
             'GEOMETRYCOLLECTION',
             'JSON',
         ];
-        $this->assertSame($expected, Util::getSupportedDatatypes());
+        self::assertSame($expected, Util::getSupportedDatatypes());
     }
 
     /**
@@ -1636,7 +1636,7 @@ SQL;
     #[DataProvider('providerForTestGetValueByKey')]
     public function testGetValueByKey(mixed $expected, array $array, array $path, mixed $default = null): void
     {
-        $this->assertSame($expected, Util::getValueByKey($array, $path, $default));
+        self::assertSame($expected, Util::getValueByKey($array, $path, $default));
     }
 
     /** @return iterable<string, array{mixed, mixed[], (string|int)[], mixed}> */
diff --git a/tests/classes/Utils/ForeignKeyTest.php b/tests/classes/Utils/ForeignKeyTest.php
index c44603e25c..69f261031b 100644
--- a/tests/classes/Utils/ForeignKeyTest.php
+++ b/tests/classes/Utils/ForeignKeyTest.php
@@ -30,7 +30,7 @@ class ForeignKeyTest extends AbstractTestCase
     #[DataProvider('providerIsSupported')]
     public function testIsSupported(string $a, bool $e): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             $e,
             ForeignKey::isSupported($a),
         );
@@ -50,17 +50,17 @@ class ForeignKeyTest extends AbstractTestCase
     {
         $config = Config::getInstance();
         $config->settings['DefaultForeignKeyChecks'] = 'enable';
-        $this->assertTrue(
+        self::assertTrue(
             ForeignKey::isCheckEnabled(),
         );
 
         $config->settings['DefaultForeignKeyChecks'] = 'disable';
-        $this->assertFalse(
+        self::assertFalse(
             ForeignKey::isCheckEnabled(),
         );
 
         $config->settings['DefaultForeignKeyChecks'] = 'default';
-        $this->assertTrue(
+        self::assertTrue(
             ForeignKey::isCheckEnabled(),
         );
     }
@@ -81,16 +81,16 @@ class ForeignKeyTest extends AbstractTestCase
 
         $_REQUEST['fk_checks'] = $checksValue;
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('getVariable')
             ->willReturn('ON');
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('setVariable')
             ->with('FOREIGN_KEY_CHECKS', $setVariableParam)
             ->willReturn(true);
 
-        $this->assertTrue(ForeignKey::handleDisableCheckInit());
+        self::assertTrue(ForeignKey::handleDisableCheckInit());
     }
 
     #[DataProvider('providerCheckInit')]
@@ -103,16 +103,16 @@ class ForeignKeyTest extends AbstractTestCase
 
         $_REQUEST['fk_checks'] = $checksValue;
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('getVariable')
             ->willReturn('OFF');
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('setVariable')
             ->with('FOREIGN_KEY_CHECKS', $setVariableParam)
             ->willReturn(true);
 
-        $this->assertFalse(ForeignKey::handleDisableCheckInit());
+        self::assertFalse(ForeignKey::handleDisableCheckInit());
     }
 
     /** @return mixed[][] */
@@ -129,7 +129,7 @@ class ForeignKeyTest extends AbstractTestCase
             ->getMock();
         DatabaseInterface::$instance = $dbi;
 
-        $dbi->expects($this->once())
+        $dbi->expects(self::once())
             ->method('setVariable')
             ->with('FOREIGN_KEY_CHECKS', $setVariableParam)
             ->willReturn(true);
diff --git a/tests/classes/Utils/FormatConverterTest.php b/tests/classes/Utils/FormatConverterTest.php
index 81c9ee2612..b98988a9a8 100644
--- a/tests/classes/Utils/FormatConverterTest.php
+++ b/tests/classes/Utils/FormatConverterTest.php
@@ -25,7 +25,7 @@ class FormatConverterTest extends AbstractTestCase
     public function testBinaryToIp(string $expected, string $input, bool $isBinary): void
     {
         $result = FormatConverter::binaryToIp($input, $isBinary);
-        $this->assertEquals($expected, $result);
+        self::assertEquals($expected, $result);
     }
 
     /**
@@ -60,7 +60,7 @@ class FormatConverterTest extends AbstractTestCase
     public function testIpToBinary(string $expected, string $input): void
     {
         $result = FormatConverter::ipToBinary($input);
-        $this->assertEquals($expected, $result);
+        self::assertEquals($expected, $result);
     }
 
     /**
@@ -83,7 +83,7 @@ class FormatConverterTest extends AbstractTestCase
     public function testIpToLong(string $expected, string $input): void
     {
         $result = FormatConverter::ipToLong($input);
-        $this->assertEquals($expected, $result);
+        self::assertEquals($expected, $result);
     }
 
     /**
@@ -106,7 +106,7 @@ class FormatConverterTest extends AbstractTestCase
     public function testLongToIp(string $expected, string $input): void
     {
         $result = FormatConverter::longToIp($input);
-        $this->assertEquals($expected, $result);
+        self::assertEquals($expected, $result);
     }
 
     /**
diff --git a/tests/classes/Utils/GisTest.php b/tests/classes/Utils/GisTest.php
index 78d6e5bfbe..a3319f5130 100644
--- a/tests/classes/Utils/GisTest.php
+++ b/tests/classes/Utils/GisTest.php
@@ -37,22 +37,22 @@ class GisTest extends AbstractTestCase
         bool $SRIDOption,
         int $mysqlVersion,
     ): void {
-        $resultStub = $this->createMock(DummyResult::class);
+        $resultStub = self::createMock(DummyResult::class);
 
         $dbi = $this->getMockBuilder(DatabaseInterface::class)
             ->disableOriginalConstructor()
             ->getMock();
 
-        $dbi->expects($SRIDOption ? $this->once() : $this->exactly(2))
+        $dbi->expects($SRIDOption ? self::once() : self::exactly(2))
             ->method('getVersion')
             ->willReturn($mysqlVersion);
 
-        $dbi->expects($SRIDOption ? $this->once() : $this->exactly(2))
+        $dbi->expects($SRIDOption ? self::once() : self::exactly(2))
             ->method('tryQuery')
             ->with($expectedQuery)
             ->willReturn($resultStub);// Omit the real object
 
-        $resultStub->expects($SRIDOption ? $this->once() : $this->exactly(2))
+        $resultStub->expects($SRIDOption ? self::once() : self::exactly(2))
             ->method('fetchRow')
             ->willReturn($returnData);
 
@@ -60,12 +60,12 @@ class GisTest extends AbstractTestCase
 
         if (! $SRIDOption) {
             // Also test default signature
-            $this->assertSame($expectedResult, Gis::convertToWellKnownText(
+            self::assertSame($expectedResult, Gis::convertToWellKnownText(
                 (string) hex2bin('000000000101000000000000000000F03F000000000000F03F'),
             ));
         }
 
-        $this->assertSame($expectedResult, Gis::convertToWellKnownText(
+        self::assertSame($expectedResult, Gis::convertToWellKnownText(
             (string) hex2bin('000000000101000000000000000000F03F000000000000F03F'),
             $SRIDOption,
         ));
@@ -140,21 +140,21 @@ class GisTest extends AbstractTestCase
 
     public function testCreateDataOldMysql(): void
     {
-        $this->assertEquals('abc', Gis::createData('abc', 50500));
-        $this->assertEquals('GeomFromText(\'POINT()\',10)', Gis::createData('\'POINT()\',10', 50500));
+        self::assertEquals('abc', Gis::createData('abc', 50500));
+        self::assertEquals('GeomFromText(\'POINT()\',10)', Gis::createData('\'POINT()\',10', 50500));
     }
 
     public function testCreateDataNewMysql(): void
     {
-        $this->assertEquals('abc', Gis::createData('abc', 50600));
-        $this->assertEquals('ST_GeomFromText(\'POINT()\',10)', Gis::createData('\'POINT()\',10', 50600));
+        self::assertEquals('abc', Gis::createData('abc', 50600));
+        self::assertEquals('ST_GeomFromText(\'POINT()\',10)', Gis::createData('\'POINT()\',10', 50600));
     }
 
     public function testGetFunctions(): void
     {
         $funcs = Gis::getFunctions();
-        $this->assertArrayHasKey('Dimension', $funcs);
-        $this->assertArrayHasKey('GeometryType', $funcs);
-        $this->assertArrayHasKey('MBRDisjoint', $funcs);
+        self::assertArrayHasKey('Dimension', $funcs);
+        self::assertArrayHasKey('GeometryType', $funcs);
+        self::assertArrayHasKey('MBRDisjoint', $funcs);
     }
 }
diff --git a/tests/classes/Utils/HttpRequestTest.php b/tests/classes/Utils/HttpRequestTest.php
index 34cc3a3543..1aa8110015 100644
--- a/tests/classes/Utils/HttpRequestTest.php
+++ b/tests/classes/Utils/HttpRequestTest.php
@@ -52,7 +52,7 @@ class HttpRequestTest extends AbstractTestCase
             return;
         }
 
-        $this->markTestSkipped('Not supported in CURL SSL backend: ' . ($curl !== false ? $curl['ssl_version'] : '?'));
+        self::markTestSkipped('Not supported in CURL SSL backend: ' . ($curl !== false ? $curl['ssl_version'] : '?'));
     }
 
     /**
@@ -152,7 +152,7 @@ class HttpRequestTest extends AbstractTestCase
     public function testFopen(string $url, string $method, bool $returnOnlyStatus, bool|string|null $expected): void
     {
         if (! ini_get('allow_url_fopen')) {
-            $this->markTestSkipped('Configuration directive allow_url_fopen is not enabled.');
+            self::markTestSkipped('Configuration directive allow_url_fopen is not enabled.');
         }
 
         $result = $this->callFunction(
@@ -179,7 +179,7 @@ class HttpRequestTest extends AbstractTestCase
     public function testCreate(string $url, string $method, bool $returnOnlyStatus, bool|string|null $expected): void
     {
         if (! ini_get('allow_url_fopen')) {
-            $this->markTestSkipped('Configuration directive allow_url_fopen is not enabled.');
+            self::markTestSkipped('Configuration directive allow_url_fopen is not enabled.');
         }
 
         $result = $this->httpRequest->create($url, $method, $returnOnlyStatus);
@@ -195,14 +195,14 @@ class HttpRequestTest extends AbstractTestCase
     private function validateHttp(mixed $result, mixed $expected): void
     {
         if ($expected === true) {
-            $this->assertTrue($result);
+            self::assertTrue($result);
         } elseif ($expected === false) {
-            $this->assertFalse($result);
+            self::assertFalse($result);
         } elseif ($expected === null) {
-            $this->assertNull($result);
+            self::assertNull($result);
         } else {
-            $this->assertNotNull($result, 'The request maybe has failed');
-            $this->assertStringContainsString($expected, $result);
+            self::assertNotNull($result, 'The request maybe has failed');
+            self::assertStringContainsString($expected, $result);
         }
     }
 
diff --git a/tests/classes/Utils/SessionCacheTest.php b/tests/classes/Utils/SessionCacheTest.php
index 5fccfc37fc..c072078d02 100644
--- a/tests/classes/Utils/SessionCacheTest.php
+++ b/tests/classes/Utils/SessionCacheTest.php
@@ -21,9 +21,9 @@ class SessionCacheTest extends TestCase
         SessionCache::set('test_data', 5);
         SessionCache::set('test_data_2', 5);
 
-        $this->assertNotNull(SessionCache::get('test_data'));
-        $this->assertNotNull(SessionCache::get('test_data_2'));
-        $this->assertNull(SessionCache::get('fake_data_2'));
+        self::assertNotNull(SessionCache::get('test_data'));
+        self::assertNotNull(SessionCache::get('test_data_2'));
+        self::assertNull(SessionCache::get('fake_data_2'));
     }
 
     public function testRemove(): void
@@ -36,9 +36,9 @@ class SessionCacheTest extends TestCase
         SessionCache::set('test_data_2', 25);
 
         SessionCache::remove('test_data');
-        $this->assertArrayNotHasKey('test_data', $_SESSION['cache']['server_2']);
+        self::assertArrayNotHasKey('test_data', $_SESSION['cache']['server_2']);
         SessionCache::remove('test_data_2');
-        $this->assertArrayNotHasKey('test_data_2', $_SESSION['cache']['server_2']);
+        self::assertArrayNotHasKey('test_data_2', $_SESSION['cache']['server_2']);
     }
 
     public function testSet(): void
@@ -49,9 +49,9 @@ class SessionCacheTest extends TestCase
 
         SessionCache::set('test_data', 25);
         SessionCache::set('test_data', 5);
-        $this->assertEquals(5, $_SESSION['cache']['server_2']['test_data']);
+        self::assertEquals(5, $_SESSION['cache']['server_2']['test_data']);
         SessionCache::set('test_data_3', 3);
-        $this->assertEquals(3, $_SESSION['cache']['server_2']['test_data_3']);
+        self::assertEquals(3, $_SESSION['cache']['server_2']['test_data_3']);
     }
 
     public function testHas(): void
@@ -64,11 +64,11 @@ class SessionCacheTest extends TestCase
         SessionCache::set('test_data_3', false);
         SessionCache::set('test_data_4', true);
 
-        $this->assertTrue(SessionCache::has('test_data'));
-        $this->assertTrue(SessionCache::has('test_data_2'));
-        $this->assertTrue(SessionCache::has('test_data_3'));
-        $this->assertTrue(SessionCache::has('test_data_4'));
-        $this->assertFalse(SessionCache::has('fake_data_2'));
+        self::assertTrue(SessionCache::has('test_data'));
+        self::assertTrue(SessionCache::has('test_data_2'));
+        self::assertTrue(SessionCache::has('test_data_3'));
+        self::assertTrue(SessionCache::has('test_data_4'));
+        self::assertFalse(SessionCache::has('fake_data_2'));
     }
 
     public function testKeyWithoutUser(): void
@@ -78,12 +78,12 @@ class SessionCacheTest extends TestCase
         Current::$server = 123;
 
         SessionCache::set('test_data', 5);
-        $this->assertArrayHasKey('cache', $_SESSION);
-        $this->assertIsArray($_SESSION['cache']);
-        $this->assertArrayHasKey('server_123', $_SESSION['cache']);
-        $this->assertIsArray($_SESSION['cache']['server_123']);
-        $this->assertArrayHasKey('test_data', $_SESSION['cache']['server_123']);
-        $this->assertSame(5, $_SESSION['cache']['server_123']['test_data']);
+        self::assertArrayHasKey('cache', $_SESSION);
+        self::assertIsArray($_SESSION['cache']);
+        self::assertArrayHasKey('server_123', $_SESSION['cache']);
+        self::assertIsArray($_SESSION['cache']['server_123']);
+        self::assertArrayHasKey('test_data', $_SESSION['cache']['server_123']);
+        self::assertSame(5, $_SESSION['cache']['server_123']['test_data']);
     }
 
     public function testKeyWithUser(): void
@@ -93,11 +93,11 @@ class SessionCacheTest extends TestCase
         Current::$server = 123;
 
         SessionCache::set('test_data', 5);
-        $this->assertArrayHasKey('cache', $_SESSION);
-        $this->assertIsArray($_SESSION['cache']);
-        $this->assertArrayHasKey('server_123_test_user', $_SESSION['cache']);
-        $this->assertIsArray($_SESSION['cache']['server_123_test_user']);
-        $this->assertArrayHasKey('test_data', $_SESSION['cache']['server_123_test_user']);
-        $this->assertSame(5, $_SESSION['cache']['server_123_test_user']['test_data']);
+        self::assertArrayHasKey('cache', $_SESSION);
+        self::assertIsArray($_SESSION['cache']);
+        self::assertArrayHasKey('server_123_test_user', $_SESSION['cache']);
+        self::assertIsArray($_SESSION['cache']['server_123_test_user']);
+        self::assertArrayHasKey('test_data', $_SESSION['cache']['server_123_test_user']);
+        self::assertSame(5, $_SESSION['cache']['server_123_test_user']['test_data']);
     }
 }
diff --git a/tests/classes/VersionInformationTest.php b/tests/classes/VersionInformationTest.php
index 3a20359a08..e5186d79af 100644
--- a/tests/classes/VersionInformationTest.php
+++ b/tests/classes/VersionInformationTest.php
@@ -51,8 +51,8 @@ class VersionInformationTest extends AbstractTestCase
         unset($_SESSION['cache']['version_check']);
         $versionInformation = new VersionInformation();
         $version = $versionInformation->getLatestVersions();
-        $this->assertIsArray($version);
-        $this->assertNotEmpty($version);
+        self::assertIsArray($version);
+        self::assertNotEmpty($version);
     }
 
     /**
@@ -65,7 +65,7 @@ class VersionInformationTest extends AbstractTestCase
     public function testVersionToInt(string $version, int $numeric): void
     {
         $versionInformation = new VersionInformation();
-        $this->assertEquals(
+        self::assertEquals(
             $numeric,
             $versionInformation->versionToInt($version),
         );
@@ -109,12 +109,12 @@ class VersionInformationTest extends AbstractTestCase
         Config::getInstance()->settings['Servers'] = [[]];
 
         $mockVersionInfo = $this->createPartialMock(VersionInformation::class, ['getPHPVersion', 'getMySQLVersion']);
-        $mockVersionInfo->expects($this->exactly(6))->method('getPHPVersion')->willReturn('5.6.0');
-        $mockVersionInfo->expects($this->exactly(2))->method('getMySQLVersion')->willReturn('5.5.0');
+        $mockVersionInfo->expects(self::exactly(6))->method('getPHPVersion')->willReturn('5.6.0');
+        $mockVersionInfo->expects(self::exactly(2))->method('getMySQLVersion')->willReturn('5.5.0');
 
         $compatible = $mockVersionInfo->getLatestCompatibleVersion($this->releases);
-        $this->assertInstanceOf(Release::class, $compatible);
-        $this->assertEquals('4.4.14.1', $compatible->version);
+        self::assertInstanceOf(Release::class, $compatible);
+        self::assertEquals('4.4.14.1', $compatible->version);
     }
 
     /**
@@ -125,12 +125,12 @@ class VersionInformationTest extends AbstractTestCase
         Config::getInstance()->settings['Servers'] = [[], []];
 
         $mockVersionInfo = $this->createPartialMock(VersionInformation::class, ['getPHPVersion', 'getMySQLVersion']);
-        $mockVersionInfo->expects($this->exactly(6))->method('getPHPVersion')->willReturn('5.6.0');
-        $mockVersionInfo->expects($this->never())->method('getMySQLVersion');
+        $mockVersionInfo->expects(self::exactly(6))->method('getPHPVersion')->willReturn('5.6.0');
+        $mockVersionInfo->expects(self::never())->method('getMySQLVersion');
 
         $compatible = $mockVersionInfo->getLatestCompatibleVersion($this->releases);
-        $this->assertInstanceOf(Release::class, $compatible);
-        $this->assertEquals('4.4.14.1', $compatible->version);
+        self::assertInstanceOf(Release::class, $compatible);
+        self::assertEquals('4.4.14.1', $compatible->version);
     }
 
     /**
@@ -141,12 +141,12 @@ class VersionInformationTest extends AbstractTestCase
         Config::getInstance()->settings['Servers'] = [[], []];
 
         $mockVersionInfo = $this->createPartialMock(VersionInformation::class, ['getPHPVersion', 'getMySQLVersion']);
-        $mockVersionInfo->expects($this->exactly(4))->method('getPHPVersion')->willReturn('5.2.1');
-        $mockVersionInfo->expects($this->never())->method('getMySQLVersion');
+        $mockVersionInfo->expects(self::exactly(4))->method('getPHPVersion')->willReturn('5.2.1');
+        $mockVersionInfo->expects(self::never())->method('getMySQLVersion');
 
         $compatible = $mockVersionInfo->getLatestCompatibleVersion($this->releases);
-        $this->assertInstanceOf(Release::class, $compatible);
-        $this->assertEquals('4.0.10.10', $compatible->version);
+        self::assertInstanceOf(Release::class, $compatible);
+        self::assertEquals('4.0.10.10', $compatible->version);
     }
 
     /**
@@ -165,11 +165,11 @@ class VersionInformationTest extends AbstractTestCase
         Config::getInstance()->settings['Servers'] = [];
 
         $mockVersionInfo = $this->createPartialMock(VersionInformation::class, ['getPHPVersion', 'getMySQLVersion']);
-        $mockVersionInfo->expects($this->exactly($conditions[0]))->method('getPHPVersion')->willReturn($conditions[1]);
-        $mockVersionInfo->expects($this->never())->method('getMySQLVersion');
+        $mockVersionInfo->expects(self::exactly($conditions[0]))->method('getPHPVersion')->willReturn($conditions[1]);
+        $mockVersionInfo->expects(self::never())->method('getMySQLVersion');
 
         $compatible = $mockVersionInfo->getLatestCompatibleVersion($versions);
-        $this->assertEquals($matchedLastVersion, $compatible->version ?? null);
+        self::assertEquals($matchedLastVersion, $compatible->version ?? null);
     }
 
     /**
@@ -249,20 +249,20 @@ class VersionInformationTest extends AbstractTestCase
             ->onlyMethods(['getPHPVersion'])
             ->getMock();
 
-        $mockVersionInfo->expects($this->any())
+        $mockVersionInfo->expects(self::any())
             ->method('getPHPVersion')
             ->willReturn('5.2.4');
 
-        $this->assertTrue($mockVersionInfo->evaluateVersionCondition('PHP', '<=5.3'));
-        $this->assertTrue($mockVersionInfo->evaluateVersionCondition('PHP', '<5.3'));
-        $this->assertTrue($mockVersionInfo->evaluateVersionCondition('PHP', '>=5.2'));
-        $this->assertTrue($mockVersionInfo->evaluateVersionCondition('PHP', '>5.2'));
-        $this->assertTrue($mockVersionInfo->evaluateVersionCondition('PHP', '!=5.3'));
+        self::assertTrue($mockVersionInfo->evaluateVersionCondition('PHP', '<=5.3'));
+        self::assertTrue($mockVersionInfo->evaluateVersionCondition('PHP', '<5.3'));
+        self::assertTrue($mockVersionInfo->evaluateVersionCondition('PHP', '>=5.2'));
+        self::assertTrue($mockVersionInfo->evaluateVersionCondition('PHP', '>5.2'));
+        self::assertTrue($mockVersionInfo->evaluateVersionCondition('PHP', '!=5.3'));
 
-        $this->assertFalse($mockVersionInfo->evaluateVersionCondition('PHP', '<=5.2'));
-        $this->assertFalse($mockVersionInfo->evaluateVersionCondition('PHP', '<5.2'));
-        $this->assertFalse($mockVersionInfo->evaluateVersionCondition('PHP', '>=7.0'));
-        $this->assertFalse($mockVersionInfo->evaluateVersionCondition('PHP', '>7.0'));
-        $this->assertTrue($mockVersionInfo->evaluateVersionCondition('PHP', '!=5.2'));
+        self::assertFalse($mockVersionInfo->evaluateVersionCondition('PHP', '<=5.2'));
+        self::assertFalse($mockVersionInfo->evaluateVersionCondition('PHP', '<5.2'));
+        self::assertFalse($mockVersionInfo->evaluateVersionCondition('PHP', '>=7.0'));
+        self::assertFalse($mockVersionInfo->evaluateVersionCondition('PHP', '>7.0'));
+        self::assertTrue($mockVersionInfo->evaluateVersionCondition('PHP', '!=5.2'));
     }
 }
diff --git a/tests/classes/VersionTest.php b/tests/classes/VersionTest.php
index 414fd218a1..669009c313 100644
--- a/tests/classes/VersionTest.php
+++ b/tests/classes/VersionTest.php
@@ -17,22 +17,22 @@ class VersionTest extends AbstractTestCase
      */
     public function testValidateVersion(): void
     {
-        $this->assertIsString(Version::VERSION);
-        $this->assertNotEmpty(Version::VERSION); // @phpstan-ignore-line
-        $this->assertStringContainsString(Version::SERIES, Version::VERSION, 'x.y must be found in x.y.z');
-        $this->assertIsInt(Version::MAJOR);
-        $this->assertIsInt(Version::MINOR);
-        $this->assertIsInt(Version::PATCH);
-        $this->assertTrue(Version::MAJOR >= 5);// @phpstan-ignore-line Just checking
-        $this->assertTrue(Version::MINOR >= 0);// @phpstan-ignore-line Just checking
-        $this->assertTrue(Version::PATCH >= 0);// @phpstan-ignore-line Just checking
-        $this->assertTrue(Version::ID >= 50000);// @phpstan-ignore-line Just checking
+        self::assertIsString(Version::VERSION);
+        self::assertNotEmpty(Version::VERSION); // @phpstan-ignore-line
+        self::assertStringContainsString(Version::SERIES, Version::VERSION, 'x.y must be found in x.y.z');
+        self::assertIsInt(Version::MAJOR);
+        self::assertIsInt(Version::MINOR);
+        self::assertIsInt(Version::PATCH);
+        self::assertTrue(Version::MAJOR >= 5);// @phpstan-ignore-line Just checking
+        self::assertTrue(Version::MINOR >= 0);// @phpstan-ignore-line Just checking
+        self::assertTrue(Version::PATCH >= 0);// @phpstan-ignore-line Just checking
+        self::assertTrue(Version::ID >= 50000);// @phpstan-ignore-line Just checking
         if (defined('VERSION_SUFFIX')) {
-            $this->assertIsString(VERSION_SUFFIX);
+            self::assertIsString(VERSION_SUFFIX);
         }
 
-        $this->assertIsInt(Version::ID);
-        $this->assertIsString(Version::PRE_RELEASE_NAME);
-        $this->assertIsBool(Version::IS_DEV);
+        self::assertIsInt(Version::ID);
+        self::assertIsString(Version::PRE_RELEASE_NAME);
+        self::assertIsBool(Version::IS_DEV);
     }
 }
diff --git a/tests/classes/WebAuthn/CBORDecoderTest.php b/tests/classes/WebAuthn/CBORDecoderTest.php
index 1848501d89..1a9a40dc5a 100644
--- a/tests/classes/WebAuthn/CBORDecoderTest.php
+++ b/tests/classes/WebAuthn/CBORDecoderTest.php
@@ -25,8 +25,8 @@ class CBORDecoderTest extends TestCase
     {
         $decoder = new CBORDecoder();
         $data = hex2bin($encoded);
-        $this->assertNotFalse($data);
-        $this->assertSame($expected, $decoder->decode(new DataStream($data)));
+        self::assertNotFalse($data);
+        self::assertSame($expected, $decoder->decode(new DataStream($data)));
     }
 
     /** @psalm-return iterable<int, array{string, mixed}> */
@@ -149,8 +149,8 @@ class CBORDecoderTest extends TestCase
         $nanValues = ['f97e00', 'fa7fc00000', 'fb7ff8000000000000'];
         foreach ($nanValues as $value) {
             $data = hex2bin($value);
-            $this->assertNotFalse($data);
-            $this->assertNan($decoder->decode(new DataStream($data)));
+            self::assertNotFalse($data);
+            self::assertNan($decoder->decode(new DataStream($data)));
         }
     }
 
@@ -159,7 +159,7 @@ class CBORDecoderTest extends TestCase
     {
         $decoder = new CBORDecoder();
         $data = hex2bin($encoded);
-        $this->assertNotFalse($data);
+        self::assertNotFalse($data);
         $this->expectException(WebAuthnException::class);
         $decoder->decode(new DataStream($data));
     }
diff --git a/tests/classes/WebAuthn/WebauthnLibServerTest.php b/tests/classes/WebAuthn/WebauthnLibServerTest.php
index 5a035a5d18..6a8b77a6db 100644
--- a/tests/classes/WebAuthn/WebauthnLibServerTest.php
+++ b/tests/classes/WebAuthn/WebauthnLibServerTest.php
@@ -24,28 +24,28 @@ class WebauthnLibServerTest extends TestCase
             return;
         }
 
-        $this->markTestSkipped('Package "web-auth/webauthn-lib" is required.');
+        self::markTestSkipped('Package "web-auth/webauthn-lib" is required.');
     }
 
     public function testGetCredentialCreationOptions(): void
     {
-        $server = new WebauthnLibServer($this->createStub(TwoFactor::class));
+        $server = new WebauthnLibServer(self::createStub(TwoFactor::class));
         $options = $server->getCredentialCreationOptions('user_name', 'user_id', 'test.localhost');
-        $this->assertNotEmpty($options['challenge']);
-        $this->assertNotEmpty($options['pubKeyCredParams']);
-        $this->assertNotEmpty($options['attestation']);
-        $this->assertSame('phpMyAdmin (test.localhost)', $options['rp']['name']);
-        $this->assertSame('test.localhost', $options['rp']['id']);
-        $this->assertSame('user_name', $options['user']['name']);
-        $this->assertSame('user_name', $options['user']['displayName']);
-        $this->assertSame(base64_encode('user_id'), $options['user']['id']);
-        $this->assertArrayHasKey('authenticatorAttachment', $options['authenticatorSelection']);
-        $this->assertSame('cross-platform', $options['authenticatorSelection']['authenticatorAttachment']);
+        self::assertNotEmpty($options['challenge']);
+        self::assertNotEmpty($options['pubKeyCredParams']);
+        self::assertNotEmpty($options['attestation']);
+        self::assertSame('phpMyAdmin (test.localhost)', $options['rp']['name']);
+        self::assertSame('test.localhost', $options['rp']['id']);
+        self::assertSame('user_name', $options['user']['name']);
+        self::assertSame('user_name', $options['user']['displayName']);
+        self::assertSame(base64_encode('user_id'), $options['user']['id']);
+        self::assertArrayHasKey('authenticatorAttachment', $options['authenticatorSelection']);
+        self::assertSame('cross-platform', $options['authenticatorSelection']['authenticatorAttachment']);
     }
 
     public function testGetCredentialRequestOptions(): void
     {
-        $twoFactor = $this->createStub(TwoFactor::class);
+        $twoFactor = self::createStub(TwoFactor::class);
         $twoFactor->config = [
             'backend' => 'WebAuthn',
             'settings' => [
@@ -70,9 +70,9 @@ class WebauthnLibServerTest extends TestCase
 
         $server = new WebauthnLibServer($twoFactor);
         $options = $server->getCredentialRequestOptions('user_name', 'userHandle1', 'test.localhost', []);
-        $this->assertNotEmpty($options['challenge']);
-        $this->assertSame('test.localhost', $options['rpId']);
-        $this->assertEquals(
+        self::assertNotEmpty($options['challenge']);
+        self::assertSame('test.localhost', $options['rpId']);
+        self::assertEquals(
             [['type' => 'public-key', 'id' => 'cHVibGljS2V5Q3JlZGVudGlhbElkMQ==']],
             $options['allowCredentials'],
         );
diff --git a/tests/classes/ZipExtensionTest.php b/tests/classes/ZipExtensionTest.php
index d10255a490..37627e1ca4 100644
--- a/tests/classes/ZipExtensionTest.php
+++ b/tests/classes/ZipExtensionTest.php
@@ -38,7 +38,7 @@ class ZipExtensionTest extends AbstractTestCase
     #[DataProvider('provideTestGetContents')]
     public function testGetContents(string $file, string|null $specificEntry, array $output): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             $this->zipExtension->getContents($file, $specificEntry),
             $output,
         );
@@ -80,7 +80,7 @@ class ZipExtensionTest extends AbstractTestCase
     #[DataProvider('provideTestFindFile')]
     public function testFindFile(string $file, string $fileRegexp, string|bool $output): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             $this->zipExtension->findFile($file, $fileRegexp),
             $output,
         );
@@ -105,7 +105,7 @@ class ZipExtensionTest extends AbstractTestCase
      */
     public function testGetNumberOfFiles(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             $this->zipExtension->getNumberOfFiles('./tests/test_data/test.zip'),
             1,
         );
@@ -116,13 +116,13 @@ class ZipExtensionTest extends AbstractTestCase
      */
     public function testExtract(): void
     {
-        $this->assertFalse(
+        self::assertFalse(
             $this->zipExtension->extract(
                 './tests/test_data/test.zip',
                 'wrongName',
             ),
         );
-        $this->assertEquals(
+        self::assertEquals(
             "TEST FILE\n",
             $this->zipExtension->extract(
                 './tests/test_data/test.zip',
@@ -137,19 +137,19 @@ class ZipExtensionTest extends AbstractTestCase
     public function testCreateSingleFile(): void
     {
         $file = $this->zipExtension->createFile('Test content', 'test.txt');
-        $this->assertIsString($file);
-        $this->assertNotEmpty($file);
+        self::assertIsString($file);
+        self::assertNotEmpty($file);
 
         $tmp = tempnam('./', 'zip-test');
-        $this->assertNotFalse($tmp);
-        $this->assertNotFalse(file_put_contents($tmp, $file));
+        self::assertNotFalse($tmp);
+        self::assertNotFalse(file_put_contents($tmp, $file));
 
         $zip = new ZipArchive();
-        $this->assertTrue(
+        self::assertTrue(
             $zip->open($tmp),
         );
 
-        $this->assertEquals(0, $zip->locateName('test.txt'));
+        self::assertEquals(0, $zip->locateName('test.txt'));
 
         $zip->close();
         unlink($tmp);
@@ -160,7 +160,7 @@ class ZipExtensionTest extends AbstractTestCase
      */
     public function testCreateFailure(): void
     {
-        $this->assertFalse(
+        self::assertFalse(
             $this->zipExtension->createFile(
                 'Content',
                 ['name1.txt', 'name2.txt'],
@@ -177,20 +177,20 @@ class ZipExtensionTest extends AbstractTestCase
             ['Content', 'Content2'],
             ['name1.txt', 'name2.txt'],
         );
-        $this->assertIsString($file);
-        $this->assertNotEmpty($file);
+        self::assertIsString($file);
+        self::assertNotEmpty($file);
 
         $tmp = tempnam('./', 'zip-test');
-        $this->assertNotFalse($tmp);
-        $this->assertNotFalse(file_put_contents($tmp, $file));
+        self::assertNotFalse($tmp);
+        self::assertNotFalse(file_put_contents($tmp, $file));
 
         $zip = new ZipArchive();
-        $this->assertTrue(
+        self::assertTrue(
             $zip->open($tmp),
         );
 
-        $this->assertEquals(0, $zip->locateName('name1.txt'));
-        $this->assertEquals(1, $zip->locateName('name2.txt'));
+        self::assertEquals(0, $zip->locateName('name1.txt'));
+        self::assertEquals(1, $zip->locateName('name2.txt'));
 
         $zip->close();
         unlink($tmp);
diff --git a/tests/selenium/ChangePasswordTest.php b/tests/selenium/ChangePasswordTest.php
index be4f62a1c1..ffb8b979d5 100644
--- a/tests/selenium/ChangePasswordTest.php
+++ b/tests/selenium/ChangePasswordTest.php
@@ -33,18 +33,18 @@ class ChangePasswordTest extends TestBase
         $this->waitForElement('xpath', "//span[contains(., 'Change password')]");
 
         $ele = $this->waitForElement('name', 'pma_pw');
-        $this->assertEquals('', $ele->getAttribute('value'));
+        self::assertEquals('', $ele->getAttribute('value'));
 
         $ele = $this->waitForElement('name', 'pma_pw2');
-        $this->assertEquals('', $ele->getAttribute('value'));
+        self::assertEquals('', $ele->getAttribute('value'));
 
         $ele = $this->waitForElement('name', 'generated_pw');
-        $this->assertEquals('', $ele->getAttribute('value'));
+        self::assertEquals('', $ele->getAttribute('value'));
 
         $this->byId('button_generate_password')->click();
-        $this->assertNotEquals('', $this->byName('pma_pw')->getAttribute('value'));
-        $this->assertNotEquals('', $this->byName('pma_pw2')->getAttribute('value'));
-        $this->assertNotEquals('', $this->byName('generated_pw')->getAttribute('value'));
+        self::assertNotEquals('', $this->byName('pma_pw')->getAttribute('value'));
+        self::assertNotEquals('', $this->byName('pma_pw2')->getAttribute('value'));
+        self::assertNotEquals('', $this->byName('generated_pw')->getAttribute('value'));
 
         if ($this->getTestSuiteUserPassword() !== '') {
             $this->byName('pma_pw')->clear();
@@ -59,7 +59,7 @@ class ChangePasswordTest extends TestBase
 
         $this->byId('changePasswordGoButton')->click();
         $ele = $this->waitForElement('cssSelector', '.alert-success');
-        $this->assertEquals(
+        self::assertEquals(
             'The profile has been updated.',
             trim($ele->getText()),
         );
diff --git a/tests/selenium/CreateDropDatabaseTest.php b/tests/selenium/CreateDropDatabaseTest.php
index f83e7bd993..cfc7dee4f5 100644
--- a/tests/selenium/CreateDropDatabaseTest.php
+++ b/tests/selenium/CreateDropDatabaseTest.php
@@ -44,8 +44,8 @@ class CreateDropDatabaseTest extends TestBase
         $this->dbQuery(
             'SHOW DATABASES LIKE \'' . $this->databaseName . '\';',
             function (): void {
-                $this->assertTrue($this->isElementPresent('className', 'table_results'));
-                $this->assertEquals($this->databaseName, $this->getCellByTableClass('table_results', 1, 1));
+                self::assertTrue($this->isElementPresent('className', 'table_results'));
+                self::assertEquals($this->databaseName, $this->getCellByTableClass('table_results', 1, 1));
             },
         );
 
@@ -83,8 +83,8 @@ class CreateDropDatabaseTest extends TestBase
         $this->dbQuery(
             'SHOW DATABASES LIKE \'' . $this->databaseName . '\';',
             function (): void {
-                $this->assertTrue($this->isElementPresent('className', 'table_results'));
-                $this->assertFalse($this->isElementPresent('cssSelector', '.table_results tbody tr'));
+                self::assertTrue($this->isElementPresent('className', 'table_results'));
+                self::assertFalse($this->isElementPresent('cssSelector', '.table_results tbody tr'));
             },
         );
     }
diff --git a/tests/selenium/CreateRemoveUserTest.php b/tests/selenium/CreateRemoveUserTest.php
index bfbe603b29..5dccb828b1 100644
--- a/tests/selenium/CreateRemoveUserTest.php
+++ b/tests/selenium/CreateRemoveUserTest.php
@@ -68,9 +68,9 @@ class CreateRemoveUserTest extends TestBase
         $genButton = $this->waitForElement('id', 'button_generate_password');
         $genButton->click();
 
-        $this->assertNotEquals('', $this->byId('text_pma_pw')->getAttribute('value'));
-        $this->assertNotEquals('', $this->byId('text_pma_pw2')->getAttribute('value'));
-        $this->assertNotEquals('', $this->byId('generated_pw')->getAttribute('value'));
+        self::assertNotEquals('', $this->byId('text_pma_pw')->getAttribute('value'));
+        self::assertNotEquals('', $this->byId('text_pma_pw2')->getAttribute('value'));
+        self::assertNotEquals('', $this->byId('generated_pw')->getAttribute('value'));
 
         $this->byId('text_pma_pw')->sendKeys($this->txtPassword);
         $this->byId('text_pma_pw2')->sendKeys($this->txtPassword);
@@ -87,7 +87,7 @@ class CreateRemoveUserTest extends TestBase
         $this->waitForElement('id', 'adduser_submit')->click();
 
         $success = $this->waitForElement('cssSelector', '.alert-success');
-        $this->assertStringContainsString('You have added a new user', $success->getText());
+        self::assertStringContainsString('You have added a new user', $success->getText());
 
         // Removing the newly added user
         $this->waitForElement('partialLinkText', 'User accounts')->click();
@@ -104,7 +104,7 @@ class CreateRemoveUserTest extends TestBase
         $this->acceptAlert();
 
         $success = $this->waitForElement('cssSelector', '.alert-success');
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             'The selected users have been deleted',
             $success->getText(),
         );
diff --git a/tests/selenium/Database/EventsTest.php b/tests/selenium/Database/EventsTest.php
index 8f29e007ba..bb9d915ae8 100644
--- a/tests/selenium/Database/EventsTest.php
+++ b/tests/selenium/Database/EventsTest.php
@@ -116,7 +116,7 @@ class EventsTest extends TestBase
         $this->byCssSelector('div.ui-dialog-buttonset button:nth-child(1)')->click();
 
         $success = $this->waitForElement('cssSelector', '.alert-success');
-        $this->assertStringContainsString('Event `test_event` has been created', $success->getText());
+        self::assertStringContainsString('Event `test_event` has been created', $success->getText());
         $this->waitForElementNotPresent(
             'xpath',
             '//div[@id=\'alertLabel\' and not(contains(@style,\'display: none;\'))]',
@@ -125,7 +125,7 @@ class EventsTest extends TestBase
         // Refresh the page
         $this->webDriver->navigate()->refresh();
 
-        $this->assertTrue(
+        self::assertTrue(
             $this->isElementPresent(
                 'xpath',
                 "//td[contains(., 'test_event')]",
@@ -136,10 +136,10 @@ class EventsTest extends TestBase
             'USE `' . $this->databaseName . '`;'
             . 'SHOW EVENTS WHERE Db=\'' . $this->databaseName . '\' AND Name=\'test_event\';',
             function (): void {
-                $this->assertTrue($this->isElementPresent('className', 'table_results'));
-                $this->assertEquals($this->databaseName, $this->getCellByTableClass('table_results', 1, 1));
-                $this->assertEquals('test_event', $this->getCellByTableClass('table_results', 1, 2));
-                $this->assertEquals('RECURRING', $this->getCellByTableClass('table_results', 1, 5));
+                self::assertTrue($this->isElementPresent('className', 'table_results'));
+                self::assertEquals($this->databaseName, $this->getCellByTableClass('table_results', 1, 1));
+                self::assertEquals('test_event', $this->getCellByTableClass('table_results', 1, 2));
+                self::assertEquals('RECURRING', $this->getCellByTableClass('table_results', 1, 5));
             },
         );
 
@@ -147,9 +147,9 @@ class EventsTest extends TestBase
         $this->dbQuery(
             'SELECT * FROM `' . $this->databaseName . '`.`test_table`',
             function (): void {
-                $this->assertTrue($this->isElementPresent('className', 'table_results'));
+                self::assertTrue($this->isElementPresent('className', 'table_results'));
                 // [ ] | Edit | Copy | Delete | 1 | <number>
-                $this->assertGreaterThan(2, (int) $this->getCellByTableClass('table_results', 1, 6));
+                self::assertGreaterThan(2, (int) $this->getCellByTableClass('table_results', 1, 6));
             },
         );
     }
@@ -176,15 +176,15 @@ class EventsTest extends TestBase
         $this->byCssSelector('div.ui-dialog-buttonset button:nth-child(1)')->click();
 
         $success = $this->waitForElement('cssSelector', '.alert-success');
-        $this->assertStringContainsString('Event `test_event` has been modified', $success->getText());
+        self::assertStringContainsString('Event `test_event` has been modified', $success->getText());
 
         sleep(2);
         $this->dbQuery(
             'SELECT * FROM `' . $this->databaseName . '`.`test_table`',
             function (): void {
-                $this->assertTrue($this->isElementPresent('className', 'table_results'));
+                self::assertTrue($this->isElementPresent('className', 'table_results'));
                 // [ ] | Edit | Copy | Delete | 4
-                $this->assertGreaterThan(3, (int) $this->getCellByTableClass('table_results', 1, 6));
+                self::assertGreaterThan(3, (int) $this->getCellByTableClass('table_results', 1, 6));
             },
         );
     }
@@ -211,8 +211,8 @@ class EventsTest extends TestBase
             'USE `' . $this->databaseName . '`;'
             . 'SHOW EVENTS WHERE Db=\'' . $this->databaseName . '\' AND Name=\'test_event\';',
             function (): void {
-                $this->assertTrue($this->isElementPresent('className', 'table_results'));
-                $this->assertFalse($this->isElementPresent('cssSelector', '.table_results tbody tr'));
+                self::assertTrue($this->isElementPresent('className', 'table_results'));
+                self::assertFalse($this->isElementPresent('cssSelector', '.table_results tbody tr'));
             },
         );
     }
diff --git a/tests/selenium/Database/OperationsTest.php b/tests/selenium/Database/OperationsTest.php
index cb849912e4..145ad8470a 100644
--- a/tests/selenium/Database/OperationsTest.php
+++ b/tests/selenium/Database/OperationsTest.php
@@ -43,7 +43,7 @@ class OperationsTest extends TestBase
         $this->byName('comment')->sendKeys('comment_foobar');
         $this->byCssSelector("form#formDatabaseComment input[type='submit']")->click();
 
-        $this->assertNotNull(
+        self::assertNotNull(
             $this->waitForElement(
                 'xpath',
                 "//span[@class='breadcrumb-comment' and contains(., 'comment_foobar')]",
@@ -74,16 +74,16 @@ class OperationsTest extends TestBase
         $this->dbQuery(
             'SHOW DATABASES LIKE \'' . $newDbName . '\'',
             function () use ($newDbName): void {
-                $this->assertTrue($this->isElementPresent('className', 'table_results'));
-                $this->assertEquals($newDbName, $this->getCellByTableClass('table_results', 1, 1));
+                self::assertTrue($this->isElementPresent('className', 'table_results'));
+                self::assertEquals($newDbName, $this->getCellByTableClass('table_results', 1, 1));
             },
         );
 
         $this->dbQuery(
             'SHOW DATABASES LIKE \'' . $this->databaseName . '\'',
             function (): void {
-                $this->assertTrue($this->isElementPresent('className', 'table_results'));
-                $this->assertFalse($this->isElementPresent('cssSelector', '.table_results tbody tr'));
+                self::assertTrue($this->isElementPresent('className', 'table_results'));
+                self::assertFalse($this->isElementPresent('cssSelector', '.table_results tbody tr'));
             },
         );
 
@@ -109,7 +109,7 @@ class OperationsTest extends TestBase
         $this->byCssSelector('form#copy_db_form input[name="submit_copy"]')->click();
 
         $success = $this->waitForElement('cssSelector', '.alert-success');
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             'Database ' . $this->databaseName . ' has been copied to ' . $newDbName,
             $success->getText(),
         );
@@ -117,8 +117,8 @@ class OperationsTest extends TestBase
         $this->dbQuery(
             'SHOW DATABASES LIKE \'' . $newDbName . '\'',
             function () use ($newDbName): void {
-                $this->assertTrue($this->isElementPresent('className', 'table_results'));
-                $this->assertEquals($newDbName, $this->getCellByTableClass('table_results', 1, 1));
+                self::assertTrue($this->isElementPresent('className', 'table_results'));
+                self::assertEquals($newDbName, $this->getCellByTableClass('table_results', 1, 1));
             },
         );
 
diff --git a/tests/selenium/Database/ProceduresTest.php b/tests/selenium/Database/ProceduresTest.php
index 35e91a4d78..07e43c1b3f 100644
--- a/tests/selenium/Database/ProceduresTest.php
+++ b/tests/selenium/Database/ProceduresTest.php
@@ -67,9 +67,9 @@ class ProceduresTest extends TestBase
                 $this->waitForElement('cssSelector', '.collapse .card-footer input[type=submit]')->click();
                 $this->waitAjax();
                 sleep(2);// Waitfor the new results
-                $this->assertTrue($this->isElementPresent('className', 'table_results'));
+                self::assertTrue($this->isElementPresent('className', 'table_results'));
                 $sqlMode = $this->getCellByTableClass('table_results', 1, 1);
-                $this->assertNotEmpty($sqlMode);
+                self::assertNotEmpty($sqlMode);
             },
         );
 
@@ -83,7 +83,7 @@ class ProceduresTest extends TestBase
     {
         if ($this->originalSqlMode !== '') {
             $this->dbQuery("SET GLOBAL sql_mode = '" . $this->originalSqlMode . "';");
-            $this->assertEquals(
+            self::assertEquals(
                 $this->originalSqlMode,
                 $this->getSqlMode(),
             );
@@ -156,13 +156,13 @@ class ProceduresTest extends TestBase
         $this->byCssSelector('div.ui-dialog-buttonset button:nth-child(1)')->click();
 
         $success = $this->waitForElement('cssSelector', '.alert-success');
-        $this->assertStringContainsString('Routine `test_procedure` has been created', $success->getText());
+        self::assertStringContainsString('Routine `test_procedure` has been created', $success->getText());
 
         $this->dbQuery(
             "SHOW PROCEDURE STATUS WHERE Db='" . $this->databaseName . "'",
             function (): void {
-                $this->assertTrue($this->isElementPresent('className', 'table_results'));
-                $this->assertEquals($this->databaseName, $this->getCellByTableClass('table_results', 1, 1));
+                self::assertTrue($this->isElementPresent('className', 'table_results'));
+                self::assertEquals($this->databaseName, $this->getCellByTableClass('table_results', 1, 1));
             },
         );
 
@@ -189,7 +189,7 @@ class ProceduresTest extends TestBase
         $this->byCssSelector('div.ui-dialog-buttonset button:nth-child(1)')->click();
 
         $success = $this->waitForElement('cssSelector', '.alert-success');
-        $this->assertStringContainsString('Routine `test_procedure` has been modified', $success->getText());
+        self::assertStringContainsString('Routine `test_procedure` has been modified', $success->getText());
 
         $this->executeProcedure('test_procedure', 14);
     }
@@ -214,8 +214,8 @@ class ProceduresTest extends TestBase
         $this->dbQuery(
             "SHOW PROCEDURE STATUS WHERE Db='" . $this->databaseName . "'",
             function (): void {
-                $this->assertTrue($this->isElementPresent('className', 'table_results'));
-                $this->assertFalse($this->isElementPresent('cssSelector', '.table_results tbody tr'));
+                self::assertTrue($this->isElementPresent('className', 'table_results'));
+                self::assertFalse($this->isElementPresent('cssSelector', '.table_results tbody tr'));
             },
         );
     }
@@ -238,6 +238,6 @@ class ProceduresTest extends TestBase
         $this->waitUntilElementIsVisible('cssSelector', 'span#PMA_slidingMessage', 30);
         sleep(2);// Give more chances to the JS effect to finish
         $head = $this->byCssSelector('span#PMA_slidingMessage table tbody')->getText();
-        $this->assertEquals("outp\n" . $length, $head);
+        self::assertEquals("outp\n" . $length, $head);
     }
 }
diff --git a/tests/selenium/Database/StructureTest.php b/tests/selenium/Database/StructureTest.php
index 5b795edabd..600f362d23 100644
--- a/tests/selenium/Database/StructureTest.php
+++ b/tests/selenium/Database/StructureTest.php
@@ -52,14 +52,14 @@ class StructureTest extends TestBase
         $this->waitForElement('id', 'functionConfirmOkButton')->click();
 
         $success = $this->waitForElement('cssSelector', '.alert-success');
-        $this->assertStringContainsString('MySQL returned an empty result', $success->getText());
+        self::assertStringContainsString('MySQL returned an empty result', $success->getText());
 
         $this->dbQuery(
             'SELECT CONCAT("Count: ", COUNT(*)) as c FROM `' . $this->databaseName . '`.`test_table`',
             function (): void {
-                $this->assertTrue($this->isElementPresent('className', 'table_results'));
+                self::assertTrue($this->isElementPresent('className', 'table_results'));
                 // [ ] | Edit | Copy | Delete | 1 | 5
-                $this->assertEquals('Count: 0', $this->getCellByTableClass('table_results', 1, 1));
+                self::assertEquals('Count: 0', $this->getCellByTableClass('table_results', 1, 1));
             },
         );
     }
@@ -85,8 +85,8 @@ class StructureTest extends TestBase
         $this->dbQuery(
             'SHOW TABLES FROM `' . $this->databaseName . '`;',
             function (): void {
-                $this->assertTrue($this->isElementPresent('className', 'table_results'));
-                $this->assertFalse($this->isElementPresent('cssSelector', '.table_results tbody tr'));
+                self::assertTrue($this->isElementPresent('className', 'table_results'));
+                self::assertFalse($this->isElementPresent('cssSelector', '.table_results tbody tr'));
             },
         );
     }
diff --git a/tests/selenium/ExportTest.php b/tests/selenium/ExportTest.php
index 0e961542b6..f4008f1038 100644
--- a/tests/selenium/ExportTest.php
+++ b/tests/selenium/ExportTest.php
@@ -46,7 +46,7 @@ class ExportTest extends TestBase
         $text = $this->doExport('server', $plugin);
 
         foreach ($expected as $str) {
-            $this->assertStringContainsString($str, $text);
+            self::assertStringContainsString($str, $text);
         }
     }
 
@@ -65,7 +65,7 @@ class ExportTest extends TestBase
         $text = $this->doExport('db', $plugin);
 
         foreach ($expected as $str) {
-            $this->assertStringContainsString($str, $text);
+            self::assertStringContainsString($str, $text);
         }
     }
 
@@ -86,7 +86,7 @@ class ExportTest extends TestBase
         $text = $this->doExport('table', $plugin);
 
         foreach ($expected as $str) {
-            $this->assertStringContainsString($str, $text);
+            self::assertStringContainsString($str, $text);
         }
     }
 
diff --git a/tests/selenium/ImportTest.php b/tests/selenium/ImportTest.php
index d6a36ed6d3..84029ef9a8 100644
--- a/tests/selenium/ImportTest.php
+++ b/tests/selenium/ImportTest.php
@@ -30,8 +30,8 @@ class ImportTest extends TestBase
         $this->dbQuery(
             'SHOW DATABASES LIKE \'test_import%\'',
             function (): void {
-                $this->assertEquals('test_import1', $this->getCellByTableClass('table_results', 1, 1));
-                $this->assertEquals('test_import2', $this->getCellByTableClass('table_results', 2, 1));
+                self::assertEquals('test_import1', $this->getCellByTableClass('table_results', 1, 1));
+                self::assertEquals('test_import2', $this->getCellByTableClass('table_results', 2, 1));
             },
         );
 
@@ -54,8 +54,8 @@ class ImportTest extends TestBase
             'USE `' . $this->databaseName . '`;'
             . 'SHOW TABLES FROM `' . $this->databaseName . '`',
             function (): void {
-                $this->assertTrue($this->isElementPresent('className', 'table_results'));
-                $this->assertEquals('test_table', $this->getCellByTableClass('table_results', 1, 1));
+                self::assertTrue($this->isElementPresent('className', 'table_results'));
+                self::assertEquals('test_table', $this->getCellByTableClass('table_results', 1, 1));
             },
         );
     }
@@ -80,9 +80,9 @@ class ImportTest extends TestBase
         $this->dbQuery(
             'SELECT * FROM `' . $this->databaseName . '`.test_table',
             function (): void {
-                $this->assertTrue($this->isElementPresent('className', 'table_results'));
-                $this->assertEquals('8', $this->getCellByTableClass('table_results', 1, 1));
-                $this->assertEquals('9', $this->getCellByTableClass('table_results', 2, 1));
+                self::assertTrue($this->isElementPresent('className', 'table_results'));
+                self::assertEquals('8', $this->getCellByTableClass('table_results', 1, 1));
+                self::assertEquals('9', $this->getCellByTableClass('table_results', 2, 1));
             },
         );
     }
@@ -109,6 +109,6 @@ class ImportTest extends TestBase
         $this->byId('buttonGo')->click();
 
         $success = $this->waitUntilElementIsVisible('cssSelector', '.alert-success', 30);
-        $this->assertStringContainsString('Import has been successfully', $success->getText());
+        self::assertStringContainsString('Import has been successfully', $success->getText());
     }
 }
diff --git a/tests/selenium/LoginTest.php b/tests/selenium/LoginTest.php
index 7816dad72a..c22c0b822f 100644
--- a/tests/selenium/LoginTest.php
+++ b/tests/selenium/LoginTest.php
@@ -30,7 +30,7 @@ class LoginTest extends TestBase
     {
         $this->login();
         $this->waitForElement('xpath', '//*[@id="server-breadcrumb"]');
-        $this->assertTrue($this->isSuccessLogin());
+        self::assertTrue($this->isSuccessLogin());
         $this->logOutIfLoggedIn();
     }
 
@@ -42,6 +42,6 @@ class LoginTest extends TestBase
     {
         $this->login('Admin', 'Admin');
         $this->waitForElement('xpath', '//*[@class="alert alert-danger" and contains(.,\'Access denied for\')]');
-        $this->assertTrue($this->isUnsuccessLogin());
+        self::assertTrue($this->isUnsuccessLogin());
     }
 }
diff --git a/tests/selenium/NormalizationTest.php b/tests/selenium/NormalizationTest.php
index 9fc4dd7724..2434b9edc0 100644
--- a/tests/selenium/NormalizationTest.php
+++ b/tests/selenium/NormalizationTest.php
@@ -44,11 +44,11 @@ class NormalizationTest extends TestBase
     #[Group('large')]
     public function testNormalizationTo1NF(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             'First step of normalization (1NF)',
             $this->byCssSelector('label[for=normalizeToRadio1]')->getText(),
         );
-        $this->assertTrue(
+        self::assertTrue(
             $this->isElementPresent(
                 'cssSelector',
                 'input[id=normalizeToRadio1][type=radio]:checked',
@@ -64,35 +64,35 @@ class NormalizationTest extends TestBase
      */
     private function assert1NFSteps(): void
     {
-        $this->assertEquals(
+        self::assertEquals(
             'First step of normalization (1NF)',
             $this->byCssSelector('#page_content h3')->getText(),
         );
-        $this->assertTrue(
+        self::assertTrue(
             $this->isElementPresent(
                 'cssSelector',
                 '#mainContent h4',
             ),
         );
-        $this->assertTrue(
+        self::assertTrue(
             $this->isElementPresent(
                 'cssSelector',
                 '#mainContent #newCols',
             ),
         );
-        $this->assertTrue(
+        self::assertTrue(
             $this->isElementPresent(
                 'cssSelector',
                 '#selectNonAtomicCol option[value=val2]',
             ),
         );
-        $this->assertFalse(
+        self::assertFalse(
             $this->isElementPresent(
                 'cssSelector',
                 '#selectNonAtomicCol option[value=val]',
             ),
         );
-        $this->assertTrue(
+        self::assertTrue(
             $this->isElementPresent(
                 'cssSelector',
                 '#selectNonAtomicCol option[value=no_such_col]',
@@ -106,23 +106,23 @@ class NormalizationTest extends TestBase
 
         $this->waitForElement('xpath', "//div[contains(., 'Step 1.2 Have a primary key')]");
         $text = $this->byCssSelector('#mainContent h4')->getText();
-        $this->assertStringContainsString('Primary key already exists.', $text);
+        self::assertStringContainsString('Primary key already exists.', $text);
         $this->waitForElement('xpath', "//div[contains(., 'Step 1.3 Move repeating groups')]");
         $this->byCssSelector('input[value="No repeating group"]')->click();
         $this->waitForElement('xpath', "//div[contains(., 'Step 1.4 Remove redundant columns')]");
-        $this->assertTrue(
+        self::assertTrue(
             $this->isElementPresent(
                 'cssSelector',
                 '#mainContent #extra',
             ),
         );
-        $this->assertTrue(
+        self::assertTrue(
             $this->isElementPresent(
                 'cssSelector',
                 '#extra input[value=val2][type=checkbox]',
             ),
         );
-        $this->assertTrue(
+        self::assertTrue(
             $this->isElementPresent(
                 'cssSelector',
                 '#extra input[value=id][type=checkbox]',
@@ -131,7 +131,7 @@ class NormalizationTest extends TestBase
         $this->byCssSelector('#extra input[value=val][type=checkbox]')->click();
         $this->byCssSelector('#removeRedundant')->click();
         $this->waitForElement('xpath', "//div[contains(., 'End of step')]");
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             "The first step of normalization is complete for table 'test_table'.",
             $this->byCssSelector('#mainContent h4')->getText(),
         );
diff --git a/tests/selenium/ServerSettingsTest.php b/tests/selenium/ServerSettingsTest.php
index 1ade87f977..8bb33f8ca3 100644
--- a/tests/selenium/ServerSettingsTest.php
+++ b/tests/selenium/ServerSettingsTest.php
@@ -46,7 +46,7 @@ class ServerSettingsTest extends TestBase
         $ele->click();
 
         $success = $this->waitUntilElementIsPresent('cssSelector', '.alert-success', 5000);
-        $this->assertStringContainsString('Configuration has been saved', $success->getText());
+        self::assertStringContainsString('Configuration has been saved', $success->getText());
     }
 
     /**
@@ -67,7 +67,7 @@ class ServerSettingsTest extends TestBase
         $ele->sendKeys($this->databaseName);
 
         $this->saveConfig();
-        $this->assertFalse(
+        self::assertFalse(
             $this->isElementPresent('partialLinkText', $this->databaseName),
         );
 
@@ -75,7 +75,7 @@ class ServerSettingsTest extends TestBase
 
         $this->waitForElement('name', 'Servers-1-hide_db')->clear();
         $this->saveConfig();
-        $this->assertTrue(
+        self::assertTrue(
             $this->isElementPresent('partialLinkText', $this->databaseName),
         );
     }
@@ -92,18 +92,18 @@ class ServerSettingsTest extends TestBase
         $this->waitForElement('className', 'nav-tabs');
 
         $this->byPartialLinkText('SQL Query box')->click();
-        $this->assertTrue(
+        self::assertTrue(
             $this->byId('Sql_box')->isDisplayed(),
         );
-        $this->assertFalse(
+        self::assertFalse(
             $this->byId('Sql_queries')->isDisplayed(),
         );
 
         $this->byCssSelector("a[href='#Sql_queries']")->click();
-        $this->assertFalse(
+        self::assertFalse(
             $this->byId('Sql_box')->isDisplayed(),
         );
-        $this->assertTrue(
+        self::assertTrue(
             $this->byId('Sql_queries')->isDisplayed(),
         );
     }
@@ -121,14 +121,14 @@ class ServerSettingsTest extends TestBase
             ->click();
         $this->saveConfig();
         sleep(1);
-        $this->assertFalse(
+        self::assertFalse(
             $this->isElementPresent('id', 'imgpmalogo'),
         );
 
         $this->byCssSelector("a[href='#NavigationDisplayLogo']")->click();
         $this->saveConfig();
         sleep(1);
-        $this->assertTrue(
+        self::assertTrue(
             $this->isElementPresent('id', 'imgpmalogo'),
         );
     }
diff --git a/tests/selenium/SqlQueryTest.php b/tests/selenium/SqlQueryTest.php
index 1786d6fd99..754a8a6087 100644
--- a/tests/selenium/SqlQueryTest.php
+++ b/tests/selenium/SqlQueryTest.php
@@ -41,23 +41,23 @@ class SqlQueryTest extends TestBase
         $this->waitAjax();
 
         $this->waitForElement('cssSelector', 'table.table_results');
-        $this->assertEquals(
+        self::assertEquals(
             1,
             $this->getCellByTableClass('table_results', 1, 1),
         );
-        $this->assertEquals(
+        self::assertEquals(
             1,
             $this->getCellByTableClass('table_results', 1, 2),
         );
-        $this->assertEquals(
+        self::assertEquals(
             2,
             $this->getCellByTableClass('table_results', 1, 3),
         );
-        $this->assertEquals(
+        self::assertEquals(
             4,
             $this->getCellByTableClass('table_results', 1, 4),
         );
-        $this->assertEquals(
+        self::assertEquals(
             7,
             $this->getCellByTableClass('table_results', 1, 5),
         );
@@ -81,15 +81,15 @@ class SqlQueryTest extends TestBase
         $this->waitAjax();
 
         $this->waitForElement('cssSelector', 'table.table_results');
-        $this->assertEquals(
+        self::assertEquals(
             'test_table',
             $this->getCellByTableClass('table_results', 1, 1),
         );
-        $this->assertEquals(
+        self::assertEquals(
             'InnoDB',
             $this->getCellByTableClass('table_results', 1, 2),
         );
-        $this->assertEquals(
+        self::assertEquals(
             4,
             $this->getCellByTableClass('table_results', 1, 5),
         );
@@ -114,19 +114,19 @@ class SqlQueryTest extends TestBase
         $this->waitAjax();
 
         $this->waitForElement('cssSelector', 'table.table_results');
-        $this->assertEquals(
+        self::assertEquals(
             3,
             $this->getCellByTableClass('table_results', 1, 5),
         );
-        $this->assertEquals(
+        self::assertEquals(
             4,
             $this->getCellByTableClass('table_results', 2, 5),
         );
-        $this->assertEquals(
+        self::assertEquals(
             4,
             $this->getCellByTableClass('table_results', 1, 6),
         );
-        $this->assertEquals(
+        self::assertEquals(
             5,
             $this->getCellByTableClass('table_results', 2, 6),
         );
@@ -149,7 +149,7 @@ class SqlQueryTest extends TestBase
         $this->waitAjax();
 
         $this->waitForElement('cssSelector', 'table.table_results');
-        $this->assertEquals(
+        self::assertEquals(
             1,
             $this->getCellByTableClass('table_results', 1, 1),
         );
diff --git a/tests/selenium/Table/BrowseTest.php b/tests/selenium/Table/BrowseTest.php
index 7e0294de2f..bc5bc2da41 100644
--- a/tests/selenium/Table/BrowseTest.php
+++ b/tests/selenium/Table/BrowseTest.php
@@ -49,17 +49,17 @@ class BrowseTest extends TestBase
         $this->byPartialLinkText('name')->click();
         $this->waitAjax();
 
-        $this->assertEquals(
+        self::assertEquals(
             '1',
             $this->getCellByTableClass('table_results', 1, 5),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             '3',
             $this->getCellByTableClass('table_results', 2, 5),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             '2',
             $this->getCellByTableClass('table_results', 3, 5),
         );
@@ -68,17 +68,17 @@ class BrowseTest extends TestBase
         $this->byPartialLinkText('name')->click();
         $this->waitAjax();
 
-        $this->assertEquals(
+        self::assertEquals(
             '2',
             $this->getCellByTableClass('table_results', 1, 5),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             '1',
             $this->getCellByTableClass('table_results', 2, 5),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             '3',
             $this->getCellByTableClass('table_results', 3, 5),
         );
@@ -88,17 +88,17 @@ class BrowseTest extends TestBase
         $this->waitAjax();
 
         $this->getCellByTableClass('table_results', 1, 5);
-        $this->assertEquals(
+        self::assertEquals(
             '3',
             $this->getCellByTableClass('table_results', 1, 5),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             '1',
             $this->getCellByTableClass('table_results', 2, 5),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             '2',
             $this->getCellByTableClass('table_results', 3, 5),
         );
@@ -107,17 +107,17 @@ class BrowseTest extends TestBase
         $this->byPartialLinkText('datetimefield')->click();
         $this->waitAjax();
 
-        $this->assertEquals(
+        self::assertEquals(
             '2',
             $this->getCellByTableClass('table_results', 1, 5),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             '1',
             $this->getCellByTableClass('table_results', 2, 5),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             '3',
             $this->getCellByTableClass('table_results', 3, 5),
         );
@@ -138,17 +138,17 @@ class BrowseTest extends TestBase
         $this->waitAjax();
         $this->waitForElement('id', 'insertForm');
 
-        $this->assertEquals(
+        self::assertEquals(
             '2',
             $this->byId('field_1_3')->getAttribute('value'),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'foo',
             $this->byId('field_2_3')->getAttribute('value'),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             '2010-01-20 02:00:02',
             $this->byId('field_3_3')->getAttribute('value'),
         );
@@ -165,14 +165,14 @@ class BrowseTest extends TestBase
 
         $this->waitAjax();
         $success = $this->waitForElement('className', 'alert-success');
-        $this->assertStringContainsString('1 row affected', $success->getText());
+        self::assertStringContainsString('1 row affected', $success->getText());
 
-        $this->assertEquals(
+        self::assertEquals(
             'foobar',
             $this->getCellByTableClass('table_results', 2, 6),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             '2009-01-02 00:00:00',
             $this->getCellByTableClass('table_results', 2, 7),
         );
@@ -189,7 +189,7 @@ class BrowseTest extends TestBase
         $this->moveto($element);
         $this->doubleclick();
 
-        $this->assertEquals(
+        self::assertEquals(
             $this->waitForElement(
                 'xpath',
                 "//div[not(contains(@style,'display: none;'))]//textarea[contains(@class, 'edit_box')]",
@@ -204,9 +204,9 @@ class BrowseTest extends TestBase
 
         $this->waitAjax();
         $success = $this->waitForElement('cssSelector', 'span.ajax_notification .alert-success');
-        $this->assertStringContainsString('1 row affected', $success->getText());
+        self::assertStringContainsString('1 row affected', $success->getText());
 
-        $this->assertEquals(
+        self::assertEquals(
             'abcde',
             $this->getCellByTableClass('table_results', 1, 6),
         );
@@ -223,12 +223,12 @@ class BrowseTest extends TestBase
         $this->click();
         $this->waitForElement('id', 'insertForm');
 
-        $this->assertEquals(
+        self::assertEquals(
             'Abcd',
             $this->byId('field_2_3')->getAttribute('value'),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             '2012-01-20 02:00:02',
             $this->byId('field_3_3')->getAttribute('value'),
         );
@@ -243,14 +243,14 @@ class BrowseTest extends TestBase
 
         $this->waitAjax();
         $success = $this->waitForElement('className', 'alert-success');
-        $this->assertStringContainsString('1 row inserted', $success->getText());
+        self::assertStringContainsString('1 row inserted', $success->getText());
 
-        $this->assertEquals(
+        self::assertEquals(
             'ABCDEFG',
             $this->getCellByTableClass('table_results', 4, 6),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             '2012-01-02 00:00:00',
             $this->getCellByTableClass('table_results', 4, 7),
         );
@@ -280,14 +280,14 @@ class BrowseTest extends TestBase
 
         $this->waitAjax();
         $success = $this->waitForElement('className', 'alert-success');
-        $this->assertStringContainsString('Showing rows', $success->getText());
+        self::assertStringContainsString('Showing rows', $success->getText());
 
-        $this->assertEquals(
+        self::assertEquals(
             '1',
             $this->getCellByTableClass('table_results', 1, 5),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             '3',
             $this->getCellByTableClass('table_results', 2, 5),
         );
@@ -312,14 +312,14 @@ class BrowseTest extends TestBase
             'cssSelector',
             '.sqlqueryresults > .result_query:nth-child(1) > .alert-success',
         );
-        $this->assertStringContainsString('Your SQL query has been executed successfully.', $success->getText());
+        self::assertStringContainsString('Your SQL query has been executed successfully.', $success->getText());
         $success = $this->waitForElement(
             'cssSelector',
             '.sqlqueryresults > .result_query:nth-child(2) > .alert-success',
         );
-        $this->assertStringContainsString('Showing rows', $success->getText());
+        self::assertStringContainsString('Showing rows', $success->getText());
 
-        $this->assertFalse(
+        self::assertFalse(
             $this->isElementPresent(
                 'cssSelector',
                 'table.table_results tbody tr:nth-child(2)',
diff --git a/tests/selenium/Table/CreateTest.php b/tests/selenium/Table/CreateTest.php
index ceb06bad6f..f1d317dd3e 100644
--- a/tests/selenium/Table/CreateTest.php
+++ b/tests/selenium/Table/CreateTest.php
@@ -103,41 +103,41 @@ class CreateTest extends TestBase
         $this->waitForElement('id', 'table_structure_id');
 
         // make assertions for first row
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             'test_id',
             $this->byCssSelector('label[for=checkbox_row_1]')->getText(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'int(14)',
             $this->getCellByTableId('tablestructure', 1, 4),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'UNSIGNED',
             $this->getCellByTableId('tablestructure', 1, 6),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'No',
             $this->getCellByTableId('tablestructure', 1, 7),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'None',
             $this->getCellByTableId('tablestructure', 1, 8),
         );
-        $this->assertEquals(
+        self::assertEquals(
             'comm1',
             $this->getCellByTableId('tablestructure', 1, 9),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'AUTO_INCREMENT',
             $this->getCellByTableId('tablestructure', 1, 10),
         );
 
-        $this->assertFalse(
+        self::assertFalse(
             $this->isElementPresent(
                 'cssSelector',
                 'table#tablestructure tbody tr:nth-child(1) "
@@ -146,32 +146,32 @@ class CreateTest extends TestBase
         );
 
         // make assertions for second row
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             'test_column',
             $this->byCssSelector('label[for=checkbox_row_2]')->getText(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'varchar(10)',
             $this->getCellByTableId('tablestructure', 2, 4),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'utf8mb4_general_ci',
             $this->getCellByTableId('tablestructure', 2, 5),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'Yes',
             $this->getCellByTableId('tablestructure', 2, 7),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'def',
             $this->getCellByTableId('tablestructure', 2, 8),
         );
 
-        $this->assertFalse(
+        self::assertFalse(
             $this->isElementPresent(
                 'cssSelector',
                 'css=ul.table-structure-actions:nth-child(2) li.primary a',
diff --git a/tests/selenium/Table/InsertTest.php b/tests/selenium/Table/InsertTest.php
index ccb3ba5783..eda6099d78 100644
--- a/tests/selenium/Table/InsertTest.php
+++ b/tests/selenium/Table/InsertTest.php
@@ -41,7 +41,7 @@ class InsertTest extends TestBase
     {
         if ($this->isSafari()) {
             /* TODO: this should be fixed, but the cause is unclear to me */
-            $this->markTestIncomplete('Fails with Safari');
+            self::markTestIncomplete('Fails with Safari');
         }
 
         $this->waitAjax();
@@ -74,7 +74,7 @@ class InsertTest extends TestBase
         $this->waitAjax();
 
         $ele = $this->waitForElement('className', 'alert-success');
-        $this->assertStringContainsString('2 rows inserted', $ele->getText());
+        self::assertStringContainsString('2 rows inserted', $ele->getText());
 
         // shorter date to prevent error,
         // automatically gets appended with 00:00:00
@@ -92,7 +92,7 @@ class InsertTest extends TestBase
             'xpath',
             "//div[contains(@class, 'alert-success') and not(contains(@class, 'message'))]",
         );
-        $this->assertStringContainsString('1 row inserted', $ele->getText());
+        self::assertStringContainsString('1 row inserted', $ele->getText());
 
         $this->assertDataPresent();
     }
@@ -107,47 +107,47 @@ class InsertTest extends TestBase
         $this->waitAjax();
         $this->waitForElement('cssSelector', 'table.table_results');
 
-        $this->assertEquals(
+        self::assertEquals(
             '1',
             $this->getCellByTableClass('table_results', 1, 5),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'abcd',
             $this->getCellByTableClass('table_results', 1, 6),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             '2011-01-02 00:00:00',
             $this->getCellByTableClass('table_results', 1, 7),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             '2',
             $this->getCellByTableClass('table_results', 2, 5),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'foo',
             $this->getCellByTableClass('table_results', 2, 6),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             '2012-01-02 00:00:00',
             $this->getCellByTableClass('table_results', 2, 7),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             '4',
             $this->getCellByTableClass('table_results', 3, 5),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'Abcd',
             $this->getCellByTableClass('table_results', 3, 6),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             '2013-01-02 00:00:00',
             $this->getCellByTableClass('table_results', 3, 7),
         );
diff --git a/tests/selenium/Table/OperationsTest.php b/tests/selenium/Table/OperationsTest.php
index ffcc8010b8..fd34484adc 100644
--- a/tests/selenium/Table/OperationsTest.php
+++ b/tests/selenium/Table/OperationsTest.php
@@ -63,14 +63,14 @@ class OperationsTest extends TestBase
         $this->waitAjax();
 
         $success = $this->waitForElement('cssSelector', '.alert-success');
-        $this->assertStringContainsString('Your SQL query has been executed successfully', $success->getText());
+        self::assertStringContainsString('Your SQL query has been executed successfully', $success->getText());
 
         $this->byPartialLinkText('Browse')->click();
 
         $this->waitAjax();
         $this->waitForElement('cssSelector', 'table.table_results');
 
-        $this->assertEquals(
+        self::assertEquals(
             '2',
             $this->getCellByTableClass('table_results', 1, 5),
         );
@@ -89,7 +89,7 @@ class OperationsTest extends TestBase
         $this->waitAjax();
 
         $success = $this->waitForElement('cssSelector', '.alert-success');
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             'Table `' . $this->databaseName . '`.`test_table` has been moved to `'
             . $this->databaseName . '`.`test_table2`',
             $success->getText(),
@@ -99,8 +99,8 @@ class OperationsTest extends TestBase
             'USE `' . $this->databaseName . '`;'
             . 'SHOW TABLES LIKE \'test_table2\'',
             function (): void {
-                $this->assertTrue($this->isElementPresent('className', 'table_results'));
-                $this->assertEquals('test_table2', $this->getCellByTableClass('table_results', 1, 1));
+                self::assertTrue($this->isElementPresent('className', 'table_results'));
+                self::assertEquals('test_table2', $this->getCellByTableClass('table_results', 1, 1));
             },
         );
     }
@@ -122,14 +122,14 @@ class OperationsTest extends TestBase
         $this->waitAjax();
 
         $success = $this->waitForElement('cssSelector', '.alert-success');
-        $this->assertStringContainsString('Table test_table has been renamed to test_table2', $success->getText());
+        self::assertStringContainsString('Table test_table has been renamed to test_table2', $success->getText());
 
         $this->dbQuery(
             'USE `' . $this->databaseName . '`;'
             . 'SHOW TABLES LIKE \'test_table2\'',
             function (): void {
-                $this->assertTrue($this->isElementPresent('className', 'table_results'));
-                $this->assertEquals('test_table2', $this->getCellByTableClass('table_results', 1, 1));
+                self::assertTrue($this->isElementPresent('className', 'table_results'));
+                self::assertEquals('test_table2', $this->getCellByTableClass('table_results', 1, 1));
             },
         );
     }
@@ -148,7 +148,7 @@ class OperationsTest extends TestBase
         $this->waitAjax();
 
         $success = $this->waitForElement('cssSelector', '.alert-success');
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             'Table `' . $this->databaseName . '`.`test_table` has been copied to `'
             . $this->databaseName . '`.`test_table2`',
             $success->getText(),
@@ -157,8 +157,8 @@ class OperationsTest extends TestBase
         $this->dbQuery(
             'SELECT COUNT(*) as c FROM `' . $this->databaseName . '`.test_table2',
             function (): void {
-                $this->assertTrue($this->isElementPresent('className', 'table_results'));
-                $this->assertEquals('2', $this->getCellByTableClass('table_results', 1, 1));
+                self::assertTrue($this->isElementPresent('className', 'table_results'));
+                self::assertEquals('2', $this->getCellByTableClass('table_results', 1, 1));
             },
         );
     }
@@ -176,13 +176,13 @@ class OperationsTest extends TestBase
         $this->waitAjax();
 
         $success = $this->waitForElement('cssSelector', '.alert-success');
-        $this->assertStringContainsString('MySQL returned an empty result set', $success->getText());
+        self::assertStringContainsString('MySQL returned an empty result set', $success->getText());
 
         $this->dbQuery(
             'SELECT CONCAT("Count: ", COUNT(*)) as c FROM `' . $this->databaseName . '`.test_table',
             function (): void {
-                $this->assertTrue($this->isElementPresent('className', 'table_results'));
-                $this->assertEquals('Count: 0', $this->getCellByTableClass('table_results', 1, 1));
+                self::assertTrue($this->isElementPresent('className', 'table_results'));
+                self::assertEquals('Count: 0', $this->getCellByTableClass('table_results', 1, 1));
             },
         );
     }
@@ -200,14 +200,14 @@ class OperationsTest extends TestBase
         $this->waitAjax();
 
         $success = $this->waitForElement('cssSelector', '.alert-success');
-        $this->assertStringContainsString('MySQL returned an empty result set', $success->getText());
+        self::assertStringContainsString('MySQL returned an empty result set', $success->getText());
 
         $this->dbQuery(
             'USE `' . $this->databaseName . '`;'
             . 'SHOW TABLES',
             function (): void {
-                $this->assertTrue($this->isElementPresent('className', 'table_results'));
-                $this->assertFalse($this->isElementPresent('cssSelector', '.table_results tbody tr'));
+                self::assertTrue($this->isElementPresent('className', 'table_results'));
+                self::assertFalse($this->isElementPresent('cssSelector', '.table_results tbody tr'));
             },
         );
     }
diff --git a/tests/selenium/Table/StructureTest.php b/tests/selenium/Table/StructureTest.php
index 4cd38bcab1..e0e46628f6 100644
--- a/tests/selenium/Table/StructureTest.php
+++ b/tests/selenium/Table/StructureTest.php
@@ -57,12 +57,12 @@ class StructureTest extends TestBase
         $this->waitAjax();
         $this->waitForElement('id', 'tablestructure');
 
-        $this->assertEquals(
+        self::assertEquals(
             'val3',
             $this->byCssSelector('label[for=checkbox_row_4]')->getText(),
         );
 
-        $this->assertEquals(
+        self::assertEquals(
             'int(11)',
             $this->getCellByTableId('tablestructure', 4, 4),
         );
@@ -79,7 +79,7 @@ class StructureTest extends TestBase
 
         $this->waitUntilElementIsPresent('className', 'append_fields_form', 30);
 
-        $this->assertEquals('val', $this->byId('field_0_1')->getAttribute('value'));
+        self::assertEquals('val', $this->byId('field_0_1')->getAttribute('value'));
         $this->byId('field_0_1')->clear();
         $this->byId('field_0_1')->sendKeys('val3');
         $this->byCssSelector("input[name='do_save_data']")->click();
@@ -89,7 +89,7 @@ class StructureTest extends TestBase
 
         $this->waitForElement('id', 'tablestructure');
 
-        $this->assertEquals(
+        self::assertEquals(
             'val3',
             $this->waitForElement('cssSelector', 'label[for=checkbox_row_2]')->getText(),
         );
@@ -108,10 +108,10 @@ class StructureTest extends TestBase
         $this->waitForElement('cssSelector', "input[id='buttonYes']")->click();
 
         $success = $this->waitForElement('cssSelector', '.alert-success');
-        $this->assertStringContainsString('2 columns have been dropped successfully.', $success->getText());
+        self::assertStringContainsString('2 columns have been dropped successfully.', $success->getText());
         $this->waitAjax();
 
-        $this->assertFalse(
+        self::assertFalse(
             $this->isElementPresent(
                 'cssSelector',
                 'label[for=checkbox_row_2]',
diff --git a/tests/selenium/TestBase.php b/tests/selenium/TestBase.php
index 7fbb22c54a..179ebcf2f2 100644
--- a/tests/selenium/TestBase.php
+++ b/tests/selenium/TestBase.php
@@ -106,16 +106,16 @@ abstract class TestBase extends TestCase
         parent::setUp();
 
         if ($this->getHubUrl() === '') {
-            $this->markTestSkipped('Selenium testing is not configured.');
+            self::markTestSkipped('Selenium testing is not configured.');
         }
 
         if ($this->getTestSuiteUrl() === '') {
-            $this->markTestSkipped('The ENV "TESTSUITE_URL" is not defined.');
+            self::markTestSkipped('The ENV "TESTSUITE_URL" is not defined.');
         }
 
         if ($this->getTestSuiteUserLogin() === '') {
             //TODO: handle config mode
-            $this->markTestSkipped(
+            self::markTestSkipped(
                 'The ENV "TESTSUITE_USER" is not defined, you may also want to define "TESTSUITE_PASSWORD".',
             );
         }
@@ -414,7 +414,7 @@ abstract class TestBase extends TestCase
             return;
         }
 
-        $this->markTestSkipped('Test user is not a superuser.');
+        self::markTestSkipped('Test user is not a superuser.');
     }
 
     /**
@@ -447,7 +447,7 @@ abstract class TestBase extends TestCase
         }
 
         if (! $this->fixUpPhpMyAdminStorage()) {
-            $this->markTestSkipped('The phpMyAdmin configuration storage is not working.');
+            self::markTestSkipped('The phpMyAdmin configuration storage is not working.');
         }
 
         // If it failed the code already has exited with markTestSkipped
@@ -722,7 +722,7 @@ abstract class TestBase extends TestCase
         $element = $this->webDriver->wait(30, 500)->until(
             WebDriverExpectedCondition::presenceOfElementLocated(WebDriverBy::$func($arg)),
         );
-        $this->assertInstanceOf(RemoteWebElement::class, $element);
+        self::assertInstanceOf(RemoteWebElement::class, $element);
 
         return $element;
     }
@@ -739,7 +739,7 @@ abstract class TestBase extends TestCase
         $element = $this->webDriver->wait($timeout, 500)->until(
             WebDriverExpectedCondition::presenceOfElementLocated(WebDriverBy::$func($arg)),
         );
-        $this->assertInstanceOf(RemoteWebElement::class, $element);
+        self::assertInstanceOf(RemoteWebElement::class, $element);
 
         return $element;
     }
@@ -756,7 +756,7 @@ abstract class TestBase extends TestCase
         $element = $this->webDriver->wait($timeout, 500)->until(
             WebDriverExpectedCondition::visibilityOfElementLocated(WebDriverBy::$func($arg)),
         );
-        $this->assertInstanceOf(WebDriverElement::class, $element);
+        self::assertInstanceOf(WebDriverElement::class, $element);
 
         return $element;
     }
@@ -846,7 +846,7 @@ abstract class TestBase extends TestCase
          * https://github.com/seleniumhq/selenium-google-code-issue-archive/issues/4136
          */
         if ($this->isSafari()) {
-            $this->markTestSkipped('Can not send keys to Safari browser.');
+            self::markTestSkipped('Can not send keys to Safari browser.');
         } else {
             $this->webDriver->getKeyboard()->sendKeys($text);
         }
@@ -865,7 +865,7 @@ abstract class TestBase extends TestCase
          * https://github.com/seleniumhq/selenium-google-code-issue-archive/issues/4136
          */
         if ($this->isSafari()) {
-            $this->markTestSkipped('MoveTo not supported on Safari browser.');
+            self::markTestSkipped('MoveTo not supported on Safari browser.');
         } else {
             $this->webDriver->getMouse()->mouseMove($element->getCoordinates());
         }
@@ -885,7 +885,7 @@ abstract class TestBase extends TestCase
             return $this->webDriver->switchTo()->alert()->getText();
         }
 
-        $this->markTestSkipped('Alerts not supported on Safari browser.');
+        self::markTestSkipped('Alerts not supported on Safari browser.');
     }
 
     /**
diff --git a/tests/selenium/TrackingTest.php b/tests/selenium/TrackingTest.php
index accb2afcb6..44d9ea794a 100644
--- a/tests/selenium/TrackingTest.php
+++ b/tests/selenium/TrackingTest.php
@@ -61,22 +61,22 @@ class TrackingTest extends TestBase
         $this->byPartialLinkText('Tracking report')->click();
         $this->waitForElement('xpath', "//h3[contains(., 'Tracking report')]");
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             'DROP TABLE IF EXISTS `test_table`',
             $this->getCellByTableId('ddl_versions', 1, 4),
         );
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             'CREATE TABLE `test_table` (',
             $this->getCellByTableId('ddl_versions', 2, 4),
         );
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             'UPDATE test_table SET val = val + 1',
             $this->getCellByTableId('dml_versions', 1, 4),
         );
 
-        $this->assertStringNotContainsString(
+        self::assertStringNotContainsString(
             'DELETE FROM test_table WHERE val = 3',
             $this->byId('dml_versions')->getText(),
         );
@@ -88,16 +88,16 @@ class TrackingTest extends TestBase
 
         $this->waitAjax();
 
-        $this->assertFalse(
+        self::assertFalse(
             $this->isElementPresent('id', 'dml_versions'),
         );
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             'DROP TABLE IF EXISTS `test_table`',
             $this->getCellByTableId('ddl_versions', 1, 4),
         );
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             'CREATE TABLE `test_table` (',
             $this->getCellByTableId('ddl_versions', 2, 4),
         );
@@ -109,16 +109,16 @@ class TrackingTest extends TestBase
 
         $this->waitAjax();
 
-        $this->assertFalse(
+        self::assertFalse(
             $this->isElementPresent('id', 'ddl_versions'),
         );
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             'UPDATE test_table SET val = val + 1',
             $this->getCellByTableId('dml_versions', 1, 4),
         );
 
-        $this->assertStringNotContainsString(
+        self::assertStringNotContainsString(
             'DELETE FROM test_table WHERE val = 3',
             $this->byId('dml_versions')->getText(),
         );
@@ -133,7 +133,7 @@ class TrackingTest extends TestBase
         $this->byCssSelector("input[value='Deactivate now']")->click();
         $this->waitForElement('cssSelector', "input[value='Activate now']");
         $this->executeSqlAndReturnToTableTracking();
-        $this->assertFalse(
+        self::assertFalse(
             $this->isElementPresent('id', 'dml_versions'),
         );
     }
@@ -160,18 +160,18 @@ class TrackingTest extends TestBase
 
         $this->waitAjax();
         $success = $this->waitForElement('cssSelector', '.alert-success');
-        $this->assertStringContainsString('Tracking data deleted successfully.', $success->getText());
+        self::assertStringContainsString('Tracking data deleted successfully.', $success->getText());
 
         // Can not use getCellByTableId,
         // since this is under 'th' and not 'td'
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             'test_table',
             $this->waitForElement(
                 'cssSelector',
                 'table#noversions tbody tr:nth-child(1) th:nth-child(2)',
             )->getText(),
         );
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             'test_table_2',
             $this->waitForElement(
                 'cssSelector',
@@ -189,22 +189,22 @@ class TrackingTest extends TestBase
         $this->byPartialLinkText('Structure snapshot')->click();
         $this->waitForElement('id', 'tablestructure');
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             'id',
             $this->getCellByTableId('tablestructure', 1, 2),
         );
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             'val',
             $this->getCellByTableId('tablestructure', 2, 2),
         );
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             'PRIMARY',
             $this->getCellByTableId('tablestructure_indexes', 1, 1),
         );
 
-        $this->assertStringContainsString(
+        self::assertStringContainsString(
             'id',
             $this->getCellByTableId('tablestructure_indexes', 1, 5),
         );
diff --git a/tests/selenium/TriggersTest.php b/tests/selenium/TriggersTest.php
index bb09b93b9b..72c9a8c426 100644
--- a/tests/selenium/TriggersTest.php
+++ b/tests/selenium/TriggersTest.php
@@ -94,9 +94,9 @@ class TriggersTest extends TestBase
         $this->byCssSelector('div.ui-dialog-buttonset button:nth-child(1)')->click();
 
         $success = $this->waitForElement('cssSelector', '.alert-success');
-        $this->assertStringContainsString('Trigger `test_trigger` has been created', $success->getText());
+        self::assertStringContainsString('Trigger `test_trigger` has been created', $success->getText());
 
-        $this->assertTrue(
+        self::assertTrue(
             $this->isElementPresent(
                 'xpath',
                 "//td[contains(., 'test_trigger')]",
@@ -106,8 +106,8 @@ class TriggersTest extends TestBase
         $this->dbQuery(
             'SHOW TRIGGERS FROM `' . $this->databaseName . '`;',
             function (): void {
-                $this->assertTrue($this->isElementPresent('className', 'table_results'));
-                $this->assertEquals('test_trigger', $this->getCellByTableClass('table_results', 1, 1));
+                self::assertTrue($this->isElementPresent('className', 'table_results'));
+                self::assertEquals('test_trigger', $this->getCellByTableClass('table_results', 1, 1));
             },
         );
 
@@ -116,9 +116,9 @@ class TriggersTest extends TestBase
         $this->dbQuery(
             'SELECT * FROM `' . $this->databaseName . '`.`test_table2`;',
             function (): void {
-                $this->assertTrue($this->isElementPresent('className', 'table_results'));
+                self::assertTrue($this->isElementPresent('className', 'table_results'));
                 // [ ] | Edit | Copy | Delete | 1 | 3
-                $this->assertEquals('3', $this->getCellByTableClass('table_results', 1, 6));
+                self::assertEquals('3', $this->getCellByTableClass('table_results', 1, 6));
             },
         );
     }
@@ -146,16 +146,16 @@ class TriggersTest extends TestBase
         $this->byCssSelector('div.ui-dialog-buttonset button:nth-child(1)')->click();
 
         $success = $this->waitForElement('cssSelector', '.alert-success');
-        $this->assertStringContainsString('Trigger `test_trigger` has been modified', $success->getText());
+        self::assertStringContainsString('Trigger `test_trigger` has been modified', $success->getText());
 
         // test trigger
         $this->dbQuery('USE `' . $this->databaseName . '`;INSERT INTO `test_table` (val) VALUES (1);');
         $this->dbQuery(
             'SELECT * FROM `' . $this->databaseName . '`.`test_table2`;',
             function (): void {
-                $this->assertTrue($this->isElementPresent('className', 'table_results'));
+                self::assertTrue($this->isElementPresent('className', 'table_results'));
                 // [ ] | Edit | Copy | Delete | 1 | 12
-                $this->assertEquals('12', $this->getCellByTableClass('table_results', 1, 6));
+                self::assertEquals('12', $this->getCellByTableClass('table_results', 1, 6));
             },
         );
     }
@@ -184,17 +184,17 @@ class TriggersTest extends TestBase
         $this->dbQuery(
             'SELECT * FROM `' . $this->databaseName . '`.`test_table2`;',
             function (): void {
-                $this->assertTrue($this->isElementPresent('className', 'table_results'));
+                self::assertTrue($this->isElementPresent('className', 'table_results'));
                 // [ ] | Edit | Copy | Delete | 1 | 2
-                $this->assertEquals('2', $this->getCellByTableClass('table_results', 1, 6));
+                self::assertEquals('2', $this->getCellByTableClass('table_results', 1, 6));
             },
         );
 
         $this->dbQuery(
             'SHOW TRIGGERS FROM `' . $this->databaseName . '`;',
             function (): void {
-                $this->assertTrue($this->isElementPresent('className', 'table_results'));
-                $this->assertFalse($this->isElementPresent('cssSelector', '.table_results tbody tr'));
+                self::assertTrue($this->isElementPresent('className', 'table_results'));
+                self::assertFalse($this->isElementPresent('cssSelector', '.table_results tbody tr'));
             },
         );
     }
diff --git a/tests/selenium/XssTest.php b/tests/selenium/XssTest.php
index f6cb582a6f..7cacf4cc3f 100644
--- a/tests/selenium/XssTest.php
+++ b/tests/selenium/XssTest.php
@@ -29,7 +29,7 @@ class XssTest extends TestBase
     public function testQueryTabWithNullValue(): void
     {
         if ($this->isSafari()) {
-            $this->markTestSkipped('Alerts not supported on Safari browser.');
+            self::markTestSkipped('Alerts not supported on Safari browser.');
         }
 
         $this->waitForElement('partialLinkText', 'SQL')->click();
@@ -37,6 +37,6 @@ class XssTest extends TestBase
 
         $this->waitForElement('id', 'querybox');
         $this->byId('button_submit_query')->click();
-        $this->assertEquals('Missing value in the form!', $this->alertText());
+        self::assertEquals('Missing value in the form!', $this->alertText());
     }
 }