Break up scripts in db unit test module.

Long scripts followed by a number of tests are really challenging to debug and update.

Instead, break up the scripts to be inline with the tests that they drive. This should make maintenance of the tests much simpler.

test/src/module/db/dbTest.c

@@ -264,47 +264,47 @@ testRun(void)
 
         HRN_PG_CONTROL_PUT(storagePgIdxWrite(0), PG_VERSION_95, .checkpoint = pgLsnFromStr(STRDEF("2/3")));
 
+        // Connect to primary
         HRN_PQ_SCRIPT_SET(
-            // Connect to primary
+            HRN_PQ_SCRIPT_OPEN_GE_93(1, "dbname='backupdb' port=5432", PG_VERSION_95, TEST_PATH "/pg1", false, NULL, NULL));
-            HRN_PQ_SCRIPT_OPEN_GE_93(1, "dbname='backupdb' port=5432", PG_VERSION_95, TEST_PATH "/pg1", false, NULL, NULL),
-
-            // Get start time
-            HRN_PQ_SCRIPT_TIME_QUERY(1, 1000),
-
-            // Start backup errors on advisory lock
-            HRN_PQ_SCRIPT_ADVISORY_LOCK(1, false),
-
-            // Start backup
-            HRN_PQ_SCRIPT_ADVISORY_LOCK(1, true),
-            HRN_PQ_SCRIPT_IS_IN_BACKUP(1, false),
-            HRN_PQ_SCRIPT_START_BACKUP_LE_95(1, false, "2/3", "000000010000000200000003"),
-            HRN_PQ_SCRIPT_DATABASE_LIST_1(1, "test1"),
-            HRN_PQ_SCRIPT_TABLESPACE_LIST_0(1),
-
-            // Stop backup
-            HRN_PQ_SCRIPT_STOP_BACKUP_LE_95(1, "2/4", "000000010000000200000004"),
-
-            // Close primary
-            HRN_PQ_SCRIPT_CLOSE(1));
 
         DbGetResult db = {0};
         TEST_ASSIGN(db, dbGet(true, true, false), "get primary");
 
+        // Get start time
+        HRN_PQ_SCRIPT_SET(HRN_PQ_SCRIPT_TIME_QUERY(1, 1000));
         TEST_RESULT_UINT(dbTimeMSec(db.primary), 1000, "check time");
 
+        // Start backup errors on advisory lock
+        HRN_PQ_SCRIPT_SET(HRN_PQ_SCRIPT_ADVISORY_LOCK(1, false));
+
         TEST_ERROR(
             dbBackupStart(db.primary, false, false, false), LockAcquireError,
             "unable to acquire pgBackRest advisory lock\n"
             "HINT: is another pgBackRest backup already running on this cluster?");
 
+        // Start backup
+        HRN_PQ_SCRIPT_SET(
+            HRN_PQ_SCRIPT_ADVISORY_LOCK(1, true),
+            HRN_PQ_SCRIPT_IS_IN_BACKUP(1, false),
+            HRN_PQ_SCRIPT_START_BACKUP_LE_95(1, false, "2/3", "000000010000000200000003"));
+
         DbBackupStartResult backupStartResult = {0};
         TEST_ASSIGN(backupStartResult, dbBackupStart(db.primary, false, true, false), "start backup");
         TEST_RESULT_STR_Z(backupStartResult.lsn, "2/3", "check lsn");
         TEST_RESULT_STR_Z(backupStartResult.walSegmentName, "000000010000000200000003", "check wal segment name");
 
+        // Get database list
+        HRN_PQ_SCRIPT_SET(HRN_PQ_SCRIPT_DATABASE_LIST_1(1, "test1"));
         TEST_RESULT_STR_Z(hrnPackToStr(dbList(db.primary)), "1:array:[1:u32:16384, 2:str:test1, 3:u32:13777]", "check db list");
+
+        // Get tablespace ist
+        HRN_PQ_SCRIPT_SET(HRN_PQ_SCRIPT_TABLESPACE_LIST_0(1));
         TEST_RESULT_STR_Z(hrnPackToStr(dbTablespaceList(db.primary)), "", "check tablespace list");
 
+        // Stop backup
+        HRN_PQ_SCRIPT_SET(HRN_PQ_SCRIPT_STOP_BACKUP_LE_95(1, "2/4", "000000010000000200000004"));
+
         DbBackupStopResult backupStopResult = {.lsn = NULL};
         TEST_ASSIGN(backupStopResult, dbBackupStop(db.primary), "stop backup");
         TEST_RESULT_STR_Z(backupStopResult.lsn, "2/4", "check lsn");
@@ -312,6 +312,8 @@ testRun(void)
         TEST_RESULT_STR_Z(backupStopResult.backupLabel, NULL, "check backup label is not set");
         TEST_RESULT_STR_Z(backupStopResult.tablespaceMap, NULL, "check tablespace map is not set");
 
