From 84a724a13ad00f27637a50ed4dcb5f188fd34805 Mon Sep 17 00:00:00 2001 From: Stefano Galarraga Date: Wed, 15 Apr 2020 13:59:00 +0100 Subject: Fix failures in TensorRankConstraint Tests Fix sporadic failures in CtsNNAPITestCases.TensorRankConstraint tests. Improves description of expectation failures when comparing OperandTypeWithExtraParams instances. Test: CtsNNAPITestCases Bug: 154093710 Change-Id: Ia2b8bc914892f2ff7908d247fa26743fa242f783 --- nn/runtime/test/TestValidateOperations.cpp | 289 ++++++++++++++++------------- 1 file changed, 163 insertions(+), 126 deletions(-) (limited to 'nn') diff --git a/nn/runtime/test/TestValidateOperations.cpp b/nn/runtime/test/TestValidateOperations.cpp index 4e4cc950c..7748acd45 100644 --- a/nn/runtime/test/TestValidateOperations.cpp +++ b/nn/runtime/test/TestValidateOperations.cpp @@ -25,6 +25,7 @@ #include #include #include +#include #include #include #include @@ -640,32 +641,49 @@ class OperationTestBase { std::vector mInputRankMutators; }; -MATCHER_P2(IsMutationWithDimensions, origin, expectedDims, "") { - OperandTypeWithExtraParams expectedWithoutDims = origin; - expectedWithoutDims.operandType.dimensionCount = 0; - expectedWithoutDims.operandType.dimensions = nullptr; - OperandTypeWithExtraParams actualWithoutDims = arg; - actualWithoutDims.operandType.dimensionCount = 0; - actualWithoutDims.operandType.dimensions = nullptr; - - if ((expectedWithoutDims != actualWithoutDims) || - (arg.operandType.dimensionCount != expectedDims.size())) { - return false; +std::ostream& operator<<(std::ostream& os, const OperandTypeWithExtraParams& operand) { + const auto& operandType = operand.operandType; + os << "{ operand_type: { type: " << operandType.type << ", " + << "dimensionCount: " << operandType.dimensionCount << ", dimensions: ["; + std::for_each(operandType.dimensions, operandType.dimensions + operandType.dimensionCount, + [&os](uint32_t dimension) { os << dimension << ", "; }); + os << "], scale: " << operandType.scale << ", zeroPoint: " << operandType.zeroPoint << " }"; + + const auto& channelQuant = operand.channelQuant; + if (channelQuant.has_value()) { + os << ", channelQuant { channelDim: " << channelQuant->channelDim + << ", scaleCount: " << channelQuant->scaleCount << ", scales: ["; + std::for_each(channelQuant->scales, channelQuant->scales + channelQuant->scaleCount, + [&os](float scale) { os << scale << ", "; }); + os << "] }"; + } else { + os << ", channelQuant: nullopt"; } + os << "}"; + return os; +} - if (expectedDims.size() > 0) { - if (!arg.operandType.dimensions || arg.operandType.dimensionCount != expectedDims.size()) { - return false; - } - std::vector actualDims( - arg.operandType.dimensions, - arg.operandType.dimensions + arg.operandType.dimensionCount); - - bool result = std::equal(actualDims.begin(), actualDims.end(), expectedDims.begin()); - return result; +inline OperandTypeWithExtraParams MutationWithDimensions( + const OperandTypeWithExtraParams& origin, const std::vector& expectedDims) { + OperandTypeWithExtraParams expected = origin; + expected.operandType.dimensionCount = expectedDims.size(); + if (expectedDims.size() == 0) { + expected.operandType.dimensions = nullptr; } else { - return arg.operandType.dimensions == nullptr; + expected.operandType.dimensions = expectedDims.data(); } + return expected; +} +std::string DescribeMutationWithDimensions(const OperandTypeWithExtraParams& origin, + const std::vector& expectedDims) { + std::ostringstream osstream; + osstream << MutationWithDimensions(origin, expectedDims); + return osstream.str(); +} + +MATCHER_P2(IsMutationWithDimensions, origin, expectedDims, + DescribeMutationWithDimensions(origin, expectedDims)) { + return arg == MutationWithDimensions(origin, expectedDims); } TEST(TensorRankConstraint, ExactlyWillReturnSameInputAsValidMutation) { @@ -676,11 +694,13 @@ TEST(TensorRankConstraint, ExactlyWillReturnSameInputAsValidMutation) { .dimensions = opDimensions, }}; - auto validMutationSet = TensorRankConstraint::Exactly(3).MutationsWithValidRank({operand}); + auto constraint = TensorRankConstraint::Exactly(3); + auto validMutationSet = constraint.MutationsWithValidRank({operand}); ASSERT_EQ(validMutationSet.size(), 1u); auto validMutations = *validMutationSet.begin(); ASSERT_EQ(validMutations.size(), 1u); - EXPECT_THAT(validMutations[0], IsMutationWithDimensions(operand, std::vector({2, 2, 2}))); + EXPECT_THAT(validMutations[0], + IsMutationWithDimensions(operand, std::vector({2, 2, 2}))); }; TEST(TensorRankConstraint, ExactlyWillFailIfValidInputHasInvalidSize) { @@ -702,20 +722,22 @@ TEST(TensorRankConstraint, ExactlyWillReturnTwoInvalidMutationsWithLowerAndHighe .dimensions = opDimensions, }}; - auto invalidMutations = TensorRankConstraint::Exactly(3).MutationsWithInvalidRank({operand}); + auto constraint = TensorRankConstraint::Exactly(3); + auto invalidMutations = constraint.MutationsWithInvalidRank({operand}); ASSERT_EQ(invalidMutations.size(), 2u); - std::for_each( - invalidMutations.begin(), invalidMutations.end(), - [&operand](const std::vector& mutations) { - EXPECT_EQ(mutations.size(), 1u); - if (mutations.size() == 1) { - EXPECT_THAT( - mutations[0], - ::testing::AnyOf( - IsMutationWithDimensions(operand, std::vector({2, 2})), - IsMutationWithDimensions(operand, std::vector({2, 2, 2, 1})))); - } - }); + std::for_each(invalidMutations.begin(), invalidMutations.end(), + [&operand](const std::vector& mutations) { + EXPECT_EQ(mutations.size(), 1u); + if (mutations.size() == 1) { + EXPECT_THAT( + mutations[0], + ::testing::AnyOf( + IsMutationWithDimensions(operand, + std::vector({2, 2})), + IsMutationWithDimensions( + operand, std::vector({2, 2, 2, 1})))); + } + }); }; TEST(TensorRankConstraint, AtLeastWillReturnTwoValidMutationsAboveThreshold) { @@ -726,20 +748,22 @@ TEST(TensorRankConstraint, AtLeastWillReturnTwoValidMutationsAboveThreshold) { .dimensions = opDimensions, }}; - auto invalidMutations = TensorRankConstraint::AtLeast(1).MutationsWithValidRank( - {(OperandTypeWithExtraParams)operand}); + auto constraint = TensorRankConstraint::AtLeast(1); + auto invalidMutations = + constraint.MutationsWithValidRank({(OperandTypeWithExtraParams)operand}); ASSERT_EQ(invalidMutations.size(), 2u); - std::for_each(invalidMutations.begin(), invalidMutations.end(), - [&operand](const std::vector& mutations) { - EXPECT_EQ(mutations.size(), 1u); - if (mutations.size() == 1) { - EXPECT_THAT( - mutations[0], - ::testing::AnyOf( - IsMutationWithDimensions(operand, std::vector({2})), - IsMutationWithDimensions(operand, std::vector({2, 2})))); - } - }); + std::for_each( + invalidMutations.begin(), invalidMutations.end(), + [&operand](const std::vector& mutations) { + EXPECT_EQ(mutations.size(), 1u); + if (mutations.size() == 1) { + EXPECT_THAT(mutations[0], + ::testing::AnyOf(IsMutationWithDimensions( + operand, std::vector({2})), + IsMutationWithDimensions( + operand, std::vector({2, 2})))); + } + }); } TEST(TensorRankConstraint, AtLeastWillReturnOneInvalidMutationsBelowThreshold) { @@ -750,12 +774,14 @@ TEST(TensorRankConstraint, AtLeastWillReturnOneInvalidMutationsBelowThreshold) { .dimensions = opDimensions, }}; - auto invalidMutations = TensorRankConstraint::AtLeast(2).MutationsWithInvalidRank( - {(OperandTypeWithExtraParams)operand}); + auto constraint = TensorRankConstraint::AtLeast(2); + auto invalidMutations = + constraint.MutationsWithInvalidRank({(OperandTypeWithExtraParams)operand}); ASSERT_EQ(invalidMutations.size(), 1u); auto invalidMutationVector = *invalidMutations.begin(); ASSERT_EQ(invalidMutationVector.size(), 1u); - ASSERT_THAT(invalidMutationVector[0], IsMutationWithDimensions(operand, std::vector({2}))); + ASSERT_THAT(invalidMutationVector[0], + IsMutationWithDimensions(operand, std::vector({2}))); } TEST(TensorRankConstraint, AtLeastWillReturnNoInvalidMutationsIfThresholdIs1) { @@ -766,8 +792,9 @@ TEST(TensorRankConstraint, AtLeastWillReturnNoInvalidMutationsIfThresholdIs1) { .dimensions = opDimensions, }}; - auto invalidMutations = TensorRankConstraint::AtLeast(1).MutationsWithInvalidRank( - {(OperandTypeWithExtraParams)operand}); + auto constraint = TensorRankConstraint::AtLeast(1); + auto invalidMutations = + constraint.MutationsWithInvalidRank({(OperandTypeWithExtraParams)operand}); ASSERT_EQ(invalidMutations.size(), 0u); } @@ -779,21 +806,24 @@ TEST(TensorRankConstraint, UpToWillReturnUpToTwoValidMutationsBelowThreshold) { .dimensions = opDimensions, }}; - auto invalidMutations = TensorRankConstraint::UpTo(3).MutationsWithValidRank( - {(OperandTypeWithExtraParams)operand}); + auto constraint = TensorRankConstraint::UpTo(3); + auto invalidMutations = + constraint.MutationsWithValidRank({(OperandTypeWithExtraParams)operand}); + + auto expected = std::vector({7, 7}); ASSERT_EQ(invalidMutations.size(), 2u); - std::for_each( - invalidMutations.begin(), invalidMutations.end(), - [&operand](const std::vector& mutations) { - EXPECT_EQ(mutations.size(), 1u); - if (mutations.size() == 1) { - EXPECT_THAT( - mutations[0], - ::testing::AnyOf( - IsMutationWithDimensions(operand, std::vector({2})), - IsMutationWithDimensions(operand, std::vector({2, 2, 2})))); - } - }); + std::for_each(invalidMutations.begin(), invalidMutations.end(), + [&operand](const std::vector& mutations) { + EXPECT_EQ(mutations.size(), 1u); + if (mutations.size() == 1) { + EXPECT_THAT(mutations[0], + ::testing::AnyOf( + IsMutationWithDimensions(operand, + std::vector({2})), + IsMutationWithDimensions( + operand, std::vector({2, 2, 1})))); + } + }); } TEST(TensorRankConstraint, UpToWillReturnOneInvalidMutationsAboveThreshold) { @@ -804,13 +834,14 @@ TEST(TensorRankConstraint, UpToWillReturnOneInvalidMutationsAboveThreshold) { .dimensions = opDimensions, }}; - auto invalidMutations = TensorRankConstraint::UpTo(3).MutationsWithInvalidRank( - {(OperandTypeWithExtraParams)operand}); + auto constraint = TensorRankConstraint::UpTo(3); + auto invalidMutations = + constraint.MutationsWithInvalidRank({(OperandTypeWithExtraParams)operand}); ASSERT_EQ(invalidMutations.size(), 1u); auto invalidMutationVector = *invalidMutations.begin(); ASSERT_EQ(invalidMutationVector.size(), 1u); ASSERT_THAT(invalidMutationVector[0], - IsMutationWithDimensions(operand, std::vector({2, 2, 2, 1}))); + IsMutationWithDimensions(operand, std::vector({2, 2, 2, 1}))); } TEST(TensorRankConstraint, BetweenWillReturnTwoValidMutationsOnRangeBoundaries) { @@ -821,8 +852,8 @@ TEST(TensorRankConstraint, BetweenWillReturnTwoValidMutationsOnRangeBoundaries) .dimensions = opDimensions, }}; - auto validMutations = TensorRankConstraint::Between(2, 4).MutationsWithValidRank( - {(OperandTypeWithExtraParams)operand}); + auto constraint = TensorRankConstraint::Between(2, 4); + auto validMutations = constraint.MutationsWithValidRank({(OperandTypeWithExtraParams)operand}); ASSERT_EQ(validMutations.size(), 2u); std::for_each(validMutations.begin(), validMutations.end(), [&operand](const std::vector& mutations) { @@ -830,10 +861,11 @@ TEST(TensorRankConstraint, BetweenWillReturnTwoValidMutationsOnRangeBoundaries) if (mutations.size() == 1) { EXPECT_THAT( mutations[0], - ::testing::AnyOf(IsMutationWithDimensions( - operand, std::vector({2, 2})), - IsMutationWithDimensions( - operand, std::vector({2, 2, 2, 1})))); + ::testing::AnyOf( + IsMutationWithDimensions(operand, + std::vector({2, 2})), + IsMutationWithDimensions( + operand, std::vector({2, 2, 2, 1})))); } }); } @@ -846,21 +878,23 @@ TEST(TensorRankConstraint, BetweenWillReturnTwoInvValidMutationsAdjacentToRangeB .dimensions = opDimensions, }}; - auto validMutations = TensorRankConstraint::Between(2, 4).MutationsWithInvalidRank( - {(OperandTypeWithExtraParams)operand}); + auto constraint = TensorRankConstraint::Between(2, 4); + auto validMutations = + constraint.MutationsWithInvalidRank({(OperandTypeWithExtraParams)operand}); ASSERT_EQ(validMutations.size(), 2u); - std::for_each(validMutations.begin(), validMutations.end(), - [&operand](const std::vector& mutations) { - EXPECT_EQ(mutations.size(), 1u); - if (mutations.size() == 1) { - EXPECT_THAT( - mutations[0], - ::testing::AnyOf(IsMutationWithDimensions( - operand, std::vector({2})), - IsMutationWithDimensions( - operand, std::vector({2, 2, 2, 1, 1})))); - } - }); + std::for_each( + validMutations.begin(), validMutations.end(), + [&operand](const std::vector& mutations) { + EXPECT_EQ(mutations.size(), 1u); + if (mutations.size() == 1) { + EXPECT_THAT( + mutations[0], + ::testing::AnyOf( + IsMutationWithDimensions(operand, std::vector({2})), + IsMutationWithDimensions( + operand, std::vector({2, 2, 2, 1, 1})))); + } + }); } TEST(TensorRankConstraint, BetweenWillReturnOneInvalidMutationsOnlyIfLowerBoundIs1) { @@ -871,13 +905,14 @@ TEST(TensorRankConstraint, BetweenWillReturnOneInvalidMutationsOnlyIfLowerBoundI .dimensions = opDimensions, }}; - auto invalidMutations = TensorRankConstraint::Between(1, 4).MutationsWithInvalidRank( - {(OperandTypeWithExtraParams)operand}); + auto constraint = TensorRankConstraint::Between(1, 4); + auto invalidMutations = + constraint.MutationsWithInvalidRank({(OperandTypeWithExtraParams)operand}); ASSERT_EQ(invalidMutations.size(), 1u); auto invalidMutationVector = *invalidMutations.begin(); ASSERT_EQ(invalidMutationVector.size(), 1u); ASSERT_THAT(invalidMutationVector[0], - IsMutationWithDimensions(operand, std::vector({2, 2, 2, 1, 1}))); + IsMutationWithDimensions(operand, std::vector({2, 2, 2, 1, 1}))); } TEST(TensorRankMutator, AppliesConstraintToInputsAtGivenInputsToGenerateValidMutations) { @@ -903,28 +938,29 @@ TEST(TensorRankMutator, AppliesConstraintToInputsAtGivenInputsToGenerateValidMut const auto mutationSet = mutator.ValidInputsMutations({operand0, operand1, operand2}); ASSERT_EQ(mutationSet.size(), 2u); - std::for_each( - mutationSet.begin(), mutationSet.end(), - [&](const std::vector& mutatedInputs) { - EXPECT_EQ(mutatedInputs.size(), 3u); - if (mutatedInputs.size() == 3) { - EXPECT_EQ(mutatedInputs[0].operandType.dimensionCount, - mutatedInputs[2].operandType.dimensionCount); - EXPECT_THAT( - mutatedInputs[0], - ::testing::AnyOf( - IsMutationWithDimensions(operand0, std::vector({0, 0})), - IsMutationWithDimensions(operand0, std::vector({0, 0, 1})))); + std::for_each(mutationSet.begin(), mutationSet.end(), + [&](const std::vector& mutatedInputs) { + EXPECT_EQ(mutatedInputs.size(), 3u); + if (mutatedInputs.size() == 3) { + EXPECT_EQ(mutatedInputs[0].operandType.dimensionCount, + mutatedInputs[2].operandType.dimensionCount); + EXPECT_THAT(mutatedInputs[0], + ::testing::AnyOf( + IsMutationWithDimensions( + operand0, std::vector({0, 0})), + IsMutationWithDimensions( + operand0, std::vector({0, 0, 1})))); - EXPECT_EQ(mutatedInputs[1], operand1); + EXPECT_EQ(mutatedInputs[1], operand1); - EXPECT_THAT( - mutatedInputs[2], - ::testing::AnyOf( - IsMutationWithDimensions(operand2, std::vector({2, 2})), - IsMutationWithDimensions(operand2, std::vector({2, 2, 1})))); - } - }); + EXPECT_THAT(mutatedInputs[2], + ::testing::AnyOf( + IsMutationWithDimensions( + operand2, std::vector({2, 2})), + IsMutationWithDimensions( + operand2, std::vector({2, 2, 1})))); + } + }); } TEST(TensorRankMutator, AppliesConstraintToInputsAtGivenInputsToGenerateInvalidMutations) { @@ -950,19 +986,20 @@ TEST(TensorRankMutator, AppliesConstraintToInputsAtGivenInputsToGenerateInvalidM const auto mutationSet = mutator.InvalidInputsMutations({operand0, operand1, operand2}); ASSERT_EQ(mutationSet.size(), 1u); - std::for_each(mutationSet.begin(), mutationSet.end(), - [&](const std::vector& mutatedInputs) { - EXPECT_EQ(mutatedInputs.size(), 3u); - if (mutatedInputs.size() == 3) { - EXPECT_THAT(mutatedInputs[0], - IsMutationWithDimensions(operand0, std::vector({0}))); + std::for_each( + mutationSet.begin(), mutationSet.end(), + [&](const std::vector& mutatedInputs) { + EXPECT_EQ(mutatedInputs.size(), 3u); + if (mutatedInputs.size() == 3) { + EXPECT_THAT(mutatedInputs[0], + IsMutationWithDimensions(operand0, std::vector({0}))); - EXPECT_EQ(mutatedInputs[1], operand1); + EXPECT_EQ(mutatedInputs[1], operand1); - EXPECT_THAT(mutatedInputs[2], - IsMutationWithDimensions(operand2, std::vector({2}))); - } - }); + EXPECT_THAT(mutatedInputs[2], + IsMutationWithDimensions(operand2, std::vector({2}))); + } + }); } void argMinMaxTest(ANeuralNetworksOperationType operationCode, int32_t inputOperandType) { -- cgit v1.2.3