private void test(final Path inputFile,
                      final FeedDoc feed,
                      final Path outputDir,
                      final String stem,
                      final boolean compareOutput,
                      final List<Exception> exceptions) throws IOException {
        LOGGER.info("Testing:" +
                        "\n--------------------------------------------------------------------------------" +
                        "\ninput:  {}" +
                        "\nfeed:   {}" +
                        "\noutput: {}" +
                        "\nstem:   {}" +
                        "\n--------------------------------------------------------------------------------",
                inputFile.toAbsolutePath(),
                feed.getName(),
                outputDir.toAbsolutePath(),
                stem);

        addStream(inputFile, feed);

        processorTaskTestHelper.createAndQueueTasks();

        final List<ProcessorTask> tasks = getTasks();
        assertThat(tasks.size())
                .as(() -> "There should be one task here. We found:\n" + tasks.stream()
                        .map(Objects::toString)
                        .collect(Collectors.joining("\n")))
                .isEqualTo(1);

        for (final ProcessorTask task : tasks) {
            final long startStreamId = getLatestStreamId();
            commonTranslationTestHelper.process(task);
            final long endStreamId = getLatestStreamId();

            if (compareOutput) {
                final List<Meta> processedMeta = new ArrayList<>();

                for (long streamId = startStreamId + 1; streamId <= endStreamId; streamId++) {
                    final Meta meta = metaService.getMeta(streamId);
                    final String streamTypeName = meta.getTypeName();
                    if (!StreamTypeNames.ERROR.equals(streamTypeName)) {
                        processedMeta.add(meta);
                    } else {
                        try (final Source errorStreamSource = streamStore.openSource(streamId)) {
                            String errorStreamStr = SourceUtil.readString(errorStreamSource);

//                            try (final InputStreamProvider inputStreamProvider = errorStreamSource.get(0)) {
                            //got an error stream so dump it to console

                            final Meta parentMeta = metaService.getMeta(meta.getParentMetaId());

//                                String errorStreamStr = StreamUtil.streamToString(inputStreamProvider.get());
//                                java.util.stream.Stream<String> errorStreamLines = StreamUtil.streamToLines(
//                                inputStreamProvider.get());
                            LOGGER.warn("Meta {} with parent {} of type {} has errors:\n{}",
                                    meta, parentMeta.getId(), parentMeta.getTypeName(), errorStreamStr);

//                            // only dump warning if debug enabled
//                            if (LOGGER.isDebugEnabled()) {
//                                errorStreamLines.forEach(System.out::println);
//
//                            } else {
//                                errorStreamLines
//                                        .filter(line -> line.contains("ERROR:"))
//                                        .forEach(System.out::println);
//                            }
//                            }
                        }
                    }
                }

                // Make sure we have at least one processed stream else it indicates an error in processing somewhere
                // If we get an error stream you can just run the pipeline in stroom, to try and diagnose the fault
                // if the above error stream dump doesn't help
                assertThat(processedMeta.size())
                        .withFailMessage("Processed count should be > 0")
                        .isGreaterThan(0);

                // Copy the contents of the latest written stream to the output.
                int i = 1;
                for (final Meta meta : processedMeta) {
                    String num = "";
                    // If we are going to output more than one file then number
                    // them.
                    if (processedMeta.size() > 1) {
                        num = "_" + i;
                    }

                    final Path actualFile = outputDir.resolve(stem + num + ".out_tmp");
                    final Path expectedFile = outputDir.resolve(stem + num + ".out");

                    try (final OutputStream outputStream = new BufferedOutputStream(
                            Files.newOutputStream(actualFile))) {
                        copyStream(meta, outputStream);
                    }

                    compareFiles(expectedFile, actualFile, exceptions);

                    i++;
                }
            }
        }

        // Make sure there are no more tasks.
        final List<ProcessorTask> tasks2 = getTasks();
        assertThat(tasks2.size())
                .as(() -> "There should not be any more tasks here. We found:\n" + tasks.stream()
                        .map(Objects::toString)
                        .collect(Collectors.joining("\n")))
                .isZero();
    }
NOTE some of the input data for this test is buried in the following zip file so you will need
to crack it open to see what is being loaded.
stroom/stroom-core/src/test/resources/samples/input/ZIP_TEST-DATA_SPLITTER-EVENTS~1.zip
stroom-app/src/test/java/stroom/pipeline/task/TranslationTest.java