+        // Close primary
+        HRN_PQ_SCRIPT_SET(HRN_PQ_SCRIPT_CLOSE(1));
         TEST_RESULT_VOID(dbFree(db.primary), "free primary");
 
         // -------------------------------------------------------------------------------------------------------------------------
@@ -319,11 +321,14 @@ testRun(void)
 
         HRN_PG_CONTROL_PUT(storagePgIdxWrite(0), PG_VERSION_95, .checkpoint = pgLsnFromStr(STRDEF("2/5")));
 
+        // Connect to primary
         HRN_PQ_SCRIPT_SET(
-            // Connect to primary
+            HRN_PQ_SCRIPT_OPEN_GE_93(1, "dbname='backupdb' port=5432", PG_VERSION_95, TEST_PATH "/pg1", false, NULL, NULL));
-            HRN_PQ_SCRIPT_OPEN_GE_93(1, "dbname='backupdb' port=5432", PG_VERSION_95, TEST_PATH "/pg1", false, NULL, NULL),
 
-            // Start backup when backup is in progress
+        TEST_ASSIGN(db, dbGet(true, true, false), "get primary");
+
+        // Start backup when backup is in progress
+        HRN_PQ_SCRIPT_SET(
             HRN_PQ_SCRIPT_ADVISORY_LOCK(1, true),
             HRN_PQ_SCRIPT_IS_IN_BACKUP(1, true),
 
@@ -331,15 +336,7 @@ testRun(void)
             HRN_PQ_SCRIPT_STOP_BACKUP_LE_95(1, "1/1", "000000010000000100000001"),
 
             // Start backup
-            HRN_PQ_SCRIPT_START_BACKUP_LE_95(1, true, "2/5", "000000010000000200000005"),
+            HRN_PQ_SCRIPT_START_BACKUP_LE_95(1, true, "2/5", "000000010000000200000005"));
-
-            // Stop backup
-            HRN_PQ_SCRIPT_STOP_BACKUP_LE_95(1, "2/6", "000000010000000200000006"),
-
-            // Close primary
-            HRN_PQ_SCRIPT_CLOSE(1));
-
-        TEST_ASSIGN(db, dbGet(true, true, false), "get primary");
 
         TEST_RESULT_STR_Z(dbBackupStart(db.primary, true, true, false).lsn, "2/5", "start backup");
 
@@ -347,8 +344,12 @@ testRun(void)
             "P00   WARN: the cluster is already in backup mode but no pgBackRest backup process is running."
             " pg_stop_backup() will be called so a new backup can be started.");
 
+        // Stop backup
+        HRN_PQ_SCRIPT_SET(HRN_PQ_SCRIPT_STOP_BACKUP_LE_95(1, "2/6", "000000010000000200000006"));
         TEST_RESULT_STR_Z(dbBackupStop(db.primary).lsn, "2/6", "stop backup");
 
+        // Close primary
+        HRN_PQ_SCRIPT_SET(HRN_PQ_SCRIPT_CLOSE(1));
         TEST_RESULT_VOID(dbFree(db.primary), "free primary");
 
         // -------------------------------------------------------------------------------------------------------------------------
@@ -356,50 +357,53 @@ testRun(void)
 
         HRN_PG_CONTROL_PUT(storagePgIdxWrite(0), PG_VERSION_96, .checkpoint = pgLsnFromStr(STRDEF("3/3")));
 
+        // Connect to primary
         HRN_PQ_SCRIPT_SET(
-            // Connect to primary
+            HRN_PQ_SCRIPT_OPEN_GE_96(1, "dbname='backupdb' port=5432", PG_VERSION_96, TEST_PATH "/pg1", false, NULL, NULL));
-            HRN_PQ_SCRIPT_OPEN_GE_96(1, "dbname='backupdb' port=5432", PG_VERSION_96, TEST_PATH "/pg1", false, NULL, NULL),
-
-            // Start backup with timeline error
-            HRN_PQ_SCRIPT_ADVISORY_LOCK(1, true),
-            HRN_PQ_SCRIPT_CURRENT_WAL_LE_96(1, "000000020000000300000002"),
-            HRN_PQ_SCRIPT_START_BACKUP_96(1, false, "3/3", "000000020000000300000003"),
-
-            // Start backup with checkpoint error
-            HRN_PQ_SCRIPT_ADVISORY_LOCK(1, true),
-            HRN_PQ_SCRIPT_CURRENT_WAL_LE_96(1, "000000010000000400000003"),
-            HRN_PQ_SCRIPT_START_BACKUP_96(1, false, "4/4", "000000010000000400000004"),
-
-            // Start backup
-            HRN_PQ_SCRIPT_ADVISORY_LOCK(1, true),
-            HRN_PQ_SCRIPT_CURRENT_WAL_LE_96(1, "000000010000000300000002"),
-            HRN_PQ_SCRIPT_START_BACKUP_96(1, false, "3/3", "000000010000000300000003"),
-
-            // Stop backup
-            HRN_PQ_SCRIPT_STOP_BACKUP_96(1, "3/4", "000000010000000300000004", false),
-
-            // Close primary
-            HRN_PQ_SCRIPT_CLOSE(1));
 
         TEST_ASSIGN(db, dbGet(true, true, false), "get primary");
 
