protected void assertLoadedKeyRangeValueData(
            final List<Tuple3<MapDefinition, Range<Long>, StringValue>> keyRangeValueLoadedData) {

        LOGGER.info("Starting range value asserts on {} entries", keyRangeValueLoadedData.size());

        final Instant startTime = Instant.now();
        final AtomicInteger counter = new AtomicInteger();
        final int tenPercent = keyRangeValueLoadedData.size() / 10;

        keyRangeValueLoadedData.forEach(tuple3 -> {
            final MapDefinition mapDefinition = tuple3._1;
            final Range<Long> keyRange = tuple3._2;
            final StringValue expectedValue = tuple3._3;

            if (keyRangeValueLoadedData.size() > 10_000) {
                if (counter.incrementAndGet() % tenPercent == 0) {
                    final Duration duration = Duration.between(startTime, Instant.now());
                    // *5 because we do 5 different gets for each tuple3 entry
                    LOGGER.info("Count so far: {}, in {}, gets/ms: {}",
                            counter.get(),
                            duration,
                            (counter.get() * 5L) / (double) duration.toMillis());
                }
            }

            // build a variety of keys from the supplied range
            final String keyAtStartOfRange = keyRange.getFrom().toString();
            final String keyAtEndOfRange = Long.toString(keyRange.getTo() - 1);
            final String keyInsideRange = Long.toString(keyRange.getFrom() + 5);
            final String keyBelowRange = Long.toString(keyRange.getFrom() - 1);
            final String keyAboveRange = Long.toString(keyRange.getTo() + 1);

            // define the expected result for each key
            final List<Tuple2<String, Boolean>> keysAndExpectedResults = Arrays.asList(
                    Tuple.of(keyAtStartOfRange, true),
                    Tuple.of(keyAtEndOfRange, true),
                    Tuple.of(keyInsideRange, true),
                    Tuple.of(keyBelowRange, false),
                    Tuple.of(keyAboveRange, false));

            keysAndExpectedResults.forEach(tuple2 -> {
                final String key = tuple2._1;
                final boolean isValueExpected = tuple2._2;

                LOGGER.debug(() -> LogUtil.message("range {}, key {}, expected {}",
                        keyRange, key, isValueExpected));

                // get the proxy object
                final RefDataValueProxy valueProxy = refDataStore.getValueProxy(mapDefinition, key);

                // Trigger the lookup
                final Optional<RefDataValue> optRefDataValue = valueProxy.supplyValue();

                assertThat(optRefDataValue.isPresent())
                        .isEqualTo(isValueExpected);

                optRefDataValue.ifPresent(refDataValue -> {

                    assertThat(refDataValue).isInstanceOf(StringValue.class);
                    assertThat((StringValue) refDataValue)
                            .isEqualTo(expectedValue);

                    valueProxy.consumeBytes(typedByteBuffer -> {
                        assertThat(typedByteBuffer.getTypeId())
                                .isEqualTo(StringValue.TYPE_ID);
                        final String foundStrVal = StandardCharsets.UTF_8.decode(typedByteBuffer.getByteBuffer())
                                .toString();
                        assertThat(foundStrVal)
                                .isEqualTo(expectedValue.getValue());
                    });
                });
            });
        });
    }
@param refStreamDefinitionCount  Number of {@link RefStreamDefinition}s to create.
@param keyValueMapCount          Number of KeyValue type maps to create per {@link RefStreamDefinition}
@param rangeValueMapCount        Number of RangeValue type maps to create per {@link RefStreamDefinition}
@param entryCount                Number of map entries to create per map
@param refStreamDefinitionOffset The offset from zero for the refStreamDefinition partIndex
@return The created {@link RefStreamDefinition} objects
stroom-pipeline/src/test/java/stroom/pipeline/refdata/store/offheapstore/AbstractRefDataOffHeapStoreTest.java