cassandra-trunk/test/unit/org/apache/cassandra/utils/bytecomparable/ByteSourceConversionTest.java
/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.cassandra.utils.bytecomparable;

import java.net.UnknownHostException;
import java.nio.ByteBuffer;
import java.nio.charset.StandardCharsets;
import java.util.*;
import java.util.concurrent.ThreadLocalRandom;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.function.Supplier;

import com.google.common.collect.ImmutableList;
import com.google.common.collect.Iterables;
import com.google.common.collect.Lists;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import org.apache.cassandra.db.BufferDecoratedKey;
import org.apache.cassandra.db.ClusteringComparator;
import org.apache.cassandra.db.ClusteringPrefix;
import org.apache.cassandra.db.DecoratedKey;
import org.apache.cassandra.db.marshal.*;
import org.apache.cassandra.dht.ByteOrderedPartitioner;
import org.apache.cassandra.dht.IPartitioner;
import org.apache.cassandra.dht.LocalPartitioner;
import org.apache.cassandra.dht.Murmur3Partitioner;
import org.apache.cassandra.dht.RandomPartitioner;
import org.apache.cassandra.utils.ByteBufferUtil;
import org.apache.cassandra.utils.TimeUUID;
import org.apache.cassandra.utils.bytecomparable.ByteComparable.Version;

import static org.apache.cassandra.utils.bytecomparable.ByteSourceComparisonTest.decomposeForTuple;
import static org.junit.Assert.assertEquals;

/**
 * Tests that the result of forward + backward ByteSource translation is the same as the original.
 */
public class ByteSourceConversionTest extends ByteSourceTestBase
{
    private final static Logger logger = LoggerFactory.getLogger(ByteSourceConversionTest.class);
    public static final Version VERSION = Version.OSS50;

    @Rule
    public final ExpectedException expectedException = ExpectedException.none();

    @Test
    public void testStringsAscii()
    {
        testType(AsciiType.instance, Arrays.stream(testStrings)
                                           .filter(s -> s.equals(new String(s.getBytes(StandardCharsets.US_ASCII),
                                                                            StandardCharsets.US_ASCII)))
                                           .toArray());
    }

    @Test
    public void testStringsUTF8()
    {
        testType(UTF8Type.instance, testStrings);
        testDirect(x -> ByteSource.of(x, VERSION), ByteSourceInverse::getString, testStrings);
    }

    @Test
    public void testBooleans()
    {
        testType(BooleanType.instance, testBools);
    }

    @Test
    public void testInts()
    {
        testType(Int32Type.instance, testInts);
        testDirect(ByteSource::of, ByteSourceInverse::getSignedInt, testInts);
    }

    @Test
    public void randomTestInts()
    {
        Random rand = new Random();
        for (int i=0; i<10000; ++i)
        {
            int i1 = rand.nextInt();
            assertConvertsSame(Int32Type.instance, i1);
        }

    }

    @Test
    public void testLongs()
    {
        testType(LongType.instance, testLongs);
        testDirect(ByteSource::of, ByteSourceInverse::getSignedLong, testLongs);
    }

    @Test
    public void testShorts()
    {
        testType(ShortType.instance, testShorts);
    }

    @Test
    public void testBytes()
    {
        testType(ByteType.instance, testBytes);
    }

    @Test
    public void testDoubles()
    {
        testType(DoubleType.instance, testDoubles);
    }

    @Test
    public void testFloats()
    {
        testType(FloatType.instance, testFloats);
    }

    @Test
    public void testBigInts()
    {
        testType(IntegerType.instance, testBigInts);
    }

    @Test
    public void testBigDecimals()
    {
        testTypeBuffers(DecimalType.instance, testBigDecimals);
    }

    @Test
    public void testUUIDs()
    {
        testType(UUIDType.instance, testUUIDs);
    }

    @Test
    public void testTimeUUIDs()
    {
        testType(TimeUUIDType.instance, Arrays.stream(testUUIDs)
                                              .filter(x -> x == null || x.version() == 1)
                                              .map(x -> x != null ? TimeUUID.fromUuid(x) : null)
                                              .toArray());
    }

