inspector/cts/PlatformInspectableProcessorTest.java

/*
 * Copyright 2019 The Android Open Source Project
 *
 * Licensed 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 android.processor.view.inspector.cts;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotEquals;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;

import android.R;
import android.content.res.Resources;
import android.graphics.Color;
import android.view.inspector.InspectableProperty;
import android.view.inspector.InspectableProperty.EnumEntry;
import android.view.inspector.InspectableProperty.ValueType;
import android.view.inspector.InspectionCompanion;

import androidx.annotation.AnimRes;
import androidx.annotation.AnimatorRes;
import androidx.annotation.AnyRes;
import androidx.annotation.ArrayRes;
import androidx.annotation.BoolRes;
import androidx.annotation.ColorInt;
import androidx.annotation.ColorLong;
import androidx.annotation.DimenRes;
import androidx.annotation.DrawableRes;
import androidx.annotation.FontRes;
import androidx.annotation.IdRes;
import androidx.annotation.IntegerRes;
import androidx.annotation.InterpolatorRes;
import androidx.annotation.LayoutRes;
import androidx.annotation.MenuRes;
import androidx.annotation.NavigationRes;
import androidx.annotation.PluralsRes;
import androidx.annotation.RawRes;
import androidx.annotation.StringRes;
import androidx.annotation.StyleRes;
import androidx.annotation.StyleableRes;
import androidx.annotation.TransitionRes;
import androidx.annotation.XmlRes;
import androidx.test.filters.SmallTest;
import androidx.test.runner.AndroidJUnit4;

import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;

import java.util.HashSet;
import java.util.Objects;
import java.util.Random;
import java.util.Set;

/**
 * Behavioral tests for {@link android.processor.view.inspector.PlatformInspectableProcessor}.
 */
@SmallTest
@RunWith(AndroidJUnit4.class)
public class PlatformInspectableProcessorTest {
    private Random mRandom;
    private TestPropertyMapper mPropertyMapper;
    private TestPropertyReader mPropertyReader;

    @Before
    public void setup() {
        mRandom = new Random();
        mPropertyMapper = new TestPropertyMapper();
        mPropertyReader = new TestPropertyReader(mPropertyMapper);
    }

    class IntPropertyTest {
        private final int mValue;

        IntPropertyTest(Random seed) {
            mValue = seed.nextInt();
        }

        @InspectableProperty
        public int getValue() {
            return mValue;
        }
    }

    @Test
    public void testMapAndReadInt() {
        IntPropertyTest node = new IntPropertyTest(mRandom);
        mapAndRead(node);
        assertEquals(node.getValue(), mPropertyReader.get("value"));
    }

    @Test
    public void testInferredAttributeId() {
        loadCompanion(IntPropertyTest.class).mapProperties(mPropertyMapper);
        assertEquals(R.attr.value, mPropertyMapper.getAttributeId("value"));
    }

    @Test(expected = InspectionCompanion.UninitializedPropertyMapException.class)
    public void testUninitializedPropertyMap() {
        IntPropertyTest node = new IntPropertyTest(mRandom);
        loadCompanion(IntPropertyTest.class).readProperties(node, mPropertyReader);
    }

    class NamedPropertyTest {
        private final int mValue;

        NamedPropertyTest(Random seed) {
            mValue = seed.nextInt();
        }

        @InspectableProperty(name = "myNamedValue", hasAttributeId = false)
        public int getValue() {
            return mValue;
        }
    }

    @Test
    public void testNamedProperty() {
        NamedPropertyTest node = new NamedPropertyTest(mRandom);
        mapAndRead(node);
        assertEquals(0, mPropertyMapper.getId("value"));
        assertEquals(node.getValue(), mPropertyReader.get("myNamedValue"));
    }

    class HasAttributeIdFalseTest {
        @InspectableProperty(hasAttributeId = false)
        public int getValue() {
            return 0;
        }
    }

    @Test
    public void testHasAttributeIdFalse() {
        loadCompanion(HasAttributeIdFalseTest.class).mapProperties(mPropertyMapper);
        assertEquals(Resources.ID_NULL, mPropertyMapper.getAttributeId("value"));
    }

    class AttributeIdEqualsTest {
        @InspectableProperty(attributeId = 0xdecafbad)
        public int getValue() {
            return 0;
        }
    }

