Initial commit

Code/Framework/AzNetworking/Tests/Utilities/CidrAddressTests.cpp

@@ -0,0 +1,97 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+
+#include <AzNetworking/Utilities/CidrAddress.h>
+#include <AzNetworking/Utilities/IpAddress.h>
+#include <AzCore/UnitTest/TestTypes.h>
+
+namespace UnitTest
+{
+    class CidrAddressTests
+        : public AllocatorsFixture
+    {
+    public:
+        void SetUp() override
+        {
+            AllocatorsFixture::SetUp();
+        }
+
+        void TearDown() override
+        {
+            AllocatorsFixture::TearDown();
+        }
+    };
+
+    static const AzNetworking::IpAddress testIp1 = AzNetworking::IpAddress(127, 0, 0, 1, 0);
+    static const AzNetworking::IpAddress testIp2 = AzNetworking::IpAddress(127, 0, 0, 255, 0);
+    static const AzNetworking::IpAddress testIp3 = AzNetworking::IpAddress(127, 0, 255, 255, 0);
+    static const AzNetworking::IpAddress testIp4 = AzNetworking::IpAddress(127, 255, 255, 255, 0);
+    static const AzNetworking::IpAddress testIp5 = AzNetworking::IpAddress(255, 255, 255, 255, 0);
+
+    TEST_F(CidrAddressTests, Test32BitMask)
+    {
+        AzNetworking::CidrAddress testCidr1("127.0.0.1/32");
+        EXPECT_TRUE (testCidr1.IsMatch(testIp1));
+        EXPECT_FALSE(testCidr1.IsMatch(testIp2));
+        EXPECT_FALSE(testCidr1.IsMatch(testIp3));
+        EXPECT_FALSE(testCidr1.IsMatch(testIp4));
+        EXPECT_FALSE(testCidr1.IsMatch(testIp5));
+    }
+
+    TEST_F(CidrAddressTests, Test24BitMask)
+    {
+        AzNetworking::CidrAddress testCidr2("127.0.0.1/24");
+        EXPECT_TRUE (testCidr2.IsMatch(testIp1));
+        EXPECT_TRUE (testCidr2.IsMatch(testIp2));
+        EXPECT_FALSE(testCidr2.IsMatch(testIp3));
+        EXPECT_FALSE(testCidr2.IsMatch(testIp4));
+        EXPECT_FALSE(testCidr2.IsMatch(testIp5));
+    }
+
+    TEST_F(CidrAddressTests, Test16BitMask)
+    {
+        AzNetworking::CidrAddress testCidr3("127.0.0.1/16");
+        EXPECT_TRUE (testCidr3.IsMatch(testIp1));
+        EXPECT_TRUE (testCidr3.IsMatch(testIp2));
+        EXPECT_TRUE (testCidr3.IsMatch(testIp3));
+        EXPECT_FALSE(testCidr3.IsMatch(testIp4));
+        EXPECT_FALSE(testCidr3.IsMatch(testIp5));
+    }
+
+    TEST_F(CidrAddressTests, Test8BitMask)
+    {
+        AzNetworking::CidrAddress testCidr4("127.0.0.1/8");
+        EXPECT_TRUE (testCidr4.IsMatch(testIp1));
+        EXPECT_TRUE (testCidr4.IsMatch(testIp2));
+        EXPECT_TRUE (testCidr4.IsMatch(testIp3));
+        EXPECT_TRUE (testCidr4.IsMatch(testIp4));
+        EXPECT_FALSE(testCidr4.IsMatch(testIp5));
+    }
+
+    TEST_F(CidrAddressTests, TestAnyMatch)
+    {
+        AzNetworking::CidrAddress testCidr5("127.0.0.1/0");
+        EXPECT_TRUE (testCidr5.IsMatch(testIp1));
+        EXPECT_TRUE (testCidr5.IsMatch(testIp2));
+        EXPECT_TRUE (testCidr5.IsMatch(testIp3));
+        EXPECT_TRUE (testCidr5.IsMatch(testIp4));
+        EXPECT_TRUE (testCidr5.IsMatch(testIp5));
+    }
+
+    TEST_F(CidrAddressTests, TestOutOfRange)
+    {
+        AzNetworking::CidrAddress testCidr6("127.0.0.1/33");
+        EXPECT_EQ(testCidr6.GetMask(), 0xFFFFFFFF);
+        AzNetworking::CidrAddress testCidr7("127.0.0.1/-1");
+        EXPECT_EQ(testCidr7.GetMask(), 0);
+    }
+}