    @Test
    public void testLexicalUUIDs()
    {
        testType(LexicalUUIDType.instance, testUUIDs);
    }

    @Test
    public void testSimpleDate()
    {
        testType(SimpleDateType.instance, Arrays.stream(testInts).filter(x -> x != null).toArray());
    }

    @Test
    public void testTimeType()
    {
        testType(TimeType.instance, Arrays.stream(testLongs).filter(x -> x != null && x >= 0 && x <= 24L * 60 * 60 * 1000 * 1000 * 1000).toArray());
    }

    @SuppressWarnings("deprecation")
    @Test
    public void testDateType()
    {
        testType(DateType.instance, testDates);
    }

    @Test
    public void testTimestampType()
    {
        testType(TimestampType.instance, testDates);
    }

    @Test
    public void testBytesType()
    {
        List<ByteBuffer> values = new ArrayList<>();
        for (int i = 0; i < testValues.length; ++i)
            for (Object o : testValues[i])
                values.add(testTypes[i].decompose(o));

        testType(BytesType.instance, values);
    }

    @Test
    public void testInetAddressType() throws UnknownHostException
    {
        testType(InetAddressType.instance, testInets);
    }

    @Test
    public void testEmptyType()
    {
        testType(EmptyType.instance, new Void[] { null });
    }

    @Test
    public void testPatitionerDefinedOrder()
    {
        List<ByteBuffer> values = new ArrayList<>();
        for (int i = 0; i < testValues.length; ++i)
            for (Object o : testValues[i])
                values.add(testTypes[i].decompose(o));

        testBuffers(new PartitionerDefinedOrder(Murmur3Partitioner.instance), values);
        testBuffers(new PartitionerDefinedOrder(RandomPartitioner.instance), values);
        testBuffers(new PartitionerDefinedOrder(ByteOrderedPartitioner.instance), values);
    }

    @Test
    public void testPatitionerOrder()
    {
        List<ByteBuffer> values = new ArrayList<>();
        for (int i = 0; i < testValues.length; ++i)
            for (Object o : testValues[i])
                values.add(testTypes[i].decompose(o));

        testDecoratedKeys(Murmur3Partitioner.instance, values);
        testDecoratedKeys(RandomPartitioner.instance, values);
        testDecoratedKeys(ByteOrderedPartitioner.instance, values);
    }

    @Test
    public void testLocalPatitionerOrder()
    {
        for (int i = 0; i < testValues.length; ++i)
        {
            final AbstractType testType = testTypes[i];
            testDecoratedKeys(new LocalPartitioner(testType), Lists.transform(Arrays.asList(testValues[i]),
                                                                                            v -> testType.decompose(v)));
        }
    }

    interface PairTester
    {
        void test(AbstractType t1, AbstractType t2, Object o1, Object o2);
    }

    void testCombinationSampling(Random rand, PairTester tester)
    {
        for (int i=0;i<testTypes.length;++i)
            for (int j=0;j<testTypes.length;++j)
            {
                Object[] tv1 = new Object[3];
                Object[] tv2 = new Object[3];
                for (int t=0; t<tv1.length; ++t)
                {
                    tv1[t] = testValues[i][rand.nextInt(testValues[i].length)];
                    tv2[t] = testValues[j][rand.nextInt(testValues[j].length)];
                }

                for (Object o1 : tv1)
                    for (Object o2 : tv2)

                {
                    tester.test(testTypes[i], testTypes[j], o1, o2);
                }
            }
    }

    @Test
    public void testCombinations()
    {
        Random rand = new Random(0);
        testCombinationSampling(rand, this::assertClusteringPairConvertsSame);
    }

