Code review comment: Ok, I made the sinkTestStep configurable.  Hopefully that is a reasonable approach.

Code under review:
void testRestore(TableTestProgram program, ExecNodeMetadata metadata) throws Exception {
        final EnvironmentSettings settings = EnvironmentSettings.inStreamingMode();
        final SavepointRestoreSettings restoreSettings =
                SavepointRestoreSettings.forPath(
                        getSavepointPath(program, metadata).toString(),
                        false,
                        RestoreMode.NO_CLAIM);
        SavepointRestoreSettings.toConfiguration(restoreSettings, settings.getConfiguration());
        final TableEnvironment tEnv = TableEnvironment.create(settings);
        tEnv.getConfig()
                .set(
                        TableConfigOptions.PLAN_RESTORE_CATALOG_OBJECTS,
                        TableConfigOptions.CatalogPlanRestore.IDENTIFIER);
        for (SourceTestStep sourceTestStep : program.getSetupSourceTestSteps()) {
            final String id = TestValuesTableFactory.registerData(sourceTestStep.dataAfterRestore);
            final Map<String, String> options = new HashMap<>();
            options.put("connector", "values");
            options.put("data-id", id);
            options.put("disable-lookup", "true");
            options.put("runtime-source", "NewSource");
            sourceTestStep.apply(tEnv, options);
        }

        for (SinkTestStep sinkTestStep : program.getSetupSinkTestSteps()) {
            final Map<String, String> options = new HashMap<>();
            options.put("connector", "values");
            options.put("disable-lookup", "true");
            options.put("sink-insert-only", "false");
            sinkTestStep.apply(tEnv, options);
        }

        program.getSetupFunctionTestSteps().forEach(s -> s.apply(tEnv));

        final CompiledPlan compiledPlan =
                tEnv.loadPlan(PlanReference.fromFile(getPlanPath(program, metadata)));
        compiledPlan.execute().await();
        for (SinkTestStep sinkTestStep : program.getSetupSinkTestSteps()) {
            
            
            assertThat(TestValuesTableFactory.getResultsAsStrings(sinkTestStep.name))
                    .containsExactlyInAnyOrder(
                            Stream.concat(
                                            sinkTestStep.getExpectedBeforeRestoreAsStrings()
                                                    .stream(),
                                            sinkTestStep.getExpectedAfterRestoreAsStrings()
                                                    .stream())
                                    .toArray(String[]::new));
        }
    }

Line commented on: assertThat(TestValuesTableFactory.getResultsAsStrings(sinkTestStep.name))

Revised code:
void testRestore(TableTestProgram program, ExecNodeMetadata metadata) throws Exception {
        final EnvironmentSettings settings = EnvironmentSettings.inStreamingMode();
        final SavepointRestoreSettings restoreSettings =
                SavepointRestoreSettings.forPath(
                        getSavepointPath(program, metadata).toString(),
                        false,
                        RestoreMode.NO_CLAIM);
        SavepointRestoreSettings.toConfiguration(restoreSettings, settings.getConfiguration());
        final TableEnvironment tEnv = TableEnvironment.create(settings);
        tEnv.getConfig()
                .set(
                        TableConfigOptions.PLAN_RESTORE_CATALOG_OBJECTS,
                        TableConfigOptions.CatalogPlanRestore.IDENTIFIER);

        for (SourceTestStep sourceTestStep : program.getSetupSourceTestSteps()) {
            final String id = TestValuesTableFactory.registerData(sourceTestStep.dataAfterRestore);
            final Map<String, String> options = new HashMap<>();
            options.put("connector", "values");
            options.put("data-id", id);
            options.put("disable-lookup", "true");
            options.put("runtime-source", "NewSource");
            if (afterRestoreSource == AfterRestoreSource.INFINITE) {
                options.put("terminating", "false");
            }
            sourceTestStep.apply(tEnv, options);
        }

        final List<CompletableFuture<?>> futures = new ArrayList<>();

        for (SinkTestStep sinkTestStep : program.getSetupSinkTestSteps()) {
            if (afterRestoreSource == AfterRestoreSource.INFINITE) {
                registerSinkObserver(futures, sinkTestStep, false);
            }
            final Map<String, String> options = new HashMap<>();
            options.put("connector", "values");
            options.put("disable-lookup", "true");
            options.put("sink-insert-only", "false");
            sinkTestStep.apply(tEnv, options);
        }

        program.getSetupFunctionTestSteps().forEach(s -> s.apply(tEnv));

        final CompiledPlan compiledPlan =
                tEnv.loadPlan(PlanReference.fromFile(getPlanPath(program, metadata)));

        if (afterRestoreSource == AfterRestoreSource.INFINITE) {
            final TableResult tableResult = compiledPlan.execute();
            CompletableFuture.allOf(futures.toArray(new CompletableFuture[0])).get();
            tableResult.getJobClient().get().cancel().get();
        } else {
            compiledPlan.execute().await();
            for (SinkTestStep sinkTestStep : program.getSetupSinkTestSteps()) {
                List<String> expectedResults = getExpectedResults(sinkTestStep, sinkTestStep.name);
                assertThat(expectedResults)
                        .containsExactlyInAnyOrder(
                                Stream.concat(
                                                sinkTestStep.getExpectedBeforeRestoreAsStrings()
                                                        .stream(),
                                                sinkTestStep.getExpectedAfterRestoreAsStrings()
                                                        .stream())
                                        .toArray(String[]::new));
            }
        }
    }