+        // Start backup with timeline error
+        HRN_PQ_SCRIPT_SET(
+            HRN_PQ_SCRIPT_ADVISORY_LOCK(1, true),
+            HRN_PQ_SCRIPT_CURRENT_WAL_LE_96(1, "000000020000000300000002"),
+            HRN_PQ_SCRIPT_START_BACKUP_96(1, false, "3/3", "000000020000000300000003"));
+
         TEST_ERROR(
             dbBackupStart(db.primary, false, true, true), DbMismatchError, "WAL timeline 2 does not match pg_control timeline 1");
+
+        // Start backup with checkpoint error
+        HRN_PQ_SCRIPT_SET(
+            HRN_PQ_SCRIPT_ADVISORY_LOCK(1, true),
+            HRN_PQ_SCRIPT_CURRENT_WAL_LE_96(1, "000000010000000400000003"),
+            HRN_PQ_SCRIPT_START_BACKUP_96(1, false, "4/4", "000000010000000400000004"));
+
         TEST_ERROR(
             dbBackupStart(db.primary, false, true, true), DbMismatchError,
             "current checkpoint '3/3' is less than backup start '4/4'");
 
+        // Start backup
+        HRN_PQ_SCRIPT_SET(
+            HRN_PQ_SCRIPT_ADVISORY_LOCK(1, true),
+            HRN_PQ_SCRIPT_CURRENT_WAL_LE_96(1, "000000010000000300000002"),
+            HRN_PQ_SCRIPT_START_BACKUP_96(1, false, "3/3", "000000010000000300000003"));
+
         TEST_ASSIGN(backupStartResult, dbBackupStart(db.primary, false, true, true), "start backup");
         TEST_RESULT_STR_Z(backupStartResult.lsn, "3/3", "check lsn");
         TEST_RESULT_STR_Z(backupStartResult.walSegmentName, "000000010000000300000003", "check wal segment name");
         TEST_RESULT_STR_Z(backupStartResult.walSegmentCheck, "000000010000000300000002", "check wal segment check");
 
+        // Stop backup
+        HRN_PQ_SCRIPT_SET(HRN_PQ_SCRIPT_STOP_BACKUP_96(1, "3/4", "000000010000000300000004", false));
+
         TEST_ASSIGN(backupStopResult, dbBackupStop(db.primary), "stop backup");
         TEST_RESULT_STR_Z(backupStopResult.lsn, "3/4", "check lsn");
         TEST_RESULT_STR_Z(backupStopResult.walSegmentName, "000000010000000300000004", "check wal segment name");
         TEST_RESULT_STR_Z(backupStopResult.backupLabel, "BACKUP_LABEL_DATA", "check backup label");
         TEST_RESULT_STR_Z(backupStopResult.tablespaceMap, NULL, "check tablespace map is not set");
 
+        // Close primary
+        HRN_PQ_SCRIPT_SET(HRN_PQ_SCRIPT_CLOSE(1));
         TEST_RESULT_VOID(dbFree(db.primary), "free primary");
 
         // -------------------------------------------------------------------------------------------------------------------------
@@ -417,58 +421,58 @@ testRun(void)
         HRN_PG_CONTROL_PUT(storagePgIdxWrite(0), PG_VERSION_95, .timeline = 5, .checkpoint = pgLsnFromStr(STRDEF("5/4")));
         HRN_PG_CONTROL_PUT(storagePgIdxWrite(1), PG_VERSION_95, .timeline = 5, .checkpoint = pgLsnFromStr(STRDEF("5/4")));
 