Code/Framework/AzNetworking/Tests/Utilities/IpAddressTests.cpp

@@ -0,0 +1,18 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+
+#include <AzNetworking/Utilities/IpAddress.h>
+#include <AzCore/UnitTest/TestTypes.h>
+
+namespace UnitTest
+{
+}

Code/Framework/AzNetworking/Tests/Utilities/NetworkCommonTests.cpp

@@ -0,0 +1,38 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+
+#include <AzNetworking/Utilities/NetworkCommon.h>
+#include <AzCore/UnitTest/TestTypes.h>
+
+namespace UnitTest
+{
+    TEST(NetworkCommon, GenerateSerializerIndexLabelByte)
+    {
+        EXPECT_STREQ(AzNetworking::GenerateIndexLabel<255>(0).c_str(), "00");
+        EXPECT_STREQ(AzNetworking::GenerateIndexLabel<255>(1).c_str(), "01");
+        EXPECT_STREQ(AzNetworking::GenerateIndexLabel<255>(10).c_str(), "0A");
+        EXPECT_STREQ(AzNetworking::GenerateIndexLabel<255>(100).c_str(), "64");
+    }
+
+    TEST(NetworkCommon, GenerateSerializerIndexLabelShort)
+    {
+        EXPECT_STREQ(AzNetworking::GenerateIndexLabel<65535>(0).c_str(), "0000");
+        EXPECT_STREQ(AzNetworking::GenerateIndexLabel<65535>(1).c_str(), "0001");
+        EXPECT_STREQ(AzNetworking::GenerateIndexLabel<65535>(10).c_str(), "000A");
+        EXPECT_STREQ(AzNetworking::GenerateIndexLabel<65535>(100).c_str(), "0064");
+    }
+
+    TEST(NetworkCommon, GenerateSerializerIndexLabelMax)
+    {
+        EXPECT_STREQ(AzNetworking::GenerateIndexLabel<UINT_MAX>(UINT_MAX).c_str(), "FFFFFFFF");
+    }
+}

Code/Framework/AzNetworking/Tests/Utilities/QuantizedValuesTests.cpp

