use PostgreSQL::Test::Utils;
use Fcntl qw(:seek);
-use Test::More tests => 272;
+use Test::More;
my ($node, $result);
}
}
}
+
+done_testing();
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 3;
+use Test::More;
my ($node, $result);
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 5;
+use Test::More;
Test::More->builder->todo_start('filesystem bug')
if PostgreSQL::Test::Utils::has_wal_read_bug;
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 4;
+use Test::More;
my $node = PostgreSQL::Test::Cluster->new('main');
$node->init;
$log_contents,
qr/"Node Type": "Index Scan"[^}]*"Index Name": "pg_class_relname_nsp_index"/s,
"index scan logged, json mode");
+
+done_testing();
use warnings;
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 31;
+use Test::More;
my $node_primary;
my $node_standby;
);
test_index_replay("insert $i");
}
+
+done_testing();
use warnings;
use PostgreSQL::Test::Utils;
-use Test::More tests => 8;
+use Test::More;
#########################################
# Basic checks
program_help_ok('oid2name');
program_version_ok('oid2name');
program_options_handling_ok('oid2name');
+
+done_testing();
use File::Path qw(rmtree);
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 2;
+use Test::More;
# Test set-up
my $node = PostgreSQL::Test::Cluster->new('test');
# shutdown
$node->stop;
+
+done_testing();
use warnings;
use PostgreSQL::Test::Utils;
-use Test::More tests => 8;
+use Test::More;
program_help_ok('vacuumlo');
program_version_ok('vacuumlo');
program_options_handling_ok('vacuumlo');
+
+done_testing();
use File::stat qw{lstat};
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 22;
+use Test::More;
my $tempdir = PostgreSQL::Test::Utils::tempdir;
my $xlogdir = "$tempdir/pgxlog";
ok(check_mode_recursive($datadir_group, 0750, 0640),
'check PGDATA permissions');
}
+
+done_testing();
use warnings;
use PostgreSQL::Test::Utils;
-use Test::More tests => 8;
+use Test::More;
program_help_ok('pg_amcheck');
program_version_ok('pg_amcheck');
program_options_handling_ok('pg_amcheck');
+
+done_testing();
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 76;
+use Test::More;
# Test set-up
my ($node, $port);
qr/pg_amcheck: error: no relations to check/
],
'schema exclusion pattern overrides all inclusion patterns');
+
+done_testing();
use PostgreSQL::Test::Utils;
use Fcntl qw(:seek);
-use Test::More tests => 63;
+use Test::More;
my ($node, $port, %corrupt_page, %remove_relation);
[ @cmd, '-d', 'db1', '-d', 'db2', '-d', 'db3', '-S', 's*' ],
0, [$no_output_re], [$no_output_re],
'pg_amcheck excluding all corrupt schemas');
+
+done_testing();
$node->start;
# Ok, Xids and page layout look ok. We can run corruption tests.
-plan tests => 19;
# Check that pg_amcheck runs against the uncorrupted table without error.
$node->command_ok(
$node->teardown_node;
$node->clean_node;
+
+done_testing();
use warnings;
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 5;
+use Test::More;
my $node = PostgreSQL::Test::Cluster->new('test');
$node->init;
[],
'pg_amcheck all schemas, tables and indexes reports fickleidx corruption'
);
+
+done_testing();
use strict;
use warnings;
use PostgreSQL::Test::Utils;
-use Test::More tests => 42;
+use Test::More;
program_help_ok('pg_archivecleanup');
program_version_ok('pg_archivecleanup');
run_check('', 'pg_archivecleanup');
run_check('.partial', 'pg_archivecleanup with .partial file');
run_check('.00000020.backup', 'pg_archivecleanup with .backup file');
+
+done_testing();
use warnings;
use PostgreSQL::Test::Utils;
use PostgreSQL::Test::Cluster;
-use Test::More tests => 42;
+use Test::More;
program_help_ok('pg_receivewal');
program_version_ok('pg_receivewal');
"WAL segment $walfile_after_promotion archived after timeline jump");
ok(-e "$timeline_dir/00000002.history",
"timeline history file archived after timeline jump");
+
+done_testing();
use warnings;
use PostgreSQL::Test::Utils;
use PostgreSQL::Test::Cluster;
-use Test::More tests => 20;
+use Test::More;
program_help_ok('pg_recvlogical');
program_version_ok('pg_recvlogical');
'--start', '--endpos', "$nextlsn", '--no-loop', '-f', '-'
],
'replayed a two-phase transaction');
+
+done_testing();
use strict;
use warnings;
use PostgreSQL::Test::Utils;
-use Test::More tests => 8;
+use Test::More;
program_help_ok('pg_checksums');
program_version_ok('pg_checksums');
program_options_handling_ok('pg_checksums');
+
+done_testing();
use PostgreSQL::Test::Utils;
use Fcntl qw(:seek);
-use Test::More tests => 66;
+use Test::More;
# Utility routine to create and check a table with corrupted checksums
fail_corrupt($node, "99990_init.123");
fail_corrupt($node, "99990_fsm.123");
fail_corrupt($node, "99990_vm.123");
+
+done_testing();
use strict;
use warnings;
use PostgreSQL::Test::Utils;
-use Test::More tests => 20;
+use Test::More;
program_help_ok('pg_config');
program_version_ok('pg_config');
qr/lib.*\n.*bin/, 'pg_config two options different order');
command_like(['pg_config'], qr/.*\n.*\n.*/,
'pg_config without options prints many lines');
+
+done_testing();
use warnings;
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 17;
+use Test::More;
program_help_ok('pg_controldata');
program_version_ok('pg_controldata');
],
[qr/^$/],
'pg_controldata with corrupted pg_control');
+
+done_testing();
use File::stat qw{lstat};
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 24;
+use Test::More;
my $tempdir = PostgreSQL::Test::Utils::tempdir;
my $tempdir_short = PostgreSQL::Test::Utils::tempdir_short;
'pg_ctl restart with server running');
system_or_bail 'pg_ctl', 'stop', '-D', "$tempdir/data";
+
+done_testing();
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 3;
+use Test::More;
my $tempdir = PostgreSQL::Test::Utils::tempdir;
0, 'pg_ctl status with server running');
system_or_bail 'pg_ctl', 'stop', '-D', $node->data_dir;
+
+done_testing();
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 12;
+use Test::More;
my $tempdir = PostgreSQL::Test::Utils::tempdir;
is($node_standby->safe_psql('postgres', 'SELECT pg_is_in_recovery()'),
'f', 'promoted standby is not in recovery');
+
+done_testing();
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 14;
+use Test::More;
use Time::HiRes qw(usleep);
# Extract the file name of a $format from the contents of
check_log_pattern('jsonlog', $new_current_logfiles, 'syntax error', $node);
$node->stop();
+
+done_testing();
use Config;
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 82;
+use Test::More;
my $tempdir = PostgreSQL::Test::Utils::tempdir;
qr/\Qpg_dumpall: error: option --exclude-database cannot be used together with -g\/--globals-only\E/,
'pg_dumpall: option --exclude-database cannot be used together with -g/--globals-only'
);
+
+done_testing();
$node->psql('postgres', 'create database regress_pg_dump_test;');
$node->psql('postgres', 'create database regress_public_owner;');
-# Start with number of command_fails_like()*2 tests below (each
-# command_fails_like is actually 2 tests)
-my $num_tests = 12;
-
-foreach my $run (sort keys %pgdump_runs)
-{
- my $test_key = $run;
- my $run_db = 'postgres';
-
- if (defined($pgdump_runs{$run}->{database}))
- {
- $run_db = $pgdump_runs{$run}->{database};
- }
-
- # Each run of pg_dump is a test itself
- $num_tests++;
-
- # If there is a restore cmd, that's another test
- if ($pgdump_runs{$run}->{restore_cmd})
- {
- $num_tests++;
- }
-
- if ($pgdump_runs{$run}->{test_key})
- {
- $test_key = $pgdump_runs{$run}->{test_key};
- }
-
- # Then count all the tests run against each run
- foreach my $test (sort keys %tests)
- {
-
- # postgres is the default database, if it isn't overridden
- my $test_db = 'postgres';
-
- # Specific tests can override the database to use
- if (defined($tests{$test}->{database}))
- {
- $test_db = $tests{$test}->{database};
- }
-
- # The database to test against needs to match the database the run is
- # for, so skip combinations where they don't match up.
- if ($run_db ne $test_db)
- {
- next;
- }
-
- # Skip any collation-related commands if there is no collation support
- if (!$collation_support && defined($tests{$test}->{collation}))
- {
- next;
- }
-
- # Skip tests specific to LZ4 if this build does not support
- # this option.
- if (!$supports_lz4 && defined($tests{$test}->{lz4}))
- {
- next;
- }
-
- # If there is a like entry, but no unlike entry, then we will test the like case
- if ($tests{$test}->{like}->{$test_key}
- && !defined($tests{$test}->{unlike}->{$test_key}))
- {
- $num_tests++;
- }
- else
- {
- # We will test everything that isn't a 'like'
- $num_tests++;
- }
- }
-}
-plan tests => $num_tests;
-
#########################################
# Set up schemas, tables, etc, to be dumped.
# Stop the database instance, which will be removed at the end of the tests.
$node->stop('fast');
+
+done_testing();
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 3;
+use Test::More;
my $tempdir = PostgreSQL::Test::Utils::tempdir;
command_ok(
[ "pg_dump", '-p', $port, '-a', '--include-foreign-data=s2', 'postgres' ],
"dump foreign server with no tables");
+
+done_testing();
{
plan skip_all => 'High bit name tests fail on Msys2';
}
-else
-{
- plan tests => 14;
-}
# We're going to use byte sequences that aren't valid UTF-8 strings. Use
# LATIN1, which accepts any byte and has a conversion from each byte to UTF-8.
ok($result,
'restore full dump with command-line options for connection parameters');
is($stderr, '', 'no dump errors');
+
+done_testing();
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 12;
+use Test::More;
program_help_ok('pg_resetwal');
program_version_ok('pg_resetwal');
ok(check_mode_recursive($node->data_dir, 0700, 0600),
'check PGDATA permissions');
}
+
+done_testing();
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 6;
+use Test::More;
my $node = PostgreSQL::Test::Cluster->new('main');
$node->init;
qr/\Qpg_resetwal: warning: pg_control specifies invalid WAL segment size (0 bytes); proceed with caution\E/
],
'processes zero WAL segment size');
+
+done_testing();
use strict;
use warnings;
use PostgreSQL::Test::Utils;
-use Test::More tests => 23;
+use Test::More;
use FindBin;
use lib $FindBin::RealBin;
run_test('remote');
run_test('archive');
-exit(0);
+done_testing();
use strict;
use warnings;
use PostgreSQL::Test::Utils;
-use Test::More tests => 7;
+use Test::More;
use FindBin;
use lib $FindBin::RealBin;
run_test('local');
run_test('remote');
-exit(0);
+done_testing();
use strict;
use warnings;
use PostgreSQL::Test::Utils;
-use Test::More tests => 5;
+use Test::More;
use File::Find;
run_test('local');
run_test('remote');
-exit(0);
+done_testing();
use File::Copy;
use File::Path qw(rmtree);
use PostgreSQL::Test::Utils;
-use Test::More tests => 5;
+use Test::More;
use FindBin;
use lib $FindBin::RealBin;
run_test('local');
run_test('remote');
-exit(0);
+done_testing();
use strict;
use warnings;
use PostgreSQL::Test::Utils;
-use Test::More tests => 1;
+use Test::More;
use FindBin;
use lib $FindBin::RealBin;
RewindTest::create_standby();
RewindTest::run_pg_rewind('local');
RewindTest::clean_rewind_test();
-exit(0);
+
+done_testing();
use strict;
use warnings;
use PostgreSQL::Test::Utils;
-use Test::More tests => 12;
+use Test::More;
program_help_ok('pg_rewind');
program_version_ok('pg_rewind');
'--write-recovery-conf'
],
'no local source with --write-recovery-conf');
+
+done_testing();
use strict;
use warnings;
use PostgreSQL::Test::Utils;
-use Test::More tests => 3;
+use Test::More;
use FindBin;
use lib $FindBin::RealBin;
$node_b->teardown_node;
$node_c->teardown_node;
-exit(0);
+done_testing();
use warnings;
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 3;
+use Test::More;
use File::Copy;
$result = $node_2->safe_psql('postgres', 'SELECT * FROM public.bar');
is($result, qq(in both), 'table bar after rewind');
+
+done_testing();
use Config;
use PostgreSQL::Test::Utils;
-use Test::More tests => 12;
+use Test::More;
#########################################
# Basic checks
[ 'pg_test_fsync', '--secs-per-test', '0' ],
qr/\Qpg_test_fsync: error: --secs-per-test must be in range 1..4294967295\E/,
'pg_test_fsync: --secs-per-test must be in range');
+
+done_testing();
use Config;
use PostgreSQL::Test::Utils;
-use Test::More tests => 12;
+use Test::More;
#########################################
# Basic checks
[ 'pg_test_timing', '--duration', '0' ],
qr/\Qpg_test_timing: --duration must be in range 1..4294967295\E/,
'pg_test_timing: --duration must be in range');
+
+done_testing();
use strict;
use warnings;
use PostgreSQL::Test::Utils;
-use Test::More tests => 16;
+use Test::More;
my $tempdir = PostgreSQL::Test::Utils::tempdir;
[ 'pg_verifybackup', '-m', "$tempdir/not_the_manifest", $tempdir ],
qr/could not open file.*\/not_the_manifest\"/,
'pg_verifybackup respects -m flag');
+
+done_testing();
use File::Path qw(rmtree);
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 19;
+use Test::More;
my $primary = PostgreSQL::Test::Cluster->new('primary');
$primary->init(allows_streaming => 1);
# Remove backup immediately to save disk space.
rmtree($backup_path);
}
+
+done_testing();
use File::Path qw(rmtree);
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 44;
+use Test::More;
my $primary = PostgreSQL::Test::Cluster->new('primary');
$primary->init(allows_streaming => 1);
chmod(0700, $pathname) || die "chmod $pathname: $!";
return;
}
+
+done_testing();
use File::Path qw(rmtree);
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 25;
+use Test::More;
# Start up the server and take a backup.
my $primary = PostgreSQL::Test::Cluster->new('primary');
],
qr/could not open directory/,
'nonexistent backup directory');
+
+done_testing();
use Config;
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 58;
+use Test::More;
my $tempdir = PostgreSQL::Test::Utils::tempdir;
command_fails_like([ 'pg_verifybackup', $tempdir ], $regexp, $test_name);
return;
}
+
+done_testing();
use Config;
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 5;
+use Test::More;
my $primary = PostgreSQL::Test::Cluster->new('primary');
$primary->init(allows_streaming => 1);
[ 'pg_verifybackup', '-s', $backup_path ],
qr/backup successfully verified/,
'backup with forced encoding verified');
+
+done_testing();
use File::Path qw(rmtree);
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 9;
+use Test::More;
# Start up the server and take a backup.
my $primary = PostgreSQL::Test::Cluster->new('primary');
command_ok(
[ 'pg_verifybackup', $backup_path2 ],
'valid base backup with timeline > 1');
+
+done_testing();
use File::Path qw(rmtree);
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 9;
+use Test::More;
my $primary = PostgreSQL::Test::Cluster->new('primary');
$primary->init(allows_streaming => 1);
rmtree($extract_path);
}
}
+
+done_testing();
use File::Path qw(rmtree);
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 6;
-
+use Test::More;
my $primary = PostgreSQL::Test::Cluster->new('primary');
$primary->init(allows_streaming => 1);
$primary->start;
# Remove backup immediately to save disk space.
rmtree($backup_path);
}
+
+done_testing();
use File::Path qw(rmtree);
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 9;
+use Test::More;
my $primary = PostgreSQL::Test::Cluster->new('primary');
$primary->init(allows_streaming => 1);
rmtree($backup_path);
}
}
+
+done_testing();
use strict;
use warnings;
use PostgreSQL::Test::Utils;
-use Test::More tests => 8;
+use Test::More;
program_help_ok('pg_waldump');
program_version_ok('pg_waldump');
program_options_handling_ok('pg_waldump');
+
+done_testing();
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 25;
+use Test::More;
program_help_ok('psql');
program_version_ok('psql');
'handling of unexpected PQresultStatus',
'START_REPLICATION 0/0',
undef, qr/unexpected PQresultStatus: 8$/);
+
+done_testing();
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 2;
+use Test::More;
use Time::HiRes qw(usleep);
my $tempdir = PostgreSQL::Test::Utils::tempdir;
ok(!$result, 'query failed as expected');
like($stderr, qr/canceling statement due to user request/, 'query was canceled');
}
+
+done_testing();
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 14;
+use Test::More;
program_help_ok('clusterdb');
program_version_ok('clusterdb');
$node->command_ok([qw(clusterdb --echo --verbose dbname=template1)],
'clusterdb with connection string');
+
+done_testing();
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 2;
+use Test::More;
my $node = PostgreSQL::Test::Cluster->new('main');
$node->init;
[ 'clusterdb', '-a' ],
qr/statement: CLUSTER.*statement: CLUSTER/s,
'cluster all databases');
+
+done_testing();
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 25;
+use Test::More;
program_help_ok('createdb');
program_version_ok('createdb');
qr/^createdb: error: database creation failed: ERROR: invalid locale name|^createdb: error: database creation failed: ERROR: new LC_CTYPE \(foo'; SELECT '1\) is incompatible with the LC_CTYPE of the template database/s
],
'createdb with incorrect --lc-ctype');
+
+done_testing();
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 17;
+use Test::More;
program_help_ok('createuser');
program_version_ok('createuser');
$node->command_fails([ 'createuser', 'regress_user1' ],
'fails if role already exists');
+
+done_testing();
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 13;
+use Test::More;
program_help_ok('dropdb');
program_version_ok('dropdb');
$node->command_fails([ 'dropdb', 'nonexistent' ],
'fails with nonexistent database');
+
+done_testing();
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 11;
+use Test::More;
program_help_ok('dropuser');
program_version_ok('dropuser');
$node->command_fails([ 'dropuser', 'regress_nonexistent' ],
'fails with nonexistent user');
+
+done_testing();
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 10;
+use Test::More;
program_help_ok('pg_isready');
program_version_ok('pg_isready');
# use a long timeout for the benefit of very slow buildfarm machines
$node->command_ok([qw(pg_isready --timeout=60)],
'succeeds with server running');
+
+done_testing();
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 58;
+use Test::More;
program_help_ok('reindexdb');
program_version_ok('reindexdb');
qr/^reindexdb: warning: cannot reindex system catalogs concurrently, skipping all/s
],
'parallel reindexdb for system with --concurrently skips catalogs');
+
+done_testing();
use warnings;
use PostgreSQL::Test::Cluster;
-use Test::More tests => 2;
+use Test::More;
my $node = PostgreSQL::Test::Cluster->new('main');
$node->init;
[ 'reindexdb', '-a' ],
qr/statement: REINDEX.*statement: REINDEX/s,
'reindex all databases');
+
+done_testing();
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 58;
+use Test::More;
program_help_ok('vacuumdb');
program_version_ok('vacuumdb');
[ 'vacuumdb', '--min-xid-age', '2147483001', 'postgres' ],
qr/GREATEST.*relfrozenxid.*2147483001/,
'vacuumdb --table --min-xid-age');
+
+done_testing();
use warnings;
use PostgreSQL::Test::Cluster;
-use Test::More tests => 2;
+use Test::More;
my $node = PostgreSQL::Test::Cluster->new('main');
$node->init;
[ 'vacuumdb', '-a' ],
qr/statement: VACUUM.*statement: VACUUM/s,
'vacuum all databases');
+
+done_testing();
use warnings;
use PostgreSQL::Test::Cluster;
-use Test::More tests => 4;
+use Test::More;
my $node = PostgreSQL::Test::Cluster->new('main');
$node->init;
.*statement:\ RESET\ default_statistics_target;
.*statement:\ ANALYZE/sx,
'analyze more than one database in stages');
+
+done_testing();
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 3;
+use Test::More;
# Tests to check connection string handling in utilities
$node->command_ok(
[qw(clusterdb --all --echo --verbose)],
'clusterdb --all with unusual database names');
+
+done_testing();
plan skip_all =>
"authentication tests cannot run without Unix-domain sockets";
}
-else
-{
- plan tests => 23;
-}
-
# Delete pg_hba.conf from the given node, add a new entry to it
# and then execute a reload to refresh it.
!);
test_role($node, 'md5_role', 'password from pgpass', 0);
+
+done_testing();
plan skip_all =>
"authentication tests cannot run without Unix-domain sockets";
}
-else
-{
- plan tests => 12;
-}
# Delete pg_hba.conf from the given node, add a new entry to it
# and then execute a reload to refresh it.
test_login($node, 'saslpreptest7_role', "foo\xd8\xa71bar", 0);
test_login($node, 'saslpreptest7_role', "foo1\xd8\xa7bar", 2);
test_login($node, 'saslpreptest7_role', "foobar", 2);
+
+done_testing();
use Test::More;
use Time::HiRes qw(usleep);
-if ($ENV{with_gssapi} eq 'yes')
-{
- plan tests => 44;
-}
-else
+if ($ENV{with_gssapi} ne 'yes')
{
plan skip_all => 'GSSAPI/Kerberos not supported by this build';
}
'',
'fails with wrong krb_realm, but still authenticates',
"connection authenticated: identity=\"test1\@$realm\" method=gss");
+
+done_testing();
use PostgreSQL::Test::Cluster;
use Test::More;
-if ($ENV{with_ldap} eq 'yes')
-{
- plan tests => 28;
-}
-else
+if ($ENV{with_ldap} ne 'yes')
{
plan skip_all => 'LDAP not supported by this build';
}
$ENV{"PGPASSWORD"} = 'secret1';
test_access($node, 'test1', 2, 'bad combination of LDAPS and StartTLS');
+
+done_testing();
use warnings;
use PostgreSQL::Test::Utils;
-use Test::More tests => 2;
+use Test::More;
use PostgreSQL::Test::Cluster;
my $node = PostgreSQL::Test::Cluster->new('tango');
);
is($count, 't', "index got summarized");
$node->stop;
+
+done_testing();
use warnings;
use PostgreSQL::Test::Utils;
-use Test::More tests => 2;
+use Test::More;
use PostgreSQL::Test::Cluster;
my $node = PostgreSQL::Test::Cluster->new('foxtrot');
'select ts.* from pg_class, pg_xact_commit_timestamp(xmin) ts where relname = \'t\''
);
is($recovered_ts, $ts, 'commit TS remains after crash recovery');
+
+done_testing();
use warnings;
use PostgreSQL::Test::Utils;
-use Test::More tests => 4;
+use Test::More;
use PostgreSQL::Test::Cluster;
my $bkplabel = 'backup';
$standby_ts_stderr,
qr/could not get commit timestamp data/,
'expected error when primary turned feature off');
+
+done_testing();
use warnings;
use PostgreSQL::Test::Utils;
-use Test::More tests => 4;
+use Test::More;
use PostgreSQL::Test::Cluster;
my $bkplabel = 'backup';
);
isnt($standby_ts, '',
"standby gives valid value ($standby_ts) after promotion");
+
+done_testing();
use warnings;
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 16;
+use Test::More;
my $node_primary = PostgreSQL::Test::Cluster->new('primary');
$node_primary->init(allows_streaming => 1);
'timestamp of disabled tx null after re-enable');
$node_primary->stop;
+
+done_testing();
use warnings;
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 42;
+use Test::More;
# Initialize a test cluster
my $node = PostgreSQL::Test::Cluster->new('primary');
run_sql_command('DROP TABLE quuux;');
$node->stop('fast');
+
+done_testing();
use warnings;
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 20;
+use Test::More;
my $node = PostgreSQL::Test::Cluster->new('main');
$node->init;
ok($result == 0, 'drop tablespace 4');
$node->stop;
+
+done_testing();
use warnings;
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 3;
+use Test::More;
my $node = PostgreSQL::Test::Cluster->new('main');
$node->init;
"found GUC $param in postgresql.conf.sample, marked as NOT_IN_SAMPLE\n"
);
}
+
+done_testing();
my $port = $node->port;
-my $num_tests = 0;
-
-foreach my $run (sort keys %pgdump_runs)
-{
- my $test_key = $run;
-
- # Each run of pg_dump is a test itself
- $num_tests++;
-
- # If there is a restore cmd, that's another test
- if ($pgdump_runs{$run}->{restore_cmd})
- {
- $num_tests++;
- }
-
- if ($pgdump_runs{$run}->{test_key})
- {
- $test_key = $pgdump_runs{$run}->{test_key};
- }
-
- # Then count all the tests run against each run
- foreach my $test (sort keys %tests)
- {
- # If there is a like entry, but no unlike entry, then we will test the like case
- if ($tests{$test}->{like}->{$test_key}
- && !defined($tests{$test}->{unlike}->{$test_key}))
- {
- $num_tests++;
- }
- else
- {
- # We will test everything that isn't a 'like'
- $num_tests++;
- }
- }
-}
-plan tests => $num_tests;
-
#########################################
# Set up schemas, tables, etc, to be dumped.
# Stop the database instance, which will be removed at the end of the tests.
$node->stop('fast');
+
+done_testing();
use warnings;
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
- # Replace with the number of tests to execute:
- use Test::More tests => 1;
+ use Test::More;
then it will generally need to set up one or more nodes, run commands
against them and evaluate the results. For example:
$node->stop('fast');
+Each test script should end with:
+
+ done_testing();
+
Test::More::like entails use of the qr// operator. Avoid Perl 5.8.8 bug
#39185 by not using the "$" regular expression metacharacter in qr// when also
using the "/m" modifier. Instead of "$", use "\n" or "(?=\n|\z)".
use warnings;
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 55;
+use Test::More;
# Initialize primary node
my $node_primary = PostgreSQL::Test::Cluster->new('primary');
my $primary_data = $node_primary->data_dir;
ok(!-f "$primary_data/pg_wal/$segment_removed",
"WAL segment $segment_removed recycled after physical slot advancing");
+
+done_testing();
use warnings;
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 7;
+use Test::More;
use File::Copy;
# Initialize primary node, doing archives
$log_contents,
qr/WARNING:.*recovery_end_command/s,
"recovery_end_command failure detected in logs after promotion");
+
+done_testing();
use warnings;
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 9;
+use Test::More;
use Time::HiRes qw(usleep);
# Create and test a standby from given backup, with a certain recovery target.
ok( $logfile =~
qr/FATAL: .* recovery ended before configured recovery target was reached/,
'recovery end before target reached is a fatal error');
+
+done_testing();
use File::Path qw(rmtree);
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 3;
+use Test::More;
$ENV{PGDATABASE} = 'postgres';
my $result_2 =
$node_standby_3->safe_psql('postgres', "SELECT count(*) FROM tab_int");
is($result_2, qq(1), 'check content of standby 3');
+
+done_testing();
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 3;
+use Test::More;
# Initialize primary node
my $node_primary = PostgreSQL::Test::Cluster->new('primary');
$node_standby2->promote;
$node_standby2->poll_query_until('postgres', "SELECT NOT pg_is_in_recovery()")
or die "Timed out while waiting for promotion to finish";
+
+done_testing();
use warnings;
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 15;
+use Test::More;
use Config;
# Initialize primary node
# done with the node
$node_primary->stop;
+
+done_testing();
use warnings;
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 11;
+use Test::More;
# Query checking sync_priority and sync_state of each standby
my $check_sql =
standby4|1|quorum),
'all standbys are considered as candidates for quorum sync standbys',
'ANY 2(*)');
+
+done_testing();
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 1;
+use Test::More;
my $node_primary = PostgreSQL::Test::Cluster->new('primary');
$node_primary->init(allows_streaming => 1);
qq{insert into testtab select generate_series(1,1000), 'foo';}),
0,
'INSERT succeeds with truncated relation FSM');
+
+done_testing();
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 24;
+use Test::More;
my $psql_out = '';
my $psql_rc = '';
is( $psql_out,
qq{27|issued to paris},
"Check expected t_009_tbl2 data on standby");
+
+done_testing();
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 13;
+use Test::More;
use File::Copy;
use IPC::Run ();
use Scalar::Util qw(blessed);
'got same output from walsender via pg_recvlogical on before_basebackup');
$node_replica->teardown_node();
+
+done_testing();
use Test::More;
use Config;
-plan tests => 3;
-
my $node = PostgreSQL::Test::Cluster->new('primary');
$node->init(allows_streaming => 1);
$node->start;
$stdin .= "\\q\n";
$tx->finish; # wait for psql to quit gracefully
+
+done_testing();
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 12;
+use Test::More;
# Setup primary node
my $node_primary = PostgreSQL::Test::Cluster->new("primary");
"SELECT coalesce(sum(id),-1) FROM t_012_tbl",
stdout => \$psql_out);
is($psql_out, '-1', "Not visible");
+
+done_testing();
use Test::More;
use Config;
-plan tests => 18;
-
-
# To avoid hanging while expecting some specific input from a psql
# instance being driven by us, add a timeout high enough that it
# should never trigger even on very slow machines, unless something
return 1;
}
+
+done_testing();
use warnings;
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 12;
+use Test::More;
my $node = PostgreSQL::Test::Cluster->new('main');
'vm fork in tablespace removed at startup');
ok( !-f "$pgdata/${ts1UnloggedPath}_fsm",
'fsm fork in tablespace removed at startup');
+
+done_testing();
use warnings;
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 1;
+use Test::More;
# Initialize primary node
my $alpha = PostgreSQL::Test::Cluster->new('alpha');
my $psql_out;
$bravo->psql('postgres', "SELECT count(*) FROM test1", stdout => \$psql_out);
is($psql_out, '1000', "Check that table state is correct");
+
+done_testing();
use warnings;
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 1;
+use Test::More;
# Find the largest LSN in the set of pages part of the given relation
# file. This is used for offline checks of page consistency. The LSN
# the pages on disk.
ok($offline_recovery_lsn ge $offline_max_lsn,
"Check offline that table data is consistent with minRecoveryPoint");
+
+done_testing();
{
plan skip_all => 'SysV shared memory not supported by this platform';
}
-else
-{
- plan tests => 4;
-}
my $tempdir = PostgreSQL::Test::Utils::tempdir;
$node->start && return 1;
return 0;
}
+
+done_testing();
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 38;
+use Test::More;
sub check_orphan_relfilenodes
{
# Run same test suite for multiple wal_level values.
run_wal_optimize("minimal");
run_wal_optimize("replica");
+
+done_testing();
use PostgreSQL::Test::Cluster;
use File::Path qw(rmtree);
-use Test::More tests => $PostgreSQL::Test::Utils::windows_os ? 16 : 20;
+use Test::More;
use Time::HiRes qw(usleep);
$ENV{PGDATABASE} = 'postgres';
return $log =~ m/$pat/;
}
+
+done_testing();
use warnings;
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 16;
+use Test::More;
use Config;
my $primary = PostgreSQL::Test::Cluster->new('primary');
&& -f "$standby2_data/$segment_path_2_done",
".done files created after archive success with archive_mode=always on standby"
);
+
+done_testing();
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 10;
+use Test::More;
use Config;
# Initialize primary node
return 1;
}
+
+done_testing();
plan skip_all => 'tests hang on Windows';
exit;
}
-else
-{
- plan tests => 9;
-}
-
# To avoid hanging while expecting some specific input from a psql
# instance being driven by us, add a timeout high enough that it
}
return 1;
}
+
+done_testing();
use warnings;
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 1;
+use Test::More;
use File::Compare;
# Initialize and start primary node with WAL archiving
# still be found.
$node_pitr->stop('immediate');
$node_pitr->start;
+
+done_testing();
use warnings;
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 2;
+use Test::More;
use Time::HiRes qw(usleep);
# Initialize and start node with wal_level = replica and WAL archiving
# Test for standby server
test_recovery_wal_level_minimal('standby', 'standby', 1);
+
+done_testing();
use File::Basename;
use FindBin;
-use Test::More tests => 1;
+use Test::More;
# Initialize primary node
my $node_primary = PostgreSQL::Test::Cluster->new('primary');
$node_cascade->safe_psql('postgres', "SELECT count(*) FROM tab_int");
print "cascade: $result\n";
is($result, 1, 'check streamed content on cascade standby');
+
+done_testing();
use PostgreSQL::Test::Utils;
use Test::More;
-plan tests => 3;
-
# Test: Create a physical replica that's missing the last WAL file,
# then restart the primary to create a divergent WAL file and observe
# that the replica replays the "overwrite contrecord" from that new
$node->stop;
$node_standby->stop;
+
+done_testing();
# this test file to die(), not merely to fail.
plan skip_all => 'filesystem bug';
}
-else
-{
- plan tests => 4;
-}
# Initialize primary node
my $node_primary = PostgreSQL::Test::Cluster->new('primary');
$node_standby_1->stop;
$node_primary->stop;
+
+done_testing();
{
plan skip_all => 'OpenSSL not supported by this build';
}
-else
-{
- plan tests => 110;
-}
#### Some configuration
"$common_connstr user=ssltestuser sslcert=ssl/client-revoked.crt sslkey=$key{'client-revoked.key'}",
"certificate authorization fails with revoked client cert with server-side CRL directory",
expected_stderr => qr/SSL error: sslv3 alert certificate revoked/);
+
+done_testing();
my $supports_tls_server_end_point =
check_pg_config("#define HAVE_X509_GET_SIGNATURE_NID 1");
-my $number_of_tests = $supports_tls_server_end_point ? 11 : 12;
-
# Allocation of base connection string shared among multiple tests.
my $common_connstr;
qr/connection authenticated: identity="ssltestuser" method=scram-sha-256/
]);
-done_testing($number_of_tests);
+done_testing();
{
plan skip_all => 'OpenSSL not supported by this build';
}
-else
-{
- plan tests => 13;
-}
#### Some configuration
"SELECT value, critical FROM ssl_extension_info() WHERE name = 'basicConstraints';",
connstr => $common_connstr);
is($result, 'CA:FALSE|t', 'extract extension from cert');
+
+done_testing();
use warnings;
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 32;
+use Test::More;
# Initialize publisher node
my $node_publisher = PostgreSQL::Test::Cluster->new('publisher');
ok( $reterr =~
m/WARNING: wal_level is insufficient to publish logical changes/,
'CREATE PUBLICATION while wal_level=minimal');
+
+done_testing();
use warnings;
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 4;
+use Test::More;
# Initialize publisher node
my $node_publisher = PostgreSQL::Test::Cluster->new('publisher');
$node_subscriber->stop('fast');
$node_publisher->stop('fast');
+
+done_testing();
use warnings;
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 6;
+use Test::More;
# Initialize publisher node
my $node_publisher = PostgreSQL::Test::Cluster->new('publisher');
$node_subscriber->stop('fast');
$node_publisher->stop('fast');
+
+done_testing();
use warnings;
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 8;
+use Test::More;
# Initialize publisher node
my $node_publisher = PostgreSQL::Test::Cluster->new('publisher');
$node_subscriber->stop('fast');
$node_publisher->stop('fast');
+
+done_testing();
use warnings;
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 1;
+use Test::More;
my $node_publisher = PostgreSQL::Test::Cluster->new('publisher');
$node_publisher->init(
$node_subscriber->stop;
$node_publisher->stop;
+
+done_testing();
use warnings;
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 2;
+use Test::More;
my $node_publisher = PostgreSQL::Test::Cluster->new('publisher');
$node_publisher->init(allows_streaming => 'logical');
$node_subscriber->stop;
$node_publisher->stop;
+
+done_testing();
use warnings;
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 1;
+use Test::More;
my $node_publisher = PostgreSQL::Test::Cluster->new('publisher');
$node_publisher->init(allows_streaming => 'logical');
$node_subscriber->stop;
$node_publisher->stop;
+
+done_testing();
use warnings;
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 5;
+use Test::More;
# Create publisher node
my $node_publisher = PostgreSQL::Test::Cluster->new('publisher');
$node_subscriber->stop;
$node_publisher->stop;
+
+done_testing();
use warnings;
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 1;
+use Test::More;
my $node_publisher = PostgreSQL::Test::Cluster->new('publisher');
$node_publisher->init(allows_streaming => 'logical');
$node_subscriber->stop;
$node_publisher->stop;
+
+done_testing();
use warnings;
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 14;
+use Test::More;
# setup
$result = $node_subscriber->safe_psql('postgres',
"SELECT deadlocks FROM pg_stat_database WHERE datname='postgres'");
is($result, qq(0), 'no deadlocks detected');
+
+done_testing();
use warnings;
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 2;
+use Test::More;
# setup
3|66
4|88
6|132), 'generated columns replicated');
+
+done_testing();
use PostgreSQL::Test::Utils;
use Test::More;
-if ($ENV{with_icu} eq 'yes')
-{
- plan tests => 2;
-}
-else
+if ($ENV{with_icu} ne 'yes')
{
plan skip_all => 'ICU not supported by this build';
}
is($node_subscriber->safe_psql('postgres', q{SELECT b FROM tab2}),
qq(bar),
'update with replica identity full with nondeterministic collation');
+
+done_testing();
use warnings;
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 63;
+use Test::More;
# setup
# $node_subscriber1->append_conf('postgresql.conf',
# "log_min_messages = warning");
# $node_subscriber1->reload;
+
+done_testing();
use warnings;
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 5;
+use Test::More;
# Create and initialize a publisher node
my $node_publisher = PostgreSQL::Test::Cluster->new('publisher');
$node_subscriber->stop('fast');
$node_publisher->stop('fast');
+
+done_testing();
use warnings;
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 4;
+use Test::More;
# Create publisher node
my $node_publisher = PostgreSQL::Test::Cluster->new('publisher');
$node_subscriber->stop;
$node_publisher->stop;
+
+done_testing();
use warnings;
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 2;
+use Test::More;
# Create publisher node
my $node_publisher = PostgreSQL::Test::Cluster->new('publisher');
$node_subscriber->stop;
$node_publisher->stop;
+
+done_testing();
use warnings;
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 3;
+use Test::More;
# Create publisher node
my $node_publisher = PostgreSQL::Test::Cluster->new('publisher');
$node_subscriber->stop;
$node_publisher->stop;
+
+done_testing();
use warnings;
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 4;
+use Test::More;
# Create publisher node
my $node_publisher = PostgreSQL::Test::Cluster->new('publisher');
$node_subscriber->stop;
$node_publisher->stop;
+
+done_testing();
use warnings;
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 2;
+use Test::More;
# Create publisher node
my $node_publisher = PostgreSQL::Test::Cluster->new('publisher');
$node_subscriber->stop;
$node_publisher->stop;
+
+done_testing();
use warnings;
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 5;
+use Test::More;
# Create publisher node
my $node_publisher = PostgreSQL::Test::Cluster->new('publisher');
$node_subscriber->stop('fast');
$node_publisher->stop('fast');
+
+done_testing();
use warnings;
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 24;
+use Test::More;
###############################
# Setup
$node_subscriber->stop('fast');
$node_publisher->stop('fast');
+
+done_testing();
use warnings;
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 41;
+use Test::More;
###############################
# Setup a cascade of pub/sub nodes.
$node_C->stop('fast');
$node_B->stop('fast');
$node_A->stop('fast');
+
+done_testing();
use warnings;
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 18;
+use Test::More;
###############################
# Setup
$node_subscriber->stop('fast');
$node_publisher->stop('fast');
+
+done_testing();
use warnings;
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 3;
+use Test::More;
# Initialize publisher node
my $node_publisher = PostgreSQL::Test::Cluster->new('publisher');
# shutdown
$node_subscriber->stop('fast');
$node_publisher->stop('fast');
+
+done_testing();
use warnings;
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 13;
+use Test::More;
# Initialize publisher node
my $node_publisher = PostgreSQL::Test::Cluster->new('publisher');
$node_subscriber->stop('fast');
$node_publisher->stop('fast');
+
+done_testing();
use warnings;
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 3;
+use Test::More;
# Test if the error reported on pg_stat_subscription_workers view is expected.
sub test_subscription_error
$node_subscriber->stop('fast');
$node_publisher->stop('fast');
+
+done_testing();
use strict;
use warnings;
use PostgreSQL::Test::Cluster;
-use Test::More tests => 14;
+use Test::More;
my ($node_publisher, $node_subscriber, $publisher_connstr, $result, $offset);
$offset = 0;
expect_replication(
"alice.unpartitioned", 2, 23, 25,
"nosuperuser nobypassrls table owner can replicate delete into unpartitioned despite rls");
+
+done_testing();
use warnings;
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
-use Test::More tests => 7;
+use Test::More;
# Bug #15114
$node_publisher->stop('fast');
$node_subscriber->stop('fast');
+
+done_testing();
projects / users / rhaas / postgres.git / commitdiff