+        // Connect to primary and standby
         HRN_PQ_SCRIPT_SET(
-            // Connect to primary
             HRN_PQ_SCRIPT_OPEN_GE_93(1, "dbname='postgres' port=5432", PG_VERSION_95, TEST_PATH "/pg1", false, NULL, NULL),
-
+            HRN_PQ_SCRIPT_OPEN_GE_93(2, "dbname='postgres' port=5433", PG_VERSION_95, TEST_PATH "/pg2", true, NULL, NULL));
-            // Connect to standby
-            HRN_PQ_SCRIPT_OPEN_GE_93(2, "dbname='postgres' port=5433", PG_VERSION_95, TEST_PATH "/pg2", true, NULL, NULL),
-
-            // Start backup
-            HRN_PQ_SCRIPT_ADVISORY_LOCK(1, true),
-            HRN_PQ_SCRIPT_START_BACKUP_LE_95(1, false, "5/4", "000000050000000500000004"),
-
-            // Wait for standby to sync
-            HRN_PQ_SCRIPT_REPLAY_WAIT_LE_95(2, "5/4"),
-
-            // Ping
-            HRN_PQ_SCRIPT_IS_STANDBY_QUERY(1, true),
-            HRN_PQ_SCRIPT_IS_STANDBY_QUERY(1, false),
-            HRN_PQ_SCRIPT_IS_STANDBY_QUERY(1, false),
-
-            HRN_PQ_SCRIPT_IS_STANDBY_QUERY(2, false),
-            HRN_PQ_SCRIPT_IS_STANDBY_QUERY(2, true),
-            HRN_PQ_SCRIPT_IS_STANDBY_QUERY(2, true),
-            HRN_PQ_SCRIPT_IS_STANDBY_QUERY(2, true),
-
-            // Close standby
-            HRN_PQ_SCRIPT_CLOSE(2),
-
-            // Close primary
-            HRN_PQ_SCRIPT_CLOSE(1));
 
         TEST_ASSIGN(db, dbGet(false, true, true), "get primary and standby");
 
+        // Start backup
+        HRN_PQ_SCRIPT_SET(
+            HRN_PQ_SCRIPT_ADVISORY_LOCK(1, true),
+            HRN_PQ_SCRIPT_START_BACKUP_LE_95(1, false, "5/4", "000000050000000500000004"));
+
         TEST_RESULT_STR_Z(dbBackupStart(db.primary, false, false, false).lsn, "5/4", "start backup");
+
+        // Wait for standby to sync
+        HRN_PQ_SCRIPT_SET(HRN_PQ_SCRIPT_REPLAY_WAIT_LE_95(2, "5/4"));
+
         TEST_RESULT_VOID(dbReplayWait(db.standby, STRDEF("5/4"), dbPgControl(db.primary).timeline, 1000), "sync standby");
 
+        // Ping
+        HRN_PQ_SCRIPT_SET(HRN_PQ_SCRIPT_IS_STANDBY_QUERY(1, true));
         TEST_ERROR(dbPing(db.primary, false), AssertError, "primary has switched to recovery");
+
+        HRN_PQ_SCRIPT_SET(HRN_PQ_SCRIPT_IS_STANDBY_QUERY(1, false));
         TEST_RESULT_VOID(dbPing(db.primary, false), "ping primary cluster");
         TEST_RESULT_VOID(dbPing(db.primary, false), "ping primary cluster (noop)");
+
+        HRN_PQ_SCRIPT_SET(HRN_PQ_SCRIPT_IS_STANDBY_QUERY(1, false));
         TEST_RESULT_VOID(dbPing(db.primary, true), "ping primary cluster (force)");
 
+        HRN_PQ_SCRIPT_SET(HRN_PQ_SCRIPT_IS_STANDBY_QUERY(2, false));
         TEST_ERROR(
             dbPing(db.standby, false), DbMismatchError,
             "standby is no longer in recovery\n"
             "HINT: was the standby promoted during the backup?");
+
+        HRN_PQ_SCRIPT_SET(HRN_PQ_SCRIPT_IS_STANDBY_QUERY(2, true));
         TEST_RESULT_VOID(dbPing(db.standby, false), "ping standby cluster");
         TEST_RESULT_VOID(dbPing(db.standby, false), "ping standby cluster (noop)");
+
+        HRN_PQ_SCRIPT_SET(HRN_PQ_SCRIPT_IS_STANDBY_QUERY(2, true));
         TEST_RESULT_VOID(dbPing(db.standby, true), "ping standby cluster (force)");
 
         db.standby->pingTimeLast -= DB_PING_SEC * 2;
+        HRN_PQ_SCRIPT_SET(HRN_PQ_SCRIPT_IS_STANDBY_QUERY(2, true));
         TEST_RESULT_VOID(dbPing(db.standby, false), "ping standby cluster");
 
+        // Close primary and standby
+        HRN_PQ_SCRIPT_SET(HRN_PQ_SCRIPT_CLOSE(2));
         TEST_RESULT_VOID(dbFree(db.standby), "free standby");
+
+        HRN_PQ_SCRIPT_SET(HRN_PQ_SCRIPT_CLOSE(1));
         TEST_RESULT_VOID(dbFree(db.primary), "free primary");
 
         // -------------------------------------------------------------------------------------------------------------------------
@@ -478,23 +482,36 @@ testRun(void)
         HRN_PG_CONTROL_PUT(storagePgIdxWrite(0), PG_VERSION_10, .timeline = 5, .checkpoint = pgLsnFromStr(STRDEF("5/5")));
         HRN_PG_CONTROL_PUT(storagePgIdxWrite(1), PG_VERSION_10, .timeline = 5, .checkpoint = pgLsnFromStr(STRDEF("5/5")));
 