    @Test
    public void testAttributeIdEquals() {
        loadCompanion(AttributeIdEqualsTest.class).mapProperties(mPropertyMapper);
        assertEquals(0xdecafbad, mPropertyMapper.getAttributeId("value"));
    }

    class InferredPropertyNameTest {
        private final int mValueA;
        private final int mValueB;
        private final int mValueC;

        InferredPropertyNameTest(Random seed) {
            mValueA = seed.nextInt();
            mValueB = seed.nextInt();
            mValueC = seed.nextInt();
        }

        @InspectableProperty(hasAttributeId = false)
        public int getValueA() {
            return mValueA;
        }

        @InspectableProperty(hasAttributeId = false)
        public int isValueB() {
            return mValueB;
        }

        @InspectableProperty(hasAttributeId = false)
        public int obtainValueC() {
            return mValueC;
        }
    }

    @Test
    public void testInferredPropertyName() {
        InferredPropertyNameTest node = new InferredPropertyNameTest(mRandom);
        mapAndRead(node);
        assertEquals(node.getValueA(), mPropertyReader.get("valueA"));
        assertEquals(node.isValueB(), mPropertyReader.get("isValueB"));
        assertEquals(node.obtainValueC(), mPropertyReader.get("obtainValueC"));
    }

    class InferredBooleanNameTest {
        private final boolean mValueA;
        private final boolean mValueB;
        private final boolean mValueC;

        InferredBooleanNameTest(Random seed) {
            mValueA = seed.nextBoolean();
            mValueB = seed.nextBoolean();
            mValueC = seed.nextBoolean();
        }

        @InspectableProperty(hasAttributeId = false)
        public boolean getValueA() {
            return mValueA;
        }

        @InspectableProperty(hasAttributeId = false)
        public boolean isValueB() {
            return mValueB;
        }

        @InspectableProperty(hasAttributeId = false)
        public boolean obtainValueC() {
            return mValueC;
        }
    }

    @Test
    public void testInferredBooleanName() {
        InferredBooleanNameTest node = new InferredBooleanNameTest(mRandom);
        mapAndRead(node);
        assertEquals(node.getValueA(), mPropertyReader.get("valueA"));
        assertEquals(node.isValueB(), mPropertyReader.get("valueB"));
        assertEquals(node.obtainValueC(), mPropertyReader.get("obtainValueC"));
    }

    class ColorTest {
        private final int mColorInt;
        private final long mColorLong;

        private final Color mColorObject;

        ColorTest(Random seed) {
            mColorInt = seed.nextInt();
            mColorLong = Color.pack(seed.nextInt());
            mColorObject = Color.valueOf(seed.nextInt());
        }

        @InspectableProperty(hasAttributeId = false)
        @ColorInt
        public int getColorInt() {
            return mColorInt;
        }

        @InspectableProperty(hasAttributeId = false)
        @ColorLong
        public long getColorLong() {
            return mColorLong;
        }

        @InspectableProperty(hasAttributeId = false)
        public Color getColorObject() {
            return mColorObject;
        }
    }

    @Test
    public void testColorTypeInference() {
        ColorTest node = new ColorTest(mRandom);
        mapAndRead(node);
        assertEquals(node.getColorInt(), mPropertyReader.get("colorInt"));
        assertEquals(node.getColorLong(), mPropertyReader.get("colorLong"));
        assertEquals(node.getColorObject(), mPropertyReader.get("colorObject"));
        assertEquals(ValueType.COLOR, mPropertyMapper.getValueType("colorInt"));
        assertEquals(ValueType.COLOR, mPropertyMapper.getValueType("colorLong"));
        assertEquals(ValueType.COLOR, mPropertyMapper.getValueType("colorObject"));
    }

    class ValueTypeTest {
        private final int mColor;
        private final int mGravity;
        private final int mValue;

        ValueTypeTest(Random seed) {
            mColor = seed.nextInt();
            mGravity = seed.nextInt();
            mValue = seed.nextInt();
        }

        @InspectableProperty(valueType = ValueType.COLOR)
        public int getColor() {
            return mColor;
        }

        @InspectableProperty(valueType = ValueType.GRAVITY)
        public int getGravity() {
            return mGravity;
        }

        @InspectableProperty(valueType = ValueType.NONE)
        @ColorInt
        public int getValue() {
            return mValue;
        }
    }