    @Test
    public void testNullsInClustering()
    {
        ByteBuffer[][] inputs = new ByteBuffer[][]
                                {
                                new ByteBuffer[] {decomposeAndRandomPad(UTF8Type.instance, "a"),
                                                  decomposeAndRandomPad(Int32Type.instance, 0)},
                                new ByteBuffer[] {decomposeAndRandomPad(UTF8Type.instance, "a"),
                                                  decomposeAndRandomPad(Int32Type.instance, null)},
                                new ByteBuffer[] {decomposeAndRandomPad(UTF8Type.instance, "a"),
                                                  null},
                                new ByteBuffer[] {decomposeAndRandomPad(UTF8Type.instance, ""),
                                                  decomposeAndRandomPad(Int32Type.instance, 0)},
                                new ByteBuffer[] {decomposeAndRandomPad(UTF8Type.instance, ""),
                                                  decomposeAndRandomPad(Int32Type.instance, null)},
                                new ByteBuffer[] {decomposeAndRandomPad(UTF8Type.instance, ""),
                                                  null},
                                new ByteBuffer[] {null,
                                                  decomposeAndRandomPad(Int32Type.instance, 0)},
                                new ByteBuffer[] {null,
                                                  decomposeAndRandomPad(Int32Type.instance, null)},
                                new ByteBuffer[] {null,
                                                  null},
                                };
        for (ByteBuffer[] input : inputs)
        {
            assertClusteringPairConvertsSame(ByteBufferAccessor.instance,
                                             UTF8Type.instance,
                                             Int32Type.instance,
                                             input[0],
                                             input[1],
                                             (t, v) -> (ByteBuffer) v);
        }
    }

    @Test
    public void testEmptyClustering()
    {
        ValueAccessor<ByteBuffer> accessor = ByteBufferAccessor.instance;
        ClusteringComparator comp = new ClusteringComparator();
        EnumSet<ClusteringPrefix.Kind> skippedKinds = EnumSet.of(ClusteringPrefix.Kind.SSTABLE_LOWER_BOUND, ClusteringPrefix.Kind.SSTABLE_UPPER_BOUND);
        for (ClusteringPrefix.Kind kind : EnumSet.complementOf(skippedKinds))
        {
            if (kind.isBoundary())
                continue;

            ClusteringPrefix<ByteBuffer> empty = ByteSourceComparisonTest.makeBound(kind);
            ClusteringPrefix<ByteBuffer> converted = getClusteringPrefix(accessor, kind, comp, comp.asByteComparable(empty));
            assertEquals(empty, converted);
        }
    }

    void assertClusteringPairConvertsSame(AbstractType t1, AbstractType t2, Object o1, Object o2)
    {
        for (ValueAccessor<?> accessor : ValueAccessors.ACCESSORS)
            assertClusteringPairConvertsSame(accessor, t1, t2, o1, o2, AbstractType::decompose);
    }

    <V> void assertClusteringPairConvertsSame(ValueAccessor<V> accessor,
                                              AbstractType<?> t1, AbstractType<?> t2,
                                              Object o1, Object o2,
                                              BiFunction<AbstractType, Object, ByteBuffer> decompose)
    {
        boolean checkEquals = t1 != DecimalType.instance && t2 != DecimalType.instance;
        EnumSet<ClusteringPrefix.Kind> skippedKinds = EnumSet.of(ClusteringPrefix.Kind.SSTABLE_LOWER_BOUND, ClusteringPrefix.Kind.SSTABLE_UPPER_BOUND);
        for (ClusteringPrefix.Kind k1 : EnumSet.complementOf(skippedKinds))
            {
                ClusteringComparator comp = new ClusteringComparator(t1, t2);
                V[] b = accessor.createArray(2);
                b[0] = accessor.valueOf(decompose.apply(t1, o1));
                b[1] = accessor.valueOf(decompose.apply(t2, o2));
                ClusteringPrefix<V> c = ByteSourceComparisonTest.makeBound(accessor.factory(), k1, b);
                final ByteComparable bsc = comp.asByteComparable(c);
                logger.info("Clustering {} bytesource {}", c.clusteringString(comp.subtypes()), bsc.byteComparableAsString(VERSION));
                ClusteringPrefix<V> converted = getClusteringPrefix(accessor, k1, comp, bsc);
                assertEquals(String.format("Failed compare(%s, converted %s ByteSource %s) == 0\ntype %s",
                                           safeStr(c.clusteringString(comp.subtypes())),
                                           safeStr(converted.clusteringString(comp.subtypes())),
                                           bsc.byteComparableAsString(VERSION),
                                           comp),
                             0, comp.compare(c, converted));
                if (checkEquals)
                    assertEquals(String.format("Failed equals %s, got %s ByteSource %s\ntype %s",
                                               safeStr(c.clusteringString(comp.subtypes())),
                                               safeStr(converted.clusteringString(comp.subtypes())),
                                               bsc.byteComparableAsString(VERSION),
                                               comp),
                                 c, converted);

                ClusteringComparator compR = new ClusteringComparator(ReversedType.getInstance(t1), ReversedType.getInstance(t2));
                final ByteComparable bsrc = compR.asByteComparable(c);
                converted = getClusteringPrefix(accessor, k1, compR, bsrc);
                assertEquals(String.format("Failed reverse compare(%s, converted %s ByteSource %s) == 0\ntype %s",
                                           safeStr(c.clusteringString(compR.subtypes())),
                                           safeStr(converted.clusteringString(compR.subtypes())),
                                           bsrc.byteComparableAsString(VERSION),
                                           compR),
                             0, compR.compare(c, converted));
                if (checkEquals)
                    assertEquals(String.format("Failed reverse equals %s, got %s ByteSource %s\ntype %s",
                                               safeStr(c.clusteringString(compR.subtypes())),
                                               safeStr(converted.clusteringString(compR.subtypes())),
                                               bsrc.byteComparableAsString(VERSION),
                                               compR),
                                 c, converted);
            }
    }