+        // Connect to primary and standby
         HRN_PQ_SCRIPT_SET(
-            // Connect to primary
             HRN_PQ_SCRIPT_OPEN_GE_96(1, "dbname='postgres' port=5432", PG_VERSION_10, TEST_PATH "/pg1", false, NULL, NULL),
+            HRN_PQ_SCRIPT_OPEN_GE_96(2, "dbname='postgres' port=5433", PG_VERSION_10, TEST_PATH "/pg2", true, NULL, NULL));
 
-            // Connect to standby
+        TEST_ASSIGN(db, dbGet(false, true, true), "get primary and standby");
-            HRN_PQ_SCRIPT_OPEN_GE_96(2, "dbname='postgres' port=5433", PG_VERSION_10, TEST_PATH "/pg2", true, NULL, NULL),
 
-            // Start backup
+        TEST_RESULT_UINT(dbPgControl(db.primary).timeline, 5, "check primary timeline");
+        TEST_RESULT_UINT(dbPgControl(db.standby).timeline, 5, "check standby timeline");
+
+        // Start backup
+        HRN_PQ_SCRIPT_SET(
             HRN_PQ_SCRIPT_ADVISORY_LOCK(1, true),
             HRN_PQ_SCRIPT_CURRENT_WAL_GE_10(1, "000000050000000500000005"),
             HRN_PQ_SCRIPT_START_BACKUP_GE_10(1, false, "5/5", "000000050000000500000005"),
 
             // Switch WAL segment so it can be checked
             HRN_PQ_SCRIPT_CREATE_RESTORE_POINT(1, "5/5"),
-            HRN_PQ_SCRIPT_WAL_SWITCH(1, "wal", "000000050000000500000005"),
+            HRN_PQ_SCRIPT_WAL_SWITCH(1, "wal", "000000050000000500000005"));
 