    @Test
    public void testValueTypeEquals() {
        ValueTypeTest node = new ValueTypeTest(mRandom);
        mapAndRead(node);
        assertEquals(node.getColor(), mPropertyReader.get("color"));
        assertEquals(node.getGravity(), mPropertyReader.get("gravity"));
        assertEquals(node.getValue(), mPropertyReader.get("value"));
        assertEquals(ValueType.COLOR, mPropertyMapper.getValueType("color"));
        assertEquals(ValueType.GRAVITY, mPropertyMapper.getValueType("gravity"));
        assertEquals(ValueType.NONE, mPropertyMapper.getValueType("value"));
    }

    class PrimitivePropertiesTest {
        private final boolean mBoolean;
        private final byte mByte;
        private final char mChar;
        private final double mDouble;
        private final float mFloat;
        private final int mInt;
        private final long mLong;
        private final short mShort;

        PrimitivePropertiesTest(Random seed) {
            mBoolean = seed.nextBoolean();
            mByte = (byte) seed.nextInt();
            mChar = randomLetter(seed);
            mDouble = seed.nextDouble();
            mFloat = seed.nextFloat();
            mInt = seed.nextInt();
            mLong = seed.nextLong();
            mShort = (short) seed.nextInt();
        }

        @InspectableProperty(hasAttributeId = false)
        public boolean getBoolean() {
            return mBoolean;
        }

        @InspectableProperty(hasAttributeId = false)
        public byte getByte() {
            return mByte;
        }

        @InspectableProperty(hasAttributeId = false)
        public char getChar() {
            return mChar;
        }

        @InspectableProperty(hasAttributeId = false)
        public double getDouble() {
            return mDouble;
        }

        @InspectableProperty(hasAttributeId = false)
        public float getFloat() {
            return mFloat;
        }

        @InspectableProperty(hasAttributeId = false)
        public int getInt() {
            return mInt;
        }

        @InspectableProperty(hasAttributeId = false)
        public long getLong() {
            return mLong;
        }

        @InspectableProperty(hasAttributeId = false)
        public short getShort() {
            return mShort;
        }
    }

    @Test
    public void testPrimitiveProperties() {
        PrimitivePropertiesTest node = new PrimitivePropertiesTest(mRandom);
        mapAndRead(node);
        assertEquals(node.getBoolean(), mPropertyReader.get("boolean"));
        assertEquals(node.getByte(), mPropertyReader.get("byte"));
        assertEquals(node.getChar(), mPropertyReader.get("char"));
        assertEquals(node.getDouble(), mPropertyReader.get("double"));
        assertEquals(node.getFloat(), mPropertyReader.get("float"));
        assertEquals(node.getInt(), mPropertyReader.get("int"));
        assertEquals(node.getLong(), mPropertyReader.get("long"));
        assertEquals(node.getShort(), mPropertyReader.get("short"));
    }

    class ObjectPropertiesTest {
        private final String mText;

        ObjectPropertiesTest(Random seed) {
            final StringBuilder stringBuilder = new StringBuilder();
            final int length = seed.nextInt(8) + 8;

            for (int i = 0; i < length; i++) {
                stringBuilder.append(randomLetter(seed));
            }

            mText = stringBuilder.toString();
        }

        @InspectableProperty
        public String getText() {
            return mText;
        }

        @InspectableProperty(hasAttributeId = false)
        public Objects getNull() {
            return null;
        }
    }

    @Test
    public void testObjectProperties() {
        ObjectPropertiesTest node = new ObjectPropertiesTest(mRandom);
        mapAndRead(node);
        assertEquals(node.getText(), mPropertyReader.get("text"));
        assertNull(mPropertyReader.get("null"));
        assertNotEquals(0, mPropertyMapper.getId("null"));
    }

    class IntEnumTest {
        private int mValue;

        @InspectableProperty(enumMapping = {
                @InspectableProperty.EnumEntry(name = "ONE", value = 1),
                @EnumEntry(name = "TWO", value = 2)})
        public int getValue() {
            return mValue;
        }

        public void setValue(int value) {
            mValue = value;
        }
    }

    @Test
    public void testIntEnum() {
        IntEnumTest node = new IntEnumTest();
        InspectionCompanion<IntEnumTest> companion = loadCompanion(IntEnumTest.class);
        companion.mapProperties(mPropertyMapper);

        node.setValue(1);
        companion.readProperties(node, mPropertyReader);
        assertEquals("ONE", mPropertyReader.getIntEnum("value"));

        node.setValue(2);
        companion.readProperties(node, mPropertyReader);
        assertEquals("TWO", mPropertyReader.getIntEnum("value"));

        node.setValue(3);
        companion.readProperties(node, mPropertyReader);
        assertNull(mPropertyReader.getIntEnum("value"));
    }

