From: Tom Lane <tgl@sss.pgh.pa.us>
Date: Wed, 13 May 2026 14:37:42 +0000 (-0400)
Subject: Pre-beta mechanical code beautification, step 2: run pgperltidy.
X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=736a97bddd16f0511dc62b7e4770376a34f10114;p=thirdparty%2Fpostgresql.git

Pre-beta mechanical code beautification, step 2: run pgperltidy.

It's as opinionated as ever.
---

diff --git a/contrib/auto_explain/t/001_auto_explain.pl b/contrib/auto_explain/t/001_auto_explain.pl
index b4e8e4b65a1..f32a5e84f65 100644
--- a/contrib/auto_explain/t/001_auto_explain.pl
+++ b/contrib/auto_explain/t/001_auto_explain.pl
@@ -173,9 +173,7 @@ like(
 	"index scan logged, json mode");
 
 # Extension options.
-$log_contents = query_log(
-	$node,
-	"SELECT 1;",
+$log_contents = query_log($node, "SELECT 1;",
 	{ "auto_explain.log_extension_options" => "debug" });
 
 like(
diff --git a/contrib/pg_prewarm/t/001_basic.pl b/contrib/pg_prewarm/t/001_basic.pl
index a11d1cbfd06..71796111bb9 100644
--- a/contrib/pg_prewarm/t/001_basic.pl
+++ b/contrib/pg_prewarm/t/001_basic.pl
@@ -45,28 +45,30 @@ ok( (        $stdout =~ qr/^[1-9][0-9]*$/
 	'prefetch mode succeeded');
 
 # test_user should be unable to prewarm table/index without privileges
-($cmdret, $stdout, $stderr) =
-  $node->psql(
-    "postgres", "SELECT pg_prewarm('test');",
-    extra_params => [ '--username' => 'test_user' ]);
-ok($stderr =~ /permission denied for table test/, 'pg_prewarm failed as expected');
-($cmdret, $stdout, $stderr) =
-  $node->psql(
-    "postgres", "SELECT pg_prewarm('test_idx');",
-    extra_params => [ '--username' => 'test_user' ]);
-ok($stderr =~ /permission denied for index test_idx/, 'pg_prewarm failed as expected');
+($cmdret, $stdout, $stderr) = $node->psql(
+	"postgres",
+	"SELECT pg_prewarm('test');",
+	extra_params => [ '--username' => 'test_user' ]);
+ok($stderr =~ /permission denied for table test/,
+	'pg_prewarm failed as expected');
+($cmdret, $stdout, $stderr) = $node->psql(
+	"postgres",
+	"SELECT pg_prewarm('test_idx');",
+	extra_params => [ '--username' => 'test_user' ]);
+ok($stderr =~ /permission denied for index test_idx/,
+	'pg_prewarm failed as expected');
 
 # test_user should be able to prewarm table/index with privileges
 $node->safe_psql("postgres", "GRANT SELECT ON test TO test_user;");
-$result =
-  $node->safe_psql(
-    "postgres", "SELECT pg_prewarm('test');",
-    extra_params => [ '--username' => 'test_user' ]);
+$result = $node->safe_psql(
+	"postgres",
+	"SELECT pg_prewarm('test');",
+	extra_params => [ '--username' => 'test_user' ]);
 like($result, qr/^[1-9][0-9]*$/, 'pg_prewarm succeeded as expected');
-$result =
-  $node->safe_psql(
-    "postgres", "SELECT pg_prewarm('test_idx');",
-    extra_params => [ '--username' => 'test_user' ]);
+$result = $node->safe_psql(
+	"postgres",
+	"SELECT pg_prewarm('test_idx');",
+	extra_params => [ '--username' => 'test_user' ]);
 like($result, qr/^[1-9][0-9]*$/, 'pg_prewarm succeeded as expected');
 
 # test autoprewarm_dump_now()
diff --git a/contrib/pg_stash_advice/t/001_persist.pl b/contrib/pg_stash_advice/t/001_persist.pl
index d1466166602..83e98889f93 100644
--- a/contrib/pg_stash_advice/t/001_persist.pl
+++ b/contrib/pg_stash_advice/t/001_persist.pl
@@ -18,11 +18,11 @@ pg_stash_advice.persist = true
 pg_stash_advice.persist_interval = 0});
 $node->start;
 
-$node->safe_psql("postgres",
-		"CREATE EXTENSION pg_stash_advice;\n");
+$node->safe_psql("postgres", "CREATE EXTENSION pg_stash_advice;\n");
 
 # Create two stashes: one with 2 entries, one with 1 entry.
-$node->safe_psql("postgres", qq{
+$node->safe_psql(
+	"postgres", qq{
 	SELECT pg_create_advice_stash('stash_a');
 	SELECT pg_set_stashed_advice('stash_a', 1001, 'IndexScan(t)');
 	SELECT pg_set_stashed_advice('stash_a', 1002, E'line1\\nline2\\ttab\\\\backslash');
@@ -32,7 +32,8 @@ $node->safe_psql("postgres", qq{
 
 # Verify before restart.
 my $result = $node->safe_psql("postgres",
-	"SELECT stash_name, num_entries FROM pg_get_advice_stashes() ORDER BY stash_name");
+	"SELECT stash_name, num_entries FROM pg_get_advice_stashes() ORDER BY stash_name"
+);
 is($result, "stash_a|2\nstash_b|1", 'stashes present before restart');
 
 # Restart and verify the data survived.
@@ -40,18 +41,21 @@ $node->restart;
 $node->wait_for_log("loaded 2 advice stashes and 3 entries");
 
 $result = $node->safe_psql("postgres",
-	"SELECT stash_name, num_entries FROM pg_get_advice_stashes() ORDER BY stash_name");
+	"SELECT stash_name, num_entries FROM pg_get_advice_stashes() ORDER BY stash_name"
+);
 is($result, "stash_a|2\nstash_b|1", 'stashes survived restart');
 
 # Verify entry contents, including the one with special characters.
 $result = $node->safe_psql("postgres",
-	"SELECT stash_name, query_id, advice_string FROM pg_get_advice_stash_contents(NULL) ORDER BY stash_name, query_id");
-is($result,
+	"SELECT stash_name, query_id, advice_string FROM pg_get_advice_stash_contents(NULL) ORDER BY stash_name, query_id"
+);
+is( $result,
 	"stash_a|1001|IndexScan(t)\nstash_a|1002|line1\nline2\ttab\\backslash\nstash_b|2001|SeqScan(t)",
 	'entry contents survived restart with special characters intact');
 
 # Add a third stash with 0 entries.
-$node->safe_psql("postgres", qq{
+$node->safe_psql(
+	"postgres", qq{
 	SELECT pg_create_advice_stash('stash_c');
 });
 
@@ -60,11 +64,15 @@ $node->restart;
 $node->wait_for_log("loaded 3 advice stashes and 3 entries");
 
 $result = $node->safe_psql("postgres",
-	"SELECT stash_name, num_entries FROM pg_get_advice_stashes() ORDER BY stash_name");
-is($result, "stash_a|2\nstash_b|1\nstash_c|0", 'all three stashes survived second restart');
+	"SELECT stash_name, num_entries FROM pg_get_advice_stashes() ORDER BY stash_name"
+);
+is( $result,
+	"stash_a|2\nstash_b|1\nstash_c|0",
+	'all three stashes survived second restart');
 
 # Drop all stashes and verify the dump file is removed after restart.
-$node->safe_psql("postgres", qq{
+$node->safe_psql(
+	"postgres", qq{
 	SELECT pg_drop_advice_stash('stash_a');
 	SELECT pg_drop_advice_stash('stash_b');
 	SELECT pg_drop_advice_stash('stash_c');
@@ -76,7 +84,7 @@ $result = $node->safe_psql("postgres",
 	"SELECT count(*) FROM pg_get_advice_stashes()");
 is($result, "0", 'no stashes after dropping all and restarting');
 
-ok(!-f $node->data_dir . '/pg_stash_advice.tsv',
+ok( !-f $node->data_dir . '/pg_stash_advice.tsv',
 	'dump file removed after all stashes dropped');
 
 $node->stop;
diff --git a/src/backend/storage/lmgr/generate-lwlocknames.pl b/src/backend/storage/lmgr/generate-lwlocknames.pl
index b49007167b0..48fa2807b2b 100644
--- a/src/backend/storage/lmgr/generate-lwlocknames.pl
+++ b/src/backend/storage/lmgr/generate-lwlocknames.pl
@@ -160,8 +160,7 @@ while (<$lwlocklist>)
 	die "unable to parse lwlocklist.h line \"$_\"";
 }
 
-die
-  "$wait_event_lwlocks[$lwlock_count] defined in wait_event_names.txt but "
+die "$wait_event_lwlocks[$lwlock_count] defined in wait_event_names.txt but "
   . " missing from lwlocklist.h"
   if $lwlock_count < scalar @wait_event_lwlocks;
 
diff --git a/src/bin/pg_combinebackup/t/011_ib_truncation.pl b/src/bin/pg_combinebackup/t/011_ib_truncation.pl
index e1ce4521558..11749286467 100644
--- a/src/bin/pg_combinebackup/t/011_ib_truncation.pl
+++ b/src/bin/pg_combinebackup/t/011_ib_truncation.pl
@@ -76,7 +76,8 @@ $primary->safe_psql('postgres', 'VACUUM (TRUNCATE) t;');
 # Verify expected length after truncation.
 $t_blocks = $primary->safe_psql('postgres',
 	"SELECT pg_relation_size('t') / current_setting('block_size')::int;");
-is($t_blocks, $rows_after_truncation, 'post-truncation row count as expected');
+is($t_blocks, $rows_after_truncation,
+	'post-truncation row count as expected');
 cmp_ok($t_blocks, '>', $target_blocks,
 	'post-truncation block count as expected');
 
@@ -89,17 +90,17 @@ $primary->backup('incr',
 # truncation limit. We can't just check whether the restored VM fork is
 # the right size on disk, because it's so small that the incremental backup
 # code will send the entire file.
-my $relfilenode = $primary->safe_psql('postgres',
-	"SELECT pg_relation_filenode('t');");
-my $vm_limits = $primary->safe_psql('postgres',
+my $relfilenode =
+  $primary->safe_psql('postgres', "SELECT pg_relation_filenode('t');");
+my $vm_limits = $primary->safe_psql(
+	'postgres',
 	"SELECT string_agg(relblocknumber::text, ',')
 	   FROM pg_available_wal_summaries() s,
 	        pg_wal_summary_contents(s.tli, s.start_lsn, s.end_lsn) c
 	  WHERE c.relfilenode = $relfilenode
 	    AND c.relforknumber = 2
 	    AND c.is_limit_block;");
-is($vm_limits, '1',
-	'WAL summary has correct VM fork truncation limit');
+is($vm_limits, '1', 'WAL summary has correct VM fork truncation limit');
 
 # Combine full and incremental backups.  Before the fix, this failed because
 # the INCREMENTAL file header contained an incorrect truncation_block_length
diff --git a/src/bin/pg_ctl/t/001_start_stop.pl b/src/bin/pg_ctl/t/001_start_stop.pl
index 4a25b35ed9c..a189b379f55 100644
--- a/src/bin/pg_ctl/t/001_start_stop.pl
+++ b/src/bin/pg_ctl/t/001_start_stop.pl
@@ -112,7 +112,12 @@ SKIP:
 	ok(check_mode_recursive("$tempdir/data", 0750, 0640));
 }
 
-command_ok([ 'pg_ctl', 'restart', '--pgdata' => "$tempdir/data", '--log' => $logFileName ],
+command_ok(
+	[
+		'pg_ctl', 'restart',
+		'--pgdata' => "$tempdir/data",
+		'--log' => $logFileName
+	],
 	'pg_ctl restart with server running');
 
 system_or_bail 'pg_ctl', 'stop', '--pgdata' => "$tempdir/data";
diff --git a/src/bin/pg_dump/t/001_basic.pl b/src/bin/pg_dump/t/001_basic.pl
index 509f4f9ce7d..687e842cde9 100644
--- a/src/bin/pg_dump/t/001_basic.pl
+++ b/src/bin/pg_dump/t/001_basic.pl
@@ -104,7 +104,8 @@ command_fails_like(
 command_fails_like(
 	[ 'pg_dumpall', '-c', '-a' ],
 	qr/\Qpg_dumpall: error: options -c\/--clean and -a\/--data-only cannot be used together\E/,
-	'pg_dumpall: options -c/--clean and -a/--data-only cannot be used together');
+	'pg_dumpall: options -c/--clean and -a/--data-only cannot be used together'
+);
 
 command_fails_like(
 	[ 'pg_restore', '-c', '-a', '-f -' ],
diff --git a/src/bin/pg_dump/t/002_pg_dump.pl b/src/bin/pg_dump/t/002_pg_dump.pl
index 3bc8e51561d..3ee9fda50e4 100644
--- a/src/bin/pg_dump/t/002_pg_dump.pl
+++ b/src/bin/pg_dump/t/002_pg_dump.pl
@@ -5279,7 +5279,7 @@ foreach my $run (sort keys %pgdump_runs)
 		#
 		# Either "all_runs" should be set or there should be a "like" list,
 		# even if it is empty.  (This makes the test more self-documenting.)
-		if (!defined($tests{$test}->{all_runs})
+		if (   !defined($tests{$test}->{all_runs})
 			&& !defined($tests{$test}->{like}))
 		{
 			die "missing \"like\" in test \"$test\"";
diff --git a/src/bin/pg_dump/t/005_pg_dump_filterfile.pl b/src/bin/pg_dump/t/005_pg_dump_filterfile.pl
index b2630ef2897..cecf0442088 100644
--- a/src/bin/pg_dump/t/005_pg_dump_filterfile.pl
+++ b/src/bin/pg_dump/t/005_pg_dump_filterfile.pl
@@ -460,8 +460,7 @@ command_fails_like(
 		'postgres'
 	],
 	qr/unsupported filter object type: "table-data"/,
-	"invalid syntax: invalid object type specified"
-);
+	"invalid syntax: invalid object type specified");
 
 # Test missing object identifier pattern
 open $inputfile, '>', "$tempdir/inputfile.txt"
diff --git a/src/bin/pg_upgrade/t/003_logical_slots.pl b/src/bin/pg_upgrade/t/003_logical_slots.pl
index 15e6d267f2f..de53c6f3eff 100644
--- a/src/bin/pg_upgrade/t/003_logical_slots.pl
+++ b/src/bin/pg_upgrade/t/003_logical_slots.pl
@@ -152,10 +152,8 @@ like(
 	slurp_file($slots_filename),
 	qr/The slot \"test_slot2\" has not consumed the WAL yet/m,
 	'the previous test failed due to unconsumed WALs');
-unlike(
-	slurp_file($slots_filename),
-	qr/test_slot3/m,
-	'caught-up slot is not reported');
+unlike(slurp_file($slots_filename),
+	qr/test_slot3/m, 'caught-up slot is not reported');
 
 
 # ------------------------------
diff --git a/src/bin/pg_upgrade/t/004_subscription.pl b/src/bin/pg_upgrade/t/004_subscription.pl
index f68821df2a3..c94a82deae0 100644
--- a/src/bin/pg_upgrade/t/004_subscription.pl
+++ b/src/bin/pg_upgrade/t/004_subscription.pl
@@ -390,7 +390,8 @@ is($result, qq($remote_lsn), "remote_lsn should have been preserved");
 
 # The conflict detection slot should be created
 $result = $new_sub->safe_psql('postgres',
-	"SELECT xmin IS NOT NULL from pg_replication_slots WHERE slot_name = 'pg_conflict_detection'");
+	"SELECT xmin IS NOT NULL from pg_replication_slots WHERE slot_name = 'pg_conflict_detection'"
+);
 is($result, qq(t), "conflict detection slot exists");
 
 # Resume the initial sync and wait until all tables of subscription
diff --git a/src/bin/pg_upgrade/t/006_transfer_modes.pl b/src/bin/pg_upgrade/t/006_transfer_modes.pl
index d317159bf12..ca2d422bf28 100644
--- a/src/bin/pg_upgrade/t/006_transfer_modes.pl
+++ b/src/bin/pg_upgrade/t/006_transfer_modes.pl
@@ -41,8 +41,10 @@ sub test_mode
 	# allow_in_place_tablespaces is available as far back as v10.
 	if ($old->pg_version >= 10)
 	{
-		$new->append_conf('postgresql.conf', "allow_in_place_tablespaces = true");
-		$old->append_conf('postgresql.conf', "allow_in_place_tablespaces = true");
+		$new->append_conf('postgresql.conf',
+			"allow_in_place_tablespaces = true");
+		$old->append_conf('postgresql.conf',
+			"allow_in_place_tablespaces = true");
 	}
 
 	# We can only test security labels if both the old and new installations
@@ -95,13 +97,15 @@ sub test_mode
 		$old->safe_psql('postgres',
 			"CREATE DATABASE testdb3 TABLESPACE inplc_tblspc");
 		$old->safe_psql('postgres',
-			"CREATE TABLE test5 TABLESPACE inplc_tblspc AS SELECT generate_series(503, 606)");
+			"CREATE TABLE test5 TABLESPACE inplc_tblspc AS SELECT generate_series(503, 606)"
+		);
 		$old->safe_psql('testdb3',
 			"CREATE TABLE test6 AS SELECT generate_series(607, 711)");
 	}
 
 	# While we are here, test handling of large objects.
-	$old->safe_psql('postgres', q|
+	$old->safe_psql(
+		'postgres', q|
 		CREATE ROLE regress_lo_1;
 		CREATE ROLE regress_lo_2;
 
@@ -115,7 +119,8 @@ sub test_mode
 
 	if ($test_seclabel)
 	{
-		$old->safe_psql('postgres', q|
+		$old->safe_psql(
+			'postgres', q|
 			CREATE EXTENSION dummy_seclabel;
 
 			SELECT lo_from_bytea(4534, '\x00ffffff');
@@ -166,9 +171,11 @@ sub test_mode
 		# Tests for in-place tablespaces.
 		if ($old->pg_version >= 10)
 		{
-			$result = $new->safe_psql('postgres', "SELECT COUNT(*) FROM test5");
+			$result =
+			  $new->safe_psql('postgres', "SELECT COUNT(*) FROM test5");
 			is($result, '104', "test5 data after pg_upgrade $mode");
-			$result = $new->safe_psql('testdb3', "SELECT COUNT(*) FROM test6");
+			$result =
+			  $new->safe_psql('testdb3', "SELECT COUNT(*) FROM test6");
 			is($result, '105', "test6 data after pg_upgrade $mode");
 		}
 
@@ -182,18 +189,21 @@ sub test_mode
 		$result = $new->safe_psql('postgres', "SELECT lo_get(4533)");
 		is($result, '\x0f0f0f0f', "LO contents after upgrade");
 		$result = $new->safe_psql('postgres',
-			"SELECT lomowner::regrole FROM pg_largeobject_metadata WHERE oid = 4533");
+			"SELECT lomowner::regrole FROM pg_largeobject_metadata WHERE oid = 4533"
+		);
 		is($result, 'regress_lo_1', "LO owner after upgrade");
 		$result = $new->safe_psql('postgres',
 			"SELECT lomacl FROM pg_largeobject_metadata WHERE oid = 4533");
-		is($result, '{regress_lo_1=rw/regress_lo_1,regress_lo_2=r/regress_lo_1}',
+		is( $result,
+			'{regress_lo_1=rw/regress_lo_1,regress_lo_2=r/regress_lo_1}',
 			"LO ACL after upgrade");
 
 		if ($test_seclabel)
 		{
 			$result = $new->safe_psql('postgres', "SELECT lo_get(4534)");
 			is($result, '\x00ffffff', "LO contents after upgrade");
-			$result = $new->safe_psql('postgres', q|
+			$result = $new->safe_psql(
+				'postgres', q|
 				SELECT label FROM pg_seclabel WHERE objoid = 4534
 				AND classoid = 'pg_largeobject'::regclass
 			|);
diff --git a/src/bin/pg_verifybackup/t/007_wal.pl b/src/bin/pg_verifybackup/t/007_wal.pl
index 0e0377bfacc..12ca30139c5 100644
--- a/src/bin/pg_verifybackup/t/007_wal.pl
+++ b/src/bin/pg_verifybackup/t/007_wal.pl
@@ -102,8 +102,7 @@ $primary->command_ok(
 		'--checkpoint' => 'fast'
 	],
 	"tar backup with separate pg_wal.tar");
-command_ok(
-	[ 'pg_verifybackup', $backup_path3 ],
+command_ok([ 'pg_verifybackup', $backup_path3 ],
 	'WAL verification succeeds with separate pg_wal.tar');
 
 done_testing();
diff --git a/src/bin/pg_verifybackup/t/008_untar.pl b/src/bin/pg_verifybackup/t/008_untar.pl
index 161c08c190d..21d152320c1 100644
--- a/src/bin/pg_verifybackup/t/008_untar.pl
+++ b/src/bin/pg_verifybackup/t/008_untar.pl
@@ -121,9 +121,7 @@ for my $tc (@test_configuration)
 
 		# Verify tar backup.
 		$primary->command_ok(
-			[
-				'pg_verifybackup', '--exit-on-error', $backup_path,
-			],
+			[ 'pg_verifybackup', '--exit-on-error', $backup_path, ],
 			"verify backup, compression $method");
 
 		# Cleanup.
diff --git a/src/bin/pg_verifybackup/t/010_client_untar.pl b/src/bin/pg_verifybackup/t/010_client_untar.pl
index 9670fbe4fda..db8b96ceb43 100644
--- a/src/bin/pg_verifybackup/t/010_client_untar.pl
+++ b/src/bin/pg_verifybackup/t/010_client_untar.pl
@@ -135,9 +135,7 @@ for my $tc (@test_configuration)
 
 		# Verify tar backup.
 		$primary->command_ok(
-			[
-				'pg_verifybackup', '--exit-on-error', $backup_path,
-			],
+			[ 'pg_verifybackup', '--exit-on-error', $backup_path, ],
 			"verify backup, compression $method");
 
 		# Cleanup.
diff --git a/src/bin/pg_waldump/t/001_basic.pl b/src/bin/pg_waldump/t/001_basic.pl
index 7dd1c3dd63e..53b2f016b80 100644
--- a/src/bin/pg_waldump/t/001_basic.pl
+++ b/src/bin/pg_waldump/t/001_basic.pl
@@ -198,8 +198,8 @@ END
 $$;
 });
 
-my $contrecord_lsn = $node->safe_psql('postgres',
-	'SELECT pg_current_wal_insert_lsn()');
+my $contrecord_lsn =
+  $node->safe_psql('postgres', 'SELECT pg_current_wal_insert_lsn()');
 # Generate contrecord record
 $node->safe_psql('postgres',
 	qq{SELECT pg_logical_emit_message(true, 'test 026', repeat('xyzxz', 123456))}
@@ -243,8 +243,9 @@ command_like(
 	'runs with start and end segment specified');
 command_like(
 	[
-		'pg_waldump', '--quiet', '--path',
-		$node->data_dir . '/pg_wal/', $start_walfile
+		'pg_waldump', '--quiet',
+		'--path', $node->data_dir . '/pg_wal/',
+		$start_walfile
 	],
 	qr/^$/,
 	'no output with --quiet option');
@@ -336,7 +337,8 @@ sub generate_archive
 
 	my @files;
 	opendir my $dh, $directory or die "opendir: $!";
-	while (my $entry = readdir $dh) {
+	while (my $entry = readdir $dh)
+	{
 		# Skip '.' and '..'
 		next if $entry eq '.' || $entry eq '..';
 		push @files, $entry;
@@ -379,20 +381,23 @@ for my $scenario (@scenarios)
 {
 	my $path = $scenario->{'path'};
 
-	SKIP:
+  SKIP:
 	{
 		skip "tar command is not available", 56
 		  if (!defined $tar || $tar eq '') && $scenario->{'is_archive'};
-		skip "$scenario->{'compression_method'} compression not supported by this build", 56
+		skip
+		  "$scenario->{'compression_method'} compression not supported by this build",
+		  56
 		  if !$scenario->{'enabled'} && $scenario->{'is_archive'};
 
-		  # create pg_wal archive
-		  if ($scenario->{'is_archive'})
-		  {
-			  generate_archive($path,
-				  $node->data_dir . '/pg_wal',
-				  $scenario->{'compression_flags'});
-		  }
+		# create pg_wal archive
+		if ($scenario->{'is_archive'})
+		{
+			generate_archive(
+				$path,
+				$node->data_dir . '/pg_wal',
+				$scenario->{'compression_flags'});
+		}
 
 		command_fails_like(
 			[ 'pg_waldump', '--path' => $path ],
@@ -445,22 +450,28 @@ for my $scenario (@scenarios)
 		like($lines[0], qr/WAL statistics/, "statistics on stdout");
 		is(grep(/^rmgr:/, @lines), 0, 'no rmgr lines output');
 
-		@lines = test_pg_waldump($path, $start_lsn, $end_lsn, '--stats=record');
+		@lines =
+		  test_pg_waldump($path, $start_lsn, $end_lsn, '--stats=record');
 		like($lines[0], qr/WAL statistics/, "statistics on stdout");
 		is(grep(/^rmgr:/, @lines), 0, 'no rmgr lines output');
 
-		@lines = test_pg_waldump($path, $start_lsn, $end_lsn, '--rmgr' => 'Btree');
+		@lines =
+		  test_pg_waldump($path, $start_lsn, $end_lsn, '--rmgr' => 'Btree');
 		is(grep(!/^rmgr: Btree/, @lines), 0, 'only Btree lines');
 
-		@lines = test_pg_waldump($path, $start_lsn, $end_lsn, '--fork' => 'init');
+		@lines =
+		  test_pg_waldump($path, $start_lsn, $end_lsn, '--fork' => 'init');
 		is(grep(!/fork init/, @lines), 0, 'only init fork lines');
 
 		@lines = test_pg_waldump($path, $start_lsn, $end_lsn,
 			'--relation' => "$default_ts_oid/$postgres_db_oid/$rel_t1_oid");
-		is(grep(!/rel $default_ts_oid\/$postgres_db_oid\/$rel_t1_oid/, @lines),
-			0, 'only lines for selected relation');
+		is( grep(!/rel $default_ts_oid\/$postgres_db_oid\/$rel_t1_oid/,
+				@lines),
+			0,
+			'only lines for selected relation');
 
-		@lines = test_pg_waldump($path, $start_lsn, $end_lsn,
+		@lines = test_pg_waldump(
+			$path, $start_lsn, $end_lsn,
 			'--relation' => "$default_ts_oid/$postgres_db_oid/$rel_i1a_oid",
 			'--block' => 1);
 		is(grep(!/\bblk 1\b/, @lines), 0, 'only lines for selected block');
diff --git a/src/bin/pgbench/t/001_pgbench_with_server.pl b/src/bin/pgbench/t/001_pgbench_with_server.pl
index b7685ea5d20..bb12ade59f5 100644
--- a/src/bin/pgbench/t/001_pgbench_with_server.pl
+++ b/src/bin/pgbench/t/001_pgbench_with_server.pl
@@ -1823,10 +1823,9 @@ update counter set i = i+1 returning i \gset
 
 # Test copy in pgbench
 $node->pgbench(
-	'-t 10',
-	2,
+	'-t 10', 2,
 	[],
-	[ qr{COPY is not supported in pgbench, aborting} ],
+	[qr{COPY is not supported in pgbench, aborting}],
 	'Test copy in script',
 	{
 		'001_copy' => q{ COPY pgbench_accounts FROM stdin }
@@ -1836,16 +1835,12 @@ $node->pgbench(
 $node->safe_psql('postgres', 'DROP TABLE counter;');
 
 # Test --continue-on-error
-$node->safe_psql('postgres',
-	'CREATE TABLE unique_table(i int unique);');
+$node->safe_psql('postgres', 'CREATE TABLE unique_table(i int unique);');
 
 $node->pgbench(
 	'-n -t 10 --continue-on-error --failures-detailed',
 	0,
-	[
-		qr{processed: 1/10\b},
-		qr{other failures: 9\b}
-	],
+	[ qr{processed: 1/10\b}, qr{other failures: 9\b} ],
 	[],
 	'test --continue-on-error',
 	{
diff --git a/src/bin/psql/t/001_basic.pl b/src/bin/psql/t/001_basic.pl
index cd4a21ca639..3961e69e1cc 100644
--- a/src/bin/psql/t/001_basic.pl
+++ b/src/bin/psql/t/001_basic.pl
@@ -142,7 +142,9 @@ my ($ret, $out, $err) = $node->psql('postgres',
 is($ret, 2, 'server crash: psql exit code');
 like($out, qr/before/, 'server crash: output before crash');
 unlike($out, qr/AFTER/, 'server crash: no output after crash');
-like( $err, qr/psql:<stdin>:2: FATAL:  terminating connection due to administrator command
+like(
+	$err,
+	qr/psql:<stdin>:2: FATAL:  terminating connection due to administrator command
 psql:<stdin>:2: server closed the connection unexpectedly
 	This probably means the server terminated abnormally
 	before or while processing the request.
diff --git a/src/bin/scripts/t/020_createdb.pl b/src/bin/scripts/t/020_createdb.pl
index a0995868363..4a8845990b6 100644
--- a/src/bin/scripts/t/020_createdb.pl
+++ b/src/bin/scripts/t/020_createdb.pl
@@ -242,16 +242,14 @@ $node->command_fails(
 	'fails for invalid locale provider');
 
 $node->command_fails_like(
-    [ 'createdb', "invalid \n dbname" ],
-    qr(contains a newline or carriage return character),
-    'fails if database name contains a newline character in name'
-);
+	[ 'createdb', "invalid \n dbname" ],
+	qr(contains a newline or carriage return character),
+	'fails if database name contains a newline character in name');
 
 $node->command_fails_like(
-    [ 'createdb', "invalid \r dbname" ],
-    qr(contains a newline or carriage return character),
-    'fails if database name contains a carriage return character in name'
-);
+	[ 'createdb', "invalid \r dbname" ],
+	qr(contains a newline or carriage return character),
+	'fails if database name contains a carriage return character in name');
 
 # Check use of templates with shared dependencies copied from the template.
 my ($ret, $stdout, $stderr) = $node->psql(
diff --git a/src/bin/scripts/t/100_vacuumdb.pl b/src/bin/scripts/t/100_vacuumdb.pl
index cf0b853e9bf..84fcacd57fa 100644
--- a/src/bin/scripts/t/100_vacuumdb.pl
+++ b/src/bin/scripts/t/100_vacuumdb.pl
@@ -241,15 +241,17 @@ $node->command_fails_like(
 	qr/cannot vacuum all databases and a specific one at the same time/,
 	'cannot use option --all and a dbname as argument at the same time');
 
-$node->safe_psql('postgres', q|
+$node->safe_psql(
+	'postgres', q|
   CREATE TABLE regression_vacuumdb_test AS select generate_series(1, 10) a, generate_series(2, 11) b;
   ALTER TABLE regression_vacuumdb_test ADD COLUMN c INT GENERATED ALWAYS AS (a + b);
 |);
 $node->issues_sql_unlike(
 	[
-		'vacuumdb', '--analyze-only', '--dry-run',
-		'--missing-stats-only', '-t',
-		'regression_vacuumdb_test', 'postgres'
+		'vacuumdb', '--analyze-only',
+		'--dry-run', '--missing-stats-only',
+		'-t', 'regression_vacuumdb_test',
+		'postgres'
 	],
 	qr/statement:\ ANALYZE/sx,
 	'--missing-stats-only --dry-run');
@@ -354,19 +356,15 @@ $node->issues_sql_unlike(
 	'--missing-stats-only with no missing partition stats');
 
 $node->safe_psql('postgres',
-	"CREATE TABLE parent_table (a INT) PARTITION BY LIST (a);\n"
+		"CREATE TABLE parent_table (a INT) PARTITION BY LIST (a);\n"
 	  . "CREATE TABLE child_table PARTITION OF parent_table FOR VALUES IN (1);\n"
 	  . "INSERT INTO parent_table VALUES (1);\n");
 $node->issues_sql_like(
-	[
-		'vacuumdb', '--analyze-only', 'postgres'
-	],
+	[ 'vacuumdb', '--analyze-only', 'postgres' ],
 	qr/statement: ANALYZE public.parent_table/s,
 	'--analyze-only updates statistics for partitioned tables');
 $node->issues_sql_unlike(
-	[
-		'vacuumdb', '--analyze-only', 'postgres'
-	],
+	[ 'vacuumdb', '--analyze-only', 'postgres' ],
 	qr/statement:\ VACUUM/sx,
 	'--analyze-only does not run vacuum');
 
diff --git a/src/interfaces/libpq/t/006_service.pl b/src/interfaces/libpq/t/006_service.pl
index 9e92e7b0203..7462d21314d 100644
--- a/src/interfaces/libpq/t/006_service.pl
+++ b/src/interfaces/libpq/t/006_service.pl
@@ -53,8 +53,7 @@ append_to_file($srvfile_nested, "service=invalid_srv\n");
 my $srvfile_nested_2 = "$td/pg_service_nested_2.conf";
 copy($srvfile_valid, $srvfile_nested_2)
   or die "Could not copy $srvfile_valid to $srvfile_nested_2: $!";
-append_to_file($srvfile_nested_2,
-	'servicefile=' . $srvfile_default . "\n");
+append_to_file($srvfile_nested_2, 'servicefile=' . $srvfile_default . "\n");
 
 # Set the fallback directory lookup of the service file to the temporary
 # directory of this test.  PGSYSCONFDIR is used if the service file
diff --git a/src/test/authentication/t/001_password.pl b/src/test/authentication/t/001_password.pl
index a4b11673c26..69ed4919b16 100644
--- a/src/test/authentication/t/001_password.pl
+++ b/src/test/authentication/t/001_password.pl
@@ -68,23 +68,24 @@ $node->init;
 $node->append_conf('postgresql.conf', "log_connections = on\n");
 # Needed to allow connect_fails to inspect postmaster log:
 $node->append_conf('postgresql.conf', "log_min_messages = debug2");
-$node->append_conf('postgresql.conf', "password_expiration_warning_threshold = '1100d'");
+$node->append_conf('postgresql.conf',
+	"password_expiration_warning_threshold = '1100d'");
 $node->start;
 
 # Set up roles for password_expiration_warning_threshold test
 my $current_year = 1900 + ${ [ localtime(time) ] }[5];
 my $expire_year = $current_year - 1;
-$node->safe_psql(
-	'postgres',
-	"CREATE ROLE expired LOGIN VALID UNTIL '$expire_year-01-01' PASSWORD 'pass'");
+$node->safe_psql('postgres',
+	"CREATE ROLE expired LOGIN VALID UNTIL '$expire_year-01-01' PASSWORD 'pass'"
+);
 $expire_year = $current_year + 2;
-$node->safe_psql(
-	'postgres',
-	"CREATE ROLE expiration_warnings LOGIN VALID UNTIL '$expire_year-01-01' PASSWORD 'pass'");
+$node->safe_psql('postgres',
+	"CREATE ROLE expiration_warnings LOGIN VALID UNTIL '$expire_year-01-01' PASSWORD 'pass'"
+);
 $expire_year = $current_year + 5;
-$node->safe_psql(
-	'postgres',
-	"CREATE ROLE no_warnings LOGIN VALID UNTIL '$expire_year-01-01' PASSWORD 'pass'");
+$node->safe_psql('postgres',
+	"CREATE ROLE no_warnings LOGIN VALID UNTIL '$expire_year-01-01' PASSWORD 'pass'"
+);
 
 # Test behavior of log_connections GUC
 #
@@ -498,9 +499,9 @@ test_conn($node, 'user=scram_role', 'md5', 0,
 SKIP:
 {
 	skip "MD5 not supported" unless $md5_works;
-	test_conn($node, 'user=md5_role', 'md5', 0,
-		expected_stderr =>
-		  qr/authenticated with an MD5-encrypted password/,
+	test_conn(
+		$node, 'user=md5_role', 'md5', 0,
+		expected_stderr => qr/authenticated with an MD5-encrypted password/,
 		log_like =>
 		  [qr/connection authenticated: identity="md5_role" method=md5/]);
 }
@@ -553,19 +554,13 @@ $node->connect_fails(
 $node->connect_fails(
 	"user=expired dbname=postgres",
 	"connection fails due to expired password",
-	expected_stderr =>
-	  qr/password authentication failed for user "expired"/
-);
+	expected_stderr => qr/password authentication failed for user "expired"/);
 $node->connect_ok(
 	"user=expiration_warnings dbname=postgres",
 	"connection succeeds with password expiration warning",
-	expected_stderr =>
-	  qr/role password will expire soon/
-);
-$node->connect_ok(
-	"user=no_warnings dbname=postgres",
-	"connection succeeds with no password expiration warning"
-);
+	expected_stderr => qr/role password will expire soon/);
+$node->connect_ok("user=no_warnings dbname=postgres",
+	"connection succeeds with no password expiration warning");
 
 # Test SYSTEM_USER <> NULL with parallel workers.
 $node->safe_psql(
diff --git a/src/test/modules/libpq_pipeline/t/001_libpq_pipeline.pl b/src/test/modules/libpq_pipeline/t/001_libpq_pipeline.pl
index f2c72581f94..c74fda8aa37 100644
--- a/src/test/modules/libpq_pipeline/t/001_libpq_pipeline.pl
+++ b/src/test/modules/libpq_pipeline/t/001_libpq_pipeline.pl
@@ -52,8 +52,7 @@ for my $testname (@tests)
 	# Execute the test using the latest protocol version.
 	$node->command_ok(
 		[
-			'libpq_pipeline', @extraargs,
-			$testname,
+			'libpq_pipeline', @extraargs, $testname,
 			$node->connstr('postgres') . " max_protocol_version=latest"
 		],
 		"libpq_pipeline $testname");
diff --git a/src/test/modules/ssl_passphrase_callback/t/001_testfunc.pl b/src/test/modules/ssl_passphrase_callback/t/001_testfunc.pl
index d8b07d4cf7b..3a08bc77195 100644
--- a/src/test/modules/ssl_passphrase_callback/t/001_testfunc.pl
+++ b/src/test/modules/ssl_passphrase_callback/t/001_testfunc.pl
@@ -106,7 +106,8 @@ example.com "$ddir/server.crt" "$ddir/server.key" "" "echo FooBaR1" on
 		qr/WARNING.*SNI is enabled; installed TLS init hook will be ignored/,
 		"server warns that init hook and SNI are incompatible");
 	# Ensure that the warning was printed once and not once per host line
-	my $count =()= $log_contents =~ m/installed TLS init hook will be ignored/;
+	my $count = () =
+	  $log_contents =~ m/installed TLS init hook will be ignored/;
 	is($count, 1, 'Only one WARNING');
 }
 
diff --git a/src/test/modules/test_aio/t/002_io_workers.pl b/src/test/modules/test_aio/t/002_io_workers.pl
index b9775811d4d..7950cb0c1db 100644
--- a/src/test/modules/test_aio/t/002_io_workers.pl
+++ b/src/test/modules/test_aio/t/002_io_workers.pl
@@ -34,7 +34,8 @@ sub test_number_of_io_workers_dynamic
 {
 	my $node = shift;
 
-	my $prev_worker_count = $node->safe_psql('postgres', 'SHOW io_min_workers');
+	my $prev_worker_count =
+	  $node->safe_psql('postgres', 'SHOW io_min_workers');
 
 	# Verify that worker count can't be set to 0
 	change_number_of_io_workers($node, 0, $prev_worker_count, 1);
@@ -65,7 +66,8 @@ sub change_number_of_io_workers
 	my ($result, $stdout, $stderr);
 
 	($result, $stdout, $stderr) =
-	  $node->psql('postgres', "ALTER SYSTEM SET io_min_workers = $worker_count");
+	  $node->psql('postgres',
+		"ALTER SYSTEM SET io_min_workers = $worker_count");
 	$node->safe_psql('postgres', 'SELECT pg_reload_conf()');
 
 	if ($expect_failure)
@@ -73,8 +75,7 @@ sub change_number_of_io_workers
 		like(
 			$stderr,
 			qr/$worker_count is outside the valid range for parameter "io_min_workers"/,
-			"updating io_min_workers to $worker_count failed, as expected"
-		);
+			"updating io_min_workers to $worker_count failed, as expected");
 
 		return $prev_worker_count;
 	}
diff --git a/src/test/modules/test_cloexec/t/001_cloexec.pl b/src/test/modules/test_cloexec/t/001_cloexec.pl
index 5cea63d982b..4c80b8d825d 100644
--- a/src/test/modules/test_cloexec/t/001_cloexec.pl
+++ b/src/test/modules/test_cloexec/t/001_cloexec.pl
@@ -43,7 +43,7 @@ if (!-f $test_prog)
 note("Using test program: $test_prog");
 
 my ($stdout, $stderr);
-my $result = run [ $test_prog ], '>', \$stdout, '2>', \$stderr;
+my $result = run [$test_prog], '>', \$stdout, '2>', \$stderr;
 
 note("Test program output:");
 note($stdout) if $stdout;
@@ -55,6 +55,6 @@ if ($stderr)
 }
 
 ok($result && $stdout =~ /SUCCESS.*O_CLOEXEC behavior verified/s,
-   "O_CLOEXEC prevents handle inheritance");
+	"O_CLOEXEC prevents handle inheritance");
 
 done_testing();
diff --git a/src/test/modules/test_extensions/t/001_extension_control_path.pl b/src/test/modules/test_extensions/t/001_extension_control_path.pl
index f8302503b4b..c1cec0dc622 100644
--- a/src/test/modules/test_extensions/t/001_extension_control_path.pl
+++ b/src/test/modules/test_extensions/t/001_extension_control_path.pl
@@ -46,7 +46,8 @@ $node->safe_psql('postgres', "CREATE USER $user");
 
 my $ecp = $node->safe_psql('postgres', 'show extension_control_path;');
 
-is($ecp, "\$system$sep$ext_dir$sep$ext_dir2",
+is( $ecp,
+	"\$system$sep$ext_dir$sep$ext_dir2",
 	"custom extension control directory path configured");
 
 $node->safe_psql('postgres', "CREATE EXTENSION $ext_name");
@@ -79,21 +80,25 @@ is( $ret,
 
 # Test that a non-superuser is not able to read the extension location in
 # pg_available_extensions
-$ret = $node->safe_psql('postgres',
+$ret = $node->safe_psql(
+	'postgres',
 	"select location from pg_available_extensions where name = '$ext_name2'",
 	connstr => "user=$user");
 is( $ret,
 	"<insufficient privilege>",
-	"extension location is hidden in pg_available_extensions for users with insufficient privilege");
+	"extension location is hidden in pg_available_extensions for users with insufficient privilege"
+);
 
 # Test that a non-superuser is not able to read the extension location in
 # pg_available_extension_versions
-$ret = $node->safe_psql('postgres',
+$ret = $node->safe_psql(
+	'postgres',
 	"select location from pg_available_extension_versions where name = '$ext_name2'",
 	connstr => "user=$user");
 is( $ret,
 	"<insufficient privilege>",
-	"extension location is hidden in pg_available_extension_versions for users with insufficient privilege");
+	"extension location is hidden in pg_available_extension_versions for users with insufficient privilege"
+);
 
 # Ensure that extensions installed in $system are still visible when used with
 # custom extension control path.
diff --git a/src/test/modules/test_misc/t/003_check_guc.pl b/src/test/modules/test_misc/t/003_check_guc.pl
index be96b5174de..8b9ef191980 100644
--- a/src/test/modules/test_misc/t/003_check_guc.pl
+++ b/src/test/modules/test_misc/t/003_check_guc.pl
@@ -105,7 +105,8 @@ my @sample_intersect = grep($not_in_sample_hash{$_}, @gucs_in_file);
 is(scalar(@sample_intersect),
 	0, "no parameters marked as NOT_IN_SAMPLE in postgresql.conf.sample");
 
-is(scalar(@lines_with_tabs), 0, "no lines with tabs in postgresql.conf.sample");
+is(scalar(@lines_with_tabs),
+	0, "no lines with tabs in postgresql.conf.sample");
 
 # These would log some information only on errors.
 foreach my $param (@missing_from_file)
diff --git a/src/test/modules/test_misc/t/010_index_concurrently_upsert.pl b/src/test/modules/test_misc/t/010_index_concurrently_upsert.pl
index 3bdb632887e..50a0e7db8f7 100644
--- a/src/test/modules/test_misc/t/010_index_concurrently_upsert.pl
+++ b/src/test/modules/test_misc/t/010_index_concurrently_upsert.pl
@@ -603,7 +603,9 @@ clean_safe_quit_ok($s1, $s2, $s3);
 $node->safe_psql('postgres', 'TRUNCATE TABLE test.tblparted');
 
 ############################################################################
-note('Test: REINDEX on partitioned table, cache inval between two get_partition_ancestors');
+note(
+	'Test: REINDEX on partitioned table, cache inval between two get_partition_ancestors'
+);
 
 $s1 = $node->background_psql('postgres', on_error_stop => 0);
 $s2 = $node->background_psql('postgres', on_error_stop => 0);
diff --git a/src/test/modules/test_misc/t/012_ddlutils.pl b/src/test/modules/test_misc/t/012_ddlutils.pl
index a0e21c69fb5..bcdb831a676 100644
--- a/src/test/modules/test_misc/t/012_ddlutils.pl
+++ b/src/test/modules/test_misc/t/012_ddlutils.pl
@@ -42,12 +42,14 @@ sub ddl_filter
 $node->safe_psql('postgres', 'CREATE ROLE regress_role_ddl_test1');
 my $result = $node->safe_psql('postgres',
 	q{SELECT * FROM pg_get_role_ddl('regress_role_ddl_test1')});
-like($result,
+like(
+	$result,
 	qr/CREATE ROLE regress_role_ddl_test1 .* NOLOGIN/,
 	'basic role DDL');
 
 # Role with multiple privileges
-$node->safe_psql('postgres', q{
+$node->safe_psql(
+	'postgres', q{
 	CREATE ROLE regress_role_ddl_test2
 	  LOGIN SUPERUSER CREATEDB CREATEROLE
 	  CONNECTION LIMIT 5
@@ -60,7 +62,8 @@ like($result, qr/CONNECTION LIMIT 5/, 'role with CONNECTION LIMIT');
 like($result, qr/VALID UNTIL '2030-12-31/, 'role with VALID UNTIL');
 
 # Role with configuration parameters
-$node->safe_psql('postgres', q{
+$node->safe_psql(
+	'postgres', q{
 	ALTER ROLE regress_role_ddl_test1 SET work_mem TO '256MB';
 	ALTER ROLE regress_role_ddl_test1 SET search_path TO myschema, public});
 $result = $node->safe_psql('postgres',
@@ -69,14 +72,16 @@ like($result, qr/SET work_mem TO '256MB'/, 'role with work_mem setting');
 like($result, qr/SET search_path TO/, 'role with search_path setting');
 
 # Role with database-specific configuration (needs a real database)
-$node->safe_psql('postgres', q{
+$node->safe_psql(
+	'postgres', q{
 	CREATE DATABASE regression_ddlutils_test
 	  TEMPLATE template0 ENCODING 'UTF8' LC_COLLATE 'C' LC_CTYPE 'C';
 	ALTER ROLE regress_role_ddl_test2
 	  IN DATABASE regression_ddlutils_test SET work_mem TO '128MB'});
 $result = $node->safe_psql('postgres',
 	q{SELECT * FROM pg_get_role_ddl('regress_role_ddl_test2')});
-like($result,
+like(
+	$result,
 	qr/IN DATABASE regression_ddlutils_test SET work_mem TO '128MB'/,
 	'role with database-specific setting');
 
@@ -84,16 +89,17 @@ like($result,
 $node->safe_psql('postgres', q{CREATE ROLE "regress_role-with-dash"});
 $result = $node->safe_psql('postgres',
 	q{SELECT * FROM pg_get_role_ddl('regress_role-with-dash')});
-like($result, qr/"regress_role-with-dash"/,
-	'role name requiring quoting');
+like($result, qr/"regress_role-with-dash"/, 'role name requiring quoting');
 
 # Pretty-printed output
 $result = $node->safe_psql('postgres',
-	q{SELECT * FROM pg_get_role_ddl('regress_role_ddl_test2', 'pretty', 'true')});
+	q{SELECT * FROM pg_get_role_ddl('regress_role_ddl_test2', 'pretty', 'true')}
+);
 like($result, qr/\n\s+SUPERUSER/, 'role pretty-print indents attributes');
 
 # Role with memberships
-$node->safe_psql('postgres', q{
+$node->safe_psql(
+	'postgres', q{
 	CREATE ROLE regress_role_ddl_grantor CREATEROLE;
 	CREATE ROLE regress_role_ddl_group1;
 	CREATE ROLE regress_role_ddl_group2;
@@ -108,36 +114,42 @@ $node->safe_psql('postgres', q{
 	RESET ROLE});
 $result = $node->safe_psql('postgres',
 	q{SELECT * FROM pg_get_role_ddl('regress_role_ddl_member')});
-like($result, qr/GRANT regress_role_ddl_group1 TO regress_role_ddl_member/,
+like(
+	$result,
+	qr/GRANT regress_role_ddl_group1 TO regress_role_ddl_member/,
 	'role with memberships includes GRANT');
 like($result, qr/SET FALSE/, 'membership includes SET FALSE');
 like($result, qr/ADMIN TRUE/, 'membership includes ADMIN TRUE');
 
 # Memberships suppressed
 $result = $node->safe_psql('postgres',
-	q{SELECT * FROM pg_get_role_ddl('regress_role_ddl_member', 'memberships', 'false')});
+	q{SELECT * FROM pg_get_role_ddl('regress_role_ddl_member', 'memberships', 'false')}
+);
 unlike($result, qr/GRANT/, 'memberships suppressed');
 
 # Non-existent role (should error)
-my ($ret, $stdout, $stderr) = $node->psql('postgres',
-	q{SELECT * FROM pg_get_role_ddl(9999999::oid)});
+my ($ret, $stdout, $stderr) =
+  $node->psql('postgres', q{SELECT * FROM pg_get_role_ddl(9999999::oid)});
 isnt($ret, 0, 'non-existent role errors');
 like($stderr, qr/does not exist/, 'non-existent role error message');
 
 # NULL input (should return no rows)
-$result = $node->safe_psql('postgres',
-	q{SELECT count(*) FROM pg_get_role_ddl(NULL)});
+$result =
+  $node->safe_psql('postgres', q{SELECT count(*) FROM pg_get_role_ddl(NULL)});
 is($result, '0', 'NULL role returns no rows');
 
 # Permission check: revoke SELECT on pg_authid
-$node->safe_psql('postgres', q{
+$node->safe_psql(
+	'postgres', q{
 	CREATE ROLE regress_role_ddl_noaccess;
 	REVOKE SELECT ON pg_authid FROM PUBLIC});
-($ret, $stdout, $stderr) = $node->psql('postgres',
+($ret, $stdout, $stderr) = $node->psql(
+	'postgres',
 	q{SET ROLE regress_role_ddl_noaccess;
 	  SELECT * FROM pg_get_role_ddl('regress_role_ddl_test1')});
 isnt($ret, 0, 'role DDL denied without pg_authid access');
-$node->safe_psql('postgres', q{
+$node->safe_psql(
+	'postgres', q{
 	GRANT SELECT ON pg_authid TO PUBLIC});
 
 
@@ -146,7 +158,8 @@ $node->safe_psql('postgres', q{
 ########################################################################
 
 # Set up: the test database was already created above for role tests.
-$node->safe_psql('postgres', q{
+$node->safe_psql(
+	'postgres', q{
 	ALTER DATABASE regression_ddlutils_test OWNER TO regress_role_ddl_test2;
 	ALTER DATABASE regression_ddlutils_test CONNECTION LIMIT 123;
 	ALTER DATABASE regression_ddlutils_test SET random_page_cost = 2.0;
@@ -165,44 +178,60 @@ is($result, '0', 'NULL database returns no rows');
 
 # Invalid option
 ($ret, $stdout, $stderr) = $node->psql('postgres',
-	q{SELECT * FROM pg_get_database_ddl('regression_ddlutils_test', 'owner', 'invalid')});
+	q{SELECT * FROM pg_get_database_ddl('regression_ddlutils_test', 'owner', 'invalid')}
+);
 isnt($ret, 0, 'invalid boolean option errors');
 like($stderr, qr/invalid value/, 'invalid option error message');
 
 # Duplicate option
-($ret, $stdout, $stderr) = $node->psql('postgres',
+($ret, $stdout, $stderr) = $node->psql(
+	'postgres',
 	q{SELECT * FROM pg_get_database_ddl('regression_ddlutils_test',
 	  'owner', 'false', 'owner', 'true')});
 isnt($ret, 0, 'duplicate option errors');
 
 # Basic output (without locale details)
-$result = ddl_filter($node->safe_psql('postgres',
-	q{SELECT pg_get_database_ddl
+$result = ddl_filter(
+	$node->safe_psql(
+		'postgres',
+		q{SELECT pg_get_database_ddl
 	  FROM pg_get_database_ddl('regression_ddlutils_test')}));
-like($result, qr/CREATE DATABASE regression_ddlutils_test/,
+like(
+	$result,
+	qr/CREATE DATABASE regression_ddlutils_test/,
 	'database DDL includes CREATE');
 like($result, qr/TEMPLATE = template0/, 'database DDL includes TEMPLATE');
 like($result, qr/ENCODING = 'UTF8'/, 'database DDL includes ENCODING');
-like($result, qr/OWNER TO regress_role_ddl_test2/, 'database DDL includes OWNER');
+like(
+	$result,
+	qr/OWNER TO regress_role_ddl_test2/,
+	'database DDL includes OWNER');
 like($result, qr/CONNECTION LIMIT = 123/, 'database DDL includes CONNLIMIT');
-like($result, qr/SET random_page_cost TO '2.0'/,
+like(
+	$result,
+	qr/SET random_page_cost TO '2.0'/,
 	'database DDL includes GUC setting');
 
 # Pretty-printed output
-$result = ddl_filter($node->safe_psql('postgres',
-	q{SELECT pg_get_database_ddl
+$result = ddl_filter(
+	$node->safe_psql(
+		'postgres',
+		q{SELECT pg_get_database_ddl
 	  FROM pg_get_database_ddl('regression_ddlutils_test',
 	    'pretty', 'true', 'tablespace', 'false')}));
 like($result, qr/\n\s+WITH TEMPLATE/, 'database DDL pretty-prints WITH');
 
 # Permission check
-$node->safe_psql('postgres', q{
+$node->safe_psql(
+	'postgres', q{
 	REVOKE CONNECT ON DATABASE regression_ddlutils_test FROM PUBLIC});
-($ret, $stdout, $stderr) = $node->psql('postgres',
+($ret, $stdout, $stderr) = $node->psql(
+	'postgres',
 	q{SET ROLE regress_role_ddl_noaccess;
 	  SELECT * FROM pg_get_database_ddl('regression_ddlutils_test')});
 isnt($ret, 0, 'database DDL denied without CONNECT');
-$node->safe_psql('postgres', q{
+$node->safe_psql(
+	'postgres', q{
 	GRANT CONNECT ON DATABASE regression_ddlutils_test TO PUBLIC});
 
 
@@ -216,8 +245,8 @@ $node->safe_psql('postgres', q{
 isnt($ret, 0, 'non-existent tablespace errors');
 
 # Non-existent tablespace by OID
-($ret, $stdout, $stderr) = $node->psql('postgres',
-	q{SELECT * FROM pg_get_tablespace_ddl(0::oid)});
+($ret, $stdout, $stderr) =
+  $node->psql('postgres', q{SELECT * FROM pg_get_tablespace_ddl(0::oid)});
 isnt($ret, 0, 'non-existent tablespace OID errors');
 
 # NULL input (name and OID variants)
@@ -229,7 +258,8 @@ $result = $node->safe_psql('postgres',
 is($result, '0', 'NULL tablespace OID returns no rows');
 
 # Tablespace name requiring quoting
-$node->safe_psql('postgres', q{
+$node->safe_psql(
+	'postgres', q{
 	SET allow_in_place_tablespaces = true;
 	CREATE TABLESPACE "regress_ tblsp" OWNER regress_role_ddl_test1
 	  LOCATION ''});
@@ -238,7 +268,8 @@ $result = $node->safe_psql('postgres',
 like($result, qr/"regress_ tblsp"/, 'tablespace name is quoted');
 
 # Rename and add options; reuse this tablespace for the remaining tests
-$node->safe_psql('postgres', q{
+$node->safe_psql(
+	'postgres', q{
 	ALTER TABLESPACE "regress_ tblsp" RENAME TO regress_allopt_tblsp;
 	ALTER TABLESPACE regress_allopt_tblsp
 	  SET (seq_page_cost = '1.5', random_page_cost = '1.1234567890',
@@ -247,41 +278,51 @@ $node->safe_psql('postgres', q{
 # Tablespace with multiple options
 $result = $node->safe_psql('postgres',
 	q{SELECT * FROM pg_get_tablespace_ddl('regress_allopt_tblsp')});
-like($result, qr/CREATE TABLESPACE regress_allopt_tblsp/,
+like(
+	$result,
+	qr/CREATE TABLESPACE regress_allopt_tblsp/,
 	'tablespace DDL includes CREATE');
-like($result, qr/OWNER regress_role_ddl_test1/,
+like(
+	$result,
+	qr/OWNER regress_role_ddl_test1/,
 	'tablespace DDL includes OWNER');
 like($result, qr/seq_page_cost='1.5'/, 'tablespace DDL includes options');
 
 # Pretty-printed output
-$result = $node->safe_psql('postgres',
+$result = $node->safe_psql(
+	'postgres',
 	q{SELECT * FROM pg_get_tablespace_ddl('regress_allopt_tblsp',
 	  'pretty', 'true')});
 like($result, qr/\n\s+OWNER/, 'tablespace DDL pretty-prints OWNER');
 
 # Owner suppressed
-$result = $node->safe_psql('postgres',
+$result = $node->safe_psql(
+	'postgres',
 	q{SELECT * FROM pg_get_tablespace_ddl('regress_allopt_tblsp',
 	  'owner', 'false')});
 unlike($result, qr/OWNER/, 'tablespace DDL owner suppressed');
 
 # Lookup by OID
-$result = $node->safe_psql('postgres', q{
+$result = $node->safe_psql(
+	'postgres', q{
 	SELECT pg_get_tablespace_ddl
 	FROM pg_get_tablespace_ddl(
 	  (SELECT oid FROM pg_tablespace
 	   WHERE spcname = 'regress_allopt_tblsp'))});
-like($result, qr/CREATE TABLESPACE regress_allopt_tblsp/,
+like(
+	$result,
+	qr/CREATE TABLESPACE regress_allopt_tblsp/,
 	'tablespace DDL by OID');
 
 # Permission check
-$node->safe_psql('postgres',
-	q{REVOKE SELECT ON pg_tablespace FROM PUBLIC});
-($ret, $stdout, $stderr) = $node->psql('postgres',
+$node->safe_psql('postgres', q{REVOKE SELECT ON pg_tablespace FROM PUBLIC});
+($ret, $stdout, $stderr) = $node->psql(
+	'postgres',
 	q{SET ROLE regress_role_ddl_noaccess;
 	  SELECT * FROM pg_get_tablespace_ddl('regress_allopt_tblsp')});
 isnt($ret, 0, 'tablespace DDL denied without pg_tablespace access');
-$node->safe_psql('postgres', q{
+$node->safe_psql(
+	'postgres', q{
 	GRANT SELECT ON pg_tablespace TO PUBLIC});
 
 $node->stop;
diff --git a/src/test/modules/test_plan_advice/t/001_replan_regress.pl b/src/test/modules/test_plan_advice/t/001_replan_regress.pl
index 452b179a665..13ef3543830 100644
--- a/src/test/modules/test_plan_advice/t/001_replan_regress.pl
+++ b/src/test/modules/test_plan_advice/t/001_replan_regress.pl
@@ -41,8 +41,10 @@ my $rc =
   system($ENV{PG_REGRESS} . " "
 	  . "--bindir= "
 	  . "--dlpath=\"$dlpath\" "
-	  . "--host=" . $node->host . " "
-	  . "--port=" . $node->port . " "
+	  . "--host="
+	  . $node->host . " "
+	  . "--port="
+	  . $node->port . " "
 	  . "--schedule=$srcdir/src/test/regress/parallel_schedule "
 	  . "--max-concurrent-tests=20 "
 	  . "--inputdir=\"$inputdir\" "
diff --git a/src/test/modules/test_shmem/t/001_late_shmem_alloc.pl b/src/test/modules/test_shmem/t/001_late_shmem_alloc.pl
index c154f57682a..5cf07d071ec 100644
--- a/src/test/modules/test_shmem/t/001_late_shmem_alloc.pl
+++ b/src/test/modules/test_shmem/t/001_late_shmem_alloc.pl
@@ -19,30 +19,41 @@ $node->start;
 $node->safe_psql("postgres", "CREATE EXTENSION test_shmem;");
 
 # Check that the attach counter is incremented on a new connection
-my $attach_count1 = $node->safe_psql("postgres", "SELECT get_test_shmem_attach_count();");
-my $attach_count2 = $node->safe_psql("postgres", "SELECT get_test_shmem_attach_count();");
-cmp_ok($attach_count2, '>', $attach_count1, "attach callback is called in each backend");
+my $attach_count1 =
+  $node->safe_psql("postgres", "SELECT get_test_shmem_attach_count();");
+my $attach_count2 =
+  $node->safe_psql("postgres", "SELECT get_test_shmem_attach_count();");
+cmp_ok($attach_count2, '>', $attach_count1,
+	"attach callback is called in each backend");
 $node->stop;
 
 ###
 # Test that loading via shared_preload_libraries also works
 ###
-$node->append_conf('postgresql.conf', "shared_preload_libraries = 'test_shmem'");
+$node->append_conf('postgresql.conf',
+	"shared_preload_libraries = 'test_shmem'");
 $node->start;
 
 # When loaded via shared_preload_libraries, the attach callback is
 # called or not, depending on whether this is an EXEC_BACKEND build.
-my $exec_backend = $node->safe_psql("postgres", "SHOW debug_exec_backend;") eq 'on';
-$attach_count1 = $node->safe_psql("postgres", "SELECT get_test_shmem_attach_count();");
-$attach_count2 = $node->safe_psql("postgres", "SELECT get_test_shmem_attach_count();");
+my $exec_backend =
+  $node->safe_psql("postgres", "SHOW debug_exec_backend;") eq 'on';
+$attach_count1 =
+  $node->safe_psql("postgres", "SELECT get_test_shmem_attach_count();");
+$attach_count2 =
+  $node->safe_psql("postgres", "SELECT get_test_shmem_attach_count();");
 
 if ($exec_backend)
 {
-   cmp_ok($attach_count2, '>', $attach_count1, "attach callback is called in each backend when loaded via shared_preload_libraries");
+	cmp_ok($attach_count2, '>', $attach_count1,
+		"attach callback is called in each backend when loaded via shared_preload_libraries"
+	);
 }
 else
 {
-   ok($attach_count1 == 0 && $attach_count2 == 0, "attach callback is not called when loaded via shared_preload_libraries");
+	ok( $attach_count1 == 0 && $attach_count2 == 0,
+		"attach callback is not called when loaded via shared_preload_libraries"
+	);
 }
 
 $node->stop;
diff --git a/src/test/perl/PostgreSQL/Test/AdjustUpgrade.pm b/src/test/perl/PostgreSQL/Test/AdjustUpgrade.pm
index 5cc7a0b50ae..8a0c6c98a39 100644
--- a/src/test/perl/PostgreSQL/Test/AdjustUpgrade.pm
+++ b/src/test/perl/PostgreSQL/Test/AdjustUpgrade.pm
@@ -117,11 +117,17 @@ sub adjust_database_contents
 	{
 		if ($dbnames{"contrib_regression_btree_gist"})
 		{
-			_add_st($result, 'contrib_regression_btree_gist',
+			_add_st(
+				$result,
+				'contrib_regression_btree_gist',
 				"drop index if exists public.inettmp_a_a1_idx");
-			_add_st($result, 'contrib_regression_btree_gist',
+			_add_st(
+				$result,
+				'contrib_regression_btree_gist',
 				"drop index if exists public.inetidx");
-			_add_st($result, 'contrib_regression_btree_gist',
+			_add_st(
+				$result,
+				'contrib_regression_btree_gist',
 				"drop index public.cidridx");
 		}
 		if ($dbnames{"regression_btree_gist"})
diff --git a/src/test/perl/PostgreSQL/Test/BackgroundPsql.pm b/src/test/perl/PostgreSQL/Test/BackgroundPsql.pm
index c6ff2dbde4c..d7797225451 100644
--- a/src/test/perl/PostgreSQL/Test/BackgroundPsql.pm
+++ b/src/test/perl/PostgreSQL/Test/BackgroundPsql.pm
@@ -246,7 +246,8 @@ sub query
 
 	local $Test::Builder::Level = $Test::Builder::Level + 1;
 
-	note "issuing query $query_cnt via background psql: $query" unless !$params{verbose};
+	note "issuing query $query_cnt via background psql: $query"
+	  unless !$params{verbose};
 
 	$self->{timeout}->start() if (defined($self->{query_timer_restart}));
 
@@ -280,7 +281,8 @@ sub query
 	  explain {
 		stdout => $self->{stdout},
 		stderr => $self->{stderr},
-	  } unless !$params{verbose};
+	  }
+	  unless !$params{verbose};
 
 	die "psql query timed out" if $self->{timeout}->is_expired;
 
diff --git a/src/test/perl/PostgreSQL/Test/Cluster.pm b/src/test/perl/PostgreSQL/Test/Cluster.pm
index bdc051e6ead..4fcb1f6be56 100644
--- a/src/test/perl/PostgreSQL/Test/Cluster.pm
+++ b/src/test/perl/PostgreSQL/Test/Cluster.pm
@@ -1352,9 +1352,9 @@ sub restart
 		my $log =
 		  PostgreSQL::Test::Utils::slurp_file($self->logfile, $log_location);
 		unlike($log, $params{log_unlike}, "unexpected fragment found in log")
-			if defined $params{log_unlike};
+		  if defined $params{log_unlike};
 		like($log, $params{log_like}, "expected fragment not found in log")
-			if defined $params{log_like};
+		  if defined $params{log_like};
 	}
 
 	if ($ret != 0)
@@ -2270,7 +2270,7 @@ sub psql
 		my $exc_save = $@;
 
 		# we need a dummy $stderr from hereon, if we didn't collect it
-		if (! defined $stderr)
+		if (!defined $stderr)
 		{
 			my $errtxt = "<not collected>";
 			$stderr = \$errtxt;
@@ -3960,7 +3960,8 @@ sub validate_slot_inactive_since
 		),
 		't',
 		"last inactive time for slot $slot_name is valid on node $name")
-	  or croak "could not validate captured inactive_since for slot $slot_name";
+	  or croak
+	  "could not validate captured inactive_since for slot $slot_name";
 
 	return $inactive_since;
 }
diff --git a/src/test/perl/PostgreSQL/Test/Utils.pm b/src/test/perl/PostgreSQL/Test/Utils.pm
index 81dbcab8257..d3e6abf7a68 100644
--- a/src/test/perl/PostgreSQL/Test/Utils.pm
+++ b/src/test/perl/PostgreSQL/Test/Utils.pm
@@ -968,7 +968,7 @@ sub _diag_command_output
 
 	diag(join(" ", @$cmd));
 
-	for my $channel (['stdout', $stdout], ['stderr', $stderr])
+	for my $channel ([ 'stdout', $stdout ], [ 'stderr', $stderr ])
 	{
 		my ($name, $output) = @$channel;
 		next unless $output;
@@ -977,9 +977,9 @@ sub _diag_command_output
 		my @lines = split /\n/, $output;
 		if (@lines > 60)
 		{
-			diag(join("\n", @lines[0 .. 29]));
+			diag(join("\n", @lines[ 0 .. 29 ]));
 			diag("... " . (@lines - 60) . " lines omitted ...");
-			diag(join("\n", @lines[-30 .. -1]));
+			diag(join("\n", @lines[ -30 .. -1 ]));
 		}
 		else
 		{
diff --git a/src/test/postmaster/t/003_start_stop.pl b/src/test/postmaster/t/003_start_stop.pl
index e384518c474..24a75362c0e 100644
--- a/src/test/postmaster/t/003_start_stop.pl
+++ b/src/test/postmaster/t/003_start_stop.pl
@@ -85,7 +85,8 @@ for (my $i = 0; $i <= 20; $i++)
 # before even looking up the user. Hence you now get "sorry, too many
 # clients already" instead of "role does not exist" error. Test that
 # to ensure that we have used up all the slots.
-$node->connect_fails("dbname=postgres user=invalid_user",
+$node->connect_fails(
+	"dbname=postgres user=invalid_user",
 	"connection is rejected when all slots are in use",
 	expected_stderr => qr/FATAL:  sorry, too many clients already/);
 
diff --git a/src/test/postmaster/t/004_negotiate.pl b/src/test/postmaster/t/004_negotiate.pl
index 949aa2ba19a..6765d947404 100644
--- a/src/test/postmaster/t/004_negotiate.pl
+++ b/src/test/postmaster/t/004_negotiate.pl
@@ -39,8 +39,7 @@ $sock->recv($reply, 1);
 if ($reply ne 'N')
 {
 	$sock->close();
-	plan skip_all =>
-	  "server accepted SSL; test requires SSL to be rejected";
+	plan skip_all => "server accepted SSL; test requires SSL to be rejected";
 }
 
 # Send GSSENCRequest, reject or bypass test.
@@ -50,8 +49,7 @@ $sock->recv($reply, 1);
 if ($reply ne 'N')
 {
 	$sock->close();
-	plan skip_all =>
-	  "server accepted GSS; test requires GSS to be rejected";
+	plan skip_all => "server accepted GSS; test requires GSS to be rejected";
 }
 
 my $log_offset = -s $node->logfile;
@@ -71,7 +69,7 @@ isnt($reply, 'N',
 
 $sock->close();
 $node->wait_for_log(qr/FATAL: .* unsupported frontend protocol 1234.5679/,
-					$log_offset);
+	$log_offset);
 
 # Check extra connection with a simple query.
 my $result = $node->safe_psql('postgres', 'select 1;');
diff --git a/src/test/recovery/t/013_crash_restart.pl b/src/test/recovery/t/013_crash_restart.pl
index 56afb1aa6eb..0fde920713e 100644
--- a/src/test/recovery/t/013_crash_restart.pl
+++ b/src/test/recovery/t/013_crash_restart.pl
@@ -255,8 +255,10 @@ is( $node->safe_psql(
 
 # Confirm that the logical replication launcher, a background worker
 # without the never-restart flag, has also restarted successfully.
-is($node->poll_query_until('postgres',
-	"SELECT count(*) = 1 FROM pg_stat_activity WHERE backend_type = 'logical replication launcher'"),
+is( $node->poll_query_until(
+		'postgres',
+		"SELECT count(*) = 1 FROM pg_stat_activity WHERE backend_type = 'logical replication launcher'"
+	),
 	'1',
 	'logical replication launcher restarted after crash');
 
diff --git a/src/test/recovery/t/035_standby_logical_decoding.pl b/src/test/recovery/t/035_standby_logical_decoding.pl
index d264a698ff6..4421059f100 100644
--- a/src/test/recovery/t/035_standby_logical_decoding.pl
+++ b/src/test/recovery/t/035_standby_logical_decoding.pl
@@ -758,12 +758,14 @@ wait_until_vacuum_can_remove(
 
 # message should not be issued
 ok( !$node_standby->log_contains(
-		"invalidating obsolete replication slot \"no_conflict_inactiveslot\"", $logstart),
+		"invalidating obsolete replication slot \"no_conflict_inactiveslot\"",
+		$logstart),
 	'inactiveslot slot invalidation is not logged with vacuum on conflict_test'
 );
 
 ok( !$node_standby->log_contains(
-		"invalidating obsolete replication slot \"no_conflict_activeslot\"", $logstart),
+		"invalidating obsolete replication slot \"no_conflict_activeslot\"",
+		$logstart),
 	'activeslot slot invalidation is not logged with vacuum on conflict_test'
 );
 
diff --git a/src/test/recovery/t/040_standby_failover_slots_sync.pl b/src/test/recovery/t/040_standby_failover_slots_sync.pl
index 47d64d05ad1..f8922aaa1a2 100644
--- a/src/test/recovery/t/040_standby_failover_slots_sync.pl
+++ b/src/test/recovery/t/040_standby_failover_slots_sync.pl
@@ -1031,9 +1031,11 @@ $primary->wait_for_replay_catchup($standby2);
 ##################################################
 
 # Recreate the slot by creating a subscription on the subscriber, keep it disabled.
-$subscriber1->safe_psql('postgres', qq[
+$subscriber1->safe_psql(
+	'postgres', qq[
 	CREATE TABLE push_wal (a int);
-	CREATE SUBSCRIPTION regress_mysub1 CONNECTION '$publisher_connstr' PUBLICATION regress_mypub WITH (slot_name = lsub1_slot, failover = true, enabled = false);]);
+	CREATE SUBSCRIPTION regress_mysub1 CONNECTION '$publisher_connstr' PUBLICATION regress_mypub WITH (slot_name = lsub1_slot, failover = true, enabled = false);]
+);
 
 # Create some DDL on the primary so that the slot lags behind the standby
 $primary->safe_psql('postgres', "CREATE TABLE push_wal (a int);");
@@ -1059,7 +1061,8 @@ $standby2->reload;
 # further calls, call the API in a background process.
 my $h = $standby2->background_psql('postgres', on_error_stop => 0);
 
-$h->query_until(qr/start/, q(
+$h->query_until(
+	qr/start/, q(
 	\echo start
 	SELECT pg_sync_replication_slots();
 	));
@@ -1089,7 +1092,8 @@ synchronized_standby_slots = 'sb2_slot'
 $primary->reload;
 
 # Enable the Subscription, so that the remote slot catches up
-$subscriber1->safe_psql('postgres', "ALTER SUBSCRIPTION regress_mysub1 ENABLE");
+$subscriber1->safe_psql('postgres',
+	"ALTER SUBSCRIPTION regress_mysub1 ENABLE");
 $subscriber1->wait_for_subscription_sync;
 
 # Create xl_running_xacts on the primary to speed up restart_lsn advancement.
@@ -1097,8 +1101,8 @@ $primary->safe_psql('postgres', "SELECT pg_log_standby_snapshot();");
 
 # Confirm from the log that the slot is sync-ready now.
 $standby2->wait_for_log(
-    qr/newly created replication slot \"lsub1_slot\" is sync-ready now/,
-    $log_offset);
+	qr/newly created replication slot \"lsub1_slot\" is sync-ready now/,
+	$log_offset);
 
 $h->quit;
 
diff --git a/src/test/recovery/t/046_checkpoint_logical_slot.pl b/src/test/recovery/t/046_checkpoint_logical_slot.pl
index 1ecb47a8b58..66761bf56c1 100644
--- a/src/test/recovery/t/046_checkpoint_logical_slot.pl
+++ b/src/test/recovery/t/046_checkpoint_logical_slot.pl
@@ -158,9 +158,7 @@ $primary->backup($backup_name);
 
 # Create a standby
 my $standby = PostgreSQL::Test::Cluster->new('standby');
-$standby->init_from_backup(
-	$primary, $backup_name,
-	has_streaming => 1);
+$standby->init_from_backup($primary, $backup_name, has_streaming => 1);
 
 my $connstr_1 = $primary->connstr;
 $standby->append_conf(
@@ -170,7 +168,8 @@ primary_slot_name = 'phys_slot'
 primary_conninfo = '$connstr_1 dbname=postgres'
 ));
 
-$primary->safe_psql('postgres',
+$primary->safe_psql(
+	'postgres',
 	q{SELECT pg_create_logical_replication_slot('failover_slot', 'test_decoding', false, false, true);
 	 SELECT pg_create_physical_replication_slot('phys_slot');}
 );
@@ -198,7 +197,8 @@ checkpoint;
 
 # Wait until the checkpoint stops right before invalidating slots
 note('waiting for injection_point');
-$standby->wait_for_event('checkpointer', 'restartpoint-before-slot-invalidation');
+$standby->wait_for_event('checkpointer',
+	'restartpoint-before-slot-invalidation');
 note('injection_point is reached');
 
 # Enable slot sync worker to synchronize the failover slot to the standby
@@ -206,12 +206,13 @@ $standby->append_conf('postgresql.conf', qq(sync_replication_slots = on));
 $standby->reload;
 
 # Wait for the slot to be synced
-$standby->poll_query_until(
-	'postgres',
-	"SELECT COUNT(*) > 0 FROM pg_replication_slots WHERE slot_name = 'failover_slot'");
+$standby->poll_query_until('postgres',
+	"SELECT COUNT(*) > 0 FROM pg_replication_slots WHERE slot_name = 'failover_slot'"
+);
 
 # Release the checkpointer
-$standby->safe_psql('postgres',
+$standby->safe_psql(
+	'postgres',
 	q{select injection_points_wakeup('restartpoint-before-slot-invalidation');
 	  select injection_points_detach('restartpoint-before-slot-invalidation')});
 
diff --git a/src/test/recovery/t/051_effective_wal_level.pl b/src/test/recovery/t/051_effective_wal_level.pl
index 991473726a9..c4c2662f72b 100644
--- a/src/test/recovery/t/051_effective_wal_level.pl
+++ b/src/test/recovery/t/051_effective_wal_level.pl
@@ -100,7 +100,8 @@ command_fails(
 		'--log' => $primary->logfile,
 		'start',
 	],
-	"cannot start server with wal_level='minimal' as there is in-use logical slot");
+	"cannot start server with wal_level='minimal' as there is in-use logical slot"
+);
 
 my $logfile = slurp_file($primary->logfile());
 like(
diff --git a/src/test/ssl/t/SSL/Server.pm b/src/test/ssl/t/SSL/Server.pm
index 4c101a26503..4400a432f42 100644
--- a/src/test/ssl/t/SSL/Server.pm
+++ b/src/test/ssl/t/SSL/Server.pm
@@ -323,8 +323,7 @@ sub switch_server_cert
 	$node->append_conf('sslconfig.conf', 'ssl=on');
 	$node->append_conf('sslconfig.conf', $backend->set_server_cert(\%params));
 	# use lists of ECDH curves and cipher suites for syntax testing
-	$node->append_conf('sslconfig.conf',
-		'ssl_groups=prime256v1:secp521r1');
+	$node->append_conf('sslconfig.conf', 'ssl_groups=prime256v1:secp521r1');
 	$node->append_conf('sslconfig.conf',
 		'ssl_tls13_ciphers=TLS_AES_256_GCM_SHA384:TLS_AES_128_GCM_SHA256');
 
diff --git a/src/test/subscription/t/023_twophase_stream.pl b/src/test/subscription/t/023_twophase_stream.pl
index 8bf93aa379b..e9e0f753f7c 100644
--- a/src/test/subscription/t/023_twophase_stream.pl
+++ b/src/test/subscription/t/023_twophase_stream.pl
@@ -451,16 +451,14 @@ $offset = -s $node_subscriber->logfile;
 
 # Confirm the ERROR is reported because max_prepared_transactions is zero
 $node_subscriber->wait_for_log(
-	qr/ERROR: ( [A-Z0-9]+:)? prepared transactions are disabled/,
-	$offset);
+	qr/ERROR: ( [A-Z0-9]+:)? prepared transactions are disabled/, $offset);
 
 # Confirm that the parallel apply worker has encountered an error. The check
 # focuses on the worker type as a keyword, since the error message content may
 # differ based on whether the leader initially detected the parallel apply
 # worker's failure or received a signal from it.
 $node_subscriber->wait_for_log(
-	qr/ERROR: .*logical replication parallel apply worker.*/,
-	$offset);
+	qr/ERROR: .*logical replication parallel apply worker.*/, $offset);
 
 # Set max_prepared_transactions to correct value to resume the replication
 $node_subscriber->append_conf('postgresql.conf',
diff --git a/src/test/subscription/t/035_conflicts.pl b/src/test/subscription/t/035_conflicts.pl
index 426ad74cf33..f23fe6af2a5 100644
--- a/src/test/subscription/t/035_conflicts.pl
+++ b/src/test/subscription/t/035_conflicts.pl
@@ -281,7 +281,7 @@ $node_A->safe_psql('postgres', "INSERT INTO tab VALUES (1, 1), (2, 2);");
 $node_A->wait_for_catchup($subname_BA);
 
 my $result = $node_B->safe_psql('postgres', "SELECT * FROM tab;");
-is($result, qq(1|1
+is( $result, qq(1|1
 2|2), 'check replicated insert on node B');
 
 # Disable the logical replication from node B to node A
@@ -297,9 +297,8 @@ my $log_location = -s $node_B->logfile;
 $node_B->safe_psql('postgres', "UPDATE tab SET b = 3 WHERE a = 1;");
 $node_A->safe_psql('postgres', "DELETE FROM tab WHERE a = 1;");
 
-($cmdret, $stdout, $stderr) = $node_A->psql(
-	'postgres', qq(VACUUM (verbose) public.tab;)
-);
+($cmdret, $stdout, $stderr) =
+  $node_A->psql('postgres', qq(VACUUM (verbose) public.tab;));
 
 like(
 	$stderr,
@@ -319,8 +318,7 @@ like(
 
 $log_location = -s $node_A->logfile;
 
-$node_A->safe_psql(
-	'postgres', "ALTER SUBSCRIPTION $subname_AB ENABLE;");
+$node_A->safe_psql('postgres', "ALTER SUBSCRIPTION $subname_AB ENABLE;");
 $node_B->wait_for_catchup($subname_AB);
 
 $logfile = slurp_file($node_A->logfile(), $log_location);
@@ -367,8 +365,7 @@ $node_A->safe_psql('postgres', "DELETE FROM tab WHERE a = 2;");
 
 $log_location = -s $node_A->logfile;
 
-$node_A->safe_psql(
-	'postgres', "ALTER SUBSCRIPTION $subname_AB ENABLE;");
+$node_A->safe_psql('postgres', "ALTER SUBSCRIPTION $subname_AB ENABLE;");
 $node_B->wait_for_catchup($subname_AB);
 
 $logfile = slurp_file($node_A->logfile(), $log_location);
@@ -406,7 +403,8 @@ ok( $node_A->poll_query_until(
 $node_B->safe_psql('postgres', "ALTER PUBLICATION tap_pub_B ADD TABLE tab");
 
 $node_A->safe_psql('postgres',
-	"ALTER SUBSCRIPTION $subname_AB REFRESH PUBLICATION WITH (copy_data = false)");
+	"ALTER SUBSCRIPTION $subname_AB REFRESH PUBLICATION WITH (copy_data = false)"
+);
 
 ###############################################################################
 # Test that publisher's transactions marked with DELAY_CHKPT_IN_COMMIT prevent
@@ -422,7 +420,8 @@ my $injection_points_supported = $node_B->check_extension('injection_points');
 # commit after marking DELAY_CHKPT_IN_COMMIT flag.
 if ($injection_points_supported != 0)
 {
-	$node_B->append_conf('postgresql.conf',
+	$node_B->append_conf(
+		'postgresql.conf',
 		"shared_preload_libraries = 'injection_points'
 		max_prepared_transactions = 1");
 	$node_B->restart;
@@ -469,11 +468,11 @@ if ($injection_points_supported != 0)
 	);
 
 	# Wait until the backend enters the injection point
-	$node_B->wait_for_event('client backend', 'commit-after-delay-checkpoint');
+	$node_B->wait_for_event('client backend',
+		'commit-after-delay-checkpoint');
 
 	# Confirm the update is suspended
-	$result =
-	  $node_B->safe_psql('postgres', 'SELECT * FROM tab WHERE a = 1');
+	$result = $node_B->safe_psql('postgres', 'SELECT * FROM tab WHERE a = 1');
 	is($result, qq(1|1), 'publisher sees the old row');
 
 	# Delete the row on the subscriber. The deleted row should be retained due to a
@@ -490,14 +489,12 @@ if ($injection_points_supported != 0)
 	# Confirm that the apply worker keeps requesting publisher status, while
 	# awaiting the prepared transaction to commit. Thus, the request log should
 	# appear more than once.
-	$node_A->wait_for_log(
-		qr/sending publisher status request message/,
+	$node_A->wait_for_log(qr/sending publisher status request message/,
 		$log_location);
 
 	$log_location = -s $node_A->logfile;
 
-	$node_A->wait_for_log(
-		qr/sending publisher status request message/,
+	$node_A->wait_for_log(qr/sending publisher status request message/,
 		$log_location);
 
 	# Confirm that the dead tuple cannot be removed
@@ -523,8 +520,7 @@ if ($injection_points_supported != 0)
 	ok($pub_session->quit, "close publisher session");
 
 	# Confirm that the transaction committed
-	$result =
-	  $node_B->safe_psql('postgres', 'SELECT * FROM tab WHERE a = 1');
+	$result = $node_B->safe_psql('postgres', 'SELECT * FROM tab WHERE a = 1');
 	is($result, qq(1|2), 'publisher sees the new row');
 
 	# Ensure the UPDATE is replayed on subscriber
@@ -539,8 +535,7 @@ if ($injection_points_supported != 0)
 		'update target row was deleted in tab');
 
 	# Remember the next transaction ID to be assigned
-	$next_xid =
-	  $node_A->safe_psql('postgres', "SELECT txid_current() + 1;");
+	$next_xid = $node_A->safe_psql('postgres', "SELECT txid_current() + 1;");
 
 	# Confirm that the xmin value is advanced to the latest nextXid after the
 	# prepared transaction on the publisher has been committed.
@@ -583,7 +578,8 @@ $node_B->reload;
 
 # Enable failover to activate the synchronized_standby_slots setting
 $node_A->safe_psql('postgres', "ALTER SUBSCRIPTION $subname_AB DISABLE;");
-$node_A->safe_psql('postgres', "ALTER SUBSCRIPTION $subname_AB SET (failover = true);");
+$node_A->safe_psql('postgres',
+	"ALTER SUBSCRIPTION $subname_AB SET (failover = true);");
 $node_A->safe_psql('postgres', "ALTER SUBSCRIPTION $subname_AB ENABLE;");
 
 # Insert a record
@@ -611,7 +607,8 @@ ok( $node_A->poll_query_until(
 	"the xmin value of slot 'pg_conflict_detection' is invalid on Node A");
 
 $result = $node_A->safe_psql('postgres',
-	"SELECT subretentionactive FROM pg_subscription WHERE subname='$subname_AB';");
+	"SELECT subretentionactive FROM pg_subscription WHERE subname='$subname_AB';"
+);
 is($result, qq(f), 'retention is inactive');
 
 ###############################################################################
@@ -648,7 +645,8 @@ ok( $node_A->poll_query_until(
 	"the xmin value of slot 'pg_conflict_detection' is valid on Node A");
 
 $result = $node_A->safe_psql('postgres',
-	"SELECT subretentionactive FROM pg_subscription WHERE subname='$subname_AB';");
+	"SELECT subretentionactive FROM pg_subscription WHERE subname='$subname_AB';"
+);
 is($result, qq(t), 'retention is active');
 
 ###############################################################################
@@ -656,8 +654,7 @@ is($result, qq(t), 'retention is active');
 # removing all the subscriptions.
 ###############################################################################
 
-$node_B->safe_psql(
-	'postgres', "DROP SUBSCRIPTION $subname_BA");
+$node_B->safe_psql('postgres', "DROP SUBSCRIPTION $subname_BA");
 
 ok( $node_B->poll_query_until(
 		'postgres',
@@ -665,8 +662,7 @@ ok( $node_B->poll_query_until(
 	),
 	"the slot 'pg_conflict_detection' has been dropped on Node B");
 
-$node_A->safe_psql(
-	'postgres', "DROP SUBSCRIPTION $subname_AB");
+$node_A->safe_psql('postgres', "DROP SUBSCRIPTION $subname_AB");
 
 ok( $node_A->poll_query_until(
 		'postgres',
diff --git a/src/test/subscription/t/036_sequences.pl b/src/test/subscription/t/036_sequences.pl
index 387b057268d..8e293871efb 100644
--- a/src/test/subscription/t/036_sequences.pl
+++ b/src/test/subscription/t/036_sequences.pl
@@ -250,15 +250,12 @@ my $publisher_limited_connstr =
   $node_publisher->connstr . ' dbname=postgres user=regress_seq_repl';
 $log_offset = -s $node_subscriber->logfile;
 
-$node_subscriber->safe_psql(
-	'postgres',
+$node_subscriber->safe_psql('postgres',
 	"ALTER SUBSCRIPTION regress_seq_sub CONNECTION '$publisher_limited_connstr'"
 );
 
-$node_subscriber->safe_psql(
-	'postgres',
-	"ALTER SUBSCRIPTION regress_seq_sub REFRESH SEQUENCES"
-);
+$node_subscriber->safe_psql('postgres',
+	"ALTER SUBSCRIPTION regress_seq_sub REFRESH SEQUENCES");
 
 $node_subscriber->wait_for_log(
 	qr/WARNING: ( [A-Z0-9]+:)? missing sequence on publisher \("public.regress_s2"\)/,
diff --git a/src/tools/add_commit_links.pl b/src/tools/add_commit_links.pl
index d9e657f0054..3db95a23361 100755
--- a/src/tools/add_commit_links.pl
+++ b/src/tools/add_commit_links.pl
@@ -51,7 +51,7 @@ sub process_file
 	$file =~ m/-(\d+)\./;
 	my $major_version = $1;
 	die "file name $file is not in the expected format\n"
-		unless defined $major_version;
+	  unless defined $major_version;
 
 	open(my $fh, '<', $file) || die "could not open file $file: $!\n";
 	open(my $tfh, '>', $tmpfile) || die "could not open file $tmpfile: $!\n";