-            // Standby returns NULL lsn
+        TEST_ASSIGN(backupStartResult, dbBackupStart(db.primary, false, false, true), "start backup");
+        TEST_RESULT_STR_Z(backupStartResult.lsn, "5/5", "check lsn");
+        TEST_RESULT_STR_Z(backupStartResult.walSegmentName, "000000050000000500000005", "check wal segment name");
+        TEST_RESULT_STR_Z(backupStartResult.walSegmentCheck, "000000050000000500000005", "check wal segment check");
+
+        TEST_ERROR(
+            dbReplayWait(db.standby, STRDEF("4/4"), 5, 1000), DbMismatchError, "standby checkpoint '5/5' is ahead of target '4/4'");
+
+        // Standby returns NULL lsn
+        HRN_PQ_SCRIPT_SET(
             {.session = 2, .function = HRN_PQ_SENDQUERY,
              .param =
                  "[\"select replayLsn::text,\\n"
@@ -513,85 +530,73 @@ testRun(void)
             {.session = 2, .function = HRN_PQ_GETISNULL, .param = "[0,0]", .resultInt = 1},
             {.session = 2, .function = HRN_PQ_GETVALUE, .param = "[0,1]", .resultZ = "false"},
             {.session = 2, .function = HRN_PQ_CLEAR},
-            {.session = 2, .function = HRN_PQ_GETRESULT, .resultNull = true},
+            {.session = 2, .function = HRN_PQ_GETRESULT, .resultNull = true});
-
-            // Timeout waiting for sync
-            HRN_PQ_SCRIPT_REPLAY_TARGET_REACHED_GE_10(2, "5/5", false, "5/3"),
-            HRN_PQ_SCRIPT_REPLAY_TARGET_REACHED_PROGRESS_GE_10(2, "5/5", false, "5/3", "5/3", false, 100),
-            HRN_PQ_SCRIPT_REPLAY_TARGET_REACHED_PROGRESS_GE_10(2, "5/5", false, "5/3", "5/3", false, 100),
-
-            // Checkpoint target timeout waiting for sync
-            HRN_PQ_SCRIPT_REPLAY_TARGET_REACHED_GE_10(2, "5/5", true, "5/5"),
-            HRN_PQ_SCRIPT_CHECKPOINT(2),
-            HRN_PQ_SCRIPT_CHECKPOINT_TARGET_REACHED_GE_10(2, "5/5", false, "5/4", 100),
-            HRN_PQ_SCRIPT_CHECKPOINT_TARGET_REACHED_GE_10(2, "5/5", false, "5/4", 100),
-            HRN_PQ_SCRIPT_CHECKPOINT_TARGET_REACHED_GE_10(2, "5/5", false, "5/4", 100),
-
-            // Wait for standby to sync
-            HRN_PQ_SCRIPT_REPLAY_TARGET_REACHED_GE_10(2, "5/5", false, "5/3"),
-            HRN_PQ_SCRIPT_REPLAY_TARGET_REACHED_PROGRESS_GE_10(2, "5/5", false, "5/3", "5/3", false, 0),
-            HRN_PQ_SCRIPT_REPLAY_TARGET_REACHED_PROGRESS_GE_10(2, "5/5", false, "5/4", "5/3", true, 0),
-            HRN_PQ_SCRIPT_REPLAY_TARGET_REACHED_PROGRESS_GE_10(2, "5/5", true, "5/5", "5/4", true, 0),
-            HRN_PQ_SCRIPT_CHECKPOINT(2),
-            HRN_PQ_SCRIPT_CHECKPOINT_TARGET_REACHED_GE_10(2, "5/5", true, "X/X", 0),
-
-            // Fail on timeline mismatch
-            HRN_PQ_SCRIPT_REPLAY_TARGET_REACHED_GE_10(2, "5/5", false, "5/3"),
-            HRN_PQ_SCRIPT_REPLAY_TARGET_REACHED_PROGRESS_GE_10(2, "5/5", false, "5/3", "5/3", false, 0),
-            HRN_PQ_SCRIPT_REPLAY_TARGET_REACHED_PROGRESS_GE_10(2, "5/5", false, "5/4", "5/3", true, 0),
-            HRN_PQ_SCRIPT_REPLAY_TARGET_REACHED_PROGRESS_GE_10(2, "5/5", true, "5/5", "5/4", true, 0),
-            HRN_PQ_SCRIPT_CHECKPOINT(2),
-            HRN_PQ_SCRIPT_CHECKPOINT_TARGET_REACHED_GE_10(2, "5/5", true, "X/X", 0),
-
-            // Close standby
-            HRN_PQ_SCRIPT_CLOSE(2),
-
-            // Stop backup
-            HRN_PQ_SCRIPT_STOP_BACKUP_GE_10(1, "5/6", "000000050000000500000006", true),
-
-            // Close primary
-            HRN_PQ_SCRIPT_CLOSE(1));
-
-        TEST_ASSIGN(db, dbGet(false, true, true), "get primary and standby");
-
-        TEST_RESULT_UINT(dbPgControl(db.primary).timeline, 5, "check primary timeline");
-        TEST_RESULT_UINT(dbPgControl(db.standby).timeline, 5, "check standby timeline");
-
-        TEST_ASSIGN(backupStartResult, dbBackupStart(db.primary, false, false, true), "start backup");
-        TEST_RESULT_STR_Z(backupStartResult.lsn, "5/5", "check lsn");
-        TEST_RESULT_STR_Z(backupStartResult.walSegmentName, "000000050000000500000005", "check wal segment name");
-        TEST_RESULT_STR_Z(backupStartResult.walSegmentCheck, "000000050000000500000005", "check wal segment check");
-
-        TEST_ERROR(
-            dbReplayWait(db.standby, STRDEF("4/4"), 5, 1000), DbMismatchError, "standby checkpoint '5/5' is ahead of target '4/4'");
 
         TEST_ERROR(
             dbReplayWait(db.standby, STRDEF("5/5"), dbPgControl(db.primary).timeline, 1000), ArchiveTimeoutError,
             "unable to query replay lsn on the standby using 'pg_catalog.pg_last_wal_replay_lsn()'\n"
             "HINT: Is this a standby?");
 
+        // Timeout waiting for sync
+        HRN_PQ_SCRIPT_SET(
+            HRN_PQ_SCRIPT_REPLAY_TARGET_REACHED_GE_10(2, "5/5", false, "5/3"),
+            HRN_PQ_SCRIPT_REPLAY_TARGET_REACHED_PROGRESS_GE_10(2, "5/5", false, "5/3", "5/3", false, 100),
+            HRN_PQ_SCRIPT_REPLAY_TARGET_REACHED_PROGRESS_GE_10(2, "5/5", false, "5/3", "5/3", false, 100));
+
         TEST_ERROR(
             dbReplayWait(db.standby, STRDEF("5/5"), dbPgControl(db.primary).timeline, 200), ArchiveTimeoutError,
             "timeout before standby replayed to 5/5 - only reached 5/3\n"
             "HINT: is replication running and current on the standby?\n"
             "HINT: disable the 'backup-standby' option to backup directly from the primary.");
 