    class IntFlagTest {
        private int mValue;

        @InspectableProperty(flagMapping = {
                @InspectableProperty.FlagEntry(name = "ONE", target = 0x1, mask = 0x3),
                @InspectableProperty.FlagEntry(name = "TWO", target = 0x2, mask = 0x3),
                @InspectableProperty.FlagEntry(name = "THREE", target = 0x3, mask = 0x3),
                @InspectableProperty.FlagEntry(name = "FOUR", target = 0x4)})
        public int getValue() {
            return mValue;
        }

        public void setValue(int value) {
            mValue = value;
        }
    }

    @Test
    public void testIntFlag() {
        IntFlagTest node = new IntFlagTest();
        InspectionCompanion<IntFlagTest> companion = loadCompanion(IntFlagTest.class);
        companion.mapProperties(mPropertyMapper);

        node.setValue(0);
        companion.readProperties(node, mPropertyReader);
        assertTrue(mPropertyReader.getIntFlag("value").isEmpty());

        node.setValue(1);
        companion.readProperties(node, mPropertyReader);
        assertEquals(setOf("ONE"), mPropertyReader.getIntFlag("value"));

        node.setValue(2);
        companion.readProperties(node, mPropertyReader);
        assertEquals(setOf("TWO"), mPropertyReader.getIntFlag("value"));

        node.setValue(3);
        companion.readProperties(node, mPropertyReader);
        assertEquals(setOf("THREE"), mPropertyReader.getIntFlag("value"));

        node.setValue(4);
        companion.readProperties(node, mPropertyReader);
        assertEquals(setOf("FOUR"), mPropertyReader.getIntFlag("value"));

        node.setValue(5);
        companion.readProperties(node, mPropertyReader);
        assertEquals(setOf("FOUR", "ONE"), mPropertyReader.getIntFlag("value"));
    }

    class PublicFieldTest {
        @InspectableProperty
        public final int value;

        PublicFieldTest(Random seed) {
            value = seed.nextInt();
        }
    }

    @Test
    public void testPublicField() {
        PublicFieldTest node = new PublicFieldTest(mRandom);
        mapAndRead(node);
        assertEquals(node.value, mPropertyReader.get("value"));
    }

    class ResourceIdTest {
        @AnimatorRes private final int mAnimatorId;
        @AnimRes private final int mAnimId;
        @AnyRes private final int mAnyId;
        @ArrayRes private final int mArrayId;
        @BoolRes private final int mBoolId;
        @DimenRes private final int mDimenId;
        @DrawableRes private final int mDrawableId;
        @FontRes private final int mFontId;
        @IdRes private final int mIdId;
        @IntegerRes private final int mIntegerId;
        @InterpolatorRes private final int mInterpolatorId;
        @LayoutRes private final int mLayoutId;
        @MenuRes private final int mMenuId;
        @NavigationRes private final int mNavigationId;
        @PluralsRes private final int mPluralsId;
        @RawRes private final int mRawId;
        @StringRes private final int mStringId;
        @StyleableRes private final int mStyleableId;
        @StyleRes private final int mStyleId;
        @TransitionRes private final int mTransitionId;
        @XmlRes private final int mXmlId;
        private final int mUnannotatedId;

        ResourceIdTest(Random seed) {
            mAnimatorId = seed.nextInt();
            mAnimId = seed.nextInt();
            mAnyId = seed.nextInt();
            mArrayId = seed.nextInt();
            mBoolId = seed.nextInt();
            mDimenId = seed.nextInt();
            mDrawableId = seed.nextInt();
            mFontId = seed.nextInt();
            mIdId = seed.nextInt();
            mIntegerId = seed.nextInt();
            mInterpolatorId = seed.nextInt();
            mLayoutId = seed.nextInt();
            mMenuId = seed.nextInt();
            mNavigationId = seed.nextInt();
            mPluralsId = seed.nextInt();
            mRawId = seed.nextInt();
            mStringId = seed.nextInt();
            mStyleableId = seed.nextInt();
            mStyleId = seed.nextInt();
            mTransitionId = seed.nextInt();
            mXmlId = seed.nextInt();
            mUnannotatedId = seed.nextInt();
        }

