static boolean verifySync(final boolean logResults,
                                  final Map<Integer, Article> consumedArticles,
                                  final Map<Integer, Comment> consumedComments,
                                  final Map<Integer, AugmentedArticle> consumedAugmentedArticles,
                                  final Map<Integer, AugmentedComment> consumedAugmentedComments) {
            final AtomicBoolean pass = new AtomicBoolean(true);
            final StringBuilder report = logResults ? new StringBuilder() : null;

            assertThat(
                pass,
                report,
                "Expected 1 article, got " + consumedArticles.size(),
                consumedArticles.size() > 0
            );
            assertThat(
                pass,
                report,
                "Expected 1 comment, got " + consumedComments.size(),
                consumedComments.size() > 0
            );

            assertThat(
                pass,
                report,
                "Mismatched article size between augmented articles (size "
                    + consumedAugmentedArticles.size() +
                    ") and consumed articles (size "
                    + consumedArticles.size() + ")",
                consumedAugmentedArticles.size() == consumedArticles.size()
            );
            assertThat(
                pass,
                report,
                "Mismatched comments size between augmented comments (size "
                    + consumedAugmentedComments.size() +
                    ") and consumed comments (size " +
                    consumedComments.size() + ")", 
                consumedAugmentedComments.size() == consumedComments.size()
            );

            final Map<Integer, Long> commentCounts = new TreeMap<>();

            for (final RelationalSmokeTest.AugmentedComment augmentedComment : consumedAugmentedComments.values()) {
                final int key = augmentedComment.getKey();
                assertThat(
                    pass,
                    report,
                    "comment missing, but found in augmentedComment: " + key,
                    consumedComments.containsKey(key)
                );

                final Comment comment = consumedComments.get(key);
                if (comment != null) {
                    assertThat(
                        pass,
                        report,
                        "comment missing, but found in augmentedComment: " + key,
                        consumedComments.containsKey(key)
                    );
                }
                commentCounts.put(
                    augmentedComment.getArticleId(),
                    commentCounts.getOrDefault(augmentedComment.getArticleId(), 0L) + 1
                );

                assertThat(
                    pass,
                    report,
                    "augmentedArticle [" + augmentedComment.getArticleId() + "] " +
                        "missing for augmentedComment [" + augmentedComment.getKey() + "]",
                    consumedAugmentedArticles.containsKey(augmentedComment.getArticleId())
                );
                final AugmentedArticle augmentedArticle =
                        consumedAugmentedArticles.get(augmentedComment.getArticleId());
                if (augmentedArticle != null) {
                    assertThat(
                        pass,
                        report,
                        "articlePrefix didn't match augmentedArticle: " + augmentedArticle.getText(),
                        augmentedArticle.getText().startsWith(augmentedComment.getArticlePrefix())
                    );
                }

                assertThat(
                    pass,
                    report,
                    "article " + augmentedComment.getArticleId() + " missing from consumedArticles",
                    consumedArticles.containsKey(augmentedComment.getArticleId())
                );
                final Article article = consumedArticles.get(augmentedComment.getArticleId());
                if (article != null) {
                    assertThat(
                        pass,
                        report,
                        "articlePrefix didn't match article: " + article.getText(),
                        article.getText().startsWith(augmentedComment.getArticlePrefix())
                    );
                }
            }


            for (final RelationalSmokeTest.AugmentedArticle augmentedArticle : consumedAugmentedArticles.values()) {
                assertThat(
                    pass,
                    report,
                    "article " + augmentedArticle.getKey() + " comment count mismatch",
                    augmentedArticle.getCommentCount() == commentCounts.getOrDefault(augmentedArticle.getKey(), 0L)
                );
            }

            if (logResults) {
                if (pass.get()) {
                    LOG.info(
                        "Evaluation passed ({}/{}) articles and ({}/{}) comments",
                        consumedAugmentedArticles.size(),
                        consumedArticles.size(),
                        consumedAugmentedComments.size(),
                        consumedComments.size()
                    );
                } else {
                    LOG.error(
                        "Evaluation failed\nReport: {}\n" +
                            "Consumed Input Articles: {}\n" +
                            "Consumed Input Comments: {}\n" +
                            "Consumed Augmented Articles: {}\n" +
                            "Consumed Augmented Comments: {}",
                        report,
                        consumedArticles,
                        consumedComments,
                        consumedAugmentedArticles,
                        consumedAugmentedComments
                    );
                }
            }

            return pass.get();
        }
Generates a keySpace number of unique keys normally distributed,
with the mean at 0 and stdDev 1/3 of the way through the keySpace
any sample more than 3 standard deviations from the mean are assigned to the 0 key.
<p>
This is designed to roughly balance the key properties of two dominant real-world
data distribution: Zipfian and Normal, while also being efficient to generate.
streams/src/test/java/org/apache/kafka/streams/tests/RelationalSmokeTest.java