+        // Checkpoint target timeout waiting for sync
+        HRN_PQ_SCRIPT_SET(
+            HRN_PQ_SCRIPT_REPLAY_TARGET_REACHED_GE_10(2, "5/5", true, "5/5"),
+            HRN_PQ_SCRIPT_CHECKPOINT(2),
+            HRN_PQ_SCRIPT_CHECKPOINT_TARGET_REACHED_GE_10(2, "5/5", false, "5/4", 100),
+            HRN_PQ_SCRIPT_CHECKPOINT_TARGET_REACHED_GE_10(2, "5/5", false, "5/4", 100),
+            HRN_PQ_SCRIPT_CHECKPOINT_TARGET_REACHED_GE_10(2, "5/5", false, "5/4", 100));
+
         TEST_ERROR(
             dbReplayWait(db.standby, STRDEF("5/5"), dbPgControl(db.primary).timeline, 200), ArchiveTimeoutError,
             "timeout before standby checkpoint lsn reached 5/5 - only reached 5/4");
 
+        // Wait for standby to sync
+        HRN_PQ_SCRIPT_SET(
+            HRN_PQ_SCRIPT_REPLAY_TARGET_REACHED_GE_10(2, "5/5", false, "5/3"),
+            HRN_PQ_SCRIPT_REPLAY_TARGET_REACHED_PROGRESS_GE_10(2, "5/5", false, "5/3", "5/3", false, 0),
+            HRN_PQ_SCRIPT_REPLAY_TARGET_REACHED_PROGRESS_GE_10(2, "5/5", false, "5/4", "5/3", true, 0),
+            HRN_PQ_SCRIPT_REPLAY_TARGET_REACHED_PROGRESS_GE_10(2, "5/5", true, "5/5", "5/4", true, 0),
+            HRN_PQ_SCRIPT_CHECKPOINT(2),
+            HRN_PQ_SCRIPT_CHECKPOINT_TARGET_REACHED_GE_10(2, "5/5", true, "X/X", 0));
+
         TEST_RESULT_VOID(dbReplayWait(db.standby, STRDEF("5/5"), dbPgControl(db.primary).timeline, 1000), "sync standby");
 
         // Update timeline to demonstrate that it is reloaded in dbReplayWait()
         HRN_PG_CONTROL_PUT(storagePgIdxWrite(1), PG_VERSION_10, .timeline = 6, .checkpoint = pgLsnFromStr(STRDEF("5/5")));
 
+        // Fail on timeline mismatch
+        HRN_PQ_SCRIPT_SET(
+            HRN_PQ_SCRIPT_REPLAY_TARGET_REACHED_GE_10(2, "5/5", false, "5/3"),
+            HRN_PQ_SCRIPT_REPLAY_TARGET_REACHED_PROGRESS_GE_10(2, "5/5", false, "5/3", "5/3", false, 0),
+            HRN_PQ_SCRIPT_REPLAY_TARGET_REACHED_PROGRESS_GE_10(2, "5/5", false, "5/4", "5/3", true, 0),
+            HRN_PQ_SCRIPT_REPLAY_TARGET_REACHED_PROGRESS_GE_10(2, "5/5", true, "5/5", "5/4", true, 0),
+            HRN_PQ_SCRIPT_CHECKPOINT(2),
+            HRN_PQ_SCRIPT_CHECKPOINT_TARGET_REACHED_GE_10(2, "5/5", true, "X/X", 0));
+
         TEST_ERROR(
             dbReplayWait(db.standby, STRDEF("5/5"), 77, 1000), DbMismatchError, "standby is on timeline 6 but expected 77");
 
+        // Close standby
+        HRN_PQ_SCRIPT_SET(HRN_PQ_SCRIPT_CLOSE(2));
         TEST_RESULT_VOID(dbFree(db.standby), "free standby");
 
+        // Stop backup
+        HRN_PQ_SCRIPT_SET(HRN_PQ_SCRIPT_STOP_BACKUP_GE_10(1, "5/6", "000000050000000500000006", true));
         TEST_RESULT_STR_Z(dbBackupStop(db.primary).tablespaceMap, "TABLESPACE_MAP_DATA", "stop backup");
 
+        // Close primary
+        HRN_PQ_SCRIPT_SET(HRN_PQ_SCRIPT_CLOSE(1));
         TEST_RESULT_VOID(dbFree(db.primary), "free primary");
 
         // -------------------------------------------------------------------------------------------------------------------------
@@ -605,25 +610,26 @@ testRun(void)
         hrnCfgArgRawZ(argList, cfgOptDbTimeout, "299");
         HRN_CFG_LOAD(cfgCmdBackup, argList);
 
+        // Connect to primary
         HRN_PQ_SCRIPT_SET(
-            // Connect to primary
+            HRN_PQ_SCRIPT_OPEN_GE_96(1, "dbname='postgres' port=5432", PG_VERSION_14, TEST_PATH "/pg1", false, NULL, NULL));
-            HRN_PQ_SCRIPT_OPEN_GE_96(1, "dbname='postgres' port=5432", PG_VERSION_14, TEST_PATH "/pg1", false, NULL, NULL),
-
-            // Start backup
-            HRN_PQ_SCRIPT_ADVISORY_LOCK(1, true),
-            HRN_PQ_SCRIPT_CURRENT_WAL_GE_10(1, "000000050000000500000004"),
-            HRN_PQ_SCRIPT_START_BACKUP_GE_10(1, false, "5/5", "000000050000000500000005"),
-
-            // Close primary
-            HRN_PQ_SCRIPT_CLOSE(1));
 
         TEST_ASSIGN(db, dbGet(true, true, false), "get primary");