        @InspectableProperty(hasAttributeId = false)
        @AnimatorRes
        public int getAnimatorId() {
            return mAnimatorId;
        }

        @InspectableProperty(hasAttributeId = false)
        @AnimRes
        public int getAnimId() {
            return mAnimId;
        }

        @InspectableProperty(hasAttributeId = false)
        @AnyRes
        public int getAnyId() {
            return mAnimId;
        }

        @InspectableProperty(hasAttributeId = false)
        @ArrayRes
        public int getArrayId() {
            return mArrayId;
        }

        @InspectableProperty(hasAttributeId = false)
        @BoolRes
        public int getBoolId() {
            return mBoolId;
        }

        @InspectableProperty(hasAttributeId = false)
        @DimenRes
        public int getDimenId() {
            return mDimenId;
        }

        @InspectableProperty(hasAttributeId = false)
        @DrawableRes
        public int getDrawableId() {
            return mDrawableId;
        }

        @InspectableProperty(hasAttributeId = false)
        @FontRes
        public int getFontId() {
            return mFontId;
        }

        @InspectableProperty(hasAttributeId = false)
        @IdRes
        public int getIdId() {
            return mIdId;
        }

        @InspectableProperty(hasAttributeId = false)
        @IntegerRes
        public int getIntegerId() {
            return mIntegerId;
        }

        @InspectableProperty(hasAttributeId = false)
        @InterpolatorRes
        public int getInterpolatorId() {
            return mInterpolatorId;
        }

        @InspectableProperty(hasAttributeId = false)
        @LayoutRes
        public int getLayoutId() {
            return mLayoutId;
        }

        @InspectableProperty(hasAttributeId = false)
        @MenuRes
        public int getMenuId() {
            return mMenuId;
        }

        @InspectableProperty(hasAttributeId = false)
        @NavigationRes
        public int getNavigationId() {
            return mNavigationId;
        }

        @InspectableProperty(hasAttributeId = false)
        @PluralsRes
        public int getPluralsId() {
            return mPluralsId;
        }

        @InspectableProperty(hasAttributeId = false)
        @RawRes
        public int getRawId() {
            return mRawId;
        }

        @InspectableProperty(hasAttributeId = false)
        @StringRes
        public int getStringId() {
            return mStringId;
        }

        @InspectableProperty(hasAttributeId = false)
        @StyleableRes
        public int getStyleableId() {
            return mStyleableId;
        }

        @InspectableProperty(hasAttributeId = false)
        @StyleRes
        public int getStyleId() {
            return mStyleId;
        }

        @InspectableProperty(hasAttributeId = false)
        @TransitionRes
        public int getTransitionId() {
            return mTransitionId;
        }

        @InspectableProperty(hasAttributeId = false)
        @XmlRes
        public int getXmlId() {
            return mXmlId;
        }

        @InspectableProperty(hasAttributeId = false, valueType = ValueType.RESOURCE_ID)
        public int getUnannotatedId() {
            return mUnannotatedId;
        }
    }