    private static <V> ClusteringPrefix<V> getClusteringPrefix(ValueAccessor<V> accessor,
                                                               ClusteringPrefix.Kind k1,
                                                               ClusteringComparator comp,
                                                               ByteComparable bsc)
    {
        switch (k1)
        {
        case STATIC_CLUSTERING:
        case CLUSTERING:
            return comp.clusteringFromByteComparable(accessor, bsc);
        case EXCL_END_BOUND:
        case INCL_END_BOUND:
            return comp.boundFromByteComparable(accessor, bsc, true);
        case INCL_START_BOUND:
        case EXCL_START_BOUND:
            return comp.boundFromByteComparable(accessor, bsc, false);
        case EXCL_END_INCL_START_BOUNDARY:
        case INCL_END_EXCL_START_BOUNDARY:
            return comp.boundaryFromByteComparable(accessor, bsc);
        default:
            throw new AssertionError();
        }
    }

    private static ByteSource.Peekable source(ByteComparable bsc)
    {
        if (bsc == null)
            return null;
        return ByteSource.peekable(bsc.asComparableBytes(VERSION));
    }

    @Test
    public void testTupleType()
    {
        Random rand = ThreadLocalRandom.current();
        testCombinationSampling(rand, this::assertTupleConvertsSame);
    }

    @Test
    public void testTupleTypeNonFull()
    {
        TupleType tt = new TupleType(ImmutableList.of(UTF8Type.instance, Int32Type.instance));
        List<ByteBuffer> tests = ImmutableList.of
            (
            TupleType.buildValue(ByteBufferAccessor.instance,
                                 decomposeAndRandomPad(UTF8Type.instance, ""),
                                 decomposeAndRandomPad(Int32Type.instance, 0)),
            // Note: a decomposed null (e.g. decomposeAndRandomPad(Int32Type.instance, null)) should not reach a tuple
            TupleType.buildValue(ByteBufferAccessor.instance,
                                 decomposeAndRandomPad(UTF8Type.instance, ""),
                                 null),
            TupleType.buildValue(ByteBufferAccessor.instance,
                                 null,
                                 decomposeAndRandomPad(Int32Type.instance, 0)),
            TupleType.buildValue(ByteBufferAccessor.instance, decomposeAndRandomPad(UTF8Type.instance, "")),
            TupleType.buildValue(ByteBufferAccessor.instance, (ByteBuffer) null),
            TupleType.buildValue(ByteBufferAccessor.instance)
            );
        testBuffers(tt, tests);
    }