+
+        // Start backup
+        HRN_PQ_SCRIPT_SET(
+            HRN_PQ_SCRIPT_ADVISORY_LOCK(1, true),
+            HRN_PQ_SCRIPT_CURRENT_WAL_GE_10(1, "000000050000000500000004"),
+            HRN_PQ_SCRIPT_START_BACKUP_GE_10(1, false, "5/5", "000000050000000500000005"));
+
         TEST_ASSIGN(backupStartResult, dbBackupStart(db.primary, false, false, true), "start backup");
 
         TEST_RESULT_LOG(
             "P00   WARN: start-fast is disabled and db-timeout (299s) is smaller than the PostgreSQL checkpoint_timeout (300s) -"
             " timeout may occur before the backup starts");
 
+        // Close primary
+        HRN_PQ_SCRIPT_SET(HRN_PQ_SCRIPT_CLOSE(1));
         TEST_RESULT_VOID(dbFree(db.primary), "free primary");
 
         // -------------------------------------------------------------------------------------------------------------------------
@@ -637,27 +643,26 @@ testRun(void)
         hrnCfgArgKeyRawZ(argList, cfgOptPgPath, 1, TEST_PATH "/pg1");
         HRN_CFG_LOAD(cfgCmdBackup, argList);
 
+        // Connect to primary
         HRN_PQ_SCRIPT_SET(
-            // Connect to primary
+            HRN_PQ_SCRIPT_OPEN_GE_96(1, "dbname='postgres' port=5432", PG_VERSION_15, TEST_PATH "/pg1", false, NULL, NULL));
-            HRN_PQ_SCRIPT_OPEN_GE_96(1, "dbname='postgres' port=5432", PG_VERSION_15, TEST_PATH "/pg1", false, NULL, NULL),
-
-            // Start backup
-            HRN_PQ_SCRIPT_ADVISORY_LOCK(1, true),
-            HRN_PQ_SCRIPT_CURRENT_WAL_GE_10(1, "000000060000000600000005"),
-            HRN_PQ_SCRIPT_START_BACKUP_GE_15(1, false, "6/6", "000000060000000600000006"),
-
-            // Stop backup
-            HRN_PQ_SCRIPT_STOP_BACKUP_GE_15(1, "6/7", "000000060000000600000006", false),
-
-            // Close primary
-            HRN_PQ_SCRIPT_CLOSE(1));
 
         TEST_ASSIGN(db, dbGet(true, true, false), "get primary");
+
+        // Start backup
+        HRN_PQ_SCRIPT_SET(
+            HRN_PQ_SCRIPT_ADVISORY_LOCK(1, true),
+            HRN_PQ_SCRIPT_CURRENT_WAL_GE_10(1, "000000060000000600000005"),
+            HRN_PQ_SCRIPT_START_BACKUP_GE_15(1, false, "6/6", "000000060000000600000006"));
+
         TEST_ASSIGN(backupStartResult, dbBackupStart(db.primary, false, false, true), "start backup");
         TEST_RESULT_STR_Z(backupStartResult.lsn, "6/6", "check lsn");
         TEST_RESULT_STR_Z(backupStartResult.walSegmentName, "000000060000000600000006", "check wal segment name");
         TEST_RESULT_STR_Z(backupStartResult.walSegmentCheck, "000000060000000600000005", "check wal segment check");
 
+        // Stop backup
+        HRN_PQ_SCRIPT_SET(HRN_PQ_SCRIPT_STOP_BACKUP_GE_15(1, "6/7", "000000060000000600000006", false));
+
         backupStopResult = (DbBackupStopResult){.lsn = NULL};
         TEST_ASSIGN(backupStopResult, dbBackupStop(db.primary), "stop backup");
         TEST_RESULT_STR_Z(backupStopResult.lsn, "6/7", "check lsn");
@@ -665,6 +670,8 @@ testRun(void)
         TEST_RESULT_STR_Z(backupStopResult.backupLabel, "BACKUP_LABEL_DATA", "check backup label");
         TEST_RESULT_STR_Z(backupStopResult.tablespaceMap, NULL, "check tablespace map is not set");
 
+        // Close primary
+        HRN_PQ_SCRIPT_SET(HRN_PQ_SCRIPT_CLOSE(1));
         TEST_RESULT_VOID(dbFree(db.primary), "free primary");
     }