    @Test
    public void testResourceId() {
        ResourceIdTest node = new ResourceIdTest(mRandom);
        mapAndRead(node);

        assertEquals(node.getAnimatorId(), mPropertyReader.get("animatorId"));
        assertEquals(ValueType.RESOURCE_ID, mPropertyMapper.getValueType("animatorId"));

        assertEquals(node.getAnimId(), mPropertyReader.get("animId"));
        assertEquals(ValueType.RESOURCE_ID, mPropertyMapper.getValueType("animId"));

        assertEquals(node.getAnyId(), mPropertyReader.get("anyId"));
        assertEquals(ValueType.RESOURCE_ID, mPropertyMapper.getValueType("anyId"));

        assertEquals(node.getArrayId(), mPropertyReader.get("arrayId"));
        assertEquals(ValueType.RESOURCE_ID, mPropertyMapper.getValueType("arrayId"));

        assertEquals(node.getBoolId(), mPropertyReader.get("boolId"));
        assertEquals(ValueType.RESOURCE_ID, mPropertyMapper.getValueType("boolId"));

        assertEquals(node.getDimenId(), mPropertyReader.get("dimenId"));
        assertEquals(ValueType.RESOURCE_ID, mPropertyMapper.getValueType("dimenId"));

        assertEquals(node.getDrawableId(), mPropertyReader.get("drawableId"));
        assertEquals(ValueType.RESOURCE_ID, mPropertyMapper.getValueType("drawableId"));

        assertEquals(node.getFontId(), mPropertyReader.get("fontId"));
        assertEquals(ValueType.RESOURCE_ID, mPropertyMapper.getValueType("fontId"));

        assertEquals(node.getIdId(), mPropertyReader.get("idId"));
        assertEquals(ValueType.RESOURCE_ID, mPropertyMapper.getValueType("idId"));

        assertEquals(node.getIntegerId(), mPropertyReader.get("integerId"));
        assertEquals(ValueType.RESOURCE_ID, mPropertyMapper.getValueType("integerId"));

        assertEquals(node.getInterpolatorId(), mPropertyReader.get("interpolatorId"));
        assertEquals(ValueType.RESOURCE_ID, mPropertyMapper.getValueType("interpolatorId"));

        assertEquals(node.getLayoutId(), mPropertyReader.get("layoutId"));
        assertEquals(ValueType.RESOURCE_ID, mPropertyMapper.getValueType("layoutId"));

        assertEquals(node.getMenuId(), mPropertyReader.get("menuId"));
        assertEquals(ValueType.RESOURCE_ID, mPropertyMapper.getValueType("menuId"));

        assertEquals(node.getNavigationId(), mPropertyReader.get("navigationId"));
        assertEquals(ValueType.RESOURCE_ID, mPropertyMapper.getValueType("navigationId"));

        assertEquals(node.getPluralsId(), mPropertyReader.get("pluralsId"));
        assertEquals(ValueType.RESOURCE_ID, mPropertyMapper.getValueType("pluralsId"));

        assertEquals(node.getRawId(), mPropertyReader.get("rawId"));
        assertEquals(ValueType.RESOURCE_ID, mPropertyMapper.getValueType("rawId"));

        assertEquals(node.getStringId(), mPropertyReader.get("stringId"));
        assertEquals(ValueType.RESOURCE_ID, mPropertyMapper.getValueType("stringId"));

        assertEquals(node.getStyleableId(), mPropertyReader.get("styleableId"));
        assertEquals(ValueType.RESOURCE_ID, mPropertyMapper.getValueType("styleableId"));

        assertEquals(node.getStyleId(), mPropertyReader.get("styleId"));
        assertEquals(ValueType.RESOURCE_ID, mPropertyMapper.getValueType("styleId"));

        assertEquals(node.getTransitionId(), mPropertyReader.get("transitionId"));
        assertEquals(ValueType.RESOURCE_ID, mPropertyMapper.getValueType("transitionId"));

        assertEquals(node.getXmlId(), mPropertyReader.get("xmlId"));
        assertEquals(ValueType.RESOURCE_ID, mPropertyMapper.getValueType("xmlId"));

        assertEquals(node.getUnannotatedId(), mPropertyReader.get("unannotatedId"));
        assertEquals(ValueType.RESOURCE_ID, mPropertyMapper.getValueType("unannotatedId"));
    }

    private static <T> Set<T> setOf(T... items) {
        Set<T> set = new HashSet<>(items.length);

        for (T item : items) {
            set.add(item);
        }

        return set;
    }

    @SuppressWarnings("unchecked")
    private <T> void mapAndRead(T node) {
        InspectionCompanion<T> companion = loadCompanion((Class<T>) node.getClass());
        companion.mapProperties(mPropertyMapper);
        companion.readProperties(node, mPropertyReader);
    }

    @SuppressWarnings("unchecked")
    private <T> InspectionCompanion<T> loadCompanion(Class<T> cls) {
        final ClassLoader classLoader = cls.getClassLoader();
        final String companionName = String.format("%s$InspectionCompanion", cls.getName());

        try {
            final Class<InspectionCompanion<T>> companion =
                    (Class<InspectionCompanion<T>>) classLoader.loadClass(companionName);
            return companion.newInstance();
        } catch (ClassNotFoundException e) {
            fail(String.format("Unable to load companion for %s", cls.getCanonicalName()));
        } catch (InstantiationException | IllegalAccessException e) {
            fail(String.format("Unable to instantiate companion for %s", cls.getCanonicalName()));
        }

        return null;
    }

    private char randomLetter(Random random) {
        final String alphabet = "abcdefghijklmnopqrstuvwxyz";
        return alphabet.charAt(random.nextInt(alphabet.length()));
    }
}