    void assertTupleConvertsSame(AbstractType t1, AbstractType t2, Object o1, Object o2)
    {
        TupleType tt = new TupleType(ImmutableList.of(t1, t2));
        ByteBuffer b1 = TupleType.buildValue(ByteBufferAccessor.instance,
                                             decomposeForTuple(t1, o1),
                                             decomposeForTuple(t2, o2));
        assertConvertsSameBuffers(tt, b1);
    }

    @Test
    public void testCompositeType()
    {
        Random rand = new Random(0);
        testCombinationSampling(rand, this::assertCompositeConvertsSame);
    }

    @Test
    public void testCompositeTypeNonFull()
    {
        CompositeType tt = CompositeType.getInstance(UTF8Type.instance, Int32Type.instance);
        List<ByteBuffer> tests = ImmutableList.of
            (
            CompositeType.build(ByteBufferAccessor.instance, decomposeAndRandomPad(UTF8Type.instance, ""), decomposeAndRandomPad(Int32Type.instance, 0)),
            CompositeType.build(ByteBufferAccessor.instance, decomposeAndRandomPad(UTF8Type.instance, ""), decomposeAndRandomPad(Int32Type.instance, null)),
            CompositeType.build(ByteBufferAccessor.instance, decomposeAndRandomPad(UTF8Type.instance, "")),
            CompositeType.build(ByteBufferAccessor.instance),
            CompositeType.build(ByteBufferAccessor.instance, true, decomposeAndRandomPad(UTF8Type.instance, "")),
            CompositeType.build(ByteBufferAccessor.instance,true)
            );
        for (ByteBuffer b : tests)
            tt.validate(b);
        testBuffers(tt, tests);
    }

    void assertCompositeConvertsSame(AbstractType t1, AbstractType t2, Object o1, Object o2)
    {
        CompositeType tt = CompositeType.getInstance(t1, t2);
        ByteBuffer b1 = CompositeType.build(ByteBufferAccessor.instance, decomposeAndRandomPad(t1, o1), decomposeAndRandomPad(t2, o2));
        assertConvertsSameBuffers(tt, b1);
    }

    @Test
    public void testDynamicComposite()
    {
        DynamicCompositeType tt = DynamicCompositeType.getInstance(DynamicCompositeTypeTest.aliases);
        UUID[] uuids = DynamicCompositeTypeTest.uuids;
        List<ByteBuffer> tests = ImmutableList.of
            (
            DynamicCompositeTypeTest.createDynamicCompositeKey("test1", null, -1, false, true),
            DynamicCompositeTypeTest.createDynamicCompositeKey("test1", uuids[0], 24, false, true),
            DynamicCompositeTypeTest.createDynamicCompositeKey("test1", uuids[0], 42, false, true),
            DynamicCompositeTypeTest.createDynamicCompositeKey("test2", uuids[0], -1, false, true),
            DynamicCompositeTypeTest.createDynamicCompositeKey("test2", uuids[1], 42, false, true)
            );
        for (ByteBuffer b : tests)
            tt.validate(b);
        testBuffers(tt, tests);
    }

    @Test
    public void testListTypeString()
    {
        testCollection(ListType.getInstance(UTF8Type.instance, true), testStrings, () -> new ArrayList<>(), new Random());
    }

    @Test
    public void testListTypeLong()
    {
        testCollection(ListType.getInstance(LongType.instance, true), testLongs, () -> new ArrayList<>(), new Random());
    }

    @Test
    public void testSetTypeString()
    {
        testCollection(SetType.getInstance(UTF8Type.instance, true), testStrings, () -> new HashSet<>(), new Random());
    }

    @Test
    public void testSetTypeLong()
    {
        testCollection(SetType.getInstance(LongType.instance, true), testLongs, () -> new HashSet<>(), new Random());
    }

    <T, CT extends Collection<T>> void testCollection(CollectionType<CT> tt, T[] values, Supplier<CT> gen, Random rand)
    {
        int cnt = 0;
        List<CT> tests = new ArrayList<>();
        tests.add(gen.get());
        for (int c = 1; c <= 3; ++c)
            for (int j = 0; j < 5; ++j)
            {
                CT l = gen.get();
                for (int i = 0; i < c; ++i)
                {
                    T value = values[cnt++ % values.length];
                    if (value != null)
                        l.add(value);
                }

                tests.add(l);
            }
        testType(tt, tests);
    }

