| // Copyright 2019 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include <array> |
| #include <lib/affine/ratio.h> |
| #include <lib/affine/transform.h> |
| #include <lib/fit/function.h> |
| #include <zxtest/zxtest.h> |
| |
| namespace { |
| enum class Fatal { No, Yes }; |
| } // namespace |
| |
| TEST(TransformTestCase, Construction) { |
| // Default constructor should produce the identitiy transformation |
| { |
| affine::Transform transform; |
| ASSERT_EQ(transform.a_offset(), 0); |
| ASSERT_EQ(transform.b_offset(), 0); |
| ASSERT_EQ(transform.numerator(), 1); |
| ASSERT_EQ(transform.denominator(), 1); |
| ASSERT_TRUE(transform.ratio() == affine::Ratio(1, 1)); |
| } |
| |
| struct TestVector { |
| int64_t a_offset, b_offset; |
| uint32_t N, D; |
| Fatal expect_fatal; |
| }; |
| |
| constexpr std::array TEST_VECTORS { |
| TestVector{ 12345, 98764, 3, 2, Fatal::No }, |
| TestVector{ -12345, 98764, 247, 931, Fatal::No }, |
| TestVector{ -12345, -98764, 48000, 44100, Fatal::No }, |
| TestVector{ 12345, -98764, 1000007, 1000000, Fatal::No }, |
| TestVector{ 12345, 98764, 0, 1000000, Fatal::No }, |
| TestVector{ 12345, 98764, 1000007, 0, Fatal::Yes }, |
| }; |
| |
| for (const auto& V : TEST_VECTORS) { |
| // Check the linear form (no offsets) |
| if (V.expect_fatal == Fatal::No) { |
| affine::Ratio ratio{ V.N, V.D }; |
| affine::Transform transform{ ratio }; |
| |
| ASSERT_EQ(transform.a_offset(), 0); |
| ASSERT_EQ(transform.b_offset(), 0); |
| ASSERT_EQ(transform.numerator(), ratio.numerator()); |
| ASSERT_EQ(transform.denominator(), ratio.denominator()); |
| ASSERT_TRUE(transform.ratio() == ratio); |
| } else { |
| ASSERT_DEATH(([&V]() { affine::Transform transform{ affine::Ratio{V.N, V.D} }; })); |
| } |
| |
| // Check the affine form (yes offsets) |
| if (V.expect_fatal == Fatal::No) { |
| affine::Ratio ratio{ V.N, V.D }; |
| affine::Transform transform{ V.a_offset, V.b_offset, ratio }; |
| |
| ASSERT_EQ(transform.a_offset(), V.a_offset); |
| ASSERT_EQ(transform.b_offset(), V.b_offset); |
| ASSERT_EQ(transform.numerator(), ratio.numerator()); |
| ASSERT_EQ(transform.denominator(), ratio.denominator()); |
| ASSERT_TRUE(transform.ratio() == ratio); |
| } else { |
| ASSERT_DEATH(([&V]() { affine::Transform transform{ V.a_offset, |
| V.b_offset, |
| affine::Ratio{V.N, V.D} }; |
| })); |
| } |
| } |
| } |
| |
| TEST(TransformTestCase, Equality) { |
| enum class Expected { Same = 0, Different }; |
| |
| struct TestVector { |
| affine::Transform transform; |
| Expected expected; |
| }; |
| |
| const std::array TEST_VECTORS { |
| TestVector{ { 10, 20, {1, 4}}, Expected::Same }, |
| TestVector{ { 10, 20, {1, 4}}, Expected::Same }, |
| TestVector{ { 10, 20, {2, 8}}, Expected::Same }, |
| TestVector{ { 10, 20, {1, 5}}, Expected::Different }, |
| TestVector{ { 11, 20, {1, 4}}, Expected::Different }, |
| TestVector{ { 10, 19, {1, 4}}, Expected::Different }, |
| }; |
| |
| for (const auto& a : TEST_VECTORS) { |
| for (const auto& b : TEST_VECTORS) { |
| // These test vectors should match if they are both in the "same" |
| // class, or if they are literally the same test vector. |
| if ((&a == &b) || ((a.expected == Expected::Same) && (b.expected == Expected::Same))) { |
| ASSERT_TRUE (a.transform == b.transform); |
| ASSERT_FALSE(a.transform != b.transform); |
| } else { |
| ASSERT_FALSE(a.transform == b.transform); |
| ASSERT_TRUE (a.transform != b.transform); |
| } |
| } |
| } |
| } |
| |
| TEST(TransformTestCase, Inverse) { |
| struct TestVector { |
| int64_t a_offset, b_offset; |
| uint32_t N, D; |
| }; |
| |
| constexpr std::array TEST_VECTORS { |
| TestVector{ 12345, 98764, 3, 2 }, |
| TestVector{ -12345, 98764, 247, 931 }, |
| TestVector{ -12345, -98764, 48000, 44100 }, |
| TestVector{ 12345, -98764, 1000007, 1000000 }, |
| TestVector{ 12345, 98764, 0, 1000000 }, |
| }; |
| |
| for (const auto& V : TEST_VECTORS) { |
| affine::Ratio ratio{ V.N, V.D }; |
| affine::Transform transform{ V.a_offset, V.b_offset, ratio }; |
| |
| if (transform.invertible()) { |
| affine::Transform res = transform.Inverse(); |
| ASSERT_EQ(transform.a_offset(), res.b_offset()); |
| ASSERT_EQ(transform.b_offset(), res.a_offset()); |
| ASSERT_EQ(transform.numerator(), res.denominator()); |
| ASSERT_EQ(transform.denominator(), res.numerator()); |
| ASSERT_TRUE(transform.ratio().Inverse() == res.ratio()); |
| } else { |
| ASSERT_DEATH(([&transform]() { transform.Inverse(); })); |
| } |
| } |
| } |
| |
| TEST(TransformTestCase, Apply) { |
| using Transform = affine::Transform; |
| using Saturate = affine::Transform::Saturate; |
| |
| enum class Method { Static = 0, Object, Operator }; |
| enum class Ovfl { No = 0, Yes }; |
| |
| struct TestVector { |
| int64_t a_offset, b_offset; |
| uint32_t N, D; |
| int64_t val; |
| int64_t expected; |
| Ovfl expect_ovfl; |
| }; |
| |
| constexpr int64_t kMinI64 = std::numeric_limits<int64_t>::min(); |
| constexpr int64_t kMaxI64 = std::numeric_limits<int64_t>::max(); |
| constexpr std::array TEST_VECTORS { |
| TestVector{ 0, 0, 1, 1, 12345, 12345, Ovfl::No }, |
| TestVector{ 50, 0, 1, 1, 12345, 12295, Ovfl::No }, |
| TestVector{ 0, -50, 1, 1, 12345, 12295, Ovfl::No }, |
| TestVector{ 50, -50, 1, 1, 12345, 12245, Ovfl::No }, |
| TestVector{ 50, 50, 1, 1, 12345, 12345, Ovfl::No }, |
| |
| TestVector{ 0, 0, 48000, 44100, 12345, 13436, Ovfl::No }, |
| TestVector{ 50, 0, 48000, 44100, 12345, 13382, Ovfl::No }, |
| TestVector{ 0, -54, 48000, 44100, 12345, 13382, Ovfl::No }, |
| TestVector{ 50, -54, 48000, 44100, 12345, 13328, Ovfl::No }, |
| TestVector{ 50, 54, 48000, 44100, 12345, 13436, Ovfl::No }, |
| |
| // Overflow/underflow during the A_offset stage. |
| TestVector{ -100, -17, 1, 1, kMaxI64 - 1, kMaxI64 - 17, Ovfl::Yes }, |
| TestVector{ 100, 17, 1, 1, kMinI64 + 1, kMinI64 + 17, Ovfl::Yes }, |
| |
| // Overflow/underflow during the Scaling stage. |
| TestVector{ 0, -17, 3, 1, kMaxI64 / 2, kMaxI64 - 17, Ovfl::Yes }, |
| TestVector{ 0, 17, 3, 1, kMinI64 / 2, kMinI64 + 17, Ovfl::Yes }, |
| |
| // Overflow/underflow during the B_offset stage. |
| TestVector{ 0, 17, 1, 1, kMaxI64 - 10, kMaxI64, Ovfl::Yes }, |
| TestVector{ 0, -17, 1, 1, kMinI64 + 10, kMinI64, Ovfl::Yes }, |
| }; |
| |
| constexpr std::array METHODS { |
| Method::Static, |
| Method::Object, |
| Method::Operator, |
| }; |
| |
| for (const auto& V : TEST_VECTORS) { |
| for (auto method : METHODS) { |
| // Test the forward transformation |
| Transform T{ V.a_offset, V.b_offset, { V.N, V.D } }; |
| int64_t res_sat, res_nosat; |
| |
| switch (method) { |
| case Method::Static: |
| res_sat = Transform::Apply(T.a_offset(), T.b_offset(), T.ratio(), V.val); |
| res_nosat = Transform::Apply<Saturate::No>(T.a_offset(), |
| T.b_offset(), |
| T.ratio(), |
| V.val); |
| break; |
| |
| case Method::Object: |
| res_sat = T.Apply(V.val); |
| res_nosat = T.Apply<Saturate::No>(V.val); |
| break; |
| |
| case Method::Operator: |
| res_sat = T(V.val); |
| res_nosat = T.operator()<Saturate::No>(V.val); |
| break; |
| } |
| |
| auto CheckExpected = [&](int64_t actual, |
| const TestVector& V, |
| const Transform& T, |
| Method method) { |
| ASSERT_EQ(actual, V.expected, |
| "((%ld - %ld) * (%u/%u)) + %ld should be %ld; " |
| "got %ld instead (method %u)\n", |
| V.val, |
| T.a_offset(), |
| T.numerator(), |
| T.denominator(), |
| T.b_offset(), |
| V.expected, |
| actual, |
| static_cast<uint32_t>(method)); |
| |
| }; |
| |
| // Make sure the saturated result matches our expectations. |
| CheckExpected(res_sat, V, T, method); |
| |
| // If we don't expect this test vector to overflow, then check to |
| // make sure that the non-saturated result matches the saturated |
| // result. |
| if (V.expect_ovfl == Ovfl::No) { |
| CheckExpected(res_nosat, V, T, method); |
| } |
| |
| // Test inverse transformations operations, but only if the |
| // transformation is invertible. Otherwise test for death. |
| fit::function<void()> func_sat; |
| fit::function<void()> func_nosat; |
| switch (method) { |
| case Method::Static: |
| func_sat = [&T, &V, &res_sat]() { |
| if (T.invertible()) { |
| auto T_inv = T.Inverse(); |
| res_sat = Transform::ApplyInverse( |
| T_inv.a_offset(), T_inv.b_offset(), T_inv.ratio(), V.val); |
| } else { |
| Transform::ApplyInverse( |
| T.a_offset(), T.b_offset(), T.ratio(), V.val); |
| } |
| }; |
| |
| func_nosat = [&T, &V, &res_nosat]() { |
| if (T.invertible()) { |
| auto T_inv = T.Inverse(); |
| res_nosat = Transform::ApplyInverse<Saturate::No>( |
| T_inv.a_offset(), T_inv.b_offset(), T_inv.ratio(), V.val); |
| } else { |
| Transform::ApplyInverse<Saturate::No>( |
| T.a_offset(), T.b_offset(), T.ratio(), V.val); |
| } |
| }; |
| break; |
| |
| case Method::Object: |
| func_sat = [&T, &V, &res_sat]() { |
| if (T.invertible()) { |
| auto T_inv = T.Inverse(); |
| res_sat = T_inv.ApplyInverse(V.val); |
| } else { |
| T.ApplyInverse(V.val); |
| } |
| }; |
| |
| func_nosat = [&T, &V, &res_nosat]() { |
| if (T.invertible()) { |
| auto T_inv = T.Inverse(); |
| res_nosat = T_inv.ApplyInverse<Saturate::No>(V.val); |
| } else { |
| T.ApplyInverse<Saturate::No>(V.val); |
| } |
| }; |
| break; |
| |
| // Note: that the functor operator method has no inverse, so we skip |
| // the test in that case. |
| case Method::Operator: |
| continue; |
| } |
| |
| if (T.invertible()) { |
| func_sat(); |
| CheckExpected(res_sat, V, T, method); |
| |
| if (V.expect_ovfl == Ovfl::No) { |
| CheckExpected(res_nosat, V, T, method); |
| } |
| } else { |
| auto CheckDeath = [](fit::function<void()> func, |
| const TestVector& V, |
| const Transform& T, |
| Method method) { |
| ASSERT_DEATH(std::move(func), |
| "((%ld - %ld) * (%u/%u)) + %ld should have resulted in death " |
| "(method %u)\n", |
| V.val, |
| T.a_offset(), |
| T.numerator(), |
| T.denominator(), |
| T.b_offset(), |
| static_cast<uint32_t>(method)); |
| }; |
| CheckDeath(std::move(func_sat), V, T, method); |
| CheckDeath(std::move(func_nosat), V, T, method); |
| } |
| } |
| } |
| } |
| |
| TEST(TransformTestCase, Compose) { |
| using Transform = affine::Transform; |
| |
| enum class Method { Static = 0, Operator }; |
| enum class Exact { No = 0, Yes }; |
| |
| constexpr int64_t kMinI64 = std::numeric_limits<int64_t>::min(); |
| constexpr int64_t kMaxI64 = std::numeric_limits<int64_t>::max(); |
| |
| struct TestVector { |
| Transform ab; |
| Transform bc; |
| Transform ac; |
| Exact is_exact; |
| }; |
| |
| // TODO(johngro) : If we ever make the Ratio/Transform constructors |
| // constexpr, then come back and make this constexpr. Right now, they are |
| // not because of the automatic reduction behavior of the Ratio constructor. |
| const std::array TEST_VECTORS { |
| // Identity(Identity(a)) == Identity(a) |
| TestVector{ |
| { 0, 0, { 1, 1 } }, |
| { 0, 0, { 1, 1 } }, |
| { 0, 0, { 1, 1 } }, |
| Exact::Yes |
| }, |
| |
| // F(Identity(a)) == F(a) |
| // |
| // TODO(MTWN-6): Note that this does not currently produce the exact |
| // same result, or even an equivalent result. The intermediate offset |
| // of the composition of bc(ab(a)) is -12345, and the current |
| // composition implementation always attempts to move this to the |
| // b_offset side of the composed function. In this case, that means |
| // running the -12345 through the 17/7 ratio, which results in some |
| // offset rounding error. For now, however, this is the expected |
| // behavior of the current implementation. If/when MTWN-6 is resolved, |
| // this test vector will start to fail and will need to be updated. |
| TestVector{ |
| { 0, 0, { 1, 1 } }, |
| { 12345, 98765, { 17, 7 } }, |
| { 0, 68784, { 17, 7 } }, |
| Exact::Yes |
| }, |
| |
| // Identity(F(a)) == F(a) |
| TestVector{ |
| { 12345, 98765, { 17, 7 } }, |
| { 0, 0, { 1, 1 } }, |
| { 12345, 98765, { 17, 7 } }, |
| Exact::Yes |
| }, |
| |
| // A moderately complicated example, but still an exact one. |
| // BC(AB(a)) == AC(a) |
| TestVector{ |
| { 34327, 86539, { 1000007, 1000000 } }, |
| { 728376, -34265, { 48000, 44100 } }, |
| { 34327, -732864, { 1000007, 918750 } }, |
| Exact::Yes |
| }, |
| |
| // Overflow saturation of the intermediate offset before distribution. |
| TestVector{ |
| { 0, kMaxI64 - 5, { 1, 1 } }, |
| { -100, 0, { 1, 1 } }, |
| { 0, kMaxI64, { 1, 1 } }, |
| Exact::Yes |
| }, |
| |
| // Underflow saturation of the intermediate offset before distribution. |
| TestVector{ |
| { 0, kMinI64 + 5, { 1, 1 } }, |
| { 100, 0, { 1, 1 } }, |
| { 0, kMinI64, { 1, 1 } }, |
| Exact::Yes |
| }, |
| |
| // Overflow saturation AC.b_offset after distribution. |
| TestVector{ |
| { 0, 100, { 1, 1 } }, |
| { 0, kMaxI64 - 5, { 1, 1 } }, |
| { 0, kMaxI64, { 1, 1 } }, |
| Exact::Yes |
| }, |
| |
| // Underflow saturation AC.b_offset after distribution. |
| TestVector{ |
| { 0, -100, { 1, 1 } }, |
| { 0, kMinI64 + 5, { 1, 1 } }, |
| { 0, kMinI64, { 1, 1 } }, |
| Exact::Yes |
| }, |
| |
| // TODO(MTWN-6): Right now, it is impossible to under/overflow saturate |
| // the AC.a_offset side of the composed function, because the current |
| // implementation always distributes the intermediate offset entirely to |
| // the C side of the equation. When this changes, we need to add test |
| // vectors to make sure that these cases behave properly. |
| |
| // Composition of the ratio which requires a loss of precision. Note |
| // that these fractions were taken from the Ratio tests. Each numerator |
| // and denominator is made up of 3 prime numbers, none of them in |
| // common. |
| TestVector{ |
| { 0, 0, { 3465653567, 2327655023 } }, |
| { 0, 0, { 1291540343, 3698423317 } }, |
| { 0, 0, { 317609835, 610852072 } }, |
| Exact::No |
| }, |
| |
| // Same idea, but this time, include an intermediate offset. The offset |
| // should be distributed before the ratios are combined, resulting in no |
| // loss of precision (in this specific case) of the intermediate |
| // distribution. |
| TestVector{ |
| { 0, 20, { 3465653567, 2327655023 } }, |
| { -3698423317 + 20, 5, { 1291540343, 3698423317 } }, |
| { 0, 1291540343 + 5, { 317609835, 610852072 } }, |
| Exact::No |
| }, |
| }; |
| |
| constexpr std::array METHODS { |
| Method::Static, |
| Method::Operator, |
| }; |
| |
| for (const auto& V : TEST_VECTORS) { |
| for (auto method : METHODS) { |
| fit::function<void()> func; |
| Transform result; |
| |
| switch (method) { |
| case Method::Static: |
| func = [&result, &V]() { result = Transform::Compose(V.bc, V.ab); }; |
| break; |
| case Method::Operator: |
| func = [&result, &V]() { result = V.bc * V.ab; }; |
| break; |
| } |
| |
| auto VerifyResult = [](const TestVector& V, const Transform& result, Method method) { |
| ASSERT_TRUE(result == V.ac, |
| "[ %ld : %u/%u : %ld ] <--> [ %ld : %u/%u : %ld ] should produce " |
| "[ %ld : %u/%u : %ld ] ; got [ %ld : %u/%u : %ld ] instead (method %u)", |
| V.ab.a_offset(), V.ab.numerator(), V.ab.denominator(), V.ab.b_offset(), |
| V.bc.a_offset(), V.bc.numerator(), V.bc.denominator(), V.bc.b_offset(), |
| V.ac.a_offset(), V.ac.numerator(), V.ac.denominator(), V.ac.b_offset(), |
| result.a_offset(), result.numerator(), result.denominator(), |
| result.b_offset(), static_cast<uint32_t>(method)); |
| }; |
| |
| // If the composition is expected to produce an exact result, then |
| // compute and validate the result. Otherwise, assert that the |
| // composition operation produces death as expected. |
| if (V.is_exact == Exact::Yes) { |
| func(); |
| VerifyResult(V, result, method); |
| } else { |
| ASSERT_DEATH(std::move(func), "Expected death during composition : " |
| "[ %ld : %u/%u : %ld ] <--> [ %ld : %u/%u : %ld ] (method %u)", |
| V.ab.a_offset(), V.ab.numerator(), V.ab.denominator(), V.ab.b_offset(), |
| V.bc.a_offset(), V.bc.numerator(), V.bc.denominator(), V.bc.b_offset(), |
| static_cast<uint32_t>(method)); |
| } |
| |
| // If this is not the operator form of composition, test the inexact |
| // version of composition. The expected result in the test vector |
| // should match the inexact result. |
| if (method == Method::Static) { |
| result = Transform::Compose(V.bc, V.ab, Transform::Exact::No); |
| VerifyResult(V, result, method); |
| } |
| } |
| } |
| } |