@@ -0,0 +1,363 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+
+#include <AzNetworking/Utilities/QuantizedValues.h>
+#include <AzNetworking/Serialization/NetworkInputSerializer.h>
+#include <AzNetworking/Serialization/NetworkOutputSerializer.h>
+#include <AzCore/UnitTest/TestTypes.h>
+
+namespace UnitTest
+{
+    template <uint32_t NUM_ELEMENTS>
+    struct ValueFromFloat {};
+
+    template <>
+    struct ValueFromFloat<1>
+    {
+        using ValueType = float;
+        static float Construct(float value)
+        {
+            return value;
+        }
+
+        static void CheckEqual(ValueType a, ValueType b)
+        {
+            EXPECT_FLOAT_EQ(a, b);
+        }
+    };
+
+    template <>
+    struct ValueFromFloat<2>
+    {
+        using ValueType = AZ::Vector2;
+        static AZ::Vector2 Construct(float value)
+        {
+            return AZ::Vector2(value, value);
+        }
+
+        static void CheckEqual(ValueType a, ValueType b)
+        {
+            EXPECT_TRUE(a.IsClose(b, 0.01f));
+        }
+    };
+
+    template <>
+    struct ValueFromFloat<3>
+    {
+        using ValueType = AZ::Vector3;
+        static AZ::Vector3 Construct(float value)
+        {
+            return AZ::Vector3(value, value, value);
+        }
+
+        static void CheckEqual(ValueType a, ValueType b)
+        {
+            EXPECT_TRUE(a.IsClose(b, 0.01f));
+        }
+    };
+
+    template <>
+    struct ValueFromFloat<4>
+    {
+        using ValueType = AZ::Quaternion;
+        static AZ::Quaternion Construct(float value)
+        {
+            return AZ::Quaternion(value, value, value, value);
+        }
+
+        static void CheckEqual(ValueType a, ValueType b)
+        {
+            EXPECT_TRUE(a.IsClose(b, 0.01f));
+        }
+    };
+
+    template <uint32_t NUM_ELEMENTS, uint32_t NUM_BYTES>
+    void TestQuantizedValuesHelper01()
+    {
+        AzNetworking::QuantizedValues<NUM_ELEMENTS, NUM_BYTES, 0, 1> testIn, testOut; // Transmits float values between 0 and 1 using NUM_BYTES
+
+        AZStd::array<uint8_t, 1024> buffer;
+        AzNetworking::NetworkInputSerializer  inputSerializer(buffer.data(), static_cast<uint32_t>(buffer.size()));
+        AzNetworking::NetworkOutputSerializer outputSerializer(buffer.data(), static_cast<uint32_t>(buffer.size()));
+
+        testIn = ValueFromFloat<NUM_ELEMENTS>::Construct(0.0f);
+        EXPECT_EQ(static_cast<typename ValueFromFloat<NUM_ELEMENTS>::ValueType>(testIn), ValueFromFloat<NUM_ELEMENTS>::Construct(0.0f));
+        testIn.Serialize(inputSerializer);
+        EXPECT_EQ(inputSerializer.GetSize(), NUM_BYTES * NUM_ELEMENTS);
+        testOut.Serialize(outputSerializer);
+        EXPECT_EQ(testIn, testOut);
+
+        testIn = ValueFromFloat<NUM_ELEMENTS>::Construct(1.0f);
+        EXPECT_EQ(static_cast<typename ValueFromFloat<NUM_ELEMENTS>::ValueType>(testIn), ValueFromFloat<NUM_ELEMENTS>::Construct(1.0f));
+        testIn.Serialize(inputSerializer);
+        testOut.Serialize(outputSerializer);
+        EXPECT_EQ(testIn, testOut);
+
+        testIn = ValueFromFloat<NUM_ELEMENTS>::Construct(0.5f);
+        EXPECT_EQ(static_cast<typename ValueFromFloat<NUM_ELEMENTS>::ValueType>(testIn), ValueFromFloat<NUM_ELEMENTS>::Construct(0.5f));
+        testIn.Serialize(inputSerializer);
+        testOut.Serialize(outputSerializer);
+        EXPECT_EQ(testIn, testOut);
+
+        testIn = ValueFromFloat<NUM_ELEMENTS>::Construct(-1.0f);
+        EXPECT_NE(static_cast<typename ValueFromFloat<NUM_ELEMENTS>::ValueType>(testIn), ValueFromFloat<NUM_ELEMENTS>::Construct(-1.0f));
+        EXPECT_EQ(static_cast<typename ValueFromFloat<NUM_ELEMENTS>::ValueType>(testIn), ValueFromFloat<NUM_ELEMENTS>::Construct(0.0f));
+        testIn.Serialize(inputSerializer);
+        testOut.Serialize(outputSerializer);
+        EXPECT_EQ(testIn, testOut);
+
+        testIn = ValueFromFloat<NUM_ELEMENTS>::Construct(2.0f);
+        EXPECT_NE(static_cast<typename ValueFromFloat<NUM_ELEMENTS>::ValueType>(testIn), ValueFromFloat<NUM_ELEMENTS>::Construct(2.0f));
+        EXPECT_EQ(static_cast<typename ValueFromFloat<NUM_ELEMENTS>::ValueType>(testIn), ValueFromFloat<NUM_ELEMENTS>::Construct(1.0f));
+        testIn.Serialize(inputSerializer);
+        testOut.Serialize(outputSerializer);
+        EXPECT_EQ(testIn, testOut);
+    }
+
+    template <uint32_t NUM_ELEMENTS, uint32_t NUM_BYTES>
+    void TestQuantizedValuesHelper11()
+    {
+        AzNetworking::QuantizedValues<NUM_ELEMENTS, NUM_BYTES, -1, 1> testIn, testOut; // Transmits float values between -1.0 and 1.0 using NUM_BYTES
+
+        AZStd::array<uint8_t, 1024> buffer;
+        AzNetworking::NetworkInputSerializer  inputSerializer(buffer.data(), static_cast<uint32_t>(buffer.size()));
+        AzNetworking::NetworkOutputSerializer outputSerializer(buffer.data(), static_cast<uint32_t>(buffer.size()));
+
+        testIn = ValueFromFloat<NUM_ELEMENTS>::Construct(-1.0f);
+        ValueFromFloat<NUM_ELEMENTS>::CheckEqual(static_cast<typename ValueFromFloat<NUM_ELEMENTS>::ValueType>(testIn), ValueFromFloat<NUM_ELEMENTS>::Construct(-1.0f));
+        testIn.Serialize(inputSerializer);
+        EXPECT_EQ(inputSerializer.GetSize(), NUM_BYTES * NUM_ELEMENTS);
+        testOut.Serialize(outputSerializer);
+        EXPECT_EQ(testIn, testOut);
+
+        testIn = ValueFromFloat<NUM_ELEMENTS>::Construct(1.0f);
+        ValueFromFloat<NUM_ELEMENTS>::CheckEqual(static_cast<typename ValueFromFloat<NUM_ELEMENTS>::ValueType>(testIn), ValueFromFloat<NUM_ELEMENTS>::Construct(1.0f));
+        testIn.Serialize(inputSerializer);
+        testOut.Serialize(outputSerializer);
+        EXPECT_EQ(testIn, testOut);
+
+        testIn = ValueFromFloat<NUM_ELEMENTS>::Construct(0.0f);
+        ValueFromFloat<NUM_ELEMENTS>::CheckEqual(static_cast<typename ValueFromFloat<NUM_ELEMENTS>::ValueType>(testIn), ValueFromFloat<NUM_ELEMENTS>::Construct(0.0f));
+        testIn.Serialize(inputSerializer);
+        testOut.Serialize(outputSerializer);
+        EXPECT_EQ(testIn, testOut);
+
+        testIn = ValueFromFloat<NUM_ELEMENTS>::Construct(-2.0f);
+        EXPECT_NE(static_cast<typename ValueFromFloat<NUM_ELEMENTS>::ValueType>(testIn), ValueFromFloat<NUM_ELEMENTS>::Construct(-2.0f));
+        ValueFromFloat<NUM_ELEMENTS>::CheckEqual(static_cast<typename ValueFromFloat<NUM_ELEMENTS>::ValueType>(testIn), ValueFromFloat<NUM_ELEMENTS>::Construct(-1.0f));
+        testIn.Serialize(inputSerializer);
+        testOut.Serialize(outputSerializer);
+        EXPECT_EQ(testIn, testOut);
+
+        testIn = ValueFromFloat<NUM_ELEMENTS>::Construct(2.0f);
+        EXPECT_NE(static_cast<typename ValueFromFloat<NUM_ELEMENTS>::ValueType>(testIn), ValueFromFloat<NUM_ELEMENTS>::Construct(2.0f));
+        ValueFromFloat<NUM_ELEMENTS>::CheckEqual(static_cast<typename ValueFromFloat<NUM_ELEMENTS>::ValueType>(testIn), ValueFromFloat<NUM_ELEMENTS>::Construct(1.0f));
+        testIn.Serialize(inputSerializer);
+        testOut.Serialize(outputSerializer);
+        EXPECT_EQ(testIn, testOut);
+    }
+
+    template <uint32_t NUM_ELEMENTS, uint32_t NUM_BYTES>
+    void TestQuantizedValuesHelper16k()
+    {
+        AzNetworking::QuantizedValues<NUM_ELEMENTS, NUM_BYTES, -16384, 16384> testIn, testOut; // Transmits float values between -1.0 and 1.0 using NUM_BYTES
+
+        AZStd::array<uint8_t, 1024> buffer;
+        AzNetworking::NetworkInputSerializer  inputSerializer(buffer.data(), static_cast<uint32_t>(buffer.size()));
+        AzNetworking::NetworkOutputSerializer outputSerializer(buffer.data(), static_cast<uint32_t>(buffer.size()));
+
+        testIn = ValueFromFloat<NUM_ELEMENTS>::Construct(-2000.0f);
+        ValueFromFloat<NUM_ELEMENTS>::CheckEqual(static_cast<typename ValueFromFloat<NUM_ELEMENTS>::ValueType>(testIn), ValueFromFloat<NUM_ELEMENTS>::Construct(-2000.0f));
+        testIn.Serialize(inputSerializer);
+        EXPECT_EQ(inputSerializer.GetSize(), NUM_BYTES * NUM_ELEMENTS);
+        testOut.Serialize(outputSerializer);
+        EXPECT_EQ(testIn, testOut);
+
+        testIn = ValueFromFloat<NUM_ELEMENTS>::Construct(2000.0f);
+        ValueFromFloat<NUM_ELEMENTS>::CheckEqual(static_cast<typename ValueFromFloat<NUM_ELEMENTS>::ValueType>(testIn), ValueFromFloat<NUM_ELEMENTS>::Construct(2000.0f));
+        testIn.Serialize(inputSerializer);
+        testOut.Serialize(outputSerializer);
+        EXPECT_EQ(testIn, testOut);
+
+        testIn = ValueFromFloat<NUM_ELEMENTS>::Construct(0.0f);
+        ValueFromFloat<NUM_ELEMENTS>::CheckEqual(static_cast<typename ValueFromFloat<NUM_ELEMENTS>::ValueType>(testIn), ValueFromFloat<NUM_ELEMENTS>::Construct(0.0f));
+        testIn.Serialize(inputSerializer);
+        testOut.Serialize(outputSerializer);
+        EXPECT_EQ(testIn, testOut);
+
+        testIn = ValueFromFloat<NUM_ELEMENTS>::Construct(-16385.0f);
+        EXPECT_NE(static_cast<typename ValueFromFloat<NUM_ELEMENTS>::ValueType>(testIn), ValueFromFloat<NUM_ELEMENTS>::Construct(-16385.0f));
+        ValueFromFloat<NUM_ELEMENTS>::CheckEqual(static_cast<typename ValueFromFloat<NUM_ELEMENTS>::ValueType>(testIn), ValueFromFloat<NUM_ELEMENTS>::Construct(-16384.0f));
+        testIn.Serialize(inputSerializer);
+        testOut.Serialize(outputSerializer);
+        EXPECT_EQ(testIn, testOut);
+
+        testIn = ValueFromFloat<NUM_ELEMENTS>::Construct(16385.0f);
+        EXPECT_NE(static_cast<typename ValueFromFloat<NUM_ELEMENTS>::ValueType>(testIn), ValueFromFloat<NUM_ELEMENTS>::Construct(16385.0f));
+        EXPECT_EQ(static_cast<typename ValueFromFloat<NUM_ELEMENTS>::ValueType>(testIn), ValueFromFloat<NUM_ELEMENTS>::Construct(16384.0f));
+        testIn.Serialize(inputSerializer);
+        testOut.Serialize(outputSerializer);
+        EXPECT_EQ(testIn, testOut);
+    }
+
+    template <uint32_t NUM_ELEMENTS, uint32_t NUM_BYTES>
+    void TestQuantizedValuesHelper24bitRange()
+    {
+        // This gives us a hash sensitivity of around 1/128th of a unit, and will detect errors within a range of -16,777,216 to +16,777,216
+        static const int32_t FloatHashMinValue = (INT_MIN >> 7);
+        static const int32_t FloatHashMaxValue = (INT_MAX >> 7);
+
+        AzNetworking::QuantizedValues<NUM_ELEMENTS, NUM_BYTES, FloatHashMinValue, FloatHashMaxValue> testIn, testOut;
+
+        AZStd::array<uint8_t, 1024> buffer;
+        AzNetworking::NetworkInputSerializer  inputSerializer(buffer.data(), static_cast<uint32_t>(buffer.size()));
+        AzNetworking::NetworkOutputSerializer outputSerializer(buffer.data(), static_cast<uint32_t>(buffer.size()));
+
+        testIn = ValueFromFloat<NUM_ELEMENTS>::Construct(-20000.0f);
+        ValueFromFloat<NUM_ELEMENTS>::CheckEqual(static_cast<typename ValueFromFloat<NUM_ELEMENTS>::ValueType>(testIn), ValueFromFloat<NUM_ELEMENTS>::Construct(-20000.0f));
+        testIn.Serialize(inputSerializer);
+        EXPECT_EQ(inputSerializer.GetSize(), NUM_BYTES * NUM_ELEMENTS);
+        testOut.Serialize(outputSerializer);
+        EXPECT_EQ(testIn, testOut);
+
+        testIn = ValueFromFloat<NUM_ELEMENTS>::Construct(20000.0f);
+        ValueFromFloat<NUM_ELEMENTS>::CheckEqual(static_cast<typename ValueFromFloat<NUM_ELEMENTS>::ValueType>(testIn), ValueFromFloat<NUM_ELEMENTS>::Construct(20000.0f));
+        testIn.Serialize(inputSerializer);
+        testOut.Serialize(outputSerializer);
+        EXPECT_EQ(testIn, testOut);
+
+        testIn = ValueFromFloat<NUM_ELEMENTS>::Construct(0.0f);
+        ValueFromFloat<NUM_ELEMENTS>::CheckEqual(static_cast<typename ValueFromFloat<NUM_ELEMENTS>::ValueType>(testIn), ValueFromFloat<NUM_ELEMENTS>::Construct(0.0f));
+        testIn.Serialize(inputSerializer);
+        testOut.Serialize(outputSerializer);
+        EXPECT_EQ(testIn, testOut);
+
+        testIn = ValueFromFloat<NUM_ELEMENTS>::Construct(-163850.0f);
+        ValueFromFloat<NUM_ELEMENTS>::CheckEqual(static_cast<typename ValueFromFloat<NUM_ELEMENTS>::ValueType>(testIn), ValueFromFloat<NUM_ELEMENTS>::Construct(-163850.0f));
+        testIn.Serialize(inputSerializer);
+        testOut.Serialize(outputSerializer);
+        EXPECT_EQ(testIn, testOut);
+
+        testIn = ValueFromFloat<NUM_ELEMENTS>::Construct(163850.0f);
+        ValueFromFloat<NUM_ELEMENTS>::CheckEqual(static_cast<typename ValueFromFloat<NUM_ELEMENTS>::ValueType>(testIn), ValueFromFloat<NUM_ELEMENTS>::Construct(163850.0f));
+        testIn.Serialize(inputSerializer);
+        testOut.Serialize(outputSerializer);
+        EXPECT_EQ(testIn, testOut);
+    }
+
+    TEST(QuantizedValues, Test1Elements1Bytes)
+    {
+        TestQuantizedValuesHelper01<1, 1>();
+        TestQuantizedValuesHelper11<1, 1>();
+    }
+
+    TEST(QuantizedValues, Test2Elements1Bytes)
+    {
+        TestQuantizedValuesHelper01<2, 1>();
+        TestQuantizedValuesHelper11<2, 1>();
+    }
+
+    TEST(QuantizedValues, Test3Elements1Bytes)
+    {
+        TestQuantizedValuesHelper01<3, 1>();
+        TestQuantizedValuesHelper11<3, 1>();
+    }
+
+    TEST(QuantizedValues, Test4Elements1Bytes)
+    {
+        TestQuantizedValuesHelper01<4, 1>();
+        TestQuantizedValuesHelper11<4, 1>();
+    }
+
+    TEST(QuantizedValues, Test1Elements2Bytes)
+    {
+        TestQuantizedValuesHelper01<1, 2>();
+        TestQuantizedValuesHelper11<1, 2>();
+    }
+
+    TEST(QuantizedValues, Test2Elements2Bytes)
+    {
+        TestQuantizedValuesHelper01<2, 2>();
+        TestQuantizedValuesHelper11<2, 2>();
+    }
+
+    TEST(QuantizedValues, Test3Elements2Bytes)
+    {
+        TestQuantizedValuesHelper01<3, 2>();
+        TestQuantizedValuesHelper11<3, 2>();
+    }
+
+    TEST(QuantizedValues, Test4Elements2Bytes)
+    {
+        TestQuantizedValuesHelper01<4, 2>();
+        TestQuantizedValuesHelper11<4, 2>();
+    }
+
+    TEST(QuantizedValues, Test1Elements3Bytes)
+    {
+        TestQuantizedValuesHelper01 <1, 3>();
+        TestQuantizedValuesHelper11 <1, 3>();
+        TestQuantizedValuesHelper16k<1, 3>();
+    }
+
+    TEST(QuantizedValues, Test2Elements3Bytes)
+    {
+        TestQuantizedValuesHelper01 <2, 3>();
+        TestQuantizedValuesHelper11 <2, 3>();
+        TestQuantizedValuesHelper16k<2, 3>();
+    }
+
+    TEST(QuantizedValues, Test3Elements3Bytes)
+    {
+        TestQuantizedValuesHelper01 <3, 3>();
+        TestQuantizedValuesHelper11 <3, 3>();
+        TestQuantizedValuesHelper16k<3, 3>();
+    }
+
+    TEST(QuantizedValues, Test4Elements3Bytes)
+    {
+        TestQuantizedValuesHelper01 <4, 3>();
+        TestQuantizedValuesHelper11 <4, 3>();
+        TestQuantizedValuesHelper16k<4, 3>();
+    }
+
+    TEST(QuantizedValues, Test1Elements4Bytes)
+    {
+        TestQuantizedValuesHelper01 <1, 4>();
+        TestQuantizedValuesHelper11 <1, 4>();
+        TestQuantizedValuesHelper16k<1, 4>();
+    }
+
+    TEST(QuantizedValues, Test2Elements4Bytes)
+    {
+        TestQuantizedValuesHelper01 <2, 4>();
+        TestQuantizedValuesHelper11 <2, 4>();
+        TestQuantizedValuesHelper16k<2, 4>();
+        TestQuantizedValuesHelper24bitRange<2, 4>();
+    }
+
+    TEST(QuantizedValues, Test3Elements4Bytes)
+    {
+        TestQuantizedValuesHelper01 <3, 4>();
+        TestQuantizedValuesHelper11 <3, 4>();
+        TestQuantizedValuesHelper16k<3, 4>();
+        TestQuantizedValuesHelper24bitRange<3, 4>();
+    }
+
+    TEST(QuantizedValues, Test4Elements4Bytes)
+    {
+        TestQuantizedValuesHelper01 <4, 4>();
+        TestQuantizedValuesHelper11 <4, 4>();
+        TestQuantizedValuesHelper16k<4, 4>();
+        TestQuantizedValuesHelper24bitRange<4, 4>();
+    }
+}