    @Test
    public void testMapTypeStringLong()
    {
        testMap(MapType.getInstance(UTF8Type.instance, LongType.instance, true), testStrings, testLongs, () -> new HashMap<>(), new Random());
    }

    @Test
    public void testMapTypeStringLongTree()
    {
        testMap(MapType.getInstance(UTF8Type.instance, LongType.instance, true), testStrings, testLongs, () -> new TreeMap<>(), new Random());
    }

    <K, V, M extends Map<K, V>> void testMap(MapType<K, V> tt, K[] keys, V[] values, Supplier<M> gen, Random rand)
    {
        List<M> tests = new ArrayList<>();
        tests.add(gen.get());
        for (int c = 1; c <= 3; ++c)
            for (int j = 0; j < 5; ++j)
            {
                M l = gen.get();
                for (int i = 0; i < c; ++i)
                {
                    V value = values[rand.nextInt(values.length)];
                    if (value != null)
                        l.put(keys[rand.nextInt(keys.length)], value);
                }

                tests.add(l);
            }
        testType(tt, tests);
    }

    /*
     * Convert type to a comparable.
     */
    private ByteComparable typeToComparable(AbstractType<?> type, ByteBuffer value)
    {
        return new ByteComparable()
        {
            @Override
            public ByteSource asComparableBytes(Version v)
            {
                return type.asComparableBytes(value, v);
            }

            @Override
            public String toString()
            {
                return type.getString(value);
            }
        };
    }

    public <T> void testType(AbstractType<T> type, Object[] values)
    {
        testType(type, Iterables.transform(Arrays.asList(values), x -> (T) x));
    }

    public <T> void testType(AbstractType<? super T> type, Iterable<T> values)
    {
        for (T i : values) {
            ByteBuffer b = decomposeAndRandomPad(type, i);
            logger.info("Value {} ({}) bytes {} ByteSource {}",
                              safeStr(i),
                              safeStr(type.getSerializer().toCQLLiteral(b)),
                              safeStr(ByteBufferUtil.bytesToHex(b)),
                              typeToComparable(type, b).byteComparableAsString(VERSION));
            assertConvertsSame(type, i);
        }
        if (!type.isReversed())
            testType(ReversedType.getInstance(type), values);
    }

    public <T> void testTypeBuffers(AbstractType<T> type, Object[] values)
    {
        testTypeBuffers(type, Lists.transform(Arrays.asList(values), x -> (T) x));
    }

    public <T> void testTypeBuffers(AbstractType<T> type, List<T> values)
    {
        // Main difference with above is that we use type.compare instead of checking equals
        testBuffers(type, Lists.transform(values, value -> decomposeAndRandomPad(type, value)));

    }
    public void testBuffers(AbstractType<?> type, List<ByteBuffer> values)
    {
        try
        {
            for (ByteBuffer b : values) {
                logger.info("Value {} bytes {} ByteSource {}",
                            safeStr(type.getSerializer().toCQLLiteral(b)),
                            safeStr(ByteBufferUtil.bytesToHex(b)),
                            typeToComparable(type, b).byteComparableAsString(VERSION));
            }
        }
        catch (UnsupportedOperationException e)
        {
            // Continue without listing values.
        }

        for (ByteBuffer i : values)
            assertConvertsSameBuffers(type, i);
    }

    void assertConvertsSameBuffers(AbstractType<?> type, ByteBuffer b1)
    {
        final ByteComparable bs1 = typeToComparable(type, b1);

        ByteBuffer actual = type.fromComparableBytes(source(bs1), VERSION);
        assertEquals(String.format("Failed compare(%s, converted %s (bytesource %s))",
                                   ByteBufferUtil.bytesToHex(b1),
                                   ByteBufferUtil.bytesToHex(actual),
                                   bs1.byteComparableAsString(VERSION)),
                     0,
                     type.compare(b1, actual));
    }

    public void testDecoratedKeys(IPartitioner type, List<ByteBuffer> values)
    {
        for (ByteBuffer i : values)
            assertConvertsSameDecoratedKeys(type, i);
    }

    void assertConvertsSameDecoratedKeys(IPartitioner type, ByteBuffer b1)
    {
        DecoratedKey k1 = type.decorateKey(b1);
        DecoratedKey actual = BufferDecoratedKey.fromByteComparable(k1, VERSION, type);

        assertEquals(String.format("Failed compare(%s[%s bs %s], %s[%s bs %s])\npartitioner %s",
                                   k1,
                                   ByteBufferUtil.bytesToHex(b1),
                                   k1.byteComparableAsString(VERSION),
                                   actual,
                                   ByteBufferUtil.bytesToHex(actual.getKey()),
                                   actual.byteComparableAsString(VERSION),
                                   type),
                     0,
                     k1.compareTo(actual));
        assertEquals(String.format("Failed equals(%s[%s bs %s], %s[%s bs %s])\npartitioner %s",
                                   k1,
                                   ByteBufferUtil.bytesToHex(b1),
                                   k1.byteComparableAsString(VERSION),
                                   actual,
                                   ByteBufferUtil.bytesToHex(actual.getKey()),
                                   actual.byteComparableAsString(VERSION),
                                   type),
                     k1,
                     actual);
    }

    static Object safeStr(Object i)
    {
        if (i == null)
            return null;
        if (i instanceof ByteBuffer)
        {
            ByteBuffer buf = (ByteBuffer) i;
            i = ByteBufferUtil.bytesToHex(buf);
        }
        String s = i.toString();
        if (s.length() > 100)
            s = s.substring(0, 100) + "...";
        return s.replaceAll("\0", "<0>");
    }

    public <T> void testDirect(Function<T, ByteSource> convertor, Function<ByteSource.Peekable, T> inverse, T[] values)
    {
        for (T i : values) {
            if (i == null)
                continue;

            logger.info("Value {} ByteSource {}\n",
                              safeStr(i),
                              convertor.apply(i));

        }
        for (T i : values)
            if (i != null)
                assertConvertsSame(convertor, inverse, i);
    }

    <T> void assertConvertsSame(Function<T, ByteSource> convertor, Function<ByteSource.Peekable, T> inverse, T v1)
    {
        ByteComparable b1 = v -> convertor.apply(v1);
        T actual = inverse.apply(source(b1));
        assertEquals(String.format("ByteSource %s", b1.byteComparableAsString(VERSION)), v1, actual);
    }

    <T> void assertConvertsSame(AbstractType<T> type, T v1)
    {
        ByteBuffer b1 = decomposeAndRandomPad(type, v1);
        final ByteComparable bc1 = typeToComparable(type, b1);
        ByteBuffer convertedBuffer = type.fromComparableBytes(source(bc1), VERSION);
        T actual = type.compose(convertedBuffer);

        assertEquals(String.format("Failed equals %s(%s bs %s), got %s",
                                   safeStr(v1),
                                   ByteBufferUtil.bytesToHex(b1),
                                   safeStr(bc1.byteComparableAsString(VERSION)),
                                   safeStr(actual)),
                     v1,
                     actual);
    }

    <T> ByteBuffer decomposeAndRandomPad(AbstractType<T> type, T v)
    {
        ByteBuffer b = type.decompose(v);
        Random rand = new Random(0);
        int padBefore = rand.nextInt(16);
        int padAfter = rand.nextInt(16);
        int paddedCapacity = b.remaining() + padBefore + padAfter;
        ByteBuffer padded = allocateBuffer(paddedCapacity);
        rand.ints(padBefore).forEach(x -> padded.put((byte) x));
        padded.put(b.duplicate());
        rand.ints(padAfter).forEach(x -> padded.put((byte) x));
        padded.clear().limit(padded.capacity() - padAfter).position(padBefore);
        return padded;
    }

    protected ByteBuffer allocateBuffer(int paddedCapacity)
    {
        return ByteBuffer.allocate(paddedCapacity);
    }
}