[llvm] d4d80a2 - Bump googletest to 1.10.0
Hubert Tong via llvm-commits
llvm-commits at lists.llvm.org
Sat May 15 09:56:01 PDT 2021
@benny.kra at gmail.com <benny.kra at googlemail.com>,
This commit is triggering deprecation warnings that cause build failures
for warning-as-errors builds:
clangd/unittests/PrintASTTests.cpp:56:1: error:
'InstantiateTestCase_P_IsDeprecated' is deprecated: INSTANTIATE_TEST_CASE_P
is deprecated, please use INSTANTIATE_TEST_SUITE_P
[-Werror,-Wdeprecated-declarations]
INSTANTIATE_TEST_CASE_P(ASTUtilsTests, ASTUtils,
^
On Fri, May 14, 2021 at 1:17 PM Benjamin Kramer via llvm-commits <
llvm-commits at lists.llvm.org> wrote:
>
> Author: Benjamin Kramer
> Date: 2021-05-14T19:16:31+02:00
> New Revision: d4d80a2903c1d074008cac653cdb0b5fe39b8a00
>
> URL:
> https://github.com/llvm/llvm-project/commit/d4d80a2903c1d074008cac653cdb0b5fe39b8a00
> DIFF:
> https://github.com/llvm/llvm-project/commit/d4d80a2903c1d074008cac653cdb0b5fe39b8a00.diff
>
> LOG: Bump googletest to 1.10.0
>
> Added:
> llvm/utils/unittest/googlemock/include/gmock/gmock-function-mocker.h
> llvm/utils/unittest/googlemock/include/gmock/gmock-nice-strict.h
> llvm/utils/unittest/googlemock/include/gmock/internal/gmock-pp.h
> llvm/utils/unittest/googletest/include/gtest/gtest-matchers.h
> llvm/utils/unittest/googletest/src/gtest-matchers.cc
>
> Modified:
> clang/unittests/AST/ASTImporterGenericRedeclTest.cpp
> clang/unittests/AST/ASTImporterODRStrategiesTest.cpp
> clang/unittests/AST/ASTImporterObjCTest.cpp
> clang/unittests/AST/ASTImporterTest.cpp
> clang/unittests/AST/ASTImporterVisibilityTest.cpp
> clang/unittests/ASTMatchers/ASTMatchersNodeTest.cpp
> clang/unittests/Analysis/ExprMutationAnalyzerTest.cpp
> clang/unittests/Rename/RenameAliasTest.cpp
> clang/unittests/Rename/RenameClassTest.cpp
> clang/unittests/Rename/RenameEnumTest.cpp
> clang/unittests/Rename/RenameMemberTest.cpp
> clang/unittests/StaticAnalyzer/RangeSetTest.cpp
> clang/unittests/Tooling/Syntax/BuildTreeTest.cpp
> clang/unittests/Tooling/Syntax/MutationsTest.cpp
> clang/unittests/Tooling/Syntax/SynthesisTest.cpp
> clang/unittests/Tooling/Syntax/TreeTest.cpp
> flang/unittests/RuntimeGTest/ListInputTest.cpp
> lldb/unittests/Host/SocketTest.cpp
> lldb/unittests/Process/Utility/LinuxProcMapsTest.cpp
> llvm/include/llvm/Testing/Support/Error.h
> llvm/unittests/ADT/BitVectorTest.cpp
> llvm/unittests/ADT/DenseMapTest.cpp
> llvm/unittests/ADT/DenseSetTest.cpp
> llvm/unittests/ADT/IListBaseTest.cpp
> llvm/unittests/ADT/IntrusiveRefCntPtrTest.cpp
> llvm/unittests/ADT/MapVectorTest.cpp
> llvm/unittests/ADT/PriorityWorklistTest.cpp
> llvm/unittests/ADT/RangeAdapterTest.cpp
> llvm/unittests/ADT/STLForwardCompatTest.cpp
> llvm/unittests/ADT/SmallVectorTest.cpp
> llvm/unittests/ADT/TinyPtrVectorTest.cpp
> llvm/unittests/Analysis/ValueTrackingTest.cpp
> llvm/unittests/CodeGen/DIETest.cpp
> llvm/unittests/DebugInfo/DWARF/DWARFDebugLineTest.cpp
> llvm/unittests/DebugInfo/DWARF/DWARFFormValueTest.cpp
> llvm/unittests/FileCheck/FileCheckTest.cpp
> llvm/unittests/Frontend/OpenMPIRBuilderTest.cpp
> llvm/unittests/IR/PassBuilderCallbacksTest.cpp
> llvm/unittests/IR/PatternMatch.cpp
> llvm/unittests/IR/ValueMapTest.cpp
> llvm/unittests/Passes/PluginsTest.cpp
> llvm/unittests/ProfileData/CoverageMappingTest.cpp
> llvm/unittests/ProfileData/InstrProfTest.cpp
> llvm/unittests/Support/DynamicLibrary/DynamicLibraryTest.cpp
> llvm/unittests/Support/MathExtrasTest.cpp
> llvm/unittests/Support/MemoryTest.cpp
> llvm/unittests/Support/TargetParserTest.cpp
> llvm/unittests/XRay/FDRProducerConsumerTest.cpp
> llvm/unittests/XRay/FDRRecordPrinterTest.cpp
> llvm/unittests/XRay/GraphTest.cpp
> llvm/utils/unittest/googlemock/include/gmock/gmock-actions.h
> llvm/utils/unittest/googlemock/include/gmock/gmock-cardinalities.h
> llvm/utils/unittest/googlemock/include/gmock/gmock-generated-actions.h
>
> llvm/utils/unittest/googlemock/include/gmock/gmock-generated-function-mockers.h
> llvm/utils/unittest/googlemock/include/gmock/gmock-generated-matchers.h
> llvm/utils/unittest/googlemock/include/gmock/gmock-matchers.h
> llvm/utils/unittest/googlemock/include/gmock/gmock-more-actions.h
> llvm/utils/unittest/googlemock/include/gmock/gmock-spec-builders.h
> llvm/utils/unittest/googlemock/include/gmock/gmock.h
>
> llvm/utils/unittest/googlemock/include/gmock/internal/gmock-internal-utils.h
> llvm/utils/unittest/googlemock/include/gmock/internal/gmock-port.h
> llvm/utils/unittest/googlemock/src/gmock-cardinalities.cc
> llvm/utils/unittest/googlemock/src/gmock-internal-utils.cc
> llvm/utils/unittest/googlemock/src/gmock-matchers.cc
> llvm/utils/unittest/googlemock/src/gmock-spec-builders.cc
> llvm/utils/unittest/googlemock/src/gmock.cc
> llvm/utils/unittest/googletest/include/gtest/gtest-death-test.h
> llvm/utils/unittest/googletest/include/gtest/gtest-message.h
> llvm/utils/unittest/googletest/include/gtest/gtest-param-test.h
> llvm/utils/unittest/googletest/include/gtest/gtest-printers.h
> llvm/utils/unittest/googletest/include/gtest/gtest-spi.h
> llvm/utils/unittest/googletest/include/gtest/gtest-test-part.h
> llvm/utils/unittest/googletest/include/gtest/gtest-typed-test.h
> llvm/utils/unittest/googletest/include/gtest/gtest.h
> llvm/utils/unittest/googletest/include/gtest/gtest_pred_impl.h
>
> llvm/utils/unittest/googletest/include/gtest/internal/gtest-death-test-internal.h
> llvm/utils/unittest/googletest/include/gtest/internal/gtest-filepath.h
> llvm/utils/unittest/googletest/include/gtest/internal/gtest-internal.h
>
> llvm/utils/unittest/googletest/include/gtest/internal/gtest-param-util.h
> llvm/utils/unittest/googletest/include/gtest/internal/gtest-port-arch.h
> llvm/utils/unittest/googletest/include/gtest/internal/gtest-port.h
> llvm/utils/unittest/googletest/include/gtest/internal/gtest-string.h
> llvm/utils/unittest/googletest/include/gtest/internal/gtest-type-util.h
> llvm/utils/unittest/googletest/src/gtest-all.cc
> llvm/utils/unittest/googletest/src/gtest-death-test.cc
> llvm/utils/unittest/googletest/src/gtest-filepath.cc
> llvm/utils/unittest/googletest/src/gtest-internal-inl.h
> llvm/utils/unittest/googletest/src/gtest-port.cc
> llvm/utils/unittest/googletest/src/gtest-printers.cc
> llvm/utils/unittest/googletest/src/gtest-test-part.cc
> llvm/utils/unittest/googletest/src/gtest-typed-test.cc
> llvm/utils/unittest/googletest/src/gtest.cc
>
> Removed:
>
> llvm/utils/unittest/googlemock/include/gmock/gmock-generated-nice-strict.h
>
> llvm/utils/unittest/googlemock/include/gmock/internal/gmock-generated-internal-utils.h
>
> llvm/utils/unittest/googletest/include/gtest/internal/gtest-linked_ptr.h
>
> llvm/utils/unittest/googletest/include/gtest/internal/gtest-param-util-generated.h
> llvm/utils/unittest/googletest/include/gtest/internal/gtest-tuple.h
>
>
>
> ################################################################################
> diff --git a/clang/unittests/AST/ASTImporterGenericRedeclTest.cpp
> b/clang/unittests/AST/ASTImporterGenericRedeclTest.cpp
> index 44930b1043e4a..1206fac15d4a2 100644
> --- a/clang/unittests/AST/ASTImporterGenericRedeclTest.cpp
> +++ b/clang/unittests/AST/ASTImporterGenericRedeclTest.cpp
> @@ -417,231 +417,231 @@ struct RedeclChain :
> ASTImporterOptionSpecificTestBase {
> }
> };
>
> -#define ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(BaseTemplate, TypeParam,
> \
> +#define ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(BaseTemplate,
> TypeParam, \
> NamePrefix, TestCase)
> \
> using BaseTemplate##TypeParam = BaseTemplate<TypeParam>;
> \
> TEST_P(BaseTemplate##TypeParam, NamePrefix##TestCase) {
> \
> TypedTest_##TestCase();
> \
> }
>
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(
> RedeclChain, Function, ,
> PrototypeShouldBeImportedAsAPrototypeWhenThereIsNoDefinition)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(
> RedeclChain, Class, ,
> PrototypeShouldBeImportedAsAPrototypeWhenThereIsNoDefinition)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(
> RedeclChain, EnumClass, ,
> PrototypeShouldBeImportedAsAPrototypeWhenThereIsNoDefinition)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(
> RedeclChain, Variable, ,
> PrototypeShouldBeImportedAsAPrototypeWhenThereIsNoDefinition)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(
> RedeclChain, FunctionTemplate, ,
> PrototypeShouldBeImportedAsAPrototypeWhenThereIsNoDefinition)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(
> RedeclChain, ClassTemplate, ,
> PrototypeShouldBeImportedAsAPrototypeWhenThereIsNoDefinition)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(
> RedeclChain, VariableTemplate, ,
> PrototypeShouldBeImportedAsAPrototypeWhenThereIsNoDefinition)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(
> RedeclChain, FunctionTemplateSpec, ,
> PrototypeShouldBeImportedAsAPrototypeWhenThereIsNoDefinition)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(
> RedeclChain, ClassTemplateSpec, ,
> PrototypeShouldBeImportedAsAPrototypeWhenThereIsNoDefinition)
>
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, Function, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain, Function, ,
>
> DefinitionShouldBeImportedAsADefinition)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, Class, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain, Class, ,
>
> DefinitionShouldBeImportedAsADefinition)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, EnumClass, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain, EnumClass, ,
>
> DefinitionShouldBeImportedAsADefinition)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, Variable, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain, Variable, ,
>
> DefinitionShouldBeImportedAsADefinition)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, FunctionTemplate, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain, FunctionTemplate, ,
>
> DefinitionShouldBeImportedAsADefinition)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, ClassTemplate, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain, ClassTemplate, ,
>
> DefinitionShouldBeImportedAsADefinition)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, VariableTemplate, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain, VariableTemplate, ,
>
> DefinitionShouldBeImportedAsADefinition)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain,
> FunctionTemplateSpec, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain,
> FunctionTemplateSpec, ,
>
> DefinitionShouldBeImportedAsADefinition)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, ClassTemplateSpec, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain, ClassTemplateSpec, ,
>
> DefinitionShouldBeImportedAsADefinition)
>
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, Function, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain, Function, ,
>
> ImportPrototypeAfterImportedPrototype)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, Class, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain, Class, ,
>
> ImportPrototypeAfterImportedPrototype)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, EnumClass, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain, EnumClass, ,
>
> ImportPrototypeAfterImportedPrototype)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, Variable, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain, Variable, ,
>
> ImportPrototypeAfterImportedPrototype)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, FunctionTemplate, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain, FunctionTemplate, ,
>
> ImportPrototypeAfterImportedPrototype)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, ClassTemplate, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain, ClassTemplate, ,
>
> ImportPrototypeAfterImportedPrototype)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, VariableTemplate, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain, VariableTemplate, ,
>
> ImportPrototypeAfterImportedPrototype)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain,
> FunctionTemplateSpec, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain,
> FunctionTemplateSpec, ,
>
> ImportPrototypeAfterImportedPrototype)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, ClassTemplateSpec, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain, ClassTemplateSpec, ,
>
> ImportPrototypeAfterImportedPrototype)
>
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, Function, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain, Function, ,
>
> ImportDefinitionAfterImportedPrototype)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, Class, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain, Class, ,
>
> ImportDefinitionAfterImportedPrototype)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, EnumClass, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain, EnumClass, ,
>
> ImportDefinitionAfterImportedPrototype)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, Variable, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain, Variable, ,
>
> ImportDefinitionAfterImportedPrototype)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, FunctionTemplate, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain, FunctionTemplate, ,
>
> ImportDefinitionAfterImportedPrototype)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, ClassTemplate, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain, ClassTemplate, ,
>
> ImportDefinitionAfterImportedPrototype)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, VariableTemplate, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain, VariableTemplate, ,
>
> ImportDefinitionAfterImportedPrototype)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain,
> FunctionTemplateSpec, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain,
> FunctionTemplateSpec, ,
>
> ImportDefinitionAfterImportedPrototype)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, ClassTemplateSpec, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain, ClassTemplateSpec, ,
>
> ImportDefinitionAfterImportedPrototype)
>
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, Function, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain, Function, ,
>
> ImportPrototypeAfterImportedDefinition)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, Class, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain, Class, ,
>
> ImportPrototypeAfterImportedDefinition)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, EnumClass, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain, EnumClass, ,
>
> ImportPrototypeAfterImportedDefinition)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, Variable, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain, Variable, ,
>
> ImportPrototypeAfterImportedDefinition)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, FunctionTemplate, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain, FunctionTemplate, ,
>
> ImportPrototypeAfterImportedDefinition)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, ClassTemplate, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain, ClassTemplate, ,
>
> ImportPrototypeAfterImportedDefinition)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, VariableTemplate, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain, VariableTemplate, ,
>
> ImportPrototypeAfterImportedDefinition)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain,
> FunctionTemplateSpec, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain,
> FunctionTemplateSpec, ,
>
> ImportPrototypeAfterImportedDefinition)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, ClassTemplateSpec, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain, ClassTemplateSpec, ,
>
> ImportPrototypeAfterImportedDefinition)
>
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, Function, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain, Function, ,
> ImportPrototypes)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, Class, ,
> ImportPrototypes)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, EnumClass, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain, Class, ,
> ImportPrototypes)
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain, EnumClass, ,
> ImportPrototypes)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, Variable, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain, Variable, ,
> ImportPrototypes)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, FunctionTemplate, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain, FunctionTemplate, ,
> ImportPrototypes)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, ClassTemplate, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain, ClassTemplate, ,
> ImportPrototypes)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, VariableTemplate, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain, VariableTemplate, ,
> ImportPrototypes)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, ClassTemplateSpec, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain, ClassTemplateSpec, ,
> ImportPrototypes)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain,
> FunctionTemplateSpec, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain,
> FunctionTemplateSpec, ,
> ImportPrototypes)
>
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, Function, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain, Function, ,
> ImportDefinitions)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, Class, ,
> ImportDefinitions)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, EnumClass, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain, Class, ,
> ImportDefinitions)
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain, EnumClass, ,
> ImportDefinitions)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, Variable, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain, Variable, ,
> ImportDefinitions)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, FunctionTemplate, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain, FunctionTemplate, ,
> ImportDefinitions)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, ClassTemplate, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain, ClassTemplate, ,
> ImportDefinitions)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, VariableTemplate, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain, VariableTemplate, ,
> ImportDefinitions)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, ClassTemplateSpec, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain, ClassTemplateSpec, ,
> ImportDefinitions)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain,
> FunctionTemplateSpec, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain,
> FunctionTemplateSpec, ,
> ImportDefinitions)
>
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, Function, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain, Function, ,
> ImportDefinitionThenPrototype)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, Class, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain, Class, ,
> ImportDefinitionThenPrototype)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, EnumClass, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain, EnumClass, ,
> ImportDefinitionThenPrototype)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, Variable, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain, Variable, ,
> ImportDefinitionThenPrototype)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, FunctionTemplate, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain, FunctionTemplate, ,
> ImportDefinitionThenPrototype)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, ClassTemplate, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain, ClassTemplate, ,
> ImportDefinitionThenPrototype)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, VariableTemplate, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain, VariableTemplate, ,
> ImportDefinitionThenPrototype)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain,
> FunctionTemplateSpec, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain,
> FunctionTemplateSpec, ,
> ImportDefinitionThenPrototype)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, ClassTemplateSpec, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain, ClassTemplateSpec, ,
> ImportDefinitionThenPrototype)
>
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, Function, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain, Function, ,
> ImportPrototypeThenDefinition)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, Class, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain, Class, ,
> ImportPrototypeThenDefinition)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, EnumClass, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain, EnumClass, ,
> ImportPrototypeThenDefinition)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, Variable, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain, Variable, ,
> ImportPrototypeThenDefinition)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, FunctionTemplate, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain, FunctionTemplate, ,
> ImportPrototypeThenDefinition)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, ClassTemplate, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain, ClassTemplate, ,
> ImportPrototypeThenDefinition)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, VariableTemplate, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain, VariableTemplate, ,
> ImportPrototypeThenDefinition)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain,
> FunctionTemplateSpec, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain,
> FunctionTemplateSpec, ,
> ImportPrototypeThenDefinition)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, ClassTemplateSpec, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain, ClassTemplateSpec, ,
> ImportPrototypeThenDefinition)
>
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, Function, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain, Function, ,
> WholeRedeclChainIsImportedAtOnce)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, Variable, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain, Variable, ,
> WholeRedeclChainIsImportedAtOnce)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, FunctionTemplate, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain, FunctionTemplate, ,
> WholeRedeclChainIsImportedAtOnce)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, VariableTemplate, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain, VariableTemplate, ,
> WholeRedeclChainIsImportedAtOnce)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain,
> FunctionTemplateSpec, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain,
> FunctionTemplateSpec, ,
> WholeRedeclChainIsImportedAtOnce)
>
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, Function, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain, Function, ,
>
> ImportPrototypeThenProtoAndDefinition)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, Variable, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain, Variable, ,
>
> ImportPrototypeThenProtoAndDefinition)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, FunctionTemplate, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain, FunctionTemplate, ,
>
> ImportPrototypeThenProtoAndDefinition)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, VariableTemplate, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain, VariableTemplate, ,
>
> ImportPrototypeThenProtoAndDefinition)
> -ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain,
> FunctionTemplateSpec, ,
> +ASTIMPORTER_INSTANTIATE_TYPED_TEST_SUITE(RedeclChain,
> FunctionTemplateSpec, ,
>
> ImportPrototypeThenProtoAndDefinition)
>
> -INSTANTIATE_TEST_CASE_P(ParameterizedTests, RedeclChainFunction,
> - DefaultTestValuesForRunOptions, );
> -INSTANTIATE_TEST_CASE_P(ParameterizedTests, RedeclChainClass,
> - DefaultTestValuesForRunOptions, );
> -INSTANTIATE_TEST_CASE_P(ParameterizedTests, RedeclChainEnumClass,
> - DefaultTestValuesForRunOptions, );
> -INSTANTIATE_TEST_CASE_P(ParameterizedTests, RedeclChainVariable,
> - DefaultTestValuesForRunOptions, );
> -INSTANTIATE_TEST_CASE_P(ParameterizedTests, RedeclChainFunctionTemplate,
> - DefaultTestValuesForRunOptions, );
> -INSTANTIATE_TEST_CASE_P(ParameterizedTests, RedeclChainClassTemplate,
> - DefaultTestValuesForRunOptions, );
> -INSTANTIATE_TEST_CASE_P(ParameterizedTests, RedeclChainVariableTemplate,
> - DefaultTestValuesForRunOptions, );
> -INSTANTIATE_TEST_CASE_P(ParameterizedTests,
> RedeclChainFunctionTemplateSpec,
> - DefaultTestValuesForRunOptions, );
> -INSTANTIATE_TEST_CASE_P(ParameterizedTests, RedeclChainClassTemplateSpec,
> - DefaultTestValuesForRunOptions, );
> +INSTANTIATE_TEST_SUITE_P(ParameterizedTests, RedeclChainFunction,
> + DefaultTestValuesForRunOptions);
> +INSTANTIATE_TEST_SUITE_P(ParameterizedTests, RedeclChainClass,
> + DefaultTestValuesForRunOptions);
> +INSTANTIATE_TEST_SUITE_P(ParameterizedTests, RedeclChainEnumClass,
> + DefaultTestValuesForRunOptions);
> +INSTANTIATE_TEST_SUITE_P(ParameterizedTests, RedeclChainVariable,
> + DefaultTestValuesForRunOptions);
> +INSTANTIATE_TEST_SUITE_P(ParameterizedTests, RedeclChainFunctionTemplate,
> + DefaultTestValuesForRunOptions);
> +INSTANTIATE_TEST_SUITE_P(ParameterizedTests, RedeclChainClassTemplate,
> + DefaultTestValuesForRunOptions);
> +INSTANTIATE_TEST_SUITE_P(ParameterizedTests, RedeclChainVariableTemplate,
> + DefaultTestValuesForRunOptions);
> +INSTANTIATE_TEST_SUITE_P(ParameterizedTests,
> RedeclChainFunctionTemplateSpec,
> + DefaultTestValuesForRunOptions);
> +INSTANTIATE_TEST_SUITE_P(ParameterizedTests, RedeclChainClassTemplateSpec,
> + DefaultTestValuesForRunOptions);
>
> } // end namespace ast_matchers
> } // end namespace clang
>
> diff --git a/clang/unittests/AST/ASTImporterODRStrategiesTest.cpp
> b/clang/unittests/AST/ASTImporterODRStrategiesTest.cpp
> index 10cafe5bc6342..eabdfeb03ede2 100644
> --- a/clang/unittests/AST/ASTImporterODRStrategiesTest.cpp
> +++ b/clang/unittests/AST/ASTImporterODRStrategiesTest.cpp
> @@ -382,7 +382,7 @@ struct ODRViolation :
> ASTImporterOptionSpecificTestBase {
> // Define the parametrized tests.
> // ==============================
>
> -#define ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
> \
> +#define ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_SUITE(
> \
> TypeParam, ODRHandlingParam, NamePrefix, TestCase)
> \
> using TypeParam##ODRHandlingParam =
> \
> ODRViolation<TypeParam,
> ASTImporter::ODRHandlingType::ODRHandlingParam>; \
> @@ -392,167 +392,167 @@ struct ODRViolation :
> ASTImporterOptionSpecificTestBase {
>
> // clang-format off
>
> -ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
> +ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_SUITE(
> Function, Liberal, ,
> ImportConflictingDefAfterDef)
> -ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
> +ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_SUITE(
> Typedef, Liberal, ,
> ImportConflictingDefAfterDef)
> -ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
> +ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_SUITE(
> TypedefAlias, Liberal, ,
> ImportConflictingDefAfterDef)
> -ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
> +ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_SUITE(
> Enum, Liberal, ,
> ImportConflictingDefAfterDef)
> -ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
> +ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_SUITE(
> EnumClass, Liberal, ,
> ImportConflictingDefAfterDef)
> -ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
> +ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_SUITE(
> EnumConstant, Liberal, ,
> ImportConflictingDefAfterDef)
> -ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
> +ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_SUITE(
> Class, Liberal, ,
> ImportConflictingDefAfterDef)
> -ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
> +ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_SUITE(
> Variable, Liberal, ,
> ImportConflictingDefAfterDef)
> -ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
> +ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_SUITE(
> ClassTemplate, Liberal, ,
> ImportConflictingDefAfterDef)
> -ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
> +ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_SUITE(
> VarTemplate, Liberal, ,
> ImportConflictingDefAfterDef)
> // Class and variable template specializations/instantiatons are always
> // imported conservatively, because the AST holds the specializations in
> a set,
> // and the key within the set is a hash calculated from the arguments of
> the
> // specialization.
> -ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
> +ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_SUITE(
> ClassTemplateSpec, Liberal, ,
> DontImportConflictingDefAfterDef) // Don't import !!!
> -ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
> +ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_SUITE(
> VarTemplateSpec, Liberal, ,
> DontImportConflictingDefAfterDef) // Don't import !!!
>
> -ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
> +ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_SUITE(
> Function, Conservative, ,
> DontImportConflictingDefAfterDef)
> -ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
> +ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_SUITE(
> Typedef, Conservative, ,
> DontImportConflictingDefAfterDef)
> -ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
> +ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_SUITE(
> TypedefAlias, Conservative, ,
> DontImportConflictingDefAfterDef)
> -ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
> +ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_SUITE(
> Enum, Conservative, ,
> DontImportConflictingDefAfterDef)
> -ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
> +ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_SUITE(
> EnumClass, Conservative, ,
> DontImportConflictingDefAfterDef)
> -ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
> +ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_SUITE(
> EnumConstant, Conservative, ,
> DontImportConflictingDefAfterDef)
> -ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
> +ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_SUITE(
> Class, Conservative, ,
> DontImportConflictingDefAfterDef)
> -ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
> +ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_SUITE(
> Variable, Conservative, ,
> DontImportConflictingDefAfterDef)
> -ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
> +ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_SUITE(
> ClassTemplate, Conservative, ,
> DontImportConflictingDefAfterDef)
> -ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
> +ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_SUITE(
> VarTemplate, Conservative, ,
> DontImportConflictingDefAfterDef)
> -ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
> +ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_SUITE(
> ClassTemplateSpec, Conservative, ,
> DontImportConflictingDefAfterDef)
> -ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
> +ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_SUITE(
> VarTemplateSpec, Conservative, ,
> DontImportConflictingDefAfterDef)
>
> -ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
> +ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_SUITE(
> Function, Liberal, ,
> ImportConflictingProtoAfterProto)
> -ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
> +ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_SUITE(
> Variable, Liberal, ,
> ImportConflictingProtoAfterProto)
> -ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
> +ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_SUITE(
> ClassTemplate, Liberal, ,
> ImportConflictingProtoAfterProto)
>
> -ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
> +ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_SUITE(
> Function, Conservative, ,
> DontImportConflictingProtoAfterProto)
> -ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
> +ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_SUITE(
> Variable, Conservative, ,
> DontImportConflictingProtoAfterProto)
> -ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
> +ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_SUITE(
> ClassTemplate, Conservative, ,
> DontImportConflictingProtoAfterProto)
>
> -ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
> +ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_SUITE(
> Variable, Liberal, ,
> ImportConflictingProtoAfterDef)
> -ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
> +ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_SUITE(
> ClassTemplate, Liberal, ,
> ImportConflictingProtoAfterDef)
>
> -ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
> +ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_SUITE(
> Variable, Conservative, ,
> DontImportConflictingProtoAfterDef)
> -ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
> +ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_SUITE(
> ClassTemplate, Conservative, ,
> DontImportConflictingProtoAfterDef)
>
> -ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
> +ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_SUITE(
> Function, Liberal, ,
> ImportConflictingDefAfterProto)
> -ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
> +ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_SUITE(
> Variable, Liberal, ,
> ImportConflictingDefAfterProto)
> -ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
> +ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_SUITE(
> ClassTemplate, Liberal, ,
> ImportConflictingDefAfterProto)
>
> -ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
> +ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_SUITE(
> Function, Conservative, ,
> DontImportConflictingDefAfterProto)
> -ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
> +ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_SUITE(
> Variable, Conservative, ,
> DontImportConflictingDefAfterProto)
> -ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
> +ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_SUITE(
> ClassTemplate, Conservative, ,
> DontImportConflictingDefAfterProto)
>
> -ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
> +ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_SUITE(
> ClassTemplate, Liberal, ,
> ImportConflictingProtoDefAfterProto)
>
> -ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
> +ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_SUITE(
> ClassTemplate, Conservative, ,
> DontImportConflictingProtoDefAfterProto)
>
> -ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
> +ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_SUITE(
> ClassTemplate, Liberal, ,
> ImportConflictingProtoAfterProtoDef)
>
> -ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
> +ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_SUITE(
> ClassTemplate, Conservative, ,
> DontImportConflictingProtoAfterProtoDef)
>
> -ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
> +ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_SUITE(
> ClassTemplate, Liberal, ,
> ImportConflictingProtoDefAfterDef)
>
> -ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
> +ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_SUITE(
> ClassTemplate, Conservative, ,
> DontImportConflictingProtoDefAfterDef)
>
> -ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
> +ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_SUITE(
> ClassTemplate, Liberal, ,
> ImportConflictingDefAfterProtoDef)
>
> -ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
> +ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_SUITE(
> ClassTemplate, Conservative, ,
> DontImportConflictingDefAfterProtoDef)
>
> @@ -565,28 +565,28 @@ ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
> // has nothing to do with function template specializations. Fully
> specialized
> // function templates are imported as new nodes if their template
> arguments are
> //
> diff erent.
> -ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
> +ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_SUITE(
> FunctionTemplate, Liberal, ,
> ImportDifferentDefAfterDef)
> -ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
> +ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_SUITE(
> FunctionTemplateSpec, Liberal, ,
> ImportDifferentDefAfterDef)
> -ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
> +ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_SUITE(
> FunctionTemplate, Conservative, ,
> ImportDifferentDefAfterDef)
> -ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
> +ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_SUITE(
> FunctionTemplateSpec, Conservative, ,
> ImportDifferentDefAfterDef)
> -ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
> +ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_SUITE(
> FunctionTemplate, Liberal, ,
> DontImportSameDefAfterDef)
> -ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
> +ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_SUITE(
> FunctionTemplateSpec, Liberal, ,
> DontImportSameDefAfterDef)
> -ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
> +ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_SUITE(
> FunctionTemplate, Conservative, ,
> DontImportSameDefAfterDef)
> -ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
> +ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_SUITE(
> FunctionTemplateSpec, Conservative, ,
> DontImportSameDefAfterDef)
>
> @@ -596,99 +596,99 @@ ASTIMPORTER_ODR_INSTANTIATE_TYPED_TEST_CASE(
>
> // FIXME: These fail on Windows.
> #if !defined(_WIN32)
> -INSTANTIATE_TEST_CASE_P(
> +INSTANTIATE_TEST_SUITE_P(
> ODRViolationTests, FunctionConservative,
> - DefaultTestValuesForRunOptions, );
> + DefaultTestValuesForRunOptions );
> #endif
> -INSTANTIATE_TEST_CASE_P(
> +INSTANTIATE_TEST_SUITE_P(
> ODRViolationTests, TypedefConservative,
> - DefaultTestValuesForRunOptions, );
> -INSTANTIATE_TEST_CASE_P(
> + DefaultTestValuesForRunOptions );
> +INSTANTIATE_TEST_SUITE_P(
> ODRViolationTests, TypedefAliasConservative,
> - DefaultTestValuesForRunOptions, );
> -INSTANTIATE_TEST_CASE_P(
> + DefaultTestValuesForRunOptions );
> +INSTANTIATE_TEST_SUITE_P(
> ODRViolationTests, EnumConservative,
> - DefaultTestValuesForRunOptions, );
> -INSTANTIATE_TEST_CASE_P(
> + DefaultTestValuesForRunOptions );
> +INSTANTIATE_TEST_SUITE_P(
> ODRViolationTests, EnumClassConservative,
> - DefaultTestValuesForRunOptions, );
> -INSTANTIATE_TEST_CASE_P(
> + DefaultTestValuesForRunOptions );
> +INSTANTIATE_TEST_SUITE_P(
> ODRViolationTests, EnumConstantConservative,
> - DefaultTestValuesForRunOptions, );
> -INSTANTIATE_TEST_CASE_P(
> + DefaultTestValuesForRunOptions );
> +INSTANTIATE_TEST_SUITE_P(
> ODRViolationTests, ClassConservative,
> - DefaultTestValuesForRunOptions, );
> -INSTANTIATE_TEST_CASE_P(
> + DefaultTestValuesForRunOptions );
> +INSTANTIATE_TEST_SUITE_P(
> ODRViolationTests, VariableConservative,
> - DefaultTestValuesForRunOptions, );
> -INSTANTIATE_TEST_CASE_P(
> + DefaultTestValuesForRunOptions);
> +INSTANTIATE_TEST_SUITE_P(
> ODRViolationTests, ClassTemplateConservative,
> - DefaultTestValuesForRunOptions, );
> -INSTANTIATE_TEST_CASE_P(
> + DefaultTestValuesForRunOptions);
> +INSTANTIATE_TEST_SUITE_P(
> ODRViolationTests, FunctionTemplateConservative,
> - DefaultTestValuesForRunOptions, );
> + DefaultTestValuesForRunOptions);
> // FIXME: Make VarTemplate tests work.
> -//INSTANTIATE_TEST_CASE_P(
> +//INSTANTIATE_TEST_SUITE_P(
> //ODRViolationTests, VarTemplateConservative,
> - //DefaultTestValuesForRunOptions, );
> -INSTANTIATE_TEST_CASE_P(
> + //DefaultTestValuesForRunOptions);
> +INSTANTIATE_TEST_SUITE_P(
> ODRViolationTests, FunctionTemplateSpecConservative,
> - DefaultTestValuesForRunOptions, );
> -INSTANTIATE_TEST_CASE_P(
> + DefaultTestValuesForRunOptions);
> +INSTANTIATE_TEST_SUITE_P(
> ODRViolationTests, ClassTemplateSpecConservative,
> - DefaultTestValuesForRunOptions, );
> + DefaultTestValuesForRunOptions);
> // FIXME: Make VarTemplateSpec tests work.
> -//INSTANTIATE_TEST_CASE_P(
> +//INSTANTIATE_TEST_SUITE_P(
> //ODRViolationTests, VarTemplateSpecConservative,
> - //DefaultTestValuesForRunOptions, );
> + //DefaultTestValuesForRunOptions);
>
> // FIXME: These fail on Windows.
> #if !defined(_WIN32)
> -INSTANTIATE_TEST_CASE_P(
> +INSTANTIATE_TEST_SUITE_P(
> ODRViolationTests, FunctionLiberal,
> - DefaultTestValuesForRunOptions, );
> + DefaultTestValuesForRunOptions);
> #endif
> -INSTANTIATE_TEST_CASE_P(
> +INSTANTIATE_TEST_SUITE_P(
> ODRViolationTests, TypedefLiberal,
> - DefaultTestValuesForRunOptions, );
> -INSTANTIATE_TEST_CASE_P(
> + DefaultTestValuesForRunOptions);
> +INSTANTIATE_TEST_SUITE_P(
> ODRViolationTests, TypedefAliasLiberal,
> - DefaultTestValuesForRunOptions, );
> -INSTANTIATE_TEST_CASE_P(
> + DefaultTestValuesForRunOptions);
> +INSTANTIATE_TEST_SUITE_P(
> ODRViolationTests, EnumLiberal,
> - DefaultTestValuesForRunOptions, );
> -INSTANTIATE_TEST_CASE_P(
> + DefaultTestValuesForRunOptions);
> +INSTANTIATE_TEST_SUITE_P(
> ODRViolationTests, EnumClassLiberal,
> - DefaultTestValuesForRunOptions, );
> -INSTANTIATE_TEST_CASE_P(
> + DefaultTestValuesForRunOptions);
> +INSTANTIATE_TEST_SUITE_P(
> ODRViolationTests, EnumConstantLiberal,
> - DefaultTestValuesForRunOptions, );
> -INSTANTIATE_TEST_CASE_P(
> + DefaultTestValuesForRunOptions);
> +INSTANTIATE_TEST_SUITE_P(
> ODRViolationTests, ClassLiberal,
> - DefaultTestValuesForRunOptions, );
> -INSTANTIATE_TEST_CASE_P(
> + DefaultTestValuesForRunOptions);
> +INSTANTIATE_TEST_SUITE_P(
> ODRViolationTests, VariableLiberal,
> - DefaultTestValuesForRunOptions, );
> -INSTANTIATE_TEST_CASE_P(
> + DefaultTestValuesForRunOptions);
> +INSTANTIATE_TEST_SUITE_P(
> ODRViolationTests, ClassTemplateLiberal,
> - DefaultTestValuesForRunOptions, );
> -INSTANTIATE_TEST_CASE_P(
> + DefaultTestValuesForRunOptions);
> +INSTANTIATE_TEST_SUITE_P(
> ODRViolationTests, FunctionTemplateLiberal,
> - DefaultTestValuesForRunOptions, );
> + DefaultTestValuesForRunOptions);
> // FIXME: Make VarTemplate tests work.
> -// INSTANTIATE_TEST_CASE_P(
> +// INSTANTIATE_TEST_SUITE_P(
> // ODRViolationTests, VarTemplateLiberal,
> -// DefaultTestValuesForRunOptions, );
> -INSTANTIATE_TEST_CASE_P(
> +// DefaultTestValuesForRunOptions);
> +INSTANTIATE_TEST_SUITE_P(
> ODRViolationTests, ClassTemplateSpecLiberal,
> - DefaultTestValuesForRunOptions, );
> -INSTANTIATE_TEST_CASE_P(
> + DefaultTestValuesForRunOptions);
> +INSTANTIATE_TEST_SUITE_P(
> ODRViolationTests, FunctionTemplateSpecLiberal,
> - DefaultTestValuesForRunOptions, );
> + DefaultTestValuesForRunOptions);
> // FIXME: Make VarTemplateSpec tests work.
> -//INSTANTIATE_TEST_CASE_P(
> +//INSTANTIATE_TEST_SUITE_P(
> //ODRViolationTests, VarTemplateSpecLiberal,
> - //DefaultTestValuesForRunOptions, );
> + //DefaultTestValuesForRunOptions );
>
> // clang-format on
>
>
> diff --git a/clang/unittests/AST/ASTImporterObjCTest.cpp
> b/clang/unittests/AST/ASTImporterObjCTest.cpp
> index 2d848dcf754ed..c9751fd8dda8b 100644
> --- a/clang/unittests/AST/ASTImporterObjCTest.cpp
> +++ b/clang/unittests/AST/ASTImporterObjCTest.cpp
> @@ -85,5 +85,5 @@ static const auto ObjCTestArrayForRunOptions =
> const auto ObjCTestValuesForRunOptions =
> ::testing::ValuesIn(ObjCTestArrayForRunOptions);
>
> -INSTANTIATE_TEST_CASE_P(ParameterizedTests, ImportObjCDecl,
> - ObjCTestValuesForRunOptions, );
> +INSTANTIATE_TEST_SUITE_P(ParameterizedTests, ImportObjCDecl,
> + ObjCTestValuesForRunOptions);
>
> diff --git a/clang/unittests/AST/ASTImporterTest.cpp
> b/clang/unittests/AST/ASTImporterTest.cpp
> index b0a8c829809dd..e62203f286572 100644
> --- a/clang/unittests/AST/ASTImporterTest.cpp
> +++ b/clang/unittests/AST/ASTImporterTest.cpp
> @@ -5568,15 +5568,15 @@ TEST_P(ASTImporterOptionSpecificTestBase,
> EXPECT_EQ(ImportedX->isAggregate(), FromX->isAggregate());
> }
>
> -INSTANTIATE_TEST_CASE_P(ParameterizedTests, SVEBuiltins,
> - ::testing::Values(std::vector<std::string>{
> - "-target", "aarch64-linux-gnu"}), );
> +INSTANTIATE_TEST_SUITE_P(ParameterizedTests, SVEBuiltins,
> + ::testing::Values(std::vector<std::string>{
> + "-target", "aarch64-linux-gnu"}));
>
> -INSTANTIATE_TEST_CASE_P(ParameterizedTests, DeclContextTest,
> - ::testing::Values(std::vector<std::string>()), );
> +INSTANTIATE_TEST_SUITE_P(ParameterizedTests, DeclContextTest,
> + ::testing::Values(std::vector<std::string>()));
>
> -INSTANTIATE_TEST_CASE_P(ParameterizedTests, CanonicalRedeclChain,
> - ::testing::Values(std::vector<std::string>()), );
> +INSTANTIATE_TEST_SUITE_P(ParameterizedTests, CanonicalRedeclChain,
> + ::testing::Values(std::vector<std::string>()));
>
> TEST_P(ASTImporterOptionSpecificTestBase, LambdasAreDifferentiated) {
> Decl *FromTU = getTuDecl(
> @@ -6226,8 +6226,8 @@ TEST_P(CTAD, DeductionGuideShouldCopyALocalTypedef) {
> EXPECT_NE(Param->getType()->castAs<TypedefType>()->getDecl(), Typedef);
> }
>
> -INSTANTIATE_TEST_CASE_P(ParameterizedTests, CTAD,
> - DefaultTestValuesForRunOptions, );
> +INSTANTIATE_TEST_SUITE_P(ParameterizedTests, CTAD,
> + DefaultTestValuesForRunOptions);
>
> TEST_P(ASTImporterOptionSpecificTestBase, TypedefWithAttribute) {
> Decl *TU = getTuDecl(
> @@ -6323,79 +6323,79 @@ TEST_P(ASTImporterOptionSpecificTestBase,
> ImportEnumMemberSpecialization) {
> ToD->getTemplateSpecializationKind());
> }
>
> -INSTANTIATE_TEST_CASE_P(ParameterizedTests, ASTImporterLookupTableTest,
> - DefaultTestValuesForRunOptions, );
> +INSTANTIATE_TEST_SUITE_P(ParameterizedTests, ASTImporterLookupTableTest,
> + DefaultTestValuesForRunOptions);
>
> -INSTANTIATE_TEST_CASE_P(ParameterizedTests, ImportPath,
> - ::testing::Values(std::vector<std::string>()), );
> +INSTANTIATE_TEST_SUITE_P(ParameterizedTests, ImportPath,
> + ::testing::Values(std::vector<std::string>()));
>
> -INSTANTIATE_TEST_CASE_P(ParameterizedTests, ImportExpr,
> - DefaultTestValuesForRunOptions, );
> +INSTANTIATE_TEST_SUITE_P(ParameterizedTests, ImportExpr,
> + DefaultTestValuesForRunOptions);
>
> -INSTANTIATE_TEST_CASE_P(ParameterizedTests, ImportFixedPointExpr,
> - ExtendWithOptions(DefaultTestArrayForRunOptions,
> - std::vector<std::string>{
> - "-ffixed-point"}), );
> +INSTANTIATE_TEST_SUITE_P(ParameterizedTests, ImportFixedPointExpr,
> + ExtendWithOptions(DefaultTestArrayForRunOptions,
> + std::vector<std::string>{
> + "-ffixed-point"}));
>
> -INSTANTIATE_TEST_CASE_P(ParameterizedTests, ImportBlock,
> - ExtendWithOptions(DefaultTestArrayForRunOptions,
> - std::vector<std::string>{
> - "-fblocks"}), );
> +INSTANTIATE_TEST_SUITE_P(ParameterizedTests, ImportBlock,
> + ExtendWithOptions(DefaultTestArrayForRunOptions,
> + std::vector<std::string>{
> + "-fblocks"}));
>
> -INSTANTIATE_TEST_CASE_P(ParameterizedTests, ImportType,
> - DefaultTestValuesForRunOptions, );
> +INSTANTIATE_TEST_SUITE_P(ParameterizedTests, ImportType,
> + DefaultTestValuesForRunOptions);
>
> -INSTANTIATE_TEST_CASE_P(ParameterizedTests, ImportDecl,
> - DefaultTestValuesForRunOptions, );
> +INSTANTIATE_TEST_SUITE_P(ParameterizedTests, ImportDecl,
> + DefaultTestValuesForRunOptions);
>
> -INSTANTIATE_TEST_CASE_P(ParameterizedTests,
> ASTImporterOptionSpecificTestBase,
> - DefaultTestValuesForRunOptions, );
> +INSTANTIATE_TEST_SUITE_P(ParameterizedTests,
> ASTImporterOptionSpecificTestBase,
> + DefaultTestValuesForRunOptions);
>
> -INSTANTIATE_TEST_CASE_P(ParameterizedTests, ErrorHandlingTest,
> - DefaultTestValuesForRunOptions, );
> +INSTANTIATE_TEST_SUITE_P(ParameterizedTests, ErrorHandlingTest,
> + DefaultTestValuesForRunOptions);
>
> -INSTANTIATE_TEST_CASE_P(ParameterizedTests, RedirectingImporterTest,
> - DefaultTestValuesForRunOptions, );
> +INSTANTIATE_TEST_SUITE_P(ParameterizedTests, RedirectingImporterTest,
> + DefaultTestValuesForRunOptions);
>
> -INSTANTIATE_TEST_CASE_P(ParameterizedTests, ImportFunctions,
> - DefaultTestValuesForRunOptions, );
> +INSTANTIATE_TEST_SUITE_P(ParameterizedTests, ImportFunctions,
> + DefaultTestValuesForRunOptions);
>
> -INSTANTIATE_TEST_CASE_P(ParameterizedTests, ImportAutoFunctions,
> - DefaultTestValuesForRunOptions, );
> +INSTANTIATE_TEST_SUITE_P(ParameterizedTests, ImportAutoFunctions,
> + DefaultTestValuesForRunOptions);
>
> -INSTANTIATE_TEST_CASE_P(ParameterizedTests, ImportFunctionTemplates,
> - DefaultTestValuesForRunOptions, );
> +INSTANTIATE_TEST_SUITE_P(ParameterizedTests, ImportFunctionTemplates,
> + DefaultTestValuesForRunOptions);
>
> -INSTANTIATE_TEST_CASE_P(ParameterizedTests, ImportFriendFunctionTemplates,
> - DefaultTestValuesForRunOptions, );
> +INSTANTIATE_TEST_SUITE_P(ParameterizedTests,
> ImportFriendFunctionTemplates,
> + DefaultTestValuesForRunOptions);
>
> -INSTANTIATE_TEST_CASE_P(ParameterizedTests, ImportClasses,
> - DefaultTestValuesForRunOptions, );
> +INSTANTIATE_TEST_SUITE_P(ParameterizedTests, ImportClasses,
> + DefaultTestValuesForRunOptions);
>
> -INSTANTIATE_TEST_CASE_P(ParameterizedTests, ImportFriendFunctions,
> - DefaultTestValuesForRunOptions, );
> +INSTANTIATE_TEST_SUITE_P(ParameterizedTests, ImportFriendFunctions,
> + DefaultTestValuesForRunOptions);
>
> -INSTANTIATE_TEST_CASE_P(ParameterizedTests, ImportFriendClasses,
> - DefaultTestValuesForRunOptions, );
> +INSTANTIATE_TEST_SUITE_P(ParameterizedTests, ImportFriendClasses,
> + DefaultTestValuesForRunOptions);
>
> -INSTANTIATE_TEST_CASE_P(ParameterizedTests,
> - ImportFunctionTemplateSpecializations,
> - DefaultTestValuesForRunOptions, );
> +INSTANTIATE_TEST_SUITE_P(ParameterizedTests,
> + ImportFunctionTemplateSpecializations,
> + DefaultTestValuesForRunOptions);
>
> -INSTANTIATE_TEST_CASE_P(ParameterizedTests, ImportImplicitMethods,
> - DefaultTestValuesForRunOptions, );
> +INSTANTIATE_TEST_SUITE_P(ParameterizedTests, ImportImplicitMethods,
> + DefaultTestValuesForRunOptions);
>
> -INSTANTIATE_TEST_CASE_P(ParameterizedTests, ImportVariables,
> - DefaultTestValuesForRunOptions, );
> +INSTANTIATE_TEST_SUITE_P(ParameterizedTests, ImportVariables,
> + DefaultTestValuesForRunOptions);
>
> -INSTANTIATE_TEST_CASE_P(ParameterizedTests, LLDBLookupTest,
> - DefaultTestValuesForRunOptions, );
> +INSTANTIATE_TEST_SUITE_P(ParameterizedTests, LLDBLookupTest,
> + DefaultTestValuesForRunOptions);
>
> -INSTANTIATE_TEST_CASE_P(ParameterizedTests, ImportSourceLocations,
> - DefaultTestValuesForRunOptions, );
> +INSTANTIATE_TEST_SUITE_P(ParameterizedTests, ImportSourceLocations,
> + DefaultTestValuesForRunOptions);
>
> -INSTANTIATE_TEST_CASE_P(ParameterizedTests, ImportWithExternalSource,
> - DefaultTestValuesForRunOptions, );
> +INSTANTIATE_TEST_SUITE_P(ParameterizedTests, ImportWithExternalSource,
> + DefaultTestValuesForRunOptions);
>
> } // end namespace ast_matchers
> } // end namespace clang
>
> diff --git a/clang/unittests/AST/ASTImporterVisibilityTest.cpp
> b/clang/unittests/AST/ASTImporterVisibilityTest.cpp
> index 262402415658f..cf3e51caeac7a 100644
> --- a/clang/unittests/AST/ASTImporterVisibilityTest.cpp
> +++ b/clang/unittests/AST/ASTImporterVisibilityTest.cpp
> @@ -177,11 +177,11 @@ TEST_P(ImportClassTemplatesVisibilityChain,
> ImportChain) {
> }
>
> // Automatic instantiation of the value-parameterized tests.
> -INSTANTIATE_TEST_CASE_P(ParameterizedTests,
> ImportFunctionsVisibilityChain,
> - ::testing::Combine(
> - DefaultTestValuesForRunOptions,
> - ::testing::Values(ExternF, StaticF, AnonF)), );
> -INSTANTIATE_TEST_CASE_P(
> +INSTANTIATE_TEST_SUITE_P(ParameterizedTests,
> ImportFunctionsVisibilityChain,
> +
> ::testing::Combine(DefaultTestValuesForRunOptions,
> + ::testing::Values(ExternF,
> StaticF,
> + AnonF)));
> +INSTANTIATE_TEST_SUITE_P(
> ParameterizedTests, ImportVariablesVisibilityChain,
> ::testing::Combine(
> DefaultTestValuesForRunOptions,
> @@ -192,31 +192,31 @@ INSTANTIATE_TEST_CASE_P(
> // initializer is a tentative definition, subsequent definitions
> may be
> // provided but they must have the same linkage. See also the
> test
> // ImportVariableChainInC which test for this special C Lang case.
> - ::testing::Values(ExternV, AnonV)), );
> -INSTANTIATE_TEST_CASE_P(
> + ::testing::Values(ExternV, AnonV)) );
> +INSTANTIATE_TEST_SUITE_P(
> ParameterizedTests, ImportClassesVisibilityChain,
> ::testing::Combine(
> DefaultTestValuesForRunOptions,
> - ::testing::Values(ExternC, AnonC)), );
> -INSTANTIATE_TEST_CASE_P(
> + ::testing::Values(ExternC, AnonC)) );
> +INSTANTIATE_TEST_SUITE_P(
> ParameterizedTests, ImportScopedEnumsVisibilityChain,
> ::testing::Combine(
> DefaultTestValuesForRunOptions,
> - ::testing::Values(ExternEC, AnonEC)), );
> -INSTANTIATE_TEST_CASE_P(ParameterizedTests,
> + ::testing::Values(ExternEC, AnonEC)) );
> +INSTANTIATE_TEST_SUITE_P(ParameterizedTests,
> ImportFunctionTemplatesVisibilityChain,
> ::testing::Combine(DefaultTestValuesForRunOptions,
> ::testing::Values(ExternFT,
> StaticFT,
> - AnonFT)), );
> -INSTANTIATE_TEST_CASE_P(ParameterizedTests,
> + AnonFT)) );
> +INSTANTIATE_TEST_SUITE_P(ParameterizedTests,
> ImportVariableTemplatesVisibilityChain,
> ::testing::Combine(DefaultTestValuesForRunOptions,
> ::testing::Values(ExternVT,
> - AnonVT)), );
> -INSTANTIATE_TEST_CASE_P(ParameterizedTests,
> ImportClassTemplatesVisibilityChain,
> + AnonVT)) );
> +INSTANTIATE_TEST_SUITE_P(ParameterizedTests,
> ImportClassTemplatesVisibilityChain,
> ::testing::Combine(DefaultTestValuesForRunOptions,
> ::testing::Values(ExternCT,
> - AnonCT)), );
> + AnonCT)) );
>
> // First value in tuple: Compile options.
> // Second value in tuple: Tuple with informations for the test.
> @@ -398,7 +398,7 @@ TEST_P(ImportClassTemplatesVisibility,
> ImportAfterImport) {
> const bool ExpectLinkedDeclChain = true;
> const bool ExpectUnlinkedDeclChain = false;
>
> -INSTANTIATE_TEST_CASE_P(
> +INSTANTIATE_TEST_SUITE_P(
> ParameterizedTests, ImportFunctionsVisibility,
> ::testing::Combine(
> DefaultTestValuesForRunOptions,
> @@ -411,8 +411,8 @@ INSTANTIATE_TEST_CASE_P(
> std::make_tuple(StaticF, AnonF, ExpectUnlinkedDeclChain),
> std::make_tuple(AnonF, ExternF, ExpectUnlinkedDeclChain),
> std::make_tuple(AnonF, StaticF, ExpectUnlinkedDeclChain),
> - std::make_tuple(AnonF, AnonF, ExpectUnlinkedDeclChain))), );
> -INSTANTIATE_TEST_CASE_P(
> + std::make_tuple(AnonF, AnonF, ExpectUnlinkedDeclChain))) );
> +INSTANTIATE_TEST_SUITE_P(
> ParameterizedTests, ImportVariablesVisibility,
> ::testing::Combine(
> DefaultTestValuesForRunOptions,
> @@ -425,8 +425,8 @@ INSTANTIATE_TEST_CASE_P(
> std::make_tuple(StaticV, AnonV, ExpectUnlinkedDeclChain),
> std::make_tuple(AnonV, ExternV, ExpectUnlinkedDeclChain),
> std::make_tuple(AnonV, StaticV, ExpectUnlinkedDeclChain),
> - std::make_tuple(AnonV, AnonV, ExpectUnlinkedDeclChain))), );
> -INSTANTIATE_TEST_CASE_P(
> + std::make_tuple(AnonV, AnonV, ExpectUnlinkedDeclChain))) );
> +INSTANTIATE_TEST_SUITE_P(
> ParameterizedTests, ImportClassesVisibility,
> ::testing::Combine(
> DefaultTestValuesForRunOptions,
> @@ -434,8 +434,8 @@ INSTANTIATE_TEST_CASE_P(
> std::make_tuple(ExternC, ExternC, ExpectLinkedDeclChain),
> std::make_tuple(ExternC, AnonC, ExpectUnlinkedDeclChain),
> std::make_tuple(AnonC, ExternC, ExpectUnlinkedDeclChain),
> - std::make_tuple(AnonC, AnonC, ExpectUnlinkedDeclChain))), );
> -INSTANTIATE_TEST_CASE_P(
> + std::make_tuple(AnonC, AnonC, ExpectUnlinkedDeclChain))) );
> +INSTANTIATE_TEST_SUITE_P(
> ParameterizedTests, ImportEnumsVisibility,
> ::testing::Combine(
> DefaultTestValuesForRunOptions,
> @@ -443,8 +443,8 @@ INSTANTIATE_TEST_CASE_P(
> std::make_tuple(ExternE, ExternE, ExpectLinkedDeclChain),
> std::make_tuple(ExternE, AnonE, ExpectUnlinkedDeclChain),
> std::make_tuple(AnonE, ExternE, ExpectUnlinkedDeclChain),
> - std::make_tuple(AnonE, AnonE, ExpectUnlinkedDeclChain))), );
> -INSTANTIATE_TEST_CASE_P(
> + std::make_tuple(AnonE, AnonE, ExpectUnlinkedDeclChain))) );
> +INSTANTIATE_TEST_SUITE_P(
> ParameterizedTests, ImportScopedEnumsVisibility,
> ::testing::Combine(
> DefaultTestValuesForRunOptions,
> @@ -452,8 +452,8 @@ INSTANTIATE_TEST_CASE_P(
> std::make_tuple(ExternEC, ExternEC, ExpectLinkedDeclChain),
> std::make_tuple(ExternEC, AnonEC, ExpectUnlinkedDeclChain),
> std::make_tuple(AnonEC, ExternEC, ExpectUnlinkedDeclChain),
> - std::make_tuple(AnonEC, AnonEC, ExpectUnlinkedDeclChain))), );
> -INSTANTIATE_TEST_CASE_P(
> + std::make_tuple(AnonEC, AnonEC, ExpectUnlinkedDeclChain))) );
> +INSTANTIATE_TEST_SUITE_P(
> ParameterizedTests, ImportTypedefNameVisibility,
> ::testing::Combine(
> DefaultTestValuesForRunOptions,
> @@ -480,8 +480,8 @@ INSTANTIATE_TEST_CASE_P(
> std::make_tuple(ExternTypedef, AnonUsing,
> ExpectUnlinkedDeclChain),
> std::make_tuple(AnonTypedef, ExternUsing,
> ExpectUnlinkedDeclChain),
> std::make_tuple(AnonTypedef, AnonUsing,
> - ExpectUnlinkedDeclChain))), );
> -INSTANTIATE_TEST_CASE_P(
> + ExpectUnlinkedDeclChain))) );
> +INSTANTIATE_TEST_SUITE_P(
> ParameterizedTests, ImportFunctionTemplatesVisibility,
> ::testing::Combine(
> DefaultTestValuesForRunOptions,
> @@ -494,8 +494,8 @@ INSTANTIATE_TEST_CASE_P(
> std::make_tuple(StaticFT, AnonFT, ExpectUnlinkedDeclChain),
> std::make_tuple(AnonFT, ExternFT, ExpectUnlinkedDeclChain),
> std::make_tuple(AnonFT, StaticFT, ExpectUnlinkedDeclChain),
> - std::make_tuple(AnonFT, AnonFT, ExpectUnlinkedDeclChain))), );
> -INSTANTIATE_TEST_CASE_P(
> + std::make_tuple(AnonFT, AnonFT, ExpectUnlinkedDeclChain))) );
> +INSTANTIATE_TEST_SUITE_P(
> ParameterizedTests, ImportVariableTemplatesVisibility,
> ::testing::Combine(
> DefaultTestValuesForRunOptions,
> @@ -508,14 +508,14 @@ INSTANTIATE_TEST_CASE_P(
> std::make_tuple(StaticVT, AnonVT, ExpectUnlinkedDeclChain),
> std::make_tuple(AnonVT, ExternVT, ExpectUnlinkedDeclChain),
> std::make_tuple(AnonVT, StaticVT, ExpectUnlinkedDeclChain),
> - std::make_tuple(AnonVT, AnonVT, ExpectUnlinkedDeclChain))), );
> -INSTANTIATE_TEST_CASE_P(
> + std::make_tuple(AnonVT, AnonVT, ExpectUnlinkedDeclChain))) );
> +INSTANTIATE_TEST_SUITE_P(
> ParameterizedTests, ImportClassTemplatesVisibility,
> ::testing::Combine(
> DefaultTestValuesForRunOptions,
> ::testing::Values(std::make_tuple(ExternCT, ExternCT,
> ExpectLinkedDeclChain),
> std::make_tuple(ExternCT, AnonCT,
> ExpectUnlinkedDeclChain),
> std::make_tuple(AnonCT, ExternCT,
> ExpectUnlinkedDeclChain),
> - std::make_tuple(AnonCT, AnonCT,
> ExpectUnlinkedDeclChain))), );
> + std::make_tuple(AnonCT, AnonCT,
> ExpectUnlinkedDeclChain))) );
> } // end namespace ast_matchers
> } // end namespace clang
>
> diff --git a/clang/unittests/ASTMatchers/ASTMatchersNodeTest.cpp
> b/clang/unittests/ASTMatchers/ASTMatchersNodeTest.cpp
> index 23b31509cd488..c179ce11fefb9 100644
> --- a/clang/unittests/ASTMatchers/ASTMatchersNodeTest.cpp
> +++ b/clang/unittests/ASTMatchers/ASTMatchersNodeTest.cpp
> @@ -2302,8 +2302,8 @@ static std::vector<TestClangConfig>
> allTestClangConfigs() {
> return all_configs;
> }
>
> -INSTANTIATE_TEST_CASE_P(ASTMatchersTests, ASTMatchersTest,
> - testing::ValuesIn(allTestClangConfigs()), );
> +INSTANTIATE_TEST_SUITE_P(ASTMatchersTests, ASTMatchersTest,
> + testing::ValuesIn(allTestClangConfigs()));
>
> } // namespace ast_matchers
> } // namespace clang
>
> diff --git a/clang/unittests/Analysis/ExprMutationAnalyzerTest.cpp
> b/clang/unittests/Analysis/ExprMutationAnalyzerTest.cpp
> index a968d292b53f5..a4410d330d393 100644
> --- a/clang/unittests/Analysis/ExprMutationAnalyzerTest.cpp
> +++ b/clang/unittests/Analysis/ExprMutationAnalyzerTest.cpp
> @@ -203,9 +203,9 @@ TEST_P(AssignmentTest, AssignmentModifies) {
> }
> }
>
> -INSTANTIATE_TEST_CASE_P(AllAssignmentOperators, AssignmentTest,
> +INSTANTIATE_TEST_SUITE_P(AllAssignmentOperators, AssignmentTest,
> Values("=", "+=", "-=", "*=", "/=", "%=", "&=",
> "|=",
> - "^=", "<<=", ">>="), );
> + "^=", "<<=", ">>=") );
>
> TEST(ExprMutationAnalyzerTest, AssignmentConditionalWithInheritance) {
> const auto AST = buildASTFromCode("struct Base {void nonconst(); };"
> @@ -230,9 +230,9 @@ TEST_P(IncDecTest, IncDecModifies) {
> EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre(ModExpr));
> }
>
> -INSTANTIATE_TEST_CASE_P(AllIncDecOperators, IncDecTest,
> +INSTANTIATE_TEST_SUITE_P(AllIncDecOperators, IncDecTest,
> Values("++x", "--x", "x++", "x--", "++(x)",
> "--(x)",
> - "(x)++", "(x)--"), );
> + "(x)++", "(x)--") );
>
> // Section: member functions
>
>
> diff --git a/clang/unittests/Rename/RenameAliasTest.cpp
> b/clang/unittests/Rename/RenameAliasTest.cpp
> index ad9ce65ac8492..50fa2c104263f 100644
> --- a/clang/unittests/Rename/RenameAliasTest.cpp
> +++ b/clang/unittests/Rename/RenameAliasTest.cpp
> @@ -45,7 +45,7 @@ class RenameAliasTest : public ClangRenameTest {
> }
> };
>
> -INSTANTIATE_TEST_CASE_P(
> +INSTANTIATE_TEST_SUITE_P(
> RenameAliasTests, RenameAliasTest,
> testing::ValuesIn(std::vector<Case>({
> // basic functions
> @@ -190,7 +190,7 @@ INSTANTIATE_TEST_CASE_P(
> "NewTPtr"},
> {"void f(::TPtr<int> p) {}", "void f(::NewTPtr<int> p) {}",
> "TPtr",
> "NewTPtr"},
> - })), );
> + })));
>
> TEST_P(RenameAliasTest, RenameAlias) {
> auto Param = GetParam();
>
> diff --git a/clang/unittests/Rename/RenameClassTest.cpp
> b/clang/unittests/Rename/RenameClassTest.cpp
> index 1b008987a16d3..24370b5795e94 100644
> --- a/clang/unittests/Rename/RenameClassTest.cpp
> +++ b/clang/unittests/Rename/RenameClassTest.cpp
> @@ -45,7 +45,7 @@ class RenameClassTest : public ClangRenameTest {
> }
> };
>
> -INSTANTIATE_TEST_CASE_P(
> +INSTANTIATE_TEST_SUITE_P(
> RenameClassTests, RenameClassTest,
> testing::ValuesIn(std::vector<Case>({
> // basic classes
> @@ -189,7 +189,7 @@ INSTANTIATE_TEST_CASE_P(
> // friends, everyone needs friends.
> {"class Foo { int i; friend class a::Foo; };",
> "class Foo { int i; friend class b::Bar; };", "", ""},
> - })), );
> + })) );
>
> TEST_P(RenameClassTest, RenameClasses) {
> auto Param = GetParam();
> @@ -217,7 +217,7 @@ class NamespaceDetectionTest : public ClangRenameTest {
> }
> };
>
> -INSTANTIATE_TEST_CASE_P(
> +INSTANTIATE_TEST_SUITE_P(
> RenameClassTest, NamespaceDetectionTest,
> ::testing::ValuesIn(std::vector<Case>({
> // Test old and new namespace overlap.
> @@ -298,7 +298,7 @@ INSTANTIATE_TEST_CASE_P(
> {"namespace o1 { class Foo { int i; friend class Old; }; }",
> "namespace o1 { class Foo { int i; friend class New; }; }",
> "::o1::Old", "::o1::New"},
> - })), );
> + })) );
>
> TEST_P(NamespaceDetectionTest, RenameClasses) {
> auto Param = GetParam();
> @@ -339,7 +339,7 @@ class TemplatedClassRenameTest : public
> ClangRenameTest {
> }
> };
>
> -INSTANTIATE_TEST_CASE_P(
> +INSTANTIATE_TEST_SUITE_P(
> RenameClassTests, TemplatedClassRenameTest,
> ::testing::ValuesIn(std::vector<Case>({
> {"Old<int> gI; Old<bool> gB;", "New<int> gI; New<bool> gB;",
> "Old",
> @@ -394,7 +394,7 @@ INSTANTIATE_TEST_CASE_P(
> {"template <typename T> struct Moo { ns::Old<T> o_; }; Moo<int>
> m;",
> "template <typename T> struct Moo { ns::New<T> o_; }; Moo<int>
> m;",
> "ns::Old", "ns::New"},
> - })), );
> + })) );
>
> TEST_P(TemplatedClassRenameTest, RenameTemplateClasses) {
> auto Param = GetParam();
>
> diff --git a/clang/unittests/Rename/RenameEnumTest.cpp
> b/clang/unittests/Rename/RenameEnumTest.cpp
> index 55dcd11ac4128..dc3440047c4a4 100644
> --- a/clang/unittests/Rename/RenameEnumTest.cpp
> +++ b/clang/unittests/Rename/RenameEnumTest.cpp
> @@ -26,7 +26,7 @@ class RenameEnumTest : public ClangRenameTest {
> }
> };
>
> -INSTANTIATE_TEST_CASE_P(
> +INSTANTIATE_TEST_SUITE_P(
> RenameEnumTests, RenameEnumTest,
> testing::ValuesIn(std::vector<Case>({
> {"void f(a::A2 arg) { a::A2 t = a::A2::Blue; }",
> @@ -142,7 +142,7 @@ INSTANTIATE_TEST_CASE_P(
> "struct Foo { template <typename T> T foo(); }; void g() { Foo
> f; "
> "f.foo<b::B2>(); }",
> "a::A2", "b::B2"},
> - })), );
> + })) );
>
> TEST_P(RenameEnumTest, RenameEnums) {
> auto Param = GetParam();
>
> diff --git a/clang/unittests/Rename/RenameMemberTest.cpp
> b/clang/unittests/Rename/RenameMemberTest.cpp
> index c9192c638a225..c16d16aa25f04 100644
> --- a/clang/unittests/Rename/RenameMemberTest.cpp
> +++ b/clang/unittests/Rename/RenameMemberTest.cpp
> @@ -69,15 +69,15 @@ class RenameMemberTest : public ClangRenameTest {
> }
> };
>
> -INSTANTIATE_TEST_CASE_P(
> +INSTANTIATE_TEST_SUITE_P(
> DISABLED_RenameTemplatedClassStaticVariableTest, RenameMemberTest,
> testing::ValuesIn(std::vector<Case>({
> // FIXME: support renaming static variables for template classes.
> {"void f() { ns::TA<int>::SMoo; }",
> "void f() { ns::TA<int>::SMeh; }", "ns::TA::SMoo",
> "ns::TA::SMeh"},
> - })), );
> + })) );
>
> -INSTANTIATE_TEST_CASE_P(
> +INSTANTIATE_TEST_SUITE_P(
> RenameMemberTest, RenameMemberTest,
> testing::ValuesIn(std::vector<Case>({
> // Normal methods and fields.
> @@ -154,7 +154,7 @@ INSTANTIATE_TEST_CASE_P(
> "TA::SFoo", "TB::SBar"},
> {"void f() { ns::TB<int>::SFoo(); }",
> "void f() { ns::TB<int>::SBar(); }", "ns::TA::SFoo",
> "ns::TB::SBar"},
> - })), );
> + })) );
>
> TEST_P(RenameMemberTest, RenameMembers) {
> auto Param = GetParam();
>
> diff --git a/clang/unittests/StaticAnalyzer/RangeSetTest.cpp
> b/clang/unittests/StaticAnalyzer/RangeSetTest.cpp
> index 5be2ee3fc520b..c29a5eef00e16 100644
> --- a/clang/unittests/StaticAnalyzer/RangeSetTest.cpp
> +++ b/clang/unittests/StaticAnalyzer/RangeSetTest.cpp
> @@ -188,7 +188,7 @@ llvm::APSInt
> RangeSetTest<BaseType>::Base{sizeof(BaseType) * 8, !isSigned()};
>
> using IntTypes = ::testing::Types<int8_t, uint8_t, int16_t, uint16_t,
> int32_t,
> uint32_t, int64_t, uint64_t>;
> -TYPED_TEST_CASE(RangeSetTest, IntTypes);
> +TYPED_TEST_SUITE(RangeSetTest, IntTypes);
>
> TYPED_TEST(RangeSetTest, RangeSetNegateTest) {
> // Use next values of the range {MIN, A, B, MID, C, D, MAX}.
>
> diff --git a/clang/unittests/Tooling/Syntax/BuildTreeTest.cpp
> b/clang/unittests/Tooling/Syntax/BuildTreeTest.cpp
> index b6bcd4eb2da5d..8529d65265761 100644
> --- a/clang/unittests/Tooling/Syntax/BuildTreeTest.cpp
> +++ b/clang/unittests/Tooling/Syntax/BuildTreeTest.cpp
> @@ -88,8 +88,8 @@ class BuildSyntaxTreeTest : public SyntaxTreeTest {
> }
> };
>
> -INSTANTIATE_TEST_CASE_P(SyntaxTreeTests, BuildSyntaxTreeTest,
> - testing::ValuesIn(allTestClangConfigs()), );
> +INSTANTIATE_TEST_SUITE_P(SyntaxTreeTests, BuildSyntaxTreeTest,
> + testing::ValuesIn(allTestClangConfigs()) );
>
> TEST_P(BuildSyntaxTreeTest, Simple) {
> EXPECT_TRUE(treeDumpEqual(
>
> diff --git a/clang/unittests/Tooling/Syntax/MutationsTest.cpp
> b/clang/unittests/Tooling/Syntax/MutationsTest.cpp
> index f63d3dffa4597..34279dc2d941b 100644
> --- a/clang/unittests/Tooling/Syntax/MutationsTest.cpp
> +++ b/clang/unittests/Tooling/Syntax/MutationsTest.cpp
> @@ -54,8 +54,8 @@ class MutationTest : public SyntaxTreeTest {
> };
> };
>
> -INSTANTIATE_TEST_CASE_P(SyntaxTreeTests, MutationTest,
> - ::testing::ValuesIn(allTestClangConfigs()), );
> +INSTANTIATE_TEST_SUITE_P(SyntaxTreeTests, MutationTest,
> + ::testing::ValuesIn(allTestClangConfigs()) );
>
> TEST_P(MutationTest, RemoveStatement_InCompound) {
> CheckTransformation(RemoveStatement, "void test() { [[100+100;]]
> test(); }",
>
> diff --git a/clang/unittests/Tooling/Syntax/SynthesisTest.cpp
> b/clang/unittests/Tooling/Syntax/SynthesisTest.cpp
> index a815989bc93fe..0bdc7bbdeb0f9 100644
> --- a/clang/unittests/Tooling/Syntax/SynthesisTest.cpp
> +++ b/clang/unittests/Tooling/Syntax/SynthesisTest.cpp
> @@ -38,8 +38,8 @@ class SynthesisTest : public SyntaxTreeTest {
> }
> };
>
> -INSTANTIATE_TEST_CASE_P(SynthesisTests, SynthesisTest,
> - ::testing::ValuesIn(allTestClangConfigs()), );
> +INSTANTIATE_TEST_SUITE_P(SynthesisTests, SynthesisTest,
> + ::testing::ValuesIn(allTestClangConfigs()) );
>
> TEST_P(SynthesisTest, Leaf_Punctuation) {
> buildTree("", GetParam());
>
> diff --git a/clang/unittests/Tooling/Syntax/TreeTest.cpp
> b/clang/unittests/Tooling/Syntax/TreeTest.cpp
> index ed839e269dde4..06da4e80156a4 100644
> --- a/clang/unittests/Tooling/Syntax/TreeTest.cpp
> +++ b/clang/unittests/Tooling/Syntax/TreeTest.cpp
> @@ -103,8 +103,8 @@ class TreeTest : public SyntaxTreeTest {
> }
> };
>
> -INSTANTIATE_TEST_CASE_P(TreeTests, TreeTest,
> - ::testing::ValuesIn(allTestClangConfigs()), );
> +INSTANTIATE_TEST_SUITE_P(TreeTests, TreeTest,
> + ::testing::ValuesIn(allTestClangConfigs()) );
>
> TEST_P(TreeTest, FirstLeaf) {
> buildTree("", GetParam());
> @@ -222,8 +222,8 @@ class ListTest : public SyntaxTreeTest {
> }
> };
>
> -INSTANTIATE_TEST_CASE_P(TreeTests, ListTest,
> - ::testing::ValuesIn(allTestClangConfigs()), );
> +INSTANTIATE_TEST_SUITE_P(TreeTests, ListTest,
> + ::testing::ValuesIn(allTestClangConfigs()) );
>
> /// "a, b, c" <=> [("a", ","), ("b", ","), ("c", null)]
> TEST_P(ListTest, List_Separated_WellFormed) {
>
> diff --git a/flang/unittests/RuntimeGTest/ListInputTest.cpp
> b/flang/unittests/RuntimeGTest/ListInputTest.cpp
> index 9654048f20bb8..7aa42905c4365 100644
> --- a/flang/unittests/RuntimeGTest/ListInputTest.cpp
> +++ b/flang/unittests/RuntimeGTest/ListInputTest.cpp
> @@ -183,9 +183,9 @@ TEST_P(SimpleListInputTest, TestListInput) {
> }
> }
>
> -INSTANTIATE_TEST_CASE_P(SimpleListInputTestInstantiation,
> SimpleListInputTest,
> +INSTANTIATE_TEST_SUITE_P(SimpleListInputTestInstantiation,
> SimpleListInputTest,
> testing::Values(std::make_tuple("", std::vector<int>{}),
> std::make_tuple("0", std::vector<int>{}),
> std::make_tuple("1", std::vector<int>{1}),
> std::make_tuple("1, 2", std::vector<int>{1, 2}),
> - std::make_tuple("3*2", std::vector<int>{2, 2, 2})), );
> + std::make_tuple("3*2", std::vector<int>{2, 2, 2})));
>
> diff --git a/lldb/unittests/Host/SocketTest.cpp
> b/lldb/unittests/Host/SocketTest.cpp
> index 901f878d2e466..27d42f835718b 100644
> --- a/lldb/unittests/Host/SocketTest.cpp
> +++ b/lldb/unittests/Host/SocketTest.cpp
> @@ -228,7 +228,7 @@ TEST_P(SocketTest, DomainGetConnectURI) {
> }
> #endif
>
> -INSTANTIATE_TEST_CASE_P(
> +INSTANTIATE_TEST_SUITE_P(
> SocketTests, SocketTest,
> testing::Values(SocketTestParams{/*is_ipv6=*/false,
> /*localhost_ip=*/"127.0.0.1"},
>
> diff --git a/lldb/unittests/Process/Utility/LinuxProcMapsTest.cpp
> b/lldb/unittests/Process/Utility/LinuxProcMapsTest.cpp
> index 203875533d93a..66db61ff65969 100644
> --- a/lldb/unittests/Process/Utility/LinuxProcMapsTest.cpp
> +++ b/lldb/unittests/Process/Utility/LinuxProcMapsTest.cpp
> @@ -62,7 +62,7 @@ TEST_P(LinuxProcMapsTestFixture, ParseMapRegions) {
>
> // Note: ConstString("") != ConstString(nullptr)
> // When a region has no name, it will have the latter in the
> MemoryRegionInfo
> -INSTANTIATE_TEST_CASE_P(
> +INSTANTIATE_TEST_SUITE_P(
> ProcMapTests, LinuxProcMapsTestFixture,
> ::testing::Values(
> // Nothing in nothing out
> @@ -125,11 +125,11 @@ INSTANTIATE_TEST_CASE_P(
> ConstString("[vsyscall]"),
> MemoryRegionInfo::eDontKnow, 0,
> MemoryRegionInfo::eDontKnow),
> },
> - "")), );
> + "")));
>
> class LinuxProcSMapsTestFixture : public LinuxProcMapsTestFixture {};
>
> -INSTANTIATE_TEST_CASE_P(
> +INSTANTIATE_TEST_SUITE_P(
> ProcSMapTests, LinuxProcSMapsTestFixture,
> ::testing::Values(
> // Nothing in nothing out
> @@ -253,7 +253,7 @@ INSTANTIATE_TEST_CASE_P(
> MemoryRegionInfo::eDontKnow, 0,
> MemoryRegionInfo::eDontKnow),
> },
> - "")), );
> + "")));
>
> TEST_P(LinuxProcSMapsTestFixture, ParseSMapRegions) {
> auto params = GetParam();
>
> diff --git a/llvm/include/llvm/Testing/Support/Error.h
> b/llvm/include/llvm/Testing/Support/Error.h
> index cd5b79cd6bfb0..67e9985b80f55 100644
> --- a/llvm/include/llvm/Testing/Support/Error.h
> +++ b/llvm/include/llvm/Testing/Support/Error.h
> @@ -42,7 +42,7 @@ class ValueMatchesMono
>
> bool result = Matcher.MatchAndExplain(*Holder.Exp, listener);
>
> - if (result)
> + if (result || !listener->IsInterested())
> return result;
> *listener << "(";
> Matcher.DescribeNegationTo(listener->stream());
>
> diff --git a/llvm/unittests/ADT/BitVectorTest.cpp
> b/llvm/unittests/ADT/BitVectorTest.cpp
> index 1779f2fcc9c27..858adb36f22e4 100644
> --- a/llvm/unittests/ADT/BitVectorTest.cpp
> +++ b/llvm/unittests/ADT/BitVectorTest.cpp
> @@ -21,7 +21,7 @@ class BitVectorTest : public ::testing::Test { };
>
> // Test both BitVector and SmallBitVector with the same suite of tests.
> typedef ::testing::Types<BitVector, SmallBitVector> BitVectorTestTypes;
> -TYPED_TEST_CASE(BitVectorTest, BitVectorTestTypes);
> +TYPED_TEST_SUITE(BitVectorTest, BitVectorTestTypes);
>
> TYPED_TEST(BitVectorTest, TrivialOperation) {
> TypeParam Vec;
>
> diff --git a/llvm/unittests/ADT/DenseMapTest.cpp
> b/llvm/unittests/ADT/DenseMapTest.cpp
> index 9cd974f5bac31..e9fe4cb8d5cd2 100644
> --- a/llvm/unittests/ADT/DenseMapTest.cpp
> +++ b/llvm/unittests/ADT/DenseMapTest.cpp
> @@ -105,7 +105,7 @@ typedef ::testing::Types<DenseMap<uint32_t, uint32_t>,
> SmallDenseMap<CtorTester, CtorTester, 4,
> CtorTesterMapInfo>
> > DenseMapTestTypes;
> -TYPED_TEST_CASE(DenseMapTest, DenseMapTestTypes);
> +TYPED_TEST_SUITE(DenseMapTest, DenseMapTestTypes);
>
> // Empty map tests
> TYPED_TEST(DenseMapTest, EmptyIntMapTest) {
>
> diff --git a/llvm/unittests/ADT/DenseSetTest.cpp
> b/llvm/unittests/ADT/DenseSetTest.cpp
> index ada53cac9b78d..1320e283c59aa 100644
> --- a/llvm/unittests/ADT/DenseSetTest.cpp
> +++ b/llvm/unittests/ADT/DenseSetTest.cpp
> @@ -68,7 +68,7 @@ typedef ::testing::Types<DenseSet<unsigned,
> TestDenseSetInfo>,
> const SmallDenseSet<unsigned, 4,
> TestDenseSetInfo>,
> SmallDenseSet<unsigned, 64, TestDenseSetInfo>>
> DenseSetTestTypes;
> -TYPED_TEST_CASE(DenseSetTest, DenseSetTestTypes);
> +TYPED_TEST_SUITE(DenseSetTest, DenseSetTestTypes);
>
> TYPED_TEST(DenseSetTest, Constructor) {
> constexpr unsigned a[] = {1, 2, 4};
>
> diff --git a/llvm/unittests/ADT/IListBaseTest.cpp
> b/llvm/unittests/ADT/IListBaseTest.cpp
> index 2983618f07e4a..f4783c46f4194 100644
> --- a/llvm/unittests/ADT/IListBaseTest.cpp
> +++ b/llvm/unittests/ADT/IListBaseTest.cpp
> @@ -19,7 +19,7 @@ template <typename T> class IListBaseTest : public
> ::testing::Test {};
> // Test variants with the same test.
> typedef ::testing::Types<ilist_base<false>, ilist_base<true>>
> IListBaseTestTypes;
> -TYPED_TEST_CASE(IListBaseTest, IListBaseTestTypes);
> +TYPED_TEST_SUITE(IListBaseTest, IListBaseTestTypes);
>
> TYPED_TEST(IListBaseTest, insertBeforeImpl) {
> typedef TypeParam list_base_type;
>
> diff --git a/llvm/unittests/ADT/IntrusiveRefCntPtrTest.cpp
> b/llvm/unittests/ADT/IntrusiveRefCntPtrTest.cpp
> index 0123709dcf2e3..e35b78484f53a 100644
> --- a/llvm/unittests/ADT/IntrusiveRefCntPtrTest.cpp
> +++ b/llvm/unittests/ADT/IntrusiveRefCntPtrTest.cpp
> @@ -28,7 +28,7 @@ template <typename T> struct IntrusiveRefCntPtrTest :
> testing::Test {};
> typedef ::testing::Types<SimpleRefCounted<RefCountedBase>,
> SimpleRefCounted<ThreadSafeRefCountedBase>>
> IntrusiveRefCntTypes;
> -TYPED_TEST_CASE(IntrusiveRefCntPtrTest, IntrusiveRefCntTypes);
> +TYPED_TEST_SUITE(IntrusiveRefCntPtrTest, IntrusiveRefCntTypes);
>
> TYPED_TEST(IntrusiveRefCntPtrTest, RefCountedBaseCopyDoesNotLeak) {
> EXPECT_EQ(0, NumInstances);
>
> diff --git a/llvm/unittests/ADT/MapVectorTest.cpp
> b/llvm/unittests/ADT/MapVectorTest.cpp
> index 7a77df45bce8d..92583e940d9c1 100644
> --- a/llvm/unittests/ADT/MapVectorTest.cpp
> +++ b/llvm/unittests/ADT/MapVectorTest.cpp
> @@ -162,7 +162,7 @@ template <class IntType> struct
> MapVectorMappedTypeTest : ::testing::Test {
>
> using MapIntTypes = ::testing::Types<int, long, long long, unsigned,
> unsigned long, unsigned long long>;
> -TYPED_TEST_CASE(MapVectorMappedTypeTest, MapIntTypes);
> +TYPED_TEST_SUITE(MapVectorMappedTypeTest, MapIntTypes);
>
> TYPED_TEST(MapVectorMappedTypeTest, DifferentDenseMap) {
> // Test that using a map with a mapped type other than 'unsigned'
> compiles
>
> diff --git a/llvm/unittests/ADT/PriorityWorklistTest.cpp
> b/llvm/unittests/ADT/PriorityWorklistTest.cpp
> index 4dfdd5f9a2611..42dca48d62fc0 100644
> --- a/llvm/unittests/ADT/PriorityWorklistTest.cpp
> +++ b/llvm/unittests/ADT/PriorityWorklistTest.cpp
> @@ -22,7 +22,7 @@ using namespace llvm;
> template <typename T> class PriorityWorklistTest : public ::testing::Test
> {};
> typedef ::testing::Types<PriorityWorklist<int>,
> SmallPriorityWorklist<int, 2>>
> TestTypes;
> -TYPED_TEST_CASE(PriorityWorklistTest, TestTypes);
> +TYPED_TEST_SUITE(PriorityWorklistTest, TestTypes);
>
> TYPED_TEST(PriorityWorklistTest, Basic) {
> TypeParam W;
>
> diff --git a/llvm/unittests/ADT/RangeAdapterTest.cpp
> b/llvm/unittests/ADT/RangeAdapterTest.cpp
> index eb1852639a3a6..ba37bcfd3d840 100644
> --- a/llvm/unittests/ADT/RangeAdapterTest.cpp
> +++ b/llvm/unittests/ADT/RangeAdapterTest.cpp
> @@ -129,7 +129,7 @@ template <typename T> class RangeAdapterLValueTest :
> public ::testing::Test {};
>
> typedef ::testing::Types<std::vector<int>, std::list<int>, int[4]>
> RangeAdapterLValueTestTypes;
> -TYPED_TEST_CASE(RangeAdapterLValueTest, RangeAdapterLValueTestTypes);
> +TYPED_TEST_SUITE(RangeAdapterLValueTest, RangeAdapterLValueTestTypes);
>
> TYPED_TEST(RangeAdapterLValueTest, TrivialOperation) {
> TypeParam v = {0, 1, 2, 3};
> @@ -145,7 +145,7 @@ typedef ::testing::Types<std::vector<int>,
> std::list<int>, CustomIteratorVector,
> ReverseOnlyVector, BidirectionalVector,
> BidirectionalVectorConsts>
> RangeAdapterRValueTestTypes;
> -TYPED_TEST_CASE(RangeAdapterRValueTest, RangeAdapterRValueTestTypes);
> +TYPED_TEST_SUITE(RangeAdapterRValueTest, RangeAdapterRValueTestTypes);
>
> TYPED_TEST(RangeAdapterRValueTest, TrivialOperation) {
> TestRev(reverse(TypeParam({0, 1, 2, 3})));
>
> diff --git a/llvm/unittests/ADT/STLForwardCompatTest.cpp
> b/llvm/unittests/ADT/STLForwardCompatTest.cpp
> index f85669516b79d..e8521fad26632 100644
> --- a/llvm/unittests/ADT/STLForwardCompatTest.cpp
> +++ b/llvm/unittests/ADT/STLForwardCompatTest.cpp
> @@ -59,7 +59,7 @@ using STLForwardCompatRemoveCVRefTestTypes =
> ::testing::Types<
> // clang-format on
> >;
>
> -TYPED_TEST_CASE(STLForwardCompatRemoveCVRefTest,
> +TYPED_TEST_SUITE(STLForwardCompatRemoveCVRefTest,
> STLForwardCompatRemoveCVRefTestTypes);
>
> TYPED_TEST(STLForwardCompatRemoveCVRefTest, RemoveCVRef) {
>
> diff --git a/llvm/unittests/ADT/SmallVectorTest.cpp
> b/llvm/unittests/ADT/SmallVectorTest.cpp
> index a533bb850a451..4673c659382d4 100644
> --- a/llvm/unittests/ADT/SmallVectorTest.cpp
> +++ b/llvm/unittests/ADT/SmallVectorTest.cpp
> @@ -208,7 +208,7 @@ typedef ::testing::Types<SmallVector<Constructable, 0>,
> SmallVector<Constructable, 4>,
> SmallVector<Constructable, 5>
> > SmallVectorTestTypes;
> -TYPED_TEST_CASE(SmallVectorTest, SmallVectorTestTypes);
> +TYPED_TEST_SUITE(SmallVectorTest, SmallVectorTestTypes);
>
> // Constructor test.
> TYPED_TEST(SmallVectorTest, ConstructorNonIterTest) {
> @@ -811,7 +811,7 @@ typedef ::testing::Types<
> std::pair<SmallVector<Constructable, 2>, SmallVector<Constructable,
> 2>>
> > DualSmallVectorTestTypes;
>
> -TYPED_TEST_CASE(DualSmallVectorsTest, DualSmallVectorTestTypes);
> +TYPED_TEST_SUITE(DualSmallVectorsTest, DualSmallVectorTestTypes);
>
> TYPED_TEST(DualSmallVectorsTest, MoveAssignment) {
> SCOPED_TRACE("MoveAssignTest-DualVectorTypes");
> @@ -1095,7 +1095,7 @@ class SmallVectorReferenceInvalidationTest : public
> SmallVectorTestBase {
> using SmallVectorReferenceInvalidationTestTypes =
> ::testing::Types<SmallVector<int, 3>, SmallVector<Constructable, 3>>;
>
> -TYPED_TEST_CASE(SmallVectorReferenceInvalidationTest,
> +TYPED_TEST_SUITE(SmallVectorReferenceInvalidationTest,
> SmallVectorReferenceInvalidationTestTypes);
>
> TYPED_TEST(SmallVectorReferenceInvalidationTest, PushBack) {
> @@ -1382,7 +1382,7 @@ using
> SmallVectorInternalReferenceInvalidationTestTypes =
> ::testing::Types<SmallVector<std::pair<int, int>, 3>,
> SmallVector<std::pair<Constructable, Constructable>,
> 3>>;
>
> -TYPED_TEST_CASE(SmallVectorInternalReferenceInvalidationTest,
> +TYPED_TEST_SUITE(SmallVectorInternalReferenceInvalidationTest,
> SmallVectorInternalReferenceInvalidationTestTypes);
>
> TYPED_TEST(SmallVectorInternalReferenceInvalidationTest, EmplaceBack) {
>
> diff --git a/llvm/unittests/ADT/TinyPtrVectorTest.cpp
> b/llvm/unittests/ADT/TinyPtrVectorTest.cpp
> index f88534787c9e4..d59bd7f4c5b47 100644
> --- a/llvm/unittests/ADT/TinyPtrVectorTest.cpp
> +++ b/llvm/unittests/ADT/TinyPtrVectorTest.cpp
> @@ -83,7 +83,7 @@ class TinyPtrVectorTest : public testing::Test {
> typedef ::testing::Types<TinyPtrVector<int *>, TinyPtrVector<double *>,
> TinyPtrVector<PointerIntPair<int *, 1>>>
> TinyPtrVectorTestTypes;
> -TYPED_TEST_CASE(TinyPtrVectorTest, TinyPtrVectorTestTypes);
> +TYPED_TEST_SUITE(TinyPtrVectorTest, TinyPtrVectorTestTypes);
>
> TYPED_TEST(TinyPtrVectorTest, EmptyTest) {
> this->expectValues(this->V, this->testArray(0));
>
> diff --git a/llvm/unittests/Analysis/ValueTrackingTest.cpp
> b/llvm/unittests/Analysis/ValueTrackingTest.cpp
> index 99a0f6daa84db..2cfbc4cc65f55 100644
> --- a/llvm/unittests/Analysis/ValueTrackingTest.cpp
> +++ b/llvm/unittests/Analysis/ValueTrackingTest.cpp
> @@ -1859,8 +1859,8 @@ const std::pair<const char *, const char *>
> IsBytewiseValueTests[] = {
> },
> };
>
> -INSTANTIATE_TEST_CASE_P(IsBytewiseValueParamTests, IsBytewiseValueTest,
> - ::testing::ValuesIn(IsBytewiseValueTests),);
> +INSTANTIATE_TEST_SUITE_P(IsBytewiseValueParamTests, IsBytewiseValueTest,
> + ::testing::ValuesIn(IsBytewiseValueTests));
>
> TEST_P(IsBytewiseValueTest, IsBytewiseValue) {
> auto M = parseModule(std::string("@test = global ") +
> GetParam().second);
> @@ -2182,5 +2182,5 @@ TEST_P(FindAllocaForValueTest,
> findAllocaForValueZeroOffset) {
> EXPECT_EQ(!!AI, GetParam().ZeroOffsetResult);
> }
>
> -INSTANTIATE_TEST_CASE_P(FindAllocaForValueTest, FindAllocaForValueTest,
> - ::testing::ValuesIn(FindAllocaForValueTests), );
> +INSTANTIATE_TEST_SUITE_P(FindAllocaForValueTest, FindAllocaForValueTest,
> + ::testing::ValuesIn(FindAllocaForValueTests));
>
> diff --git a/llvm/unittests/CodeGen/DIETest.cpp
> b/llvm/unittests/CodeGen/DIETest.cpp
> index 44fb0c0bf6c88..2e3f7b5f76c18 100644
> --- a/llvm/unittests/CodeGen/DIETest.cpp
> +++ b/llvm/unittests/CodeGen/DIETest.cpp
> @@ -67,7 +67,7 @@ TEST_P(DIEExprFixture, EmitValue) {
> Tst.emitValue(TestPrinter->getAP(), Form);
> }
>
> -INSTANTIATE_TEST_CASE_P(
> +INSTANTIATE_TEST_SUITE_P(
> DIETestParams, DIEExprFixture,
> testing::Values(
> DIETestParams{4, dwarf::DWARF32, dwarf::DW_FORM_data4, 4u},
> @@ -75,7 +75,7 @@ INSTANTIATE_TEST_CASE_P(
> DIETestParams{4, dwarf::DWARF32, dwarf::DW_FORM_sec_offset, 4u},
> DIETestParams{4, dwarf::DWARF64, dwarf::DW_FORM_data4, 4u},
> DIETestParams{4, dwarf::DWARF64, dwarf::DW_FORM_data8, 8u},
> - DIETestParams{4, dwarf::DWARF64, dwarf::DW_FORM_sec_offset, 8u}),
> );
> + DIETestParams{4, dwarf::DWARF64, dwarf::DW_FORM_sec_offset, 8u}));
>
> struct DIELabelFixture : public DIEFixtureBase {
> void SetUp() override {
> @@ -113,7 +113,7 @@ TEST_P(DIELabelFixture, EmitValue) {
> EXPECT_EQ(&(ActualArg0->getSymbol()), Val);
> }
>
> -INSTANTIATE_TEST_CASE_P(
> +INSTANTIATE_TEST_SUITE_P(
> DIETestParams, DIELabelFixture,
> testing::Values(
> DIETestParams{4, dwarf::DWARF32, dwarf::DW_FORM_data4, 4u},
> @@ -125,7 +125,7 @@ INSTANTIATE_TEST_CASE_P(
> DIETestParams{4, dwarf::DWARF64, dwarf::DW_FORM_data8, 8u},
> DIETestParams{4, dwarf::DWARF64, dwarf::DW_FORM_sec_offset, 8u},
> DIETestParams{4, dwarf::DWARF64, dwarf::DW_FORM_strp, 8u},
> - DIETestParams{4, dwarf::DWARF64, dwarf::DW_FORM_addr, 8u}), );
> + DIETestParams{4, dwarf::DWARF64, dwarf::DW_FORM_addr, 8u}));
>
> struct DIEDeltaFixture : public DIEFixtureBase {
> void SetUp() override {
> @@ -158,7 +158,7 @@ TEST_P(DIEDeltaFixture, EmitValue) {
> Tst.emitValue(TestPrinter->getAP(), Form);
> }
>
> -INSTANTIATE_TEST_CASE_P(
> +INSTANTIATE_TEST_SUITE_P(
> DIETestParams, DIEDeltaFixture,
> testing::Values(
> DIETestParams{4, dwarf::DWARF32, dwarf::DW_FORM_data4, 4u},
> @@ -166,7 +166,7 @@ INSTANTIATE_TEST_CASE_P(
> DIETestParams{4, dwarf::DWARF32, dwarf::DW_FORM_sec_offset, 4u},
> DIETestParams{4, dwarf::DWARF64, dwarf::DW_FORM_data4, 4u},
> DIETestParams{4, dwarf::DWARF64, dwarf::DW_FORM_data8, 8u},
> - DIETestParams{4, dwarf::DWARF64, dwarf::DW_FORM_sec_offset, 8u}),
> );
> + DIETestParams{4, dwarf::DWARF64, dwarf::DW_FORM_sec_offset, 8u}));
>
> struct DIELocListFixture : public DIEFixtureBase {
> void SetUp() override { DIEFixtureBase::SetUp(); }
> @@ -180,7 +180,7 @@ TEST_P(DIELocListFixture, SizeOf) {
> EXPECT_EQ(Size, Tst.SizeOf(TestPrinter->getAP(), Form));
> }
>
> -INSTANTIATE_TEST_CASE_P(
> +INSTANTIATE_TEST_SUITE_P(
> DIETestParams, DIELocListFixture,
> testing::Values(
> DIETestParams{4, dwarf::DWARF32, dwarf::DW_FORM_loclistx, 2u},
> @@ -188,6 +188,6 @@ INSTANTIATE_TEST_CASE_P(
> DIETestParams{4, dwarf::DWARF32, dwarf::DW_FORM_sec_offset, 4u},
> DIETestParams{4, dwarf::DWARF64, dwarf::DW_FORM_loclistx, 2u},
> DIETestParams{4, dwarf::DWARF64, dwarf::DW_FORM_data8, 8u},
> - DIETestParams{4, dwarf::DWARF64, dwarf::DW_FORM_sec_offset, 8u}),
> );
> + DIETestParams{4, dwarf::DWARF64, dwarf::DW_FORM_sec_offset, 8u}));
>
> } // end namespace
>
> diff --git a/llvm/unittests/DebugInfo/DWARF/DWARFDebugLineTest.cpp
> b/llvm/unittests/DebugInfo/DWARF/DWARFDebugLineTest.cpp
> index 987e0e46ed195..9de6c83f5cc66 100644
> --- a/llvm/unittests/DebugInfo/DWARF/DWARFDebugLineTest.cpp
> +++ b/llvm/unittests/DebugInfo/DWARF/DWARFDebugLineTest.cpp
> @@ -349,10 +349,10 @@ TEST_P(DebugLineUnsupportedVersionFixture,
> ErrorForUnsupportedVersion) {
> std::to_string(Version)));
> }
>
> -INSTANTIATE_TEST_CASE_P(UnsupportedVersionTestParams,
> - DebugLineUnsupportedVersionFixture,
> - Values(/*1 below min */ 1, /* 1 above max */ 6,
> - /* Maximum possible */ 0xffff), );
> +INSTANTIATE_TEST_SUITE_P(UnsupportedVersionTestParams,
> + DebugLineUnsupportedVersionFixture,
> + Values(/*1 below min */ 1, /* 1 above max */ 6,
> + /* Maximum possible */ 0xffff));
>
> TEST_F(DebugLineBasicFixture, ErrorForInvalidV5IncludeDirTable) {
> if (!setupGenerator(5))
> @@ -477,13 +477,13 @@ TEST_P(DebugLineParameterisedFixture,
> ErrorForTooShortPrologueLength) {
>
> FailedWithMessageArray(testing::ElementsAreArray(Errs)));
> }
>
> -INSTANTIATE_TEST_CASE_P(
> +INSTANTIATE_TEST_SUITE_P(
> LineTableTestParams, DebugLineParameterisedFixture,
> Values(std::make_pair(
> 2, DWARF32), // Test lower-bound of v2-3 fields and
> DWARF32.
> std::make_pair(3, DWARF32), // Test upper-bound of v2-3 fields.
> std::make_pair(4, DWARF64), // Test v4 fields and DWARF64.
> - std::make_pair(5, DWARF32), std::make_pair(5, DWARF64)), );
> + std::make_pair(5, DWARF32), std::make_pair(5, DWARF64)));
>
> TEST_F(DebugLineBasicFixture,
> ErrorForExtendedOpcodeLengthSmallerThanExpected) {
> if (!setupGenerator())
> @@ -950,13 +950,13 @@ TEST_P(MaxOpsPerInstFixture,
> MaxOpsPerInstProblemsReportedCorrectly) {
> ", which is unsupported. Assuming a value of 1 instead");
> }
>
> -INSTANTIATE_TEST_CASE_P(
> +INSTANTIATE_TEST_SUITE_P(
> MaxOpsPerInstParams, MaxOpsPerInstFixture,
> Values(std::make_tuple(3, 0, false), // Test for version < 4 (no
> error).
> std::make_tuple(4, 0, true), // Test zero value for V4
> (error).
> std::make_tuple(4, 1, false), // Test good value for V4 (no
> error).
> std::make_tuple(
> - 4, 2, true)), ); // Test one higher than permitted V4
> (error).
> + 4, 2, true))); // Test one higher than permitted V4
> (error).
>
> struct LineRangeFixture : TestWithParam<std::tuple<uint8_t, bool>>,
> AdjustAddressFixtureBase {
> @@ -993,10 +993,10 @@ TEST_P(LineRangeFixture,
> LineRangeProblemsReportedCorrectly) {
> "not be adjusted");
> }
>
> -INSTANTIATE_TEST_CASE_P(
> +INSTANTIATE_TEST_SUITE_P(
> LineRangeParams, LineRangeFixture,
> - Values(std::make_tuple(0, true), // Test zero value (error).
> - std::make_tuple(14, false)), ); // Test non-zero value (no
> error).
> + Values(std::make_tuple(0, true), // Test zero value (error).
> + std::make_tuple(14, false))); // Test non-zero value (no
> error).
>
> struct BadMinInstLenFixture : TestWithParam<std::tuple<uint8_t, bool>>,
> AdjustAddressFixtureBase {
> @@ -1028,10 +1028,10 @@ TEST_P(BadMinInstLenFixture,
> MinInstLengthProblemsReportedCorrectly) {
> "prevents any address advancing");
> }
>
> -INSTANTIATE_TEST_CASE_P(
> +INSTANTIATE_TEST_SUITE_P(
> BadMinInstLenParams, BadMinInstLenFixture,
> - Values(std::make_tuple(0, true), // Test zero value (error).
> - std::make_tuple(1, false)), ); // Test non-zero value (no
> error).
> + Values(std::make_tuple(0, true), // Test zero value (error).
> + std::make_tuple(1, false))); // Test non-zero value (no error).
>
> TEST_F(DebugLineBasicFixture, ParserParsesCorrectly) {
> if (!setupGenerator())
> @@ -1422,7 +1422,7 @@ TEST_P(TruncatedPrologueFixture,
> ErrorForTruncatedPrologue) {
> EXPECT_EQ(Offset, ExpectedOffset);
> }
>
> -INSTANTIATE_TEST_CASE_P(
> +INSTANTIATE_TEST_SUITE_P(
> TruncatedPrologueParams, TruncatedPrologueFixture,
> Values(
> // Truncated length:
> @@ -1501,7 +1501,7 @@ INSTANTIATE_TEST_CASE_P(
> std::make_tuple(
> 0x12, 0x12, 4, DWARF32,
> "parsing line table prologue at offset 0x00000001: unexpected
> end "
> - "of data at offset 0x12 while reading [0x12, 0x13)")), );
> + "of data at offset 0x12 while reading [0x12, 0x13)")));
>
> using ValueAndLengths = std::vector<LineTable::ValueAndLength>;
>
> @@ -1581,7 +1581,7 @@ TEST_P(TruncatedExtendedOpcodeFixture,
> ErrorForTruncatedExtendedOpcode) {
> FailedWithMessage(ExpectedErr.str()));
> }
>
> -INSTANTIATE_TEST_CASE_P(
> +INSTANTIATE_TEST_SUITE_P(
> TruncatedExtendedOpcodeParams, TruncatedExtendedOpcodeFixture,
> Values(
> // Truncated length:
> @@ -1648,7 +1648,7 @@ INSTANTIATE_TEST_CASE_P(
> ValueAndLengths{{0x12343412, LineTable::Long}},
> "Unrecognized extended op 0x7f length 5 (<parsing error> 12
> 34 34)",
> "unexpected end of data at offset 0x35 while reading [0x32, "
> - "0x36)")), );
> + "0x36)")));
>
> TEST_P(TruncatedStandardOpcodeFixture, ErrorForTruncatedStandardOpcode) {
> if (!setupGenerator())
> @@ -1660,7 +1660,7 @@ TEST_P(TruncatedStandardOpcodeFixture,
> ErrorForTruncatedStandardOpcode) {
> FailedWithMessage(ExpectedErr.str()));
> }
>
> -INSTANTIATE_TEST_CASE_P(
> +INSTANTIATE_TEST_SUITE_P(
> TruncatedStandardOpcodeParams, TruncatedStandardOpcodeFixture,
> Values(
> std::make_tuple(2, DW_LNS_advance_pc,
> @@ -1704,7 +1704,7 @@ INSTANTIATE_TEST_CASE_P(
> ValueAndLengths{{0x900, LineTable::ULEB}, {0xa00,
> LineTable::ULEB}},
> "Unrecognized standard opcode (operands: 0x0000000000000900)",
> "unable to decode LEB128 at offset 0x00000032: "
> - "malformed uleb128, extends past end")), );
> + "malformed uleb128, extends past end")));
>
> TEST_F(DebugLineBasicFixture, PrintPathsProperly) {
> if (!setupGenerator(5))
>
> diff --git a/llvm/unittests/DebugInfo/DWARF/DWARFFormValueTest.cpp
> b/llvm/unittests/DebugInfo/DWARF/DWARFFormValueTest.cpp
> index 0a0b8084f65f0..954abb7691253 100644
> --- a/llvm/unittests/DebugInfo/DWARF/DWARFFormValueTest.cpp
> +++ b/llvm/unittests/DebugInfo/DWARF/DWARFFormValueTest.cpp
> @@ -187,7 +187,7 @@ struct FormSkipValueFixture2 :
> FormSkipValueFixtureBase {};
> TEST_P(FormSkipValueFixture1, skipValuePart1) { doSkipValueTest(); }
> TEST_P(FormSkipValueFixture2, skipValuePart2) { doSkipValueTest(); }
>
> -INSTANTIATE_TEST_CASE_P(
> +INSTANTIATE_TEST_SUITE_P(
> SkipValueTestParams1, FormSkipValueFixture1,
> testing::Values(
> // Form, Version, AddrSize, DwarfFormat, InitialData,
> ExpectedSize,
> @@ -246,9 +246,9 @@ INSTANTIATE_TEST_CASE_P(
> ParamType(DW_FORM_strp_sup, 0, 1, DWARF32, SampleU32, 0, false),
> ParamType(DW_FORM_strp_sup, 1, 0, DWARF32, SampleU32, 0, false),
> ParamType(DW_FORM_strp_sup, 1, 1, DWARF32, SampleU32, 4, true),
> - ParamType(DW_FORM_strp_sup, 1, 1, DWARF64, SampleU32, 8, true)),
> );
> + ParamType(DW_FORM_strp_sup, 1, 1, DWARF64, SampleU32, 8, true)));
>
> -INSTANTIATE_TEST_CASE_P(
> +INSTANTIATE_TEST_SUITE_P(
> SkipValueTestParams2, FormSkipValueFixture2,
> testing::Values(
> ParamType(DW_FORM_line_strp, 0, 1, DWARF32, SampleU32, 0, false),
> @@ -301,8 +301,7 @@ INSTANTIATE_TEST_CASE_P(
> ArrayRef<uint8_t>(IndirectIndirectEnd,
> sizeof(IndirectIndirectEnd)),
> 2, false),
> - ParamType(/*Unknown=*/Form(0xff), 4, 4, DWARF32, SampleU32, 0,
> - false)), );
> + ParamType(/*Unknown=*/Form(0xff), 4, 4, DWARF32, SampleU32, 0,
> false)));
>
> using ErrorParams = std::tuple<Form, std::vector<uint8_t>>;
> struct ExtractValueErrorFixture : public
> testing::TestWithParam<ErrorParams> {
> @@ -323,7 +322,7 @@ TEST_P(ExtractValueErrorFixture, Test) {
> EXPECT_FALSE(Form.extractValue(Data, &Offset, {0, 0, DWARF32}));
> }
>
> -INSTANTIATE_TEST_CASE_P(
> +INSTANTIATE_TEST_SUITE_P(
> ExtractValueErrorParams, ExtractValueErrorFixture,
> testing::Values(
> ErrorParams{DW_FORM_ref_addr, {}}, ErrorParams{DW_FORM_block, {}},
> @@ -336,8 +335,7 @@ INSTANTIATE_TEST_CASE_P(
> ErrorParams{DW_FORM_udata, {}}, ErrorParams{DW_FORM_string, {}},
> ErrorParams{DW_FORM_indirect, {}},
> ErrorParams{DW_FORM_indirect, {DW_FORM_data1}},
> - ErrorParams{DW_FORM_strp_sup, {}},
> - ErrorParams{DW_FORM_ref_sig8, {}}), );
> + ErrorParams{DW_FORM_strp_sup, {}}, ErrorParams{DW_FORM_ref_sig8,
> {}}));
>
> using DumpValueParams =
> std::tuple<Form, ArrayRef<uint8_t>, DwarfFormat, StringRef>;
> @@ -379,7 +377,7 @@ ArrayRef<uint8_t> DumpTestSample32 =
> toBytes(DumpTestSample32Val);
> const uint64_t DumpTestSample64Val = 0x11223344556677;
> ArrayRef<uint8_t> DumpTestSample64 = toBytes(DumpTestSample64Val);
>
> -INSTANTIATE_TEST_CASE_P(
> +INSTANTIATE_TEST_SUITE_P(
> DumpValueParams, DumpValueFixture,
> testing::Values(DumpValueParams{DW_FORM_strp, DumpTestSample32,
> DWARF32,
> " .debug_str[0x00112233] = "},
> @@ -393,6 +391,6 @@ INSTANTIATE_TEST_CASE_P(
> DumpValueParams{DW_FORM_sec_offset, DumpTestSample32,
> DWARF32, "0x00112233"},
> DumpValueParams{DW_FORM_sec_offset, DumpTestSample64,
> - DWARF64, "0x0011223344556677"}), );
> + DWARF64, "0x0011223344556677"}));
>
> } // end anonymous namespace
>
> diff --git a/llvm/unittests/FileCheck/FileCheckTest.cpp
> b/llvm/unittests/FileCheck/FileCheckTest.cpp
> index 60ada3836a6a1..f3b5d3d2aaab6 100644
> --- a/llvm/unittests/FileCheck/FileCheckTest.cpp
> +++ b/llvm/unittests/FileCheck/FileCheckTest.cpp
> @@ -330,7 +330,7 @@ TEST_P(ExpressionFormatParameterisedFixture,
> FormatBoolOperator) {
> EXPECT_TRUE(bool(Format));
> }
>
> -INSTANTIATE_TEST_CASE_P(
> +INSTANTIATE_TEST_SUITE_P(
> AllowedExplicitExpressionFormat, ExpressionFormatParameterisedFixture,
> ::testing::Values(
> std::make_tuple(ExpressionFormat::Kind::Unsigned, 0, false),
> @@ -355,7 +355,7 @@ INSTANTIATE_TEST_CASE_P(
> std::make_tuple(ExpressionFormat::Kind::HexUpper, 16, true),
>
> std::make_tuple(ExpressionFormat::Kind::Unsigned, 20, false),
> - std::make_tuple(ExpressionFormat::Kind::Signed, 20, false)), );
> + std::make_tuple(ExpressionFormat::Kind::Signed, 20, false)));
>
> TEST_F(FileCheckTest, NoFormatProperties) {
> ExpressionFormat NoFormat(ExpressionFormat::Kind::NoFormat);
>
> diff --git a/llvm/unittests/Frontend/OpenMPIRBuilderTest.cpp
> b/llvm/unittests/Frontend/OpenMPIRBuilderTest.cpp
> index 894311363ba10..35a52310d3767 100644
> --- a/llvm/unittests/Frontend/OpenMPIRBuilderTest.cpp
> +++ b/llvm/unittests/Frontend/OpenMPIRBuilderTest.cpp
> @@ -1827,7 +1827,7 @@ TEST_P(OpenMPIRBuilderTestWithParams,
> DynamicWorkShareLoop) {
> EXPECT_FALSE(verifyModule(*M, &errs()));
> }
>
> -INSTANTIATE_TEST_CASE_P(OpenMPWSLoopSchedulingTypes,
> +INSTANTIATE_TEST_SUITE_P(OpenMPWSLoopSchedulingTypes,
> OpenMPIRBuilderTestWithParams,
>
> ::testing::Values(omp::OMPScheduleType::DynamicChunked,
>
> omp::OMPScheduleType::GuidedChunked,
>
> diff --git a/llvm/unittests/IR/PassBuilderCallbacksTest.cpp
> b/llvm/unittests/IR/PassBuilderCallbacksTest.cpp
> index 6d0b9e8abcb6d..e0bd129bc1605 100644
> --- a/llvm/unittests/IR/PassBuilderCallbacksTest.cpp
> +++ b/llvm/unittests/IR/PassBuilderCallbacksTest.cpp
> @@ -27,11 +27,12 @@ using namespace llvm;
> namespace {
> using testing::AnyNumber;
> using testing::AtLeast;
> +using testing::DoAll;
> using testing::DoDefault;
> -using testing::Not;
> -using testing::Return;
> using testing::Expectation;
> using testing::Invoke;
> +using testing::Not;
> +using testing::Return;
> using testing::WithArgs;
> using testing::_;
>
>
> diff --git a/llvm/unittests/IR/PatternMatch.cpp
> b/llvm/unittests/IR/PatternMatch.cpp
> index fd4e446738b0b..31b312ba35d15 100644
> --- a/llvm/unittests/IR/PatternMatch.cpp
> +++ b/llvm/unittests/IR/PatternMatch.cpp
> @@ -1641,7 +1641,7 @@ template <typename T> struct MutableConstTest :
> PatternMatchTest { };
> typedef ::testing::Types<std::tuple<Value*, Instruction*>,
> std::tuple<const Value*, const Instruction *>>
> MutableConstTestTypes;
> -TYPED_TEST_CASE(MutableConstTest, MutableConstTestTypes);
> +TYPED_TEST_SUITE(MutableConstTest, MutableConstTestTypes);
>
> TYPED_TEST(MutableConstTest, ICmp) {
> auto &IRB = PatternMatchTest::IRB;
>
> diff --git a/llvm/unittests/IR/ValueMapTest.cpp
> b/llvm/unittests/IR/ValueMapTest.cpp
> index cfb37f0b8df7f..57f2b7bea19ae 100644
> --- a/llvm/unittests/IR/ValueMapTest.cpp
> +++ b/llvm/unittests/IR/ValueMapTest.cpp
> @@ -35,7 +35,7 @@ class ValueMapTest : public testing::Test {
> // Run everything on Value*, a subtype to make sure that casting works as
> // expected, and a const subtype to make sure we cast const correctly.
> typedef ::testing::Types<Value, Instruction, const Instruction> KeyTypes;
> -TYPED_TEST_CASE(ValueMapTest, KeyTypes);
> +TYPED_TEST_SUITE(ValueMapTest, KeyTypes);
>
> TYPED_TEST(ValueMapTest, Null) {
> ValueMap<TypeParam*, int> VM1;
>
> diff --git a/llvm/unittests/Passes/PluginsTest.cpp
> b/llvm/unittests/Passes/PluginsTest.cpp
> index 62334c828cb4b..9fa5a0bdaf983 100644
> --- a/llvm/unittests/Passes/PluginsTest.cpp
> +++ b/llvm/unittests/Passes/PluginsTest.cpp
> @@ -27,8 +27,7 @@ using namespace llvm;
> void anchor() {}
>
> static std::string LibPath(const std::string Name = "TestPlugin") {
> - const std::vector<testing::internal::string> &Argvs =
> - testing::internal::GetArgvs();
> + const auto &Argvs = testing::internal::GetArgvs();
> const char *Argv0 = Argvs.size() > 0 ? Argvs[0].c_str() :
> "PluginsTests";
> void *Ptr = (void *)(intptr_t)anchor;
> std::string Path = sys::fs::getMainExecutable(Argv0, Ptr);
>
> diff --git a/llvm/unittests/ProfileData/CoverageMappingTest.cpp
> b/llvm/unittests/ProfileData/CoverageMappingTest.cpp
> index 6434474b06850..f1d09c28f035a 100644
> --- a/llvm/unittests/ProfileData/CoverageMappingTest.cpp
> +++ b/llvm/unittests/ProfileData/CoverageMappingTest.cpp
> @@ -893,11 +893,12 @@ TEST_P(CoverageMappingTest,
> skip_duplicate_function_record) {
> }
>
> // FIXME: Use ::testing::Combine() when llvm updates its copy of
> googletest.
> -INSTANTIATE_TEST_CASE_P(ParameterizedCovMapTest, CoverageMappingTest,
> - ::testing::Values(std::pair<bool, bool>({false,
> false}),
> - std::pair<bool, bool>({false,
> true}),
> - std::pair<bool, bool>({true,
> false}),
> - std::pair<bool, bool>({true,
> true})),);
> +INSTANTIATE_TEST_SUITE_P(
> + ParameterizedCovMapTest, CoverageMappingTest,
> + ::testing::Values(std::pair<bool, bool>({false, false}),
> + std::pair<bool, bool>({false, true}),
> + std::pair<bool, bool>({true, false}),
> + std::pair<bool, bool>({true, true})));
>
> TEST(CoverageMappingTest, filename_roundtrip) {
> std::vector<std::string> Paths({"dir", "a", "b", "c", "d", "e"});
>
> diff --git a/llvm/unittests/ProfileData/InstrProfTest.cpp
> b/llvm/unittests/ProfileData/InstrProfTest.cpp
> index d94906991b0c6..d7661776d75fa 100644
> --- a/llvm/unittests/ProfileData/InstrProfTest.cpp
> +++ b/llvm/unittests/ProfileData/InstrProfTest.cpp
> @@ -1041,8 +1041,8 @@ TEST_F(SparseInstrProfTest, preserve_no_records) {
> ASSERT_TRUE(I == E);
> }
>
> -INSTANTIATE_TEST_CASE_P(MaybeSparse, MaybeSparseInstrProfTest,
> - ::testing::Bool(),);
> +INSTANTIATE_TEST_SUITE_P(MaybeSparse, MaybeSparseInstrProfTest,
> + ::testing::Bool());
>
> #if defined(_LP64) && defined(EXPENSIVE_CHECKS)
> TEST(ProfileReaderTest, ReadsLargeFiles) {
>
> diff --git a/llvm/unittests/Support/DynamicLibrary/DynamicLibraryTest.cpp
> b/llvm/unittests/Support/DynamicLibrary/DynamicLibraryTest.cpp
> index a06399a0b3133..6c9063775a59d 100644
> --- a/llvm/unittests/Support/DynamicLibrary/DynamicLibraryTest.cpp
> +++ b/llvm/unittests/Support/DynamicLibrary/DynamicLibraryTest.cpp
> @@ -19,8 +19,7 @@ using namespace llvm;
> using namespace llvm::sys;
>
> std::string LibPath(const std::string Name = "PipSqueak") {
> - const std::vector<testing::internal::string> &Argvs =
> - testing::internal::GetArgvs();
> + const auto &Argvs = testing::internal::GetArgvs();
> const char *Argv0 =
> Argvs.size() > 0 ? Argvs[0].c_str() : "DynamicLibraryTests";
> void *Ptr = (void*)(intptr_t)TestA;
>
> diff --git a/llvm/unittests/Support/MathExtrasTest.cpp
> b/llvm/unittests/Support/MathExtrasTest.cpp
> index d899af9685e30..50dd1513e0274 100644
> --- a/llvm/unittests/Support/MathExtrasTest.cpp
> +++ b/llvm/unittests/Support/MathExtrasTest.cpp
> @@ -483,7 +483,7 @@ class OverflowTest : public ::testing::Test { };
> using OverflowTestTypes = ::testing::Types<signed char, short, int, long,
> long long>;
>
> -TYPED_TEST_CASE(OverflowTest, OverflowTestTypes);
> +TYPED_TEST_SUITE(OverflowTest, OverflowTestTypes);
>
> TYPED_TEST(OverflowTest, AddNoOverflow) {
> TypeParam Result;
>
> diff --git a/llvm/unittests/Support/MemoryTest.cpp
> b/llvm/unittests/Support/MemoryTest.cpp
> index 6e5f7472e4549..bcbbd285823ee 100644
> --- a/llvm/unittests/Support/MemoryTest.cpp
> +++ b/llvm/unittests/Support/MemoryTest.cpp
> @@ -428,8 +428,7 @@ unsigned MemoryFlags[] = {
>
> Memory::MF_READ|Memory::MF_WRITE|Memory::MF_EXEC
> };
>
> -INSTANTIATE_TEST_CASE_P(AllocationTests,
> - MappedMemoryTest,
> - ::testing::ValuesIn(MemoryFlags),);
> +INSTANTIATE_TEST_SUITE_P(AllocationTests, MappedMemoryTest,
> + ::testing::ValuesIn(MemoryFlags));
>
> } // anonymous namespace
>
> diff --git a/llvm/unittests/Support/TargetParserTest.cpp
> b/llvm/unittests/Support/TargetParserTest.cpp
> index e820ff8754d22..0d4fd08b7fce1 100644
> --- a/llvm/unittests/Support/TargetParserTest.cpp
> +++ b/llvm/unittests/Support/TargetParserTest.cpp
> @@ -118,7 +118,7 @@ TEST_P(ARMCPUTestFixture, ARMCPUTests) {
> // we expect. This is because the default extensions for a CPU are the sum
> // of the default extensions for its architecture and for the CPU.
> // So if a CPU has no extra extensions, it adds AEK_NONE.
> -INSTANTIATE_TEST_CASE_P(
> +INSTANTIATE_TEST_SUITE_P(
> ARMCPUTestsPart1, ARMCPUTestFixture,
> ::testing::Values(
> ARMCPUTestParams("invalid", "invalid", "invalid", ARM::AEK_NONE,
> ""),
> @@ -194,11 +194,11 @@ INSTANTIATE_TEST_CASE_P(
> ARM::AEK_SEC | ARM::AEK_VIRT | ARM::AEK_DSP,
> "7-A"),
> ARMCPUTestParams("cortex-a8", "armv7-a", "neon",
> - ARM::AEK_SEC | ARM::AEK_DSP, "7-A")), );
> + ARM::AEK_SEC | ARM::AEK_DSP, "7-A")));
>
> // gtest in llvm has a limit of 50 test cases when using ::Values so we
> split
> // them into 2 blocks
> -INSTANTIATE_TEST_CASE_P(
> +INSTANTIATE_TEST_SUITE_P(
> ARMCPUTestsPart2, ARMCPUTestFixture,
> ::testing::Values(
> ARMCPUTestParams("cortex-a9", "armv7-a", "neon-fp16",
> @@ -309,10 +309,9 @@ INSTANTIATE_TEST_CASE_P(
> ARM::AEK_FP16 | ARM::AEK_RAS |
> ARM::AEK_DOTPROD,
> "8.2-A"),
> ARMCPUTestParams("cortex-a78c", "armv8.2-a",
> "crypto-neon-fp-armv8",
> - ARM::AEK_SEC | ARM::AEK_MP |
> - ARM::AEK_VIRT | ARM::AEK_HWDIVARM |
> - ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP |
> - ARM::AEK_CRC | ARM::AEK_RAS |
> + ARM::AEK_SEC | ARM::AEK_MP | ARM::AEK_VIRT |
> + ARM::AEK_HWDIVARM | ARM::AEK_HWDIVTHUMB |
> + ARM::AEK_DSP | ARM::AEK_CRC | ARM::AEK_RAS |
> ARM::AEK_FP16 | ARM::AEK_DOTPROD,
> "8.2-A"),
> ARMCPUTestParams("cortex-a77", "armv8.2-a",
> "crypto-neon-fp-armv8",
> @@ -390,7 +389,7 @@ INSTANTIATE_TEST_CASE_P(
> ARMCPUTestParams("xscale", "xscale", "none", ARM::AEK_NONE,
> "xscale"),
> ARMCPUTestParams("swift", "armv7s", "neon-vfpv4",
> ARM::AEK_HWDIVARM | ARM::AEK_HWDIVTHUMB |
> ARM::AEK_DSP,
> - "7-S")), );
> + "7-S")));
>
> static constexpr unsigned NumARMCPUArchs = 92;
>
> @@ -876,7 +875,7 @@ TEST_P(AArch64CPUTestFixture, testAArch64CPU) {
> EXPECT_EQ(params.CPUAttr, AArch64::getCPUAttr(AK));
> }
>
> -INSTANTIATE_TEST_CASE_P(
> +INSTANTIATE_TEST_SUITE_P(
> AArch64CPUTests, AArch64CPUTestFixture,
> ::testing::Values(
> ARMCPUTestParams("invalid", "invalid", "invalid",
> AArch64::AEK_NONE,
> @@ -1180,7 +1179,7 @@ INSTANTIATE_TEST_CASE_P(
> AArch64::AEK_FP | AArch64::AEK_SIMD |
> AArch64::AEK_FP16 | AArch64::AEK_RAS |
> AArch64::AEK_LSE | AArch64::AEK_RDM,
> - "8.2-A")), );
> + "8.2-A")));
>
> static constexpr unsigned NumAArch64CPUArchs = 48;
>
>
> diff --git a/llvm/unittests/XRay/FDRProducerConsumerTest.cpp
> b/llvm/unittests/XRay/FDRProducerConsumerTest.cpp
> index 6eff4dfcc505f..f96ba55476d32 100644
> --- a/llvm/unittests/XRay/FDRProducerConsumerTest.cpp
> +++ b/llvm/unittests/XRay/FDRProducerConsumerTest.cpp
> @@ -94,7 +94,7 @@ template <class T> class RoundTripTest : public
> ::testing::Test {
> std::unique_ptr<Record> Rec;
> };
>
> -TYPED_TEST_CASE_P(RoundTripTest);
> +TYPED_TEST_SUITE_P(RoundTripTest);
>
> template <class T> class RoundTripTestV5 : public ::testing::Test {
> public:
> @@ -117,7 +117,7 @@ template <class T> class RoundTripTestV5 : public
> ::testing::Test {
> std::unique_ptr<Record> Rec;
> };
>
> -TYPED_TEST_CASE_P(RoundTripTestV5);
> +TYPED_TEST_SUITE_P(RoundTripTestV5);
>
> // This test ensures that the writing and reading implementations are in
> sync --
> // that given write(read(write(R))) == R.
> @@ -160,7 +160,7 @@ TYPED_TEST_P(RoundTripTest, RoundTripsSingleValue) {
> EXPECT_THAT(Records[1]->getRecordType(), Eq(R->getRecordType()));
> }
>
> -REGISTER_TYPED_TEST_CASE_P(RoundTripTest, RoundTripsSingleValue);
> +REGISTER_TYPED_TEST_SUITE_P(RoundTripTest, RoundTripsSingleValue);
>
> // We duplicate the above case for the V5 version using
> diff erent types and
> // encodings.
> @@ -201,21 +201,21 @@ TYPED_TEST_P(RoundTripTestV5, RoundTripsSingleValue)
> {
> EXPECT_THAT(Records[1]->getRecordType(), Eq(R->getRecordType()));
> }
>
> -REGISTER_TYPED_TEST_CASE_P(RoundTripTestV5, RoundTripsSingleValue);
> +REGISTER_TYPED_TEST_SUITE_P(RoundTripTestV5, RoundTripsSingleValue);
>
> // These are the record types we support for v4 and below.
> using RecordTypes =
> ::testing::Types<NewBufferRecord, NewCPUIDRecord, TSCWrapRecord,
> WallclockRecord, CustomEventRecord, CallArgRecord,
> PIDRecord, FunctionRecord>;
> -INSTANTIATE_TYPED_TEST_CASE_P(Records, RoundTripTest, RecordTypes);
> +INSTANTIATE_TYPED_TEST_SUITE_P(Records, RoundTripTest, RecordTypes);
>
> // For V5, we have two new types we're supporting.
> using RecordTypesV5 =
> ::testing::Types<NewBufferRecord, NewCPUIDRecord, TSCWrapRecord,
> WallclockRecord, CustomEventRecordV5,
> TypedEventRecord,
> CallArgRecord, PIDRecord, FunctionRecord>;
> -INSTANTIATE_TYPED_TEST_CASE_P(Records, RoundTripTestV5, RecordTypesV5);
> +INSTANTIATE_TYPED_TEST_SUITE_P(Records, RoundTripTestV5, RecordTypesV5);
>
> } // namespace
> } // namespace xray
>
> diff --git a/llvm/unittests/XRay/FDRRecordPrinterTest.cpp
> b/llvm/unittests/XRay/FDRRecordPrinterTest.cpp
> index bfee1c5d388c4..a1fb8c3183dbe 100644
> --- a/llvm/unittests/XRay/FDRRecordPrinterTest.cpp
> +++ b/llvm/unittests/XRay/FDRRecordPrinterTest.cpp
> @@ -107,7 +107,7 @@ template <class T> class PrinterTest : public
> ::testing::Test {
> PrinterTest() : Data(), OS(Data), P(OS), R(Helper<T>::construct()) {}
> };
>
> -TYPED_TEST_CASE_P(PrinterTest);
> +TYPED_TEST_SUITE_P(PrinterTest);
>
> TYPED_TEST_P(PrinterTest, PrintsRecord) {
> ASSERT_NE(nullptr, this->R);
> @@ -116,13 +116,13 @@ TYPED_TEST_P(PrinterTest, PrintsRecord) {
> EXPECT_THAT(this->Data, Eq(Helper<TypeParam>::expected()));
> }
>
> -REGISTER_TYPED_TEST_CASE_P(PrinterTest, PrintsRecord);
> +REGISTER_TYPED_TEST_SUITE_P(PrinterTest, PrintsRecord);
> using FDRRecordTypes =
> ::testing::Types<BufferExtents, NewBufferRecord, EndBufferRecord,
> NewCPUIDRecord, TSCWrapRecord, WallclockRecord,
> CustomEventRecord, CallArgRecord, BufferExtents,
> PIDRecord>;
> -INSTANTIATE_TYPED_TEST_CASE_P(Records, PrinterTest, FDRRecordTypes);
> +INSTANTIATE_TYPED_TEST_SUITE_P(Records, PrinterTest, FDRRecordTypes);
>
> TEST(FDRRecordPrinterTest, WriteFunctionRecordEnter) {
> std::string Data;
>
> diff --git a/llvm/unittests/XRay/GraphTest.cpp
> b/llvm/unittests/XRay/GraphTest.cpp
> index 52580b3068266..f9453f57ebf02 100644
> --- a/llvm/unittests/XRay/GraphTest.cpp
> +++ b/llvm/unittests/XRay/GraphTest.cpp
> @@ -59,7 +59,7 @@ typedef ::testing::Types<GraphT, const GraphT>
> GraphTestTypes;
> using VVT = typename GraphT::VertexValueType;
> using EVT = typename GraphT::EdgeValueType;
>
> -TYPED_TEST_CASE(GraphTest, GraphTestTypes);
> +TYPED_TEST_SUITE(GraphTest, GraphTestTypes);
>
> template <typename T> void graphVertexTester(T &G) {
> std::set<unsigned> V({1u, 2u, 3u, 4u, 5u, 6u});
>
> diff --git a/llvm/utils/unittest/googlemock/include/gmock/gmock-actions.h
> b/llvm/utils/unittest/googlemock/include/gmock/gmock-actions.h
> index 5a00f3ba9f461..8cfc292e9b7c8 100644
> --- a/llvm/utils/unittest/googlemock/include/gmock/gmock-actions.h
> +++ b/llvm/utils/unittest/googlemock/include/gmock/gmock-actions.h
> @@ -44,15 +44,19 @@
> #endif
>
> #include <algorithm>
> +#include <functional>
> +#include <memory>
> #include <string>
> +#include <type_traits>
> +#include <utility>
>
> #include "gmock/internal/gmock-internal-utils.h"
> #include "gmock/internal/gmock-port.h"
>
> -#if GTEST_LANG_CXX11 // Defined by gtest-port.h via gmock-port.h.
> -#include <functional>
> -#include <type_traits>
> -#endif // GTEST_LANG_CXX11
> +#ifdef _MSC_VER
> +# pragma warning(push)
> +# pragma warning(disable:4100)
> +#endif
>
> namespace testing {
>
> @@ -67,9 +71,6 @@ namespace testing {
>
> namespace internal {
>
> -template <typename F1, typename F2>
> -class ActionAdaptor;
> -
> // BuiltInDefaultValueGetter<T, true>::Get() returns a
> // default-constructed T value. BuiltInDefaultValueGetter<T,
> // false>::Get() crashes with an error.
> @@ -100,8 +101,8 @@ struct BuiltInDefaultValueGetter<T, false> {
> template <typename T>
> class BuiltInDefaultValue {
> public:
> -#if GTEST_LANG_CXX11
> - // This function returns true iff type T has a built-in default value.
> + // This function returns true if and only if type T has a built-in
> default
> + // value.
> static bool Exists() {
> return ::std::is_default_constructible<T>::value;
> }
> @@ -110,18 +111,6 @@ class BuiltInDefaultValue {
> return BuiltInDefaultValueGetter<
> T, ::std::is_default_constructible<T>::value>::Get();
> }
> -
> -#else // GTEST_LANG_CXX11
> - // This function returns true iff type T has a built-in default value.
> - static bool Exists() {
> - return false;
> - }
> -
> - static T Get() {
> - return BuiltInDefaultValueGetter<T, false>::Get();
> - }
> -
> -#endif // GTEST_LANG_CXX11
> };
>
> // This partial specialization says that we use the same built-in
> @@ -139,7 +128,7 @@ template <typename T>
> class BuiltInDefaultValue<T*> {
> public:
> static bool Exists() { return true; }
> - static T* Get() { return NULL; }
> + static T* Get() { return nullptr; }
> };
>
> // The following specializations define the default values for
> @@ -153,9 +142,6 @@ class BuiltInDefaultValue<T*> {
> }
>
> GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(void, ); // NOLINT
> -#if GTEST_HAS_GLOBAL_STRING
> -GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(::string, "");
> -#endif // GTEST_HAS_GLOBAL_STRING
> GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(::std::string, "");
> GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(bool, false);
> GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned char, '\0');
> @@ -222,11 +208,11 @@ class DefaultValue {
> // Unsets the default value for type T.
> static void Clear() {
> delete producer_;
> - producer_ = NULL;
> + producer_ = nullptr;
> }
>
> - // Returns true iff the user has set the default value for type T.
> - static bool IsSet() { return producer_ != NULL; }
> + // Returns true if and only if the user has set the default value for
> type T.
> + static bool IsSet() { return producer_ != nullptr; }
>
> // Returns true if T has a default return value set by the user or there
> // exists a built-in default value.
> @@ -238,8 +224,8 @@ class DefaultValue {
> // otherwise returns the built-in default value. Requires that Exists()
> // is true, which ensures that the return value is well-defined.
> static T Get() {
> - return producer_ == NULL ?
> - internal::BuiltInDefaultValue<T>::Get() : producer_->Produce();
> + return producer_ == nullptr ? internal::BuiltInDefaultValue<T>::Get()
> + : producer_->Produce();
> }
>
> private:
> @@ -252,7 +238,7 @@ class DefaultValue {
> class FixedValueProducer : public ValueProducer {
> public:
> explicit FixedValueProducer(T value) : value_(value) {}
> - virtual T Produce() { return value_; }
> + T Produce() override { return value_; }
>
> private:
> const T value_;
> @@ -263,7 +249,7 @@ class DefaultValue {
> public:
> explicit FactoryValueProducer(FactoryFunction factory)
> : factory_(factory) {}
> - virtual T Produce() { return factory_(); }
> + T Produce() override { return factory_(); }
>
> private:
> const FactoryFunction factory_;
> @@ -284,12 +270,10 @@ class DefaultValue<T&> {
> }
>
> // Unsets the default value for type T&.
> - static void Clear() {
> - address_ = NULL;
> - }
> + static void Clear() { address_ = nullptr; }
>
> - // Returns true iff the user has set the default value for type T&.
> - static bool IsSet() { return address_ != NULL; }
> + // Returns true if and only if the user has set the default value for
> type T&.
> + static bool IsSet() { return address_ != nullptr; }
>
> // Returns true if T has a default return value set by the user or there
> // exists a built-in default value.
> @@ -301,8 +285,8 @@ class DefaultValue<T&> {
> // otherwise returns the built-in default value if there is one;
> // otherwise aborts the process.
> static T& Get() {
> - return address_ == NULL ?
> - internal::BuiltInDefaultValue<T&>::Get() : *address_;
> + return address_ == nullptr ? internal::BuiltInDefaultValue<T&>::Get()
> + : *address_;
> }
>
> private:
> @@ -320,11 +304,11 @@ class DefaultValue<void> {
>
> // Points to the user-set default value for type T.
> template <typename T>
> -typename DefaultValue<T>::ValueProducer* DefaultValue<T>::producer_ =
> NULL;
> +typename DefaultValue<T>::ValueProducer* DefaultValue<T>::producer_ =
> nullptr;
>
> // Points to the user-set default value for type T&.
> template <typename T>
> -T* DefaultValue<T&>::address_ = NULL;
> +T* DefaultValue<T&>::address_ = nullptr;
>
> // Implement this interface to define an action for function type F.
> template <typename F>
> @@ -349,14 +333,25 @@ class ActionInterface {
> // An Action<F> is a copyable and IMMUTABLE (except by assignment)
> // object that represents an action to be taken when a mock function
> // of type F is called. The implementation of Action<T> is just a
> -// linked_ptr to const ActionInterface<T>, so copying is fairly cheap.
> -// Don't inherit from Action!
> -//
> +// std::shared_ptr to const ActionInterface<T>. Don't inherit from Action!
> // You can view an object implementing ActionInterface<F> as a
> // concrete action (including its current state), and an Action<F>
> // object as a handle to it.
> template <typename F>
> class Action {
> + // Adapter class to allow constructing Action from a legacy
> ActionInterface.
> + // New code should create Actions from functors instead.
> + struct ActionAdapter {
> + // Adapter must be copyable to satisfy std::function requirements.
> + ::std::shared_ptr<ActionInterface<F>> impl_;
> +
> + template <typename... Args>
> + typename internal::Function<F>::Result operator()(Args&&... args) {
> + return impl_->Perform(
> + ::std::forward_as_tuple(::std::forward<Args>(args)...));
> + }
> + };
> +
> public:
> typedef typename internal::Function<F>::Result Result;
> typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
> @@ -365,7 +360,6 @@ class Action {
> // STL containers.
> Action() {}
>
> -#if GTEST_LANG_CXX11
> // Construct an Action from a specified callable.
> // This cannot take std::function directly, because then Action would
> not be
> // directly constructible from lambda (it would require two
> conversions).
> @@ -373,26 +367,19 @@ class Action {
> typename = typename ::std::enable_if<
> ::std::is_constructible<::std::function<F>,
> G>::value>::type>
> Action(G&& fun) : fun_(::std::forward<G>(fun)) {} // NOLINT
> -#endif
>
> // Constructs an Action from its implementation.
> - explicit Action(ActionInterface<F>* impl) : impl_(impl) {}
> + explicit Action(ActionInterface<F>* impl)
> + : fun_(ActionAdapter{::std::shared_ptr<ActionInterface<F>>(impl)})
> {}
>
> // This constructor allows us to turn an Action<Func> object into an
> // Action<F>, as long as F's arguments can be implicitly converted
> - // to Func's and Func's return type can be implicitly converted to
> - // F's.
> + // to Func's and Func's return type can be implicitly converted to F's.
> template <typename Func>
> - explicit Action(const Action<Func>& action);
> -
> - // Returns true iff this is the DoDefault() action.
> - bool IsDoDefault() const {
> -#if GTEST_LANG_CXX11
> - return impl_ == nullptr && fun_ == nullptr;
> -#else
> - return impl_ == NULL;
> -#endif
> - }
> + explicit Action(const Action<Func>& action) : fun_(action.fun_) {}
> +
> + // Returns true if and only if this is the DoDefault() action.
> + bool IsDoDefault() const { return fun_ == nullptr; }
>
> // Performs the action. Note that this method is const even though
> // the corresponding method in ActionInterface is not. The reason
> @@ -404,31 +391,15 @@ class Action {
> if (IsDoDefault()) {
> internal::IllegalDoDefault(__FILE__, __LINE__);
> }
> -#if GTEST_LANG_CXX11
> - if (fun_ != nullptr) {
> - return internal::Apply(fun_, ::std::move(args));
> - }
> -#endif
> - return impl_->Perform(args);
> + return internal::Apply(fun_, ::std::move(args));
> }
>
> private:
> - template <typename F1, typename F2>
> - friend class internal::ActionAdaptor;
> -
> template <typename G>
> friend class Action;
>
> - // In C++11, Action can be implemented either as a generic functor
> (through
> - // std::function), or legacy ActionInterface. In C++98, only
> ActionInterface
> - // is available. The invariants are as follows:
> - // * in C++98, impl_ is null iff this is the default action
> - // * in C++11, at most one of fun_ & impl_ may be nonnull; both are
> null iff
> - // this is the default action
> -#if GTEST_LANG_CXX11
> + // fun_ is an empty function if and only if this is the DoDefault()
> action.
> ::std::function<F> fun_;
> -#endif
> - internal::linked_ptr<ActionInterface<F> > impl_;
> };
>
> // The PolymorphicAction class template makes it easy to implement a
> @@ -443,7 +414,7 @@ class Action {
> // template <typename Result, typename ArgumentTuple>
> // Result Perform(const ArgumentTuple& args) const {
> // // Processes the arguments and returns a result, using
> -// // tr1::get<N>(args) to get the N-th (0-based) argument in the
> tuple.
> +// // std::get<N>(args) to get the N-th (0-based) argument in the
> tuple.
> // }
> // ...
> // };
> @@ -471,7 +442,7 @@ class PolymorphicAction {
>
> explicit MonomorphicImpl(const Impl& impl) : impl_(impl) {}
>
> - virtual Result Perform(const ArgumentTuple& args) {
> + Result Perform(const ArgumentTuple& args) override {
> return impl_.template Perform<Result>(args);
> }
>
> @@ -507,31 +478,11 @@ inline PolymorphicAction<Impl>
> MakePolymorphicAction(const Impl& impl) {
>
> namespace internal {
>
> -// Allows an Action<F2> object to pose as an Action<F1>, as long as F2
> -// and F1 are compatible.
> -template <typename F1, typename F2>
> -class ActionAdaptor : public ActionInterface<F1> {
> - public:
> - typedef typename internal::Function<F1>::Result Result;
> - typedef typename internal::Function<F1>::ArgumentTuple ArgumentTuple;
> -
> - explicit ActionAdaptor(const Action<F2>& from) : impl_(from.impl_) {}
> -
> - virtual Result Perform(const ArgumentTuple& args) {
> - return impl_->Perform(args);
> - }
> -
> - private:
> - const internal::linked_ptr<ActionInterface<F2> > impl_;
> -
> - GTEST_DISALLOW_ASSIGN_(ActionAdaptor);
> -};
> -
> // Helper struct to specialize ReturnAction to execute a move instead of
> a copy
> // on return. Useful for move-only types, but could be used on any type.
> template <typename T>
> struct ByMoveWrapper {
> - explicit ByMoveWrapper(T value) : payload(internal::move(value)) {}
> + explicit ByMoveWrapper(T value) : payload(std::move(value)) {}
> T payload;
> };
>
> @@ -568,12 +519,12 @@ class ReturnAction {
> // Constructs a ReturnAction object from the value to be returned.
> // 'value' is passed by value instead of by const reference in order
> // to allow Return("string literal") to compile.
> - explicit ReturnAction(R value) : value_(new R(internal::move(value))) {}
> + explicit ReturnAction(R value) : value_(new R(std::move(value))) {}
>
> // This template type conversion operator allows Return(x) to be
> // used in ANY function that returns x's type.
> template <typename F>
> - operator Action<F>() const {
> + operator Action<F>() const { // NOLINT
> // Assert statement belongs here because this is the best place to
> verify
> // conditions on F. It produces the clearest error messages
> // in most compilers.
> @@ -584,8 +535,10 @@ class ReturnAction {
> // in the Impl class. But both definitions must be the same.
> typedef typename Function<F>::Result Result;
> GTEST_COMPILE_ASSERT_(
> - !is_reference<Result>::value,
> + !std::is_reference<Result>::value,
> use_ReturnRef_instead_of_Return_to_return_a_reference);
> + static_assert(!std::is_void<Result>::value,
> + "Can't use Return() on an action expected to return
> `void`.");
> return Action<F>(new Impl<R, F>(value_));
> }
>
> @@ -604,14 +557,14 @@ class ReturnAction {
> // Result to call. ImplicitCast_ forces the compiler to convert R to
> // Result without considering explicit constructors, thus resolving
> the
> // ambiguity. value_ is then initialized using its copy constructor.
> - explicit Impl(const linked_ptr<R>& value)
> + explicit Impl(const std::shared_ptr<R>& value)
> : value_before_cast_(*value),
> value_(ImplicitCast_<Result>(value_before_cast_)) {}
>
> - virtual Result Perform(const ArgumentTuple&) { return value_; }
> + Result Perform(const ArgumentTuple&) override { return value_; }
>
> private:
> - GTEST_COMPILE_ASSERT_(!is_reference<Result>::value,
> + GTEST_COMPILE_ASSERT_(!std::is_reference<Result>::value,
> Result_cannot_be_a_reference_type);
> // We save the value before casting just in case it is being cast to a
> // wrapper type.
> @@ -629,24 +582,24 @@ class ReturnAction {
> typedef typename Function<F>::Result Result;
> typedef typename Function<F>::ArgumentTuple ArgumentTuple;
>
> - explicit Impl(const linked_ptr<R>& wrapper)
> + explicit Impl(const std::shared_ptr<R>& wrapper)
> : performed_(false), wrapper_(wrapper) {}
>
> - virtual Result Perform(const ArgumentTuple&) {
> + Result Perform(const ArgumentTuple&) override {
> GTEST_CHECK_(!performed_)
> << "A ByMove() action should only be performed once.";
> performed_ = true;
> - return internal::move(wrapper_->payload);
> + return std::move(wrapper_->payload);
> }
>
> private:
> bool performed_;
> - const linked_ptr<R> wrapper_;
> + const std::shared_ptr<R> wrapper_;
>
> GTEST_DISALLOW_ASSIGN_(Impl);
> };
>
> - const linked_ptr<R> value_;
> + const std::shared_ptr<R> value_;
>
> GTEST_DISALLOW_ASSIGN_(ReturnAction);
> };
> @@ -659,13 +612,7 @@ class ReturnNullAction {
> // pointer type on compile time.
> template <typename Result, typename ArgumentTuple>
> static Result Perform(const ArgumentTuple&) {
> -#if GTEST_LANG_CXX11
> return nullptr;
> -#else
> - GTEST_COMPILE_ASSERT_(internal::is_pointer<Result>::value,
> -
> ReturnNull_can_be_used_to_return_a_pointer_only);
> - return NULL;
> -#endif // GTEST_LANG_CXX11
> }
> };
>
> @@ -675,7 +622,7 @@ class ReturnVoidAction {
> // Allows Return() to be used in any void-returning function.
> template <typename Result, typename ArgumentTuple>
> static void Perform(const ArgumentTuple&) {
> - CompileAssertTypesEqual<void, Result>();
> + static_assert(std::is_void<Result>::value, "Result should be void.");
> }
> };
>
> @@ -696,7 +643,7 @@ class ReturnRefAction {
> // Asserts that the function return type is a reference. This
> // catches the user error of using ReturnRef(x) when Return(x)
> // should be used, and generates some helpful error message.
> - GTEST_COMPILE_ASSERT_(internal::is_reference<Result>::value,
> + GTEST_COMPILE_ASSERT_(std::is_reference<Result>::value,
>
> use_Return_instead_of_ReturnRef_to_return_a_value);
> return Action<F>(new Impl<F>(ref_));
> }
> @@ -711,9 +658,7 @@ class ReturnRefAction {
>
> explicit Impl(T& ref) : ref_(ref) {} // NOLINT
>
> - virtual Result Perform(const ArgumentTuple&) {
> - return ref_;
> - }
> + Result Perform(const ArgumentTuple&) override { return ref_; }
>
> private:
> T& ref_;
> @@ -745,7 +690,7 @@ class ReturnRefOfCopyAction {
> // catches the user error of using ReturnRefOfCopy(x) when Return(x)
> // should be used, and generates some helpful error message.
> GTEST_COMPILE_ASSERT_(
> - internal::is_reference<Result>::value,
> + std::is_reference<Result>::value,
> use_Return_instead_of_ReturnRefOfCopy_to_return_a_value);
> return Action<F>(new Impl<F>(value_));
> }
> @@ -760,9 +705,7 @@ class ReturnRefOfCopyAction {
>
> explicit Impl(const T& value) : value_(value) {} // NOLINT
>
> - virtual Result Perform(const ArgumentTuple&) {
> - return value_;
> - }
> + Result Perform(const ArgumentTuple&) override { return value_; }
>
> private:
> T value_;
> @@ -829,114 +772,58 @@ class SetErrnoAndReturnAction {
> #endif // !GTEST_OS_WINDOWS_MOBILE
>
> // Implements the SetArgumentPointee<N>(x) action for any function
> -// whose N-th argument (0-based) is a pointer to x's type. The
> -// template parameter kIsProto is true iff type A is ProtocolMessage,
> -// proto2::Message, or a sub-class of those.
> -template <size_t N, typename A, bool kIsProto>
> -class SetArgumentPointeeAction {
> - public:
> - // Constructs an action that sets the variable pointed to by the
> - // N-th function argument to 'value'.
> - explicit SetArgumentPointeeAction(const A& value) : value_(value) {}
> -
> - template <typename Result, typename ArgumentTuple>
> - void Perform(const ArgumentTuple& args) const {
> - CompileAssertTypesEqual<void, Result>();
> - *::testing::get<N>(args) = value_;
> +// whose N-th argument (0-based) is a pointer to x's type.
> +template <size_t N, typename A, typename = void>
> +struct SetArgumentPointeeAction {
> + A value;
> +
> + template <typename... Args>
> + void operator()(const Args&... args) const {
> + *::std::get<N>(std::tie(args...)) = value;
> }
> -
> - private:
> - const A value_;
> -
> - GTEST_DISALLOW_ASSIGN_(SetArgumentPointeeAction);
> };
>
> -template <size_t N, typename Proto>
> -class SetArgumentPointeeAction<N, Proto, true> {
> - public:
> - // Constructs an action that sets the variable pointed to by the
> - // N-th function argument to 'proto'. Both ProtocolMessage and
> - // proto2::Message have the CopyFrom() method, so the same
> - // implementation works for both.
> - explicit SetArgumentPointeeAction(const Proto& proto) : proto_(new
> Proto) {
> - proto_->CopyFrom(proto);
> - }
> -
> - template <typename Result, typename ArgumentTuple>
> - void Perform(const ArgumentTuple& args) const {
> - CompileAssertTypesEqual<void, Result>();
> - ::testing::get<N>(args)->CopyFrom(*proto_);
> +// Implements the Invoke(object_ptr, &Class::Method) action.
> +template <class Class, typename MethodPtr>
> +struct InvokeMethodAction {
> + Class* const obj_ptr;
> + const MethodPtr method_ptr;
> +
> + template <typename... Args>
> + auto operator()(Args&&... args) const
> + -> decltype((obj_ptr->*method_ptr)(std::forward<Args>(args)...)) {
> + return (obj_ptr->*method_ptr)(std::forward<Args>(args)...);
> }
> -
> - private:
> - const internal::linked_ptr<Proto> proto_;
> -
> - GTEST_DISALLOW_ASSIGN_(SetArgumentPointeeAction);
> };
>
> // Implements the InvokeWithoutArgs(f) action. The template argument
> // FunctionImpl is the implementation type of f, which can be either a
> // function pointer or a functor. InvokeWithoutArgs(f) can be used as an
> -// Action<F> as long as f's type is compatible with F (i.e. f can be
> -// assigned to a tr1::function<F>).
> +// Action<F> as long as f's type is compatible with F.
> template <typename FunctionImpl>
> -class InvokeWithoutArgsAction {
> - public:
> - // The c'tor makes a copy of function_impl (either a function
> - // pointer or a functor).
> - explicit InvokeWithoutArgsAction(FunctionImpl function_impl)
> - : function_impl_(function_impl) {}
> +struct InvokeWithoutArgsAction {
> + FunctionImpl function_impl;
>
> // Allows InvokeWithoutArgs(f) to be used as any action whose type is
> // compatible with f.
> - template <typename Result, typename ArgumentTuple>
> - Result Perform(const ArgumentTuple&) { return function_impl_(); }
> -
> - private:
> - FunctionImpl function_impl_;
> -
> - GTEST_DISALLOW_ASSIGN_(InvokeWithoutArgsAction);
> + template <typename... Args>
> + auto operator()(const Args&...) -> decltype(function_impl()) {
> + return function_impl();
> + }
> };
>
> // Implements the InvokeWithoutArgs(object_ptr, &Class::Method) action.
> template <class Class, typename MethodPtr>
> -class InvokeMethodWithoutArgsAction {
> - public:
> - InvokeMethodWithoutArgsAction(Class* obj_ptr, MethodPtr method_ptr)
> - : obj_ptr_(obj_ptr), method_ptr_(method_ptr) {}
> -
> - template <typename Result, typename ArgumentTuple>
> - Result Perform(const ArgumentTuple&) const {
> - return (obj_ptr_->*method_ptr_)();
> - }
> +struct InvokeMethodWithoutArgsAction {
> + Class* const obj_ptr;
> + const MethodPtr method_ptr;
>
> - private:
> - Class* const obj_ptr_;
> - const MethodPtr method_ptr_;
> -
> - GTEST_DISALLOW_ASSIGN_(InvokeMethodWithoutArgsAction);
> -};
> + using ReturnType = typename std::result_of<MethodPtr(Class*)>::type;
>
> -// Implements the InvokeWithoutArgs(callback) action.
> -template <typename CallbackType>
> -class InvokeCallbackWithoutArgsAction {
> - public:
> - // The c'tor takes ownership of the callback.
> - explicit InvokeCallbackWithoutArgsAction(CallbackType* callback)
> - : callback_(callback) {
> - callback->CheckIsRepeatable(); // Makes sure the callback is
> permanent.
> + template <typename... Args>
> + ReturnType operator()(const Args&...) const {
> + return (obj_ptr->*method_ptr)();
> }
> -
> - // This type conversion operator template allows Invoke(callback) to
> - // be used wherever the callback's return type can be implicitly
> - // converted to that of the mock function.
> - template <typename Result, typename ArgumentTuple>
> - Result Perform(const ArgumentTuple&) const { return callback_->Run(); }
> -
> - private:
> - const internal::linked_ptr<CallbackType> callback_;
> -
> - GTEST_DISALLOW_ASSIGN_(InvokeCallbackWithoutArgsAction);
> };
>
> // Implements the IgnoreResult(action) action.
> @@ -958,7 +845,7 @@ class IgnoreResultAction {
> typedef typename internal::Function<F>::Result Result;
>
> // Asserts at compile time that F returns void.
> - CompileAssertTypesEqual<void, Result>();
> + static_assert(std::is_void<Result>::value, "Result type should be
> void.");
>
> return Action<F>(new Impl<F>(action_));
> }
> @@ -972,7 +859,7 @@ class IgnoreResultAction {
>
> explicit Impl(const A& action) : action_(action) {}
>
> - virtual void Perform(const ArgumentTuple& args) {
> + void Perform(const ArgumentTuple& args) override {
> // Performs the action and ignores its result.
> action_.Perform(args);
> }
> @@ -993,76 +880,51 @@ class IgnoreResultAction {
> GTEST_DISALLOW_ASSIGN_(IgnoreResultAction);
> };
>
> -// A ReferenceWrapper<T> object represents a reference to type T,
> -// which can be either const or not. It can be explicitly converted
> -// from, and implicitly converted to, a T&. Unlike a reference,
> -// ReferenceWrapper<T> can be copied and can survive template type
> -// inference. This is used to support by-reference arguments in the
> -// InvokeArgument<N>(...) action. The idea was from "reference
> -// wrappers" in tr1, which we don't have in our source tree yet.
> -template <typename T>
> -class ReferenceWrapper {
> - public:
> - // Constructs a ReferenceWrapper<T> object from a T&.
> - explicit ReferenceWrapper(T& l_value) : pointer_(&l_value) {} // NOLINT
> -
> - // Allows a ReferenceWrapper<T> object to be implicitly converted to
> - // a T&.
> - operator T&() const { return *pointer_; }
> - private:
> - T* pointer_;
> +template <typename InnerAction, size_t... I>
> +struct WithArgsAction {
> + InnerAction action;
> +
> + // The inner action could be anything convertible to Action<X>.
> + // We use the conversion operator to detect the signature of the inner
> Action.
> + template <typename R, typename... Args>
> + operator Action<R(Args...)>() const { // NOLINT
> + Action<R(typename std::tuple_element<I,
> std::tuple<Args...>>::type...)>
> + converted(action);
> +
> + return [converted](Args... args) -> R {
> + return converted.Perform(std::forward_as_tuple(
> +
> std::get<I>(std::forward_as_tuple(std::forward<Args>(args)...))...));
> + };
> + }
> };
>
> -// Allows the expression ByRef(x) to be printed as a reference to x.
> -template <typename T>
> -void PrintTo(const ReferenceWrapper<T>& ref, ::std::ostream* os) {
> - T& value = ref;
> - UniversalPrinter<T&>::Print(value, os);
> -}
> +template <typename... Actions>
> +struct DoAllAction {
> + private:
> + template <typename... Args, size_t... I>
> + std::vector<Action<void(Args...)>> Convert(IndexSequence<I...>) const {
> + return {std::get<I>(actions)...};
> + }
>
> -// Does two actions sequentially. Used for implementing the DoAll(a1,
> -// a2, ...) action.
> -template <typename Action1, typename Action2>
> -class DoBothAction {
> public:
> - DoBothAction(Action1 action1, Action2 action2)
> - : action1_(action1), action2_(action2) {}
> -
> - // This template type conversion operator allows DoAll(a1, ..., a_n)
> - // to be used in ANY function of compatible type.
> - template <typename F>
> - operator Action<F>() const {
> - return Action<F>(new Impl<F>(action1_, action2_));
> + std::tuple<Actions...> actions;
> +
> + template <typename R, typename... Args>
> + operator Action<R(Args...)>() const { // NOLINT
> + struct Op {
> + std::vector<Action<void(Args...)>> converted;
> + Action<R(Args...)> last;
> + R operator()(Args... args) const {
> + auto tuple_args =
> std::forward_as_tuple(std::forward<Args>(args)...);
> + for (auto& a : converted) {
> + a.Perform(tuple_args);
> + }
> + return last.Perform(tuple_args);
> + }
> + };
> + return Op{Convert<Args...>(MakeIndexSequence<sizeof...(Actions) -
> 1>()),
> + std::get<sizeof...(Actions) - 1>(actions)};
> }
> -
> - private:
> - // Implements the DoAll(...) action for a particular function type F.
> - template <typename F>
> - class Impl : public ActionInterface<F> {
> - public:
> - typedef typename Function<F>::Result Result;
> - typedef typename Function<F>::ArgumentTuple ArgumentTuple;
> - typedef typename Function<F>::MakeResultVoid VoidResult;
> -
> - Impl(const Action<VoidResult>& action1, const Action<F>& action2)
> - : action1_(action1), action2_(action2) {}
> -
> - virtual Result Perform(const ArgumentTuple& args) {
> - action1_.Perform(args);
> - return action2_.Perform(args);
> - }
> -
> - private:
> - const Action<VoidResult> action1_;
> - const Action<F> action2_;
> -
> - GTEST_DISALLOW_ASSIGN_(Impl);
> - };
> -
> - Action1 action1_;
> - Action2 action2_;
> -
> - GTEST_DISALLOW_ASSIGN_(DoBothAction);
> };
>
> } // namespace internal
> @@ -1099,19 +961,43 @@ class DoBothAction {
> // EXPECT_CALL(mock, Bar(5, _, _)).WillOnce(Invoke(DistanceToOrigin));
> typedef internal::IgnoredValue Unused;
>
> -// This constructor allows us to turn an Action<From> object into an
> -// Action<To>, as long as To's arguments can be implicitly converted
> -// to From's and From's return type cann be implicitly converted to
> -// To's.
> -template <typename To>
> -template <typename From>
> -Action<To>::Action(const Action<From>& from)
> - :
> -#if GTEST_LANG_CXX11
> - fun_(from.fun_),
> -#endif
> - impl_(from.impl_ == NULL ? NULL
> - : new internal::ActionAdaptor<To,
> From>(from)) {
> +// Creates an action that does actions a1, a2, ..., sequentially in
> +// each invocation.
> +template <typename... Action>
> +internal::DoAllAction<typename std::decay<Action>::type...> DoAll(
> + Action&&... action) {
> + return {std::forward_as_tuple(std::forward<Action>(action)...)};
> +}
> +
> +// WithArg<k>(an_action) creates an action that passes the k-th
> +// (0-based) argument of the mock function to an_action and performs
> +// it. It adapts an action accepting one argument to one that accepts
> +// multiple arguments. For convenience, we also provide
> +// WithArgs<k>(an_action) (defined below) as a synonym.
> +template <size_t k, typename InnerAction>
> +internal::WithArgsAction<typename std::decay<InnerAction>::type, k>
> +WithArg(InnerAction&& action) {
> + return {std::forward<InnerAction>(action)};
> +}
> +
> +// WithArgs<N1, N2, ..., Nk>(an_action) creates an action that passes
> +// the selected arguments of the mock function to an_action and
> +// performs it. It serves as an adaptor between actions with
> +//
> diff erent argument lists.
> +template <size_t k, size_t... ks, typename InnerAction>
> +internal::WithArgsAction<typename std::decay<InnerAction>::type, k, ks...>
> +WithArgs(InnerAction&& action) {
> + return {std::forward<InnerAction>(action)};
> +}
> +
> +// WithoutArgs(inner_action) can be used in a mock function with a
> +// non-empty argument list to perform inner_action, which takes no
> +// argument. In other words, it adapts an action accepting no
> +// argument to one that accepts (and ignores) arguments.
> +template <typename InnerAction>
> +internal::WithArgsAction<typename std::decay<InnerAction>::type>
> +WithoutArgs(InnerAction&& action) {
> + return {std::forward<InnerAction>(action)};
> }
>
> // Creates an action that returns 'value'. 'value' is passed by value
> @@ -1119,7 +1005,7 @@ Action<To>::Action(const Action<From>& from)
> // will trigger a compiler error about using array as initializer.
> template <typename R>
> internal::ReturnAction<R> Return(R value) {
> - return internal::ReturnAction<R>(internal::move(value));
> + return internal::ReturnAction<R>(std::move(value));
> }
>
> // Creates an action that returns NULL.
> @@ -1152,7 +1038,7 @@ inline internal::ReturnRefOfCopyAction<R>
> ReturnRefOfCopy(const R& x) {
> // invariant.
> template <typename R>
> internal::ByMoveWrapper<R> ByMove(R x) {
> - return internal::ByMoveWrapper<R>(internal::move(x));
> + return internal::ByMoveWrapper<R>(std::move(x));
> }
>
> // Creates an action that does the default action for the give mock
> function.
> @@ -1163,43 +1049,14 @@ inline internal::DoDefaultAction DoDefault() {
> // Creates an action that sets the variable pointed by the N-th
> // (0-based) function argument to 'value'.
> template <size_t N, typename T>
> -PolymorphicAction<
> - internal::SetArgumentPointeeAction<
> - N, T, internal::IsAProtocolMessage<T>::value> >
> -SetArgPointee(const T& x) {
> - return MakePolymorphicAction(internal::SetArgumentPointeeAction<
> - N, T, internal::IsAProtocolMessage<T>::value>(x));
> -}
> -
> -#if !((GTEST_GCC_VER_ && GTEST_GCC_VER_ < 40000) || GTEST_OS_SYMBIAN)
> -// This overload allows SetArgPointee() to accept a string literal.
> -// GCC prior to the version 4.0 and Symbian C++ compiler cannot
> distinguish
> -// this overload from the templated version and emit a compile error.
> -template <size_t N>
> -PolymorphicAction<
> - internal::SetArgumentPointeeAction<N, const char*, false> >
> -SetArgPointee(const char* p) {
> - return MakePolymorphicAction(internal::SetArgumentPointeeAction<
> - N, const char*, false>(p));
> +internal::SetArgumentPointeeAction<N, T> SetArgPointee(T x) {
> + return {std::move(x)};
> }
>
> -template <size_t N>
> -PolymorphicAction<
> - internal::SetArgumentPointeeAction<N, const wchar_t*, false> >
> -SetArgPointee(const wchar_t* p) {
> - return MakePolymorphicAction(internal::SetArgumentPointeeAction<
> - N, const wchar_t*, false>(p));
> -}
> -#endif
> -
> // The following version is DEPRECATED.
> template <size_t N, typename T>
> -PolymorphicAction<
> - internal::SetArgumentPointeeAction<
> - N, T, internal::IsAProtocolMessage<T>::value> >
> -SetArgumentPointee(const T& x) {
> - return MakePolymorphicAction(internal::SetArgumentPointeeAction<
> - N, T, internal::IsAProtocolMessage<T>::value>(x));
> +internal::SetArgumentPointeeAction<N, T> SetArgumentPointee(T x) {
> + return {std::move(x)};
> }
>
> // Creates an action that sets a pointer referent to a given value.
> @@ -1220,24 +1077,38 @@ SetErrnoAndReturn(int errval, T result) {
>
> #endif // !GTEST_OS_WINDOWS_MOBILE
>
> -// Various overloads for InvokeWithoutArgs().
> +// Various overloads for Invoke().
> +
> +// Legacy function.
> +// Actions can now be implicitly constructed from callables. No need to
> create
> +// wrapper objects.
> +// This function exists for backwards compatibility.
> +template <typename FunctionImpl>
> +typename std::decay<FunctionImpl>::type Invoke(FunctionImpl&&
> function_impl) {
> + return std::forward<FunctionImpl>(function_impl);
> +}
> +
> +// Creates an action that invokes the given method on the given object
> +// with the mock function's arguments.
> +template <class Class, typename MethodPtr>
> +internal::InvokeMethodAction<Class, MethodPtr> Invoke(Class* obj_ptr,
> + MethodPtr
> method_ptr) {
> + return {obj_ptr, method_ptr};
> +}
>
> // Creates an action that invokes 'function_impl' with no argument.
> template <typename FunctionImpl>
> -PolymorphicAction<internal::InvokeWithoutArgsAction<FunctionImpl> >
> +internal::InvokeWithoutArgsAction<typename std::decay<FunctionImpl>::type>
> InvokeWithoutArgs(FunctionImpl function_impl) {
> - return MakePolymorphicAction(
> - internal::InvokeWithoutArgsAction<FunctionImpl>(function_impl));
> + return {std::move(function_impl)};
> }
>
> // Creates an action that invokes the given method on the given object
> // with no argument.
> template <class Class, typename MethodPtr>
> -PolymorphicAction<internal::InvokeMethodWithoutArgsAction<Class,
> MethodPtr> >
> -InvokeWithoutArgs(Class* obj_ptr, MethodPtr method_ptr) {
> - return MakePolymorphicAction(
> - internal::InvokeMethodWithoutArgsAction<Class, MethodPtr>(
> - obj_ptr, method_ptr));
> +internal::InvokeMethodWithoutArgsAction<Class, MethodPtr>
> InvokeWithoutArgs(
> + Class* obj_ptr, MethodPtr method_ptr) {
> + return {obj_ptr, method_ptr};
> }
>
> // Creates an action that performs an_action and throws away its
> @@ -1255,11 +1126,19 @@ inline internal::IgnoreResultAction<A>
> IgnoreResult(const A& an_action) {
> // where Base is a base class of Derived, just write:
> //
> // ByRef<const Base>(derived)
> +//
> +// N.B. ByRef is redundant with std::ref, std::cref and
> std::reference_wrapper.
> +// However, it may still be used for consistency with ByMove().
> template <typename T>
> -inline internal::ReferenceWrapper<T> ByRef(T& l_value) { // NOLINT
> - return internal::ReferenceWrapper<T>(l_value);
> +inline ::std::reference_wrapper<T> ByRef(T& l_value) { // NOLINT
> + return ::std::reference_wrapper<T>(l_value);
> }
>
> } // namespace testing
>
> +#ifdef _MSC_VER
> +# pragma warning(pop)
> +#endif
> +
> +
> #endif // GMOCK_INCLUDE_GMOCK_GMOCK_ACTIONS_H_
>
> diff --git
> a/llvm/utils/unittest/googlemock/include/gmock/gmock-cardinalities.h
> b/llvm/utils/unittest/googlemock/include/gmock/gmock-cardinalities.h
> index dafbcbce669d5..05b66d4fffdc8 100644
> --- a/llvm/utils/unittest/googlemock/include/gmock/gmock-cardinalities.h
> +++ b/llvm/utils/unittest/googlemock/include/gmock/gmock-cardinalities.h
> @@ -42,6 +42,7 @@
> #define GMOCK_INCLUDE_GMOCK_GMOCK_CARDINALITIES_H_
>
> #include <limits.h>
> +#include <memory>
> #include <ostream> // NOLINT
> #include "gmock/internal/gmock-port.h"
> #include "gtest/gtest.h"
> @@ -71,10 +72,12 @@ class CardinalityInterface {
> virtual int ConservativeLowerBound() const { return 0; }
> virtual int ConservativeUpperBound() const { return INT_MAX; }
>
> - // Returns true iff call_count calls will satisfy this cardinality.
> + // Returns true if and only if call_count calls will satisfy this
> + // cardinality.
> virtual bool IsSatisfiedByCallCount(int call_count) const = 0;
>
> - // Returns true iff call_count calls will saturate this cardinality.
> + // Returns true if and only if call_count calls will saturate this
> + // cardinality.
> virtual bool IsSaturatedByCallCount(int call_count) const = 0;
>
> // Describes self to an ostream.
> @@ -83,9 +86,8 @@ class CardinalityInterface {
>
> // A Cardinality is a copyable and IMMUTABLE (except by assignment)
> // object that specifies how many times a mock function is expected to
> -// be called. The implementation of Cardinality is just a linked_ptr
> -// to const CardinalityInterface, so copying is fairly cheap.
> -// Don't inherit from Cardinality!
> +// be called. The implementation of Cardinality is just a std::shared_ptr
> +// to const CardinalityInterface. Don't inherit from Cardinality!
> class GTEST_API_ Cardinality {
> public:
> // Constructs a null cardinality. Needed for storing Cardinality
> @@ -100,17 +102,19 @@ class GTEST_API_ Cardinality {
> int ConservativeLowerBound() const { return
> impl_->ConservativeLowerBound(); }
> int ConservativeUpperBound() const { return
> impl_->ConservativeUpperBound(); }
>
> - // Returns true iff call_count calls will satisfy this cardinality.
> + // Returns true if and only if call_count calls will satisfy this
> + // cardinality.
> bool IsSatisfiedByCallCount(int call_count) const {
> return impl_->IsSatisfiedByCallCount(call_count);
> }
>
> - // Returns true iff call_count calls will saturate this cardinality.
> + // Returns true if and only if call_count calls will saturate this
> + // cardinality.
> bool IsSaturatedByCallCount(int call_count) const {
> return impl_->IsSaturatedByCallCount(call_count);
> }
>
> - // Returns true iff call_count calls will over-saturate this
> + // Returns true if and only if call_count calls will over-saturate this
> // cardinality, i.e. exceed the maximum number of allowed calls.
> bool IsOverSaturatedByCallCount(int call_count) const {
> return impl_->IsSaturatedByCallCount(call_count) &&
> @@ -125,7 +129,7 @@ class GTEST_API_ Cardinality {
> ::std::ostream* os);
>
> private:
> - internal::linked_ptr<const CardinalityInterface> impl_;
> + std::shared_ptr<const CardinalityInterface> impl_;
> };
>
> // Creates a cardinality that allows at least n calls.
>
> diff --git
> a/llvm/utils/unittest/googlemock/include/gmock/gmock-function-mocker.h
> b/llvm/utils/unittest/googlemock/include/gmock/gmock-function-mocker.h
> new file mode 100644
> index 0000000000000..cc1535c806bf4
> --- /dev/null
> +++ b/llvm/utils/unittest/googlemock/include/gmock/gmock-function-mocker.h
> @@ -0,0 +1,253 @@
> +// Copyright 2007, Google Inc.
> +// All rights reserved.
> +//
> +// Redistribution and use in source and binary forms, with or without
> +// modification, are permitted provided that the following conditions are
> +// met:
> +//
> +// * Redistributions of source code must retain the above copyright
> +// notice, this list of conditions and the following disclaimer.
> +// * Redistributions in binary form must reproduce the above
> +// copyright notice, this list of conditions and the following disclaimer
> +// in the documentation and/or other materials provided with the
> +// distribution.
> +// * Neither the name of Google Inc. nor the names of its
> +// contributors may be used to endorse or promote products derived from
> +// this software without specific prior written permission.
> +//
> +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
> +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
> +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
> +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
> +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
> +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
> +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
> +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
> +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
> +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
> +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
> +
> +// Google Mock - a framework for writing C++ mock classes.
> +//
> +// This file implements MOCK_METHOD.
> +
> +// GOOGLETEST_CM0002 DO NOT DELETE
> +
> +#ifndef
> THIRD_PARTY_GOOGLETEST_GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_FUNCTION_MOCKER_H_
> // NOLINT
> +#define
> THIRD_PARTY_GOOGLETEST_GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_FUNCTION_MOCKER_H_
> // NOLINT
> +
> +#include "gmock/gmock-generated-function-mockers.h" // NOLINT
> +#include "gmock/internal/gmock-pp.h"
> +
> +#define MOCK_METHOD(...) \
> + GMOCK_PP_VARIADIC_CALL(GMOCK_INTERNAL_MOCK_METHOD_ARG_, __VA_ARGS__)
> +
> +#define GMOCK_INTERNAL_MOCK_METHOD_ARG_1(...) \
> + GMOCK_INTERNAL_WRONG_ARITY(__VA_ARGS__)
> +
> +#define GMOCK_INTERNAL_MOCK_METHOD_ARG_2(...) \
> + GMOCK_INTERNAL_WRONG_ARITY(__VA_ARGS__)
> +
> +#define GMOCK_INTERNAL_MOCK_METHOD_ARG_3(_Ret, _MethodName, _Args) \
> + GMOCK_INTERNAL_MOCK_METHOD_ARG_4(_Ret, _MethodName, _Args, ())
> +
> +#define GMOCK_INTERNAL_MOCK_METHOD_ARG_4(_Ret, _MethodName, _Args,
> _Spec) \
> + GMOCK_INTERNAL_ASSERT_PARENTHESIS(_Args);
> \
> + GMOCK_INTERNAL_ASSERT_PARENTHESIS(_Spec);
> \
> + GMOCK_INTERNAL_ASSERT_VALID_SIGNATURE(
> \
> + GMOCK_PP_NARG0 _Args, GMOCK_INTERNAL_SIGNATURE(_Ret, _Args));
> \
> + GMOCK_INTERNAL_ASSERT_VALID_SPEC(_Spec)
> \
> + GMOCK_INTERNAL_MOCK_METHOD_IMPL(
> \
> + GMOCK_PP_NARG0 _Args, _MethodName,
> GMOCK_INTERNAL_HAS_CONST(_Spec), \
> + GMOCK_INTERNAL_HAS_OVERRIDE(_Spec),
> GMOCK_INTERNAL_HAS_FINAL(_Spec), \
> + GMOCK_INTERNAL_HAS_NOEXCEPT(_Spec),
> GMOCK_INTERNAL_GET_CALLTYPE(_Spec), \
> + (GMOCK_INTERNAL_SIGNATURE(_Ret, _Args)))
> +
> +#define GMOCK_INTERNAL_MOCK_METHOD_ARG_5(...) \
> + GMOCK_INTERNAL_WRONG_ARITY(__VA_ARGS__)
> +
> +#define GMOCK_INTERNAL_MOCK_METHOD_ARG_6(...) \
> + GMOCK_INTERNAL_WRONG_ARITY(__VA_ARGS__)
> +
> +#define GMOCK_INTERNAL_MOCK_METHOD_ARG_7(...) \
> + GMOCK_INTERNAL_WRONG_ARITY(__VA_ARGS__)
> +
> +#define GMOCK_INTERNAL_WRONG_ARITY(...)
> \
> + static_assert(
> \
> + false,
> \
> + "MOCK_METHOD must be called with 3 or 4 arguments. _Ret, "
> \
> + "_MethodName, _Args and optionally _Spec. _Args and _Spec must be
> " \
> + "enclosed in parentheses. If _Ret is a type with unprotected
> commas, " \
> + "it must also be enclosed in parentheses.")
> +
> +#define GMOCK_INTERNAL_ASSERT_PARENTHESIS(_Tuple) \
> + static_assert( \
> + GMOCK_PP_IS_ENCLOSED_PARENS(_Tuple), \
> + GMOCK_PP_STRINGIZE(_Tuple) " should be enclosed in parentheses.")
> +
> +#define GMOCK_INTERNAL_ASSERT_VALID_SIGNATURE(_N, ...) \
> + static_assert( \
> + std::is_function<__VA_ARGS__>::value, \
> + "Signature must be a function type, maybe return type contains " \
> + "unprotected comma."); \
> + static_assert( \
> + ::testing::tuple_size<typename ::testing::internal::Function< \
> + __VA_ARGS__>::ArgumentTuple>::value == _N, \
> + "This method does not take " GMOCK_PP_STRINGIZE( \
> + _N) " arguments. Parenthesize all types with unproctected
> commas.")
> +
> +#define GMOCK_INTERNAL_ASSERT_VALID_SPEC(_Spec) \
> + GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_ASSERT_VALID_SPEC_ELEMENT, ~, _Spec)
> +
> +#define GMOCK_INTERNAL_MOCK_METHOD_IMPL(_N, _MethodName, _Constness,
> \
> + _Override, _Final, _Noexcept,
> \
> + _CallType, _Signature)
> \
> + typename ::testing::internal::Function<GMOCK_PP_REMOVE_PARENS(
> \
> + _Signature)>::Result
> \
> + GMOCK_INTERNAL_EXPAND(_CallType)
> \
> + _MethodName(GMOCK_PP_REPEAT(GMOCK_INTERNAL_PARAMETER, _Signature,
> _N)) \
> + GMOCK_PP_IF(_Constness, const, ) GMOCK_PP_IF(_Noexcept,
> noexcept, ) \
> + GMOCK_PP_IF(_Override, override, )
> \
> + GMOCK_PP_IF(_Final, final, ) {
> \
> + GMOCK_MOCKER_(_N, _Constness, _MethodName)
> \
> + .SetOwnerAndName(this, #_MethodName);
> \
> + return GMOCK_MOCKER_(_N, _Constness, _MethodName)
> \
> + .Invoke(GMOCK_PP_REPEAT(GMOCK_INTERNAL_FORWARD_ARG, _Signature,
> _N)); \
> + }
> \
> + ::testing::MockSpec<GMOCK_PP_REMOVE_PARENS(_Signature)>
> gmock_##_MethodName( \
> + GMOCK_PP_REPEAT(GMOCK_INTERNAL_MATCHER_PARAMETER, _Signature, _N))
> \
> + GMOCK_PP_IF(_Constness, const, ) {
> \
> + GMOCK_MOCKER_(_N, _Constness, _MethodName).RegisterOwner(this);
> \
> + return GMOCK_MOCKER_(_N, _Constness, _MethodName)
> \
> + .With(GMOCK_PP_REPEAT(GMOCK_INTERNAL_MATCHER_ARGUMENT, , _N));
> \
> + }
> \
> + ::testing::MockSpec<GMOCK_PP_REMOVE_PARENS(_Signature)>
> gmock_##_MethodName( \
> + const ::testing::internal::WithoutMatchers&,
> \
> + GMOCK_PP_IF(_Constness, const, )::testing::internal::Function<
> \
> + GMOCK_PP_REMOVE_PARENS(_Signature)>*)
> \
> + const GMOCK_PP_IF(_Noexcept, noexcept, ) {
> \
> + return GMOCK_PP_CAT(::testing::internal::AdjustConstness_,
> \
> + GMOCK_PP_IF(_Constness, const, ))(this)
> \
> + ->gmock_##_MethodName(GMOCK_PP_REPEAT(
> \
> + GMOCK_INTERNAL_A_MATCHER_ARGUMENT, _Signature, _N));
> \
> + }
> \
> + mutable ::testing::FunctionMocker<GMOCK_PP_REMOVE_PARENS(_Signature)>
> \
> + GMOCK_MOCKER_(_N, _Constness, _MethodName)
> +
> +#define GMOCK_INTERNAL_EXPAND(...) __VA_ARGS__
> +
> +// Five Valid modifiers.
> +#define GMOCK_INTERNAL_HAS_CONST(_Tuple) \
> + GMOCK_PP_HAS_COMMA(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_DETECT_CONST, ~,
> _Tuple))
> +
> +#define GMOCK_INTERNAL_HAS_OVERRIDE(_Tuple) \
> + GMOCK_PP_HAS_COMMA( \
> + GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_DETECT_OVERRIDE, ~, _Tuple))
> +
> +#define GMOCK_INTERNAL_HAS_FINAL(_Tuple) \
> + GMOCK_PP_HAS_COMMA(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_DETECT_FINAL, ~,
> _Tuple))
> +
> +#define GMOCK_INTERNAL_HAS_NOEXCEPT(_Tuple) \
> + GMOCK_PP_HAS_COMMA( \
> + GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_DETECT_NOEXCEPT, ~, _Tuple))
> +
> +#define GMOCK_INTERNAL_GET_CALLTYPE(_Tuple) \
> + GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_GET_CALLTYPE_IMPL, ~, _Tuple)
> +
> +#define GMOCK_INTERNAL_ASSERT_VALID_SPEC_ELEMENT(_i, _, _elem)
> \
> + static_assert(
> \
> + (GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_CONST(_i, _, _elem)) +
> \
> + GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_OVERRIDE(_i, _, _elem)) +
> \
> + GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_FINAL(_i, _, _elem)) +
> \
> + GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_NOEXCEPT(_i, _, _elem)) +
> \
> + GMOCK_INTERNAL_IS_CALLTYPE(_elem)) == 1,
> \
> + GMOCK_PP_STRINGIZE(
> \
> + _elem) " cannot be recognized as a valid specification
> modifier.");
> +
> +// Modifiers implementation.
> +#define GMOCK_INTERNAL_DETECT_CONST(_i, _, _elem) \
> + GMOCK_PP_CAT(GMOCK_INTERNAL_DETECT_CONST_I_, _elem)
> +
> +#define GMOCK_INTERNAL_DETECT_CONST_I_const ,
> +
> +#define GMOCK_INTERNAL_DETECT_OVERRIDE(_i, _, _elem) \
> + GMOCK_PP_CAT(GMOCK_INTERNAL_DETECT_OVERRIDE_I_, _elem)
> +
> +#define GMOCK_INTERNAL_DETECT_OVERRIDE_I_override ,
> +
> +#define GMOCK_INTERNAL_DETECT_FINAL(_i, _, _elem) \
> + GMOCK_PP_CAT(GMOCK_INTERNAL_DETECT_FINAL_I_, _elem)
> +
> +#define GMOCK_INTERNAL_DETECT_FINAL_I_final ,
> +
> +// TODO(iserna): Maybe noexcept should accept an argument here as well.
> +#define GMOCK_INTERNAL_DETECT_NOEXCEPT(_i, _, _elem) \
> + GMOCK_PP_CAT(GMOCK_INTERNAL_DETECT_NOEXCEPT_I_, _elem)
> +
> +#define GMOCK_INTERNAL_DETECT_NOEXCEPT_I_noexcept ,
> +
> +#define GMOCK_INTERNAL_GET_CALLTYPE_IMPL(_i, _, _elem) \
> + GMOCK_PP_IF(GMOCK_INTERNAL_IS_CALLTYPE(_elem), \
> + GMOCK_INTERNAL_GET_VALUE_CALLTYPE, GMOCK_PP_EMPTY) \
> + (_elem)
> +
> +// TODO(iserna): GMOCK_INTERNAL_IS_CALLTYPE and
> +// GMOCK_INTERNAL_GET_VALUE_CALLTYPE needed more expansions to work on
> windows
> +// maybe they can be simplified somehow.
> +#define GMOCK_INTERNAL_IS_CALLTYPE(_arg) \
> + GMOCK_INTERNAL_IS_CALLTYPE_I( \
> + GMOCK_PP_CAT(GMOCK_INTERNAL_IS_CALLTYPE_HELPER_, _arg))
> +#define GMOCK_INTERNAL_IS_CALLTYPE_I(_arg)
> GMOCK_PP_IS_ENCLOSED_PARENS(_arg)
> +
> +#define GMOCK_INTERNAL_GET_VALUE_CALLTYPE(_arg) \
> + GMOCK_INTERNAL_GET_VALUE_CALLTYPE_I( \
> + GMOCK_PP_CAT(GMOCK_INTERNAL_IS_CALLTYPE_HELPER_, _arg))
> +#define GMOCK_INTERNAL_GET_VALUE_CALLTYPE_I(_arg) \
> + GMOCK_PP_CAT(GMOCK_PP_IDENTITY, _arg)
> +
> +#define GMOCK_INTERNAL_IS_CALLTYPE_HELPER_Calltype
> +
> +#define GMOCK_INTERNAL_SIGNATURE(_Ret, _Args) \
> + GMOCK_PP_IF(GMOCK_PP_IS_BEGIN_PARENS(_Ret), GMOCK_PP_REMOVE_PARENS, \
> + GMOCK_PP_IDENTITY) \
> + (_Ret)(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_GET_TYPE, _, _Args))
> +
> +#define GMOCK_INTERNAL_GET_TYPE(_i, _, _elem) \
> + GMOCK_PP_COMMA_IF(_i) \
> + GMOCK_PP_IF(GMOCK_PP_IS_BEGIN_PARENS(_elem), GMOCK_PP_REMOVE_PARENS, \
> + GMOCK_PP_IDENTITY) \
> + (_elem)
> +
> +#define GMOCK_INTERNAL_PARAMETER(_i, _Signature, _) \
> + GMOCK_PP_COMMA_IF(_i) \
> + GMOCK_INTERNAL_ARG_O(typename, GMOCK_PP_INC(_i), \
> + GMOCK_PP_REMOVE_PARENS(_Signature)) \
> + gmock_a##_i
> +
> +#define GMOCK_INTERNAL_FORWARD_ARG(_i, _Signature, _)
> \
> + GMOCK_PP_COMMA_IF(_i)
> \
> + ::std::forward<GMOCK_INTERNAL_ARG_O(typename, GMOCK_PP_INC(_i),
> \
> +
> GMOCK_PP_REMOVE_PARENS(_Signature))>( \
> + gmock_a##_i)
> +
> +#define GMOCK_INTERNAL_MATCHER_PARAMETER(_i, _Signature, _) \
> + GMOCK_PP_COMMA_IF(_i) \
> + GMOCK_INTERNAL_MATCHER_O(typename, GMOCK_PP_INC(_i), \
> + GMOCK_PP_REMOVE_PARENS(_Signature)) \
> + gmock_a##_i
> +
> +#define GMOCK_INTERNAL_MATCHER_ARGUMENT(_i, _1, _2) \
> + GMOCK_PP_COMMA_IF(_i) \
> + gmock_a##_i
> +
> +#define GMOCK_INTERNAL_A_MATCHER_ARGUMENT(_i, _Signature, _) \
> + GMOCK_PP_COMMA_IF(_i) \
> + ::testing::A<GMOCK_INTERNAL_ARG_O(typename, GMOCK_PP_INC(_i), \
> + GMOCK_PP_REMOVE_PARENS(_Signature))>()
> +
> +#define GMOCK_INTERNAL_ARG_O(_tn, _i, ...) GMOCK_ARG_(_tn, _i,
> __VA_ARGS__)
> +
> +#define GMOCK_INTERNAL_MATCHER_O(_tn, _i, ...) \
> + GMOCK_MATCHER_(_tn, _i, __VA_ARGS__)
> +
> +#endif //
> THIRD_PARTY_GOOGLETEST_GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_FUNCTION_MOCKER_H_
>
> diff --git
> a/llvm/utils/unittest/googlemock/include/gmock/gmock-generated-actions.h
> b/llvm/utils/unittest/googlemock/include/gmock/gmock-generated-actions.h
> index 8b47568b24529..9b5b78b165b61 100644
> ---
> a/llvm/utils/unittest/googlemock/include/gmock/gmock-generated-actions.h
> +++
> b/llvm/utils/unittest/googlemock/include/gmock/gmock-generated-actions.h
> @@ -38,537 +38,20 @@
>
> // GOOGLETEST_CM0002 DO NOT DELETE
>
> -// IWYU pragma: private, include "gmock/gmock.h
> +// IWYU pragma: private, include "gmock/gmock.h"
>
> #ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_ACTIONS_H_
> #define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_ACTIONS_H_
>
> +#include <memory>
> +#include <utility>
> +
> #include "gmock/gmock-actions.h"
> #include "gmock/internal/gmock-port.h"
>
> namespace testing {
> namespace internal {
>
> -// InvokeHelper<F> knows how to unpack an N-tuple and invoke an N-ary
> -// function, method, or callback with the unpacked values, where F is
> -// a function type that takes N arguments.
> -template <typename Result, typename ArgumentTuple>
> -class InvokeHelper;
> -
> -template <typename R>
> -class InvokeHelper<R, ::testing::tuple<> > {
> - public:
> - template <typename Function>
> - static R Invoke(Function function, const ::testing::tuple<>&) {
> - return function();
> - }
> -
> - template <class Class, typename MethodPtr>
> - static R InvokeMethod(Class* obj_ptr,
> - MethodPtr method_ptr,
> - const ::testing::tuple<>&) {
> - return (obj_ptr->*method_ptr)();
> - }
> -
> - template <typename CallbackType>
> - static R InvokeCallback(CallbackType* callback,
> - const ::testing::tuple<>&) {
> - return callback->Run();
> - }
> -};
> -
> -template <typename R, typename A1>
> -class InvokeHelper<R, ::testing::tuple<A1> > {
> - public:
> - template <typename Function>
> - static R Invoke(Function function, const ::testing::tuple<A1>& args) {
> - return function(get<0>(args));
> - }
> -
> - template <class Class, typename MethodPtr>
> - static R InvokeMethod(Class* obj_ptr,
> - MethodPtr method_ptr,
> - const ::testing::tuple<A1>& args) {
> - return (obj_ptr->*method_ptr)(get<0>(args));
> - }
> -
> - template <typename CallbackType>
> - static R InvokeCallback(CallbackType* callback,
> - const ::testing::tuple<A1>& args) {
> - return callback->Run(get<0>(args));
> - }
> -};
> -
> -template <typename R, typename A1, typename A2>
> -class InvokeHelper<R, ::testing::tuple<A1, A2> > {
> - public:
> - template <typename Function>
> - static R Invoke(Function function, const ::testing::tuple<A1, A2>&
> args) {
> - return function(get<0>(args), get<1>(args));
> - }
> -
> - template <class Class, typename MethodPtr>
> - static R InvokeMethod(Class* obj_ptr,
> - MethodPtr method_ptr,
> - const ::testing::tuple<A1, A2>& args) {
> - return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args));
> - }
> -
> - template <typename CallbackType>
> - static R InvokeCallback(CallbackType* callback,
> - const ::testing::tuple<A1, A2>& args) {
> - return callback->Run(get<0>(args), get<1>(args));
> - }
> -};
> -
> -template <typename R, typename A1, typename A2, typename A3>
> -class InvokeHelper<R, ::testing::tuple<A1, A2, A3> > {
> - public:
> - template <typename Function>
> - static R Invoke(Function function, const ::testing::tuple<A1, A2, A3>&
> args) {
> - return function(get<0>(args), get<1>(args), get<2>(args));
> - }
> -
> - template <class Class, typename MethodPtr>
> - static R InvokeMethod(Class* obj_ptr,
> - MethodPtr method_ptr,
> - const ::testing::tuple<A1, A2, A3>& args) {
> - return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args),
> - get<2>(args));
> - }
> -
> - template <typename CallbackType>
> - static R InvokeCallback(CallbackType* callback,
> - const ::testing::tuple<A1, A2, A3>& args) {
> - return callback->Run(get<0>(args), get<1>(args), get<2>(args));
> - }
> -};
> -
> -template <typename R, typename A1, typename A2, typename A3, typename A4>
> -class InvokeHelper<R, ::testing::tuple<A1, A2, A3, A4> > {
> - public:
> - template <typename Function>
> - static R Invoke(Function function, const ::testing::tuple<A1, A2, A3,
> - A4>& args) {
> - return function(get<0>(args), get<1>(args), get<2>(args),
> - get<3>(args));
> - }
> -
> - template <class Class, typename MethodPtr>
> - static R InvokeMethod(Class* obj_ptr,
> - MethodPtr method_ptr,
> - const ::testing::tuple<A1, A2, A3, A4>& args) {
> - return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args),
> - get<2>(args), get<3>(args));
> - }
> -
> - template <typename CallbackType>
> - static R InvokeCallback(CallbackType* callback,
> - const ::testing::tuple<A1, A2, A3, A4>& args) {
> - return callback->Run(get<0>(args), get<1>(args), get<2>(args),
> - get<3>(args));
> - }
> -};
> -
> -template <typename R, typename A1, typename A2, typename A3, typename A4,
> - typename A5>
> -class InvokeHelper<R, ::testing::tuple<A1, A2, A3, A4, A5> > {
> - public:
> - template <typename Function>
> - static R Invoke(Function function, const ::testing::tuple<A1, A2, A3,
> A4,
> - A5>& args) {
> - return function(get<0>(args), get<1>(args), get<2>(args),
> - get<3>(args), get<4>(args));
> - }
> -
> - template <class Class, typename MethodPtr>
> - static R InvokeMethod(Class* obj_ptr,
> - MethodPtr method_ptr,
> - const ::testing::tuple<A1, A2, A3, A4, A5>& args)
> {
> - return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args),
> - get<2>(args), get<3>(args), get<4>(args));
> - }
> -
> - template <typename CallbackType>
> - static R InvokeCallback(CallbackType* callback,
> - const ::testing::tuple<A1, A2, A3, A4, A5>&
> args) {
> - return callback->Run(get<0>(args), get<1>(args), get<2>(args),
> - get<3>(args), get<4>(args));
> - }
> -};
> -
> -template <typename R, typename A1, typename A2, typename A3, typename A4,
> - typename A5, typename A6>
> -class InvokeHelper<R, ::testing::tuple<A1, A2, A3, A4, A5, A6> > {
> - public:
> - template <typename Function>
> - static R Invoke(Function function, const ::testing::tuple<A1, A2, A3,
> A4, A5,
> - A6>& args) {
> - return function(get<0>(args), get<1>(args), get<2>(args),
> - get<3>(args), get<4>(args), get<5>(args));
> - }
> -
> - template <class Class, typename MethodPtr>
> - static R InvokeMethod(Class* obj_ptr,
> - MethodPtr method_ptr,
> - const ::testing::tuple<A1, A2, A3, A4, A5, A6>&
> args) {
> - return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args),
> - get<2>(args), get<3>(args), get<4>(args), get<5>(args));
> - }
> -
> - // There is no InvokeCallback() for 6-tuples
> -};
> -
> -template <typename R, typename A1, typename A2, typename A3, typename A4,
> - typename A5, typename A6, typename A7>
> -class InvokeHelper<R, ::testing::tuple<A1, A2, A3, A4, A5, A6, A7> > {
> - public:
> - template <typename Function>
> - static R Invoke(Function function, const ::testing::tuple<A1, A2, A3,
> A4, A5,
> - A6, A7>& args) {
> - return function(get<0>(args), get<1>(args), get<2>(args),
> - get<3>(args), get<4>(args), get<5>(args), get<6>(args));
> - }
> -
> - template <class Class, typename MethodPtr>
> - static R InvokeMethod(Class* obj_ptr,
> - MethodPtr method_ptr,
> - const ::testing::tuple<A1, A2, A3, A4, A5, A6,
> - A7>& args) {
> - return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args),
> - get<2>(args), get<3>(args), get<4>(args), get<5>(args),
> - get<6>(args));
> - }
> -
> - // There is no InvokeCallback() for 7-tuples
> -};
> -
> -template <typename R, typename A1, typename A2, typename A3, typename A4,
> - typename A5, typename A6, typename A7, typename A8>
> -class InvokeHelper<R, ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, A8> > {
> - public:
> - template <typename Function>
> - static R Invoke(Function function, const ::testing::tuple<A1, A2, A3,
> A4, A5,
> - A6, A7, A8>& args) {
> - return function(get<0>(args), get<1>(args), get<2>(args),
> - get<3>(args), get<4>(args), get<5>(args), get<6>(args),
> - get<7>(args));
> - }
> -
> - template <class Class, typename MethodPtr>
> - static R InvokeMethod(Class* obj_ptr,
> - MethodPtr method_ptr,
> - const ::testing::tuple<A1, A2, A3, A4, A5, A6, A7,
> - A8>& args) {
> - return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args),
> - get<2>(args), get<3>(args), get<4>(args), get<5>(args),
> - get<6>(args), get<7>(args));
> - }
> -
> - // There is no InvokeCallback() for 8-tuples
> -};
> -
> -template <typename R, typename A1, typename A2, typename A3, typename A4,
> - typename A5, typename A6, typename A7, typename A8, typename A9>
> -class InvokeHelper<R, ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, A8,
> A9> > {
> - public:
> - template <typename Function>
> - static R Invoke(Function function, const ::testing::tuple<A1, A2, A3,
> A4, A5,
> - A6, A7, A8, A9>& args) {
> - return function(get<0>(args), get<1>(args), get<2>(args),
> - get<3>(args), get<4>(args), get<5>(args), get<6>(args),
> - get<7>(args), get<8>(args));
> - }
> -
> - template <class Class, typename MethodPtr>
> - static R InvokeMethod(Class* obj_ptr,
> - MethodPtr method_ptr,
> - const ::testing::tuple<A1, A2, A3, A4, A5, A6,
> A7, A8,
> - A9>& args) {
> - return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args),
> - get<2>(args), get<3>(args), get<4>(args), get<5>(args),
> - get<6>(args), get<7>(args), get<8>(args));
> - }
> -
> - // There is no InvokeCallback() for 9-tuples
> -};
> -
> -template <typename R, typename A1, typename A2, typename A3, typename A4,
> - typename A5, typename A6, typename A7, typename A8, typename A9,
> - typename A10>
> -class InvokeHelper<R, ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, A8, A9,
> - A10> > {
> - public:
> - template <typename Function>
> - static R Invoke(Function function, const ::testing::tuple<A1, A2, A3,
> A4, A5,
> - A6, A7, A8, A9, A10>& args) {
> - return function(get<0>(args), get<1>(args), get<2>(args),
> - get<3>(args), get<4>(args), get<5>(args), get<6>(args),
> - get<7>(args), get<8>(args), get<9>(args));
> - }
> -
> - template <class Class, typename MethodPtr>
> - static R InvokeMethod(Class* obj_ptr,
> - MethodPtr method_ptr,
> - const ::testing::tuple<A1, A2, A3, A4, A5, A6,
> A7, A8,
> - A9, A10>& args) {
> - return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args),
> - get<2>(args), get<3>(args), get<4>(args), get<5>(args),
> - get<6>(args), get<7>(args), get<8>(args), get<9>(args));
> - }
> -
> - // There is no InvokeCallback() for 10-tuples
> -};
> -
> -// Implements the Invoke(callback) action.
> -template <typename CallbackType>
> -class InvokeCallbackAction {
> - public:
> - // The c'tor takes ownership of the callback.
> - explicit InvokeCallbackAction(CallbackType* callback)
> - : callback_(callback) {
> - callback->CheckIsRepeatable(); // Makes sure the callback is
> permanent.
> - }
> -
> - // This type conversion operator template allows Invoke(callback) to
> - // be used wherever the callback's type is compatible with that of
> - // the mock function, i.e. if the mock function's arguments can be
> - // implicitly converted to the callback's arguments and the
> - // callback's result can be implicitly converted to the mock
> - // function's result.
> - template <typename Result, typename ArgumentTuple>
> - Result Perform(const ArgumentTuple& args) const {
> - return InvokeHelper<Result, ArgumentTuple>::InvokeCallback(
> - callback_.get(), args);
> - }
> - private:
> - const linked_ptr<CallbackType> callback_;
> -};
> -
> -// An INTERNAL macro for extracting the type of a tuple field. It's
> -// subject to change without notice - DO NOT USE IN USER CODE!
> -#define GMOCK_FIELD_(Tuple, N) \
> - typename ::testing::tuple_element<N, Tuple>::type
> -
> -// SelectArgs<Result, ArgumentTuple, k1, k2, ..., k_n>::type is the
> -// type of an n-ary function whose i-th (1-based) argument type is the
> -// k{i}-th (0-based) field of ArgumentTuple, which must be a tuple
> -// type, and whose return type is Result. For example,
> -// SelectArgs<int, ::testing::tuple<bool, char, double, long>, 0,
> 3>::type
> -// is int(bool, long).
> -//
> -// SelectArgs<Result, ArgumentTuple, k1, k2, ..., k_n>::Select(args)
> -// returns the selected fields (k1, k2, ..., k_n) of args as a tuple.
> -// For example,
> -// SelectArgs<int, tuple<bool, char, double>, 2, 0>::Select(
> -// ::testing::make_tuple(true, 'a', 2.5))
> -// returns tuple (2.5, true).
> -//
> -// The numbers in list k1, k2, ..., k_n must be >= 0, where n can be
> -// in the range [0, 10]. Duplicates are allowed and they don't have
> -// to be in an ascending or descending order.
> -
> -template <typename Result, typename ArgumentTuple, int k1, int k2, int k3,
> - int k4, int k5, int k6, int k7, int k8, int k9, int k10>
> -class SelectArgs {
> - public:
> - typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1),
> - GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3),
> - GMOCK_FIELD_(ArgumentTuple, k4), GMOCK_FIELD_(ArgumentTuple, k5),
> - GMOCK_FIELD_(ArgumentTuple, k6), GMOCK_FIELD_(ArgumentTuple, k7),
> - GMOCK_FIELD_(ArgumentTuple, k8), GMOCK_FIELD_(ArgumentTuple, k9),
> - GMOCK_FIELD_(ArgumentTuple, k10));
> - typedef typename Function<type>::ArgumentTuple SelectedArgs;
> - static SelectedArgs Select(const ArgumentTuple& args) {
> - return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args),
> - get<k4>(args), get<k5>(args), get<k6>(args), get<k7>(args),
> - get<k8>(args), get<k9>(args), get<k10>(args));
> - }
> -};
> -
> -template <typename Result, typename ArgumentTuple>
> -class SelectArgs<Result, ArgumentTuple,
> - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1> {
> - public:
> - typedef Result type();
> - typedef typename Function<type>::ArgumentTuple SelectedArgs;
> - static SelectedArgs Select(const ArgumentTuple& /* args */) {
> - return SelectedArgs();
> - }
> -};
> -
> -template <typename Result, typename ArgumentTuple, int k1>
> -class SelectArgs<Result, ArgumentTuple,
> - k1, -1, -1, -1, -1, -1, -1, -1, -1, -1> {
> - public:
> - typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1));
> - typedef typename Function<type>::ArgumentTuple SelectedArgs;
> - static SelectedArgs Select(const ArgumentTuple& args) {
> - return SelectedArgs(get<k1>(args));
> - }
> -};
> -
> -template <typename Result, typename ArgumentTuple, int k1, int k2>
> -class SelectArgs<Result, ArgumentTuple,
> - k1, k2, -1, -1, -1, -1, -1, -1, -1, -1> {
> - public:
> - typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1),
> - GMOCK_FIELD_(ArgumentTuple, k2));
> - typedef typename Function<type>::ArgumentTuple SelectedArgs;
> - static SelectedArgs Select(const ArgumentTuple& args) {
> - return SelectedArgs(get<k1>(args), get<k2>(args));
> - }
> -};
> -
> -template <typename Result, typename ArgumentTuple, int k1, int k2, int k3>
> -class SelectArgs<Result, ArgumentTuple,
> - k1, k2, k3, -1, -1, -1, -1, -1, -1, -1> {
> - public:
> - typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1),
> - GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3));
> - typedef typename Function<type>::ArgumentTuple SelectedArgs;
> - static SelectedArgs Select(const ArgumentTuple& args) {
> - return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args));
> - }
> -};
> -
> -template <typename Result, typename ArgumentTuple, int k1, int k2, int k3,
> - int k4>
> -class SelectArgs<Result, ArgumentTuple,
> - k1, k2, k3, k4, -1, -1, -1, -1, -1, -1> {
> - public:
> - typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1),
> - GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3),
> - GMOCK_FIELD_(ArgumentTuple, k4));
> - typedef typename Function<type>::ArgumentTuple SelectedArgs;
> - static SelectedArgs Select(const ArgumentTuple& args) {
> - return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args),
> - get<k4>(args));
> - }
> -};
> -
> -template <typename Result, typename ArgumentTuple, int k1, int k2, int k3,
> - int k4, int k5>
> -class SelectArgs<Result, ArgumentTuple,
> - k1, k2, k3, k4, k5, -1, -1, -1, -1, -1> {
> - public:
> - typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1),
> - GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3),
> - GMOCK_FIELD_(ArgumentTuple, k4), GMOCK_FIELD_(ArgumentTuple, k5));
> - typedef typename Function<type>::ArgumentTuple SelectedArgs;
> - static SelectedArgs Select(const ArgumentTuple& args) {
> - return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args),
> - get<k4>(args), get<k5>(args));
> - }
> -};
> -
> -template <typename Result, typename ArgumentTuple, int k1, int k2, int k3,
> - int k4, int k5, int k6>
> -class SelectArgs<Result, ArgumentTuple,
> - k1, k2, k3, k4, k5, k6, -1, -1, -1, -1> {
> - public:
> - typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1),
> - GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3),
> - GMOCK_FIELD_(ArgumentTuple, k4), GMOCK_FIELD_(ArgumentTuple, k5),
> - GMOCK_FIELD_(ArgumentTuple, k6));
> - typedef typename Function<type>::ArgumentTuple SelectedArgs;
> - static SelectedArgs Select(const ArgumentTuple& args) {
> - return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args),
> - get<k4>(args), get<k5>(args), get<k6>(args));
> - }
> -};
> -
> -template <typename Result, typename ArgumentTuple, int k1, int k2, int k3,
> - int k4, int k5, int k6, int k7>
> -class SelectArgs<Result, ArgumentTuple,
> - k1, k2, k3, k4, k5, k6, k7, -1, -1, -1> {
> - public:
> - typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1),
> - GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3),
> - GMOCK_FIELD_(ArgumentTuple, k4), GMOCK_FIELD_(ArgumentTuple, k5),
> - GMOCK_FIELD_(ArgumentTuple, k6), GMOCK_FIELD_(ArgumentTuple, k7));
> - typedef typename Function<type>::ArgumentTuple SelectedArgs;
> - static SelectedArgs Select(const ArgumentTuple& args) {
> - return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args),
> - get<k4>(args), get<k5>(args), get<k6>(args), get<k7>(args));
> - }
> -};
> -
> -template <typename Result, typename ArgumentTuple, int k1, int k2, int k3,
> - int k4, int k5, int k6, int k7, int k8>
> -class SelectArgs<Result, ArgumentTuple,
> - k1, k2, k3, k4, k5, k6, k7, k8, -1, -1> {
> - public:
> - typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1),
> - GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3),
> - GMOCK_FIELD_(ArgumentTuple, k4), GMOCK_FIELD_(ArgumentTuple, k5),
> - GMOCK_FIELD_(ArgumentTuple, k6), GMOCK_FIELD_(ArgumentTuple, k7),
> - GMOCK_FIELD_(ArgumentTuple, k8));
> - typedef typename Function<type>::ArgumentTuple SelectedArgs;
> - static SelectedArgs Select(const ArgumentTuple& args) {
> - return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args),
> - get<k4>(args), get<k5>(args), get<k6>(args), get<k7>(args),
> - get<k8>(args));
> - }
> -};
> -
> -template <typename Result, typename ArgumentTuple, int k1, int k2, int k3,
> - int k4, int k5, int k6, int k7, int k8, int k9>
> -class SelectArgs<Result, ArgumentTuple,
> - k1, k2, k3, k4, k5, k6, k7, k8, k9, -1> {
> - public:
> - typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1),
> - GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3),
> - GMOCK_FIELD_(ArgumentTuple, k4), GMOCK_FIELD_(ArgumentTuple, k5),
> - GMOCK_FIELD_(ArgumentTuple, k6), GMOCK_FIELD_(ArgumentTuple, k7),
> - GMOCK_FIELD_(ArgumentTuple, k8), GMOCK_FIELD_(ArgumentTuple, k9));
> - typedef typename Function<type>::ArgumentTuple SelectedArgs;
> - static SelectedArgs Select(const ArgumentTuple& args) {
> - return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args),
> - get<k4>(args), get<k5>(args), get<k6>(args), get<k7>(args),
> - get<k8>(args), get<k9>(args));
> - }
> -};
> -
> -#undef GMOCK_FIELD_
> -
> -// Implements the WithArgs action.
> -template <typename InnerAction, int k1 = -1, int k2 = -1, int k3 = -1,
> - int k4 = -1, int k5 = -1, int k6 = -1, int k7 = -1, int k8 = -1,
> - int k9 = -1, int k10 = -1>
> -class WithArgsAction {
> - public:
> - explicit WithArgsAction(const InnerAction& action) : action_(action) {}
> -
> - template <typename F>
> - operator Action<F>() const { return MakeAction(new Impl<F>(action_)); }
> -
> - private:
> - template <typename F>
> - class Impl : public ActionInterface<F> {
> - public:
> - typedef typename Function<F>::Result Result;
> - typedef typename Function<F>::ArgumentTuple ArgumentTuple;
> -
> - explicit Impl(const InnerAction& action) : action_(action) {}
> -
> - virtual Result Perform(const ArgumentTuple& args) {
> - return action_.Perform(SelectArgs<Result, ArgumentTuple, k1, k2,
> k3, k4,
> - k5, k6, k7, k8, k9, k10>::Select(args));
> - }
> -
> - private:
> - typedef typename SelectArgs<Result, ArgumentTuple,
> - k1, k2, k3, k4, k5, k6, k7, k8, k9, k10>::type InnerFunctionType;
> -
> - Action<InnerFunctionType> action_;
> - };
> -
> - const InnerAction action_;
> -
> - GTEST_DISALLOW_ASSIGN_(WithArgsAction);
> -};
> -
> // A macro from the ACTION* family (defined later in this file)
> // defines an action that can be used in a mock function. Typically,
> // these actions only care about a subset of the arguments of the mock
> @@ -589,7 +72,7 @@ struct ExcessiveArg {};
> template <typename Result, class Impl>
> class ActionHelper {
> public:
> - static Result Perform(Impl* impl, const ::testing::tuple<>& args) {
> + static Result Perform(Impl* impl, const ::std::tuple<>& args) {
> return impl->template gmock_PerformImpl<>(args, ExcessiveArg(),
> ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
> ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
> @@ -597,266 +80,100 @@ class ActionHelper {
> }
>
> template <typename A0>
> - static Result Perform(Impl* impl, const ::testing::tuple<A0>& args) {
> - return impl->template gmock_PerformImpl<A0>(args, get<0>(args),
> + static Result Perform(Impl* impl, const ::std::tuple<A0>& args) {
> + return impl->template gmock_PerformImpl<A0>(args, std::get<0>(args),
> ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
> ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
> ExcessiveArg());
> }
>
> template <typename A0, typename A1>
> - static Result Perform(Impl* impl, const ::testing::tuple<A0, A1>& args)
> {
> - return impl->template gmock_PerformImpl<A0, A1>(args, get<0>(args),
> - get<1>(args), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
> + static Result Perform(Impl* impl, const ::std::tuple<A0, A1>& args) {
> + return impl->template gmock_PerformImpl<A0, A1>(args,
> std::get<0>(args),
> + std::get<1>(args), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
> ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
> ExcessiveArg());
> }
>
> template <typename A0, typename A1, typename A2>
> - static Result Perform(Impl* impl, const ::testing::tuple<A0, A1, A2>&
> args) {
> - return impl->template gmock_PerformImpl<A0, A1, A2>(args,
> get<0>(args),
> - get<1>(args), get<2>(args), ExcessiveArg(), ExcessiveArg(),
> + static Result Perform(Impl* impl, const ::std::tuple<A0, A1, A2>& args)
> {
> + return impl->template gmock_PerformImpl<A0, A1, A2>(args,
> + std::get<0>(args), std::get<1>(args), std::get<2>(args),
> ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
> - ExcessiveArg());
> + ExcessiveArg(), ExcessiveArg(), ExcessiveArg());
> }
>
> template <typename A0, typename A1, typename A2, typename A3>
> - static Result Perform(Impl* impl, const ::testing::tuple<A0, A1, A2,
> - A3>& args) {
> - return impl->template gmock_PerformImpl<A0, A1, A2, A3>(args,
> get<0>(args),
> - get<1>(args), get<2>(args), get<3>(args), ExcessiveArg(),
> - ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
> - ExcessiveArg());
> + static Result Perform(Impl* impl, const ::std::tuple<A0, A1, A2, A3>&
> args) {
> + return impl->template gmock_PerformImpl<A0, A1, A2, A3>(args,
> + std::get<0>(args), std::get<1>(args), std::get<2>(args),
> + std::get<3>(args), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
> + ExcessiveArg(), ExcessiveArg(), ExcessiveArg());
> }
>
> template <typename A0, typename A1, typename A2, typename A3, typename
> A4>
> - static Result Perform(Impl* impl, const ::testing::tuple<A0, A1, A2, A3,
> + static Result Perform(Impl* impl, const ::std::tuple<A0, A1, A2, A3,
> A4>& args) {
> return impl->template gmock_PerformImpl<A0, A1, A2, A3, A4>(args,
> - get<0>(args), get<1>(args), get<2>(args), get<3>(args),
> get<4>(args),
> - ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
> - ExcessiveArg());
> + std::get<0>(args), std::get<1>(args), std::get<2>(args),
> + std::get<3>(args), std::get<4>(args), ExcessiveArg(),
> ExcessiveArg(),
> + ExcessiveArg(), ExcessiveArg(), ExcessiveArg());
> }
>
> template <typename A0, typename A1, typename A2, typename A3, typename
> A4,
> typename A5>
> - static Result Perform(Impl* impl, const ::testing::tuple<A0, A1, A2,
> A3, A4,
> + static Result Perform(Impl* impl, const ::std::tuple<A0, A1, A2, A3, A4,
> A5>& args) {
> return impl->template gmock_PerformImpl<A0, A1, A2, A3, A4, A5>(args,
> - get<0>(args), get<1>(args), get<2>(args), get<3>(args),
> get<4>(args),
> - get<5>(args), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
> - ExcessiveArg());
> + std::get<0>(args), std::get<1>(args), std::get<2>(args),
> + std::get<3>(args), std::get<4>(args), std::get<5>(args),
> + ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg());
> }
>
> template <typename A0, typename A1, typename A2, typename A3, typename
> A4,
> typename A5, typename A6>
> - static Result Perform(Impl* impl, const ::testing::tuple<A0, A1, A2,
> A3, A4,
> - A5, A6>& args) {
> + static Result Perform(Impl* impl, const ::std::tuple<A0, A1, A2, A3,
> A4, A5,
> + A6>& args) {
> return impl->template gmock_PerformImpl<A0, A1, A2, A3, A4, A5,
> A6>(args,
> - get<0>(args), get<1>(args), get<2>(args), get<3>(args),
> get<4>(args),
> - get<5>(args), get<6>(args), ExcessiveArg(), ExcessiveArg(),
> - ExcessiveArg());
> + std::get<0>(args), std::get<1>(args), std::get<2>(args),
> + std::get<3>(args), std::get<4>(args), std::get<5>(args),
> + std::get<6>(args), ExcessiveArg(), ExcessiveArg(),
> ExcessiveArg());
> }
>
> template <typename A0, typename A1, typename A2, typename A3, typename
> A4,
> typename A5, typename A6, typename A7>
> - static Result Perform(Impl* impl, const ::testing::tuple<A0, A1, A2,
> A3, A4,
> - A5, A6, A7>& args) {
> + static Result Perform(Impl* impl, const ::std::tuple<A0, A1, A2, A3,
> A4, A5,
> + A6, A7>& args) {
> return impl->template gmock_PerformImpl<A0, A1, A2, A3, A4, A5, A6,
> - A7>(args, get<0>(args), get<1>(args), get<2>(args), get<3>(args),
> - get<4>(args), get<5>(args), get<6>(args), get<7>(args),
> ExcessiveArg(),
> - ExcessiveArg());
> + A7>(args, std::get<0>(args), std::get<1>(args), std::get<2>(args),
> + std::get<3>(args), std::get<4>(args), std::get<5>(args),
> + std::get<6>(args), std::get<7>(args), ExcessiveArg(),
> ExcessiveArg());
> }
>
> template <typename A0, typename A1, typename A2, typename A3, typename
> A4,
> typename A5, typename A6, typename A7, typename A8>
> - static Result Perform(Impl* impl, const ::testing::tuple<A0, A1, A2,
> A3, A4,
> - A5, A6, A7, A8>& args) {
> + static Result Perform(Impl* impl, const ::std::tuple<A0, A1, A2, A3,
> A4, A5,
> + A6, A7, A8>& args) {
> return impl->template gmock_PerformImpl<A0, A1, A2, A3, A4, A5, A6,
> A7,
> - A8>(args, get<0>(args), get<1>(args), get<2>(args), get<3>(args),
> - get<4>(args), get<5>(args), get<6>(args), get<7>(args),
> get<8>(args),
> + A8>(args, std::get<0>(args), std::get<1>(args), std::get<2>(args),
> + std::get<3>(args), std::get<4>(args), std::get<5>(args),
> + std::get<6>(args), std::get<7>(args), std::get<8>(args),
> ExcessiveArg());
> }
>
> template <typename A0, typename A1, typename A2, typename A3, typename
> A4,
> typename A5, typename A6, typename A7, typename A8, typename A9>
> - static Result Perform(Impl* impl, const ::testing::tuple<A0, A1, A2,
> A3, A4,
> - A5, A6, A7, A8, A9>& args) {
> + static Result Perform(Impl* impl, const ::std::tuple<A0, A1, A2, A3,
> A4, A5,
> + A6, A7, A8, A9>& args) {
> return impl->template gmock_PerformImpl<A0, A1, A2, A3, A4, A5, A6,
> A7, A8,
> - A9>(args, get<0>(args), get<1>(args), get<2>(args), get<3>(args),
> - get<4>(args), get<5>(args), get<6>(args), get<7>(args),
> get<8>(args),
> - get<9>(args));
> + A9>(args, std::get<0>(args), std::get<1>(args), std::get<2>(args),
> + std::get<3>(args), std::get<4>(args), std::get<5>(args),
> + std::get<6>(args), std::get<7>(args), std::get<8>(args),
> + std::get<9>(args));
> }
> };
>
> } // namespace internal
> -
> -// Various overloads for Invoke().
> -
> -// WithArgs<N1, N2, ..., Nk>(an_action) creates an action that passes
> -// the selected arguments of the mock function to an_action and
> -// performs it. It serves as an adaptor between actions with
> -//
> diff erent argument lists. C++ doesn't support default arguments for
> -// function templates, so we have to overload it.
> -template <int k1, typename InnerAction>
> -inline internal::WithArgsAction<InnerAction, k1>
> -WithArgs(const InnerAction& action) {
> - return internal::WithArgsAction<InnerAction, k1>(action);
> -}
> -
> -template <int k1, int k2, typename InnerAction>
> -inline internal::WithArgsAction<InnerAction, k1, k2>
> -WithArgs(const InnerAction& action) {
> - return internal::WithArgsAction<InnerAction, k1, k2>(action);
> -}
> -
> -template <int k1, int k2, int k3, typename InnerAction>
> -inline internal::WithArgsAction<InnerAction, k1, k2, k3>
> -WithArgs(const InnerAction& action) {
> - return internal::WithArgsAction<InnerAction, k1, k2, k3>(action);
> -}
> -
> -template <int k1, int k2, int k3, int k4, typename InnerAction>
> -inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4>
> -WithArgs(const InnerAction& action) {
> - return internal::WithArgsAction<InnerAction, k1, k2, k3, k4>(action);
> -}
> -
> -template <int k1, int k2, int k3, int k4, int k5, typename InnerAction>
> -inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5>
> -WithArgs(const InnerAction& action) {
> - return internal::WithArgsAction<InnerAction, k1, k2, k3, k4,
> k5>(action);
> -}
> -
> -template <int k1, int k2, int k3, int k4, int k5, int k6, typename
> InnerAction>
> -inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6>
> -WithArgs(const InnerAction& action) {
> - return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5,
> k6>(action);
> -}
> -
> -template <int k1, int k2, int k3, int k4, int k5, int k6, int k7,
> - typename InnerAction>
> -inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7>
> -WithArgs(const InnerAction& action) {
> - return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6,
> - k7>(action);
> -}
> -
> -template <int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8,
> - typename InnerAction>
> -inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7,
> k8>
> -WithArgs(const InnerAction& action) {
> - return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7,
> - k8>(action);
> -}
> -
> -template <int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8,
> - int k9, typename InnerAction>
> -inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7,
> k8, k9>
> -WithArgs(const InnerAction& action) {
> - return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6,
> k7, k8,
> - k9>(action);
> -}
> -
> -template <int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8,
> - int k9, int k10, typename InnerAction>
> -inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7,
> k8,
> - k9, k10>
> -WithArgs(const InnerAction& action) {
> - return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6,
> k7, k8,
> - k9, k10>(action);
> -}
> -
> -// Creates an action that does actions a1, a2, ..., sequentially in
> -// each invocation.
> -template <typename Action1, typename Action2>
> -inline internal::DoBothAction<Action1, Action2>
> -DoAll(Action1 a1, Action2 a2) {
> - return internal::DoBothAction<Action1, Action2>(a1, a2);
> -}
> -
> -template <typename Action1, typename Action2, typename Action3>
> -inline internal::DoBothAction<Action1, internal::DoBothAction<Action2,
> - Action3> >
> -DoAll(Action1 a1, Action2 a2, Action3 a3) {
> - return DoAll(a1, DoAll(a2, a3));
> -}
> -
> -template <typename Action1, typename Action2, typename Action3,
> - typename Action4>
> -inline internal::DoBothAction<Action1, internal::DoBothAction<Action2,
> - internal::DoBothAction<Action3, Action4> > >
> -DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4) {
> - return DoAll(a1, DoAll(a2, a3, a4));
> -}
> -
> -template <typename Action1, typename Action2, typename Action3,
> - typename Action4, typename Action5>
> -inline internal::DoBothAction<Action1, internal::DoBothAction<Action2,
> - internal::DoBothAction<Action3, internal::DoBothAction<Action4,
> - Action5> > > >
> -DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5) {
> - return DoAll(a1, DoAll(a2, a3, a4, a5));
> -}
> -
> -template <typename Action1, typename Action2, typename Action3,
> - typename Action4, typename Action5, typename Action6>
> -inline internal::DoBothAction<Action1, internal::DoBothAction<Action2,
> - internal::DoBothAction<Action3, internal::DoBothAction<Action4,
> - internal::DoBothAction<Action5, Action6> > > > >
> -DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6
> a6) {
> - return DoAll(a1, DoAll(a2, a3, a4, a5, a6));
> -}
> -
> -template <typename Action1, typename Action2, typename Action3,
> - typename Action4, typename Action5, typename Action6, typename
> Action7>
> -inline internal::DoBothAction<Action1, internal::DoBothAction<Action2,
> - internal::DoBothAction<Action3, internal::DoBothAction<Action4,
> - internal::DoBothAction<Action5, internal::DoBothAction<Action6,
> - Action7> > > > > >
> -DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6
> a6,
> - Action7 a7) {
> - return DoAll(a1, DoAll(a2, a3, a4, a5, a6, a7));
> -}
> -
> -template <typename Action1, typename Action2, typename Action3,
> - typename Action4, typename Action5, typename Action6, typename
> Action7,
> - typename Action8>
> -inline internal::DoBothAction<Action1, internal::DoBothAction<Action2,
> - internal::DoBothAction<Action3, internal::DoBothAction<Action4,
> - internal::DoBothAction<Action5, internal::DoBothAction<Action6,
> - internal::DoBothAction<Action7, Action8> > > > > > >
> -DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6
> a6,
> - Action7 a7, Action8 a8) {
> - return DoAll(a1, DoAll(a2, a3, a4, a5, a6, a7, a8));
> -}
> -
> -template <typename Action1, typename Action2, typename Action3,
> - typename Action4, typename Action5, typename Action6, typename
> Action7,
> - typename Action8, typename Action9>
> -inline internal::DoBothAction<Action1, internal::DoBothAction<Action2,
> - internal::DoBothAction<Action3, internal::DoBothAction<Action4,
> - internal::DoBothAction<Action5, internal::DoBothAction<Action6,
> - internal::DoBothAction<Action7, internal::DoBothAction<Action8,
> - Action9> > > > > > > >
> -DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6
> a6,
> - Action7 a7, Action8 a8, Action9 a9) {
> - return DoAll(a1, DoAll(a2, a3, a4, a5, a6, a7, a8, a9));
> -}
> -
> -template <typename Action1, typename Action2, typename Action3,
> - typename Action4, typename Action5, typename Action6, typename
> Action7,
> - typename Action8, typename Action9, typename Action10>
> -inline internal::DoBothAction<Action1, internal::DoBothAction<Action2,
> - internal::DoBothAction<Action3, internal::DoBothAction<Action4,
> - internal::DoBothAction<Action5, internal::DoBothAction<Action6,
> - internal::DoBothAction<Action7, internal::DoBothAction<Action8,
> - internal::DoBothAction<Action9, Action10> > > > > > > > >
> -DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6
> a6,
> - Action7 a7, Action8 a8, Action9 a9, Action10 a10) {
> - return DoAll(a1, DoAll(a2, a3, a4, a5, a6, a7, a8, a9, a10));
> -}
> -
> } // namespace testing
>
> // The ACTION* family of macros can be used in a namespace scope to
> @@ -944,30 +261,29 @@ DoAll(Action1 a1, Action2 a2, Action3 a3, Action4
> a4, Action5 a5, Action6 a6,
> //
> // CAVEAT:
> //
> -// ACTION*() can only be used in a namespace scope. The reason is
> -// that C++ doesn't yet allow function-local types to be used to
> -// instantiate templates. The up-coming C++0x standard will fix this.
> -// Once that's done, we'll consider supporting using ACTION*() inside
> -// a function.
> +// ACTION*() can only be used in a namespace scope as templates cannot be
> +// declared inside of a local class.
> +// Users can, however, define any local functors (e.g. a lambda) that
> +// can be used as actions.
> //
> // MORE INFORMATION:
> //
> -// To learn more about using these macros, please search for 'ACTION'
> -// on
> https://github.com/google/googletest/blob/master/googlemock/docs/CookBook.md
> +// To learn more about using these macros, please search for 'ACTION' on
> +//
> https://github.com/google/googletest/blob/master/googlemock/docs/cook_book.md
>
> // An internal macro needed for implementing ACTION*().
> #define GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_\
> const args_type& args GTEST_ATTRIBUTE_UNUSED_, \
> - arg0_type arg0 GTEST_ATTRIBUTE_UNUSED_, \
> - arg1_type arg1 GTEST_ATTRIBUTE_UNUSED_, \
> - arg2_type arg2 GTEST_ATTRIBUTE_UNUSED_, \
> - arg3_type arg3 GTEST_ATTRIBUTE_UNUSED_, \
> - arg4_type arg4 GTEST_ATTRIBUTE_UNUSED_, \
> - arg5_type arg5 GTEST_ATTRIBUTE_UNUSED_, \
> - arg6_type arg6 GTEST_ATTRIBUTE_UNUSED_, \
> - arg7_type arg7 GTEST_ATTRIBUTE_UNUSED_, \
> - arg8_type arg8 GTEST_ATTRIBUTE_UNUSED_, \
> - arg9_type arg9 GTEST_ATTRIBUTE_UNUSED_
> + const arg0_type& arg0 GTEST_ATTRIBUTE_UNUSED_, \
> + const arg1_type& arg1 GTEST_ATTRIBUTE_UNUSED_, \
> + const arg2_type& arg2 GTEST_ATTRIBUTE_UNUSED_, \
> + const arg3_type& arg3 GTEST_ATTRIBUTE_UNUSED_, \
> + const arg4_type& arg4 GTEST_ATTRIBUTE_UNUSED_, \
> + const arg5_type& arg5 GTEST_ATTRIBUTE_UNUSED_, \
> + const arg6_type& arg6 GTEST_ATTRIBUTE_UNUSED_, \
> + const arg7_type& arg7 GTEST_ATTRIBUTE_UNUSED_, \
> + const arg8_type& arg8 GTEST_ATTRIBUTE_UNUSED_, \
> + const arg9_type& arg9 GTEST_ATTRIBUTE_UNUSED_
>
> // Sometimes you want to give an action explicit template parameters
> // that cannot be inferred from its value parameters. ACTION() and
> @@ -993,7 +309,7 @@ DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4,
> Action5 a5, Action6 a6,
> // ACTION_TEMPLATE(DuplicateArg,
> // HAS_2_TEMPLATE_PARAMS(int, k, typename, T),
> // AND_1_VALUE_PARAMS(output)) {
> -// *output = T(::testing::get<k>(args));
> +// *output = T(::std::get<k>(args));
> // }
> // ...
> // int n;
> @@ -1151,90 +467,67 @@ DoAll(Action1 a1, Action2 a2, Action3 a3, Action4
> a4, Action5 a5, Action6 a6,
> #define GMOCK_INTERNAL_INIT_AND_0_VALUE_PARAMS()\
> ()
> #define GMOCK_INTERNAL_INIT_AND_1_VALUE_PARAMS(p0)\
> - (p0##_type gmock_p0) : p0(::testing::internal::move(gmock_p0))
> + (p0##_type gmock_p0) : p0(::std::move(gmock_p0))
> #define GMOCK_INTERNAL_INIT_AND_2_VALUE_PARAMS(p0, p1)\
> - (p0##_type gmock_p0, \
> - p1##_type gmock_p1) : p0(::testing::internal::move(gmock_p0)), \
> - p1(::testing::internal::move(gmock_p1))
> + (p0##_type gmock_p0, p1##_type gmock_p1) : p0(::std::move(gmock_p0)),
> \
> + p1(::std::move(gmock_p1))
> #define GMOCK_INTERNAL_INIT_AND_3_VALUE_PARAMS(p0, p1, p2)\
> (p0##_type gmock_p0, p1##_type gmock_p1, \
> - p2##_type gmock_p2) : p0(::testing::internal::move(gmock_p0)), \
> - p1(::testing::internal::move(gmock_p1)), \
> - p2(::testing::internal::move(gmock_p2))
> + p2##_type gmock_p2) : p0(::std::move(gmock_p0)), \
> + p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2))
> #define GMOCK_INTERNAL_INIT_AND_4_VALUE_PARAMS(p0, p1, p2, p3)\
> (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
> - p3##_type gmock_p3) : p0(::testing::internal::move(gmock_p0)), \
> - p1(::testing::internal::move(gmock_p1)), \
> - p2(::testing::internal::move(gmock_p2)), \
> - p3(::testing::internal::move(gmock_p3))
> + p3##_type gmock_p3) : p0(::std::move(gmock_p0)), \
> + p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \
> + p3(::std::move(gmock_p3))
> #define GMOCK_INTERNAL_INIT_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4)\
> (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
> - p3##_type gmock_p3, \
> - p4##_type gmock_p4) : p0(::testing::internal::move(gmock_p0)), \
> - p1(::testing::internal::move(gmock_p1)), \
> - p2(::testing::internal::move(gmock_p2)), \
> - p3(::testing::internal::move(gmock_p3)), \
> - p4(::testing::internal::move(gmock_p4))
> + p3##_type gmock_p3, p4##_type gmock_p4) :
> p0(::std::move(gmock_p0)), \
> + p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \
> + p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4))
> #define GMOCK_INTERNAL_INIT_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5)\
> (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
> p3##_type gmock_p3, p4##_type gmock_p4, \
> - p5##_type gmock_p5) : p0(::testing::internal::move(gmock_p0)), \
> - p1(::testing::internal::move(gmock_p1)), \
> - p2(::testing::internal::move(gmock_p2)), \
> - p3(::testing::internal::move(gmock_p3)), \
> - p4(::testing::internal::move(gmock_p4)), \
> - p5(::testing::internal::move(gmock_p5))
> + p5##_type gmock_p5) : p0(::std::move(gmock_p0)), \
> + p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \
> + p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \
> + p5(::std::move(gmock_p5))
> #define GMOCK_INTERNAL_INIT_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5,
> p6)\
> (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
> p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
> - p6##_type gmock_p6) : p0(::testing::internal::move(gmock_p0)), \
> - p1(::testing::internal::move(gmock_p1)), \
> - p2(::testing::internal::move(gmock_p2)), \
> - p3(::testing::internal::move(gmock_p3)), \
> - p4(::testing::internal::move(gmock_p4)), \
> - p5(::testing::internal::move(gmock_p5)), \
> - p6(::testing::internal::move(gmock_p6))
> + p6##_type gmock_p6) : p0(::std::move(gmock_p0)), \
> + p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \
> + p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \
> + p5(::std::move(gmock_p5)), p6(::std::move(gmock_p6))
> #define GMOCK_INTERNAL_INIT_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5,
> p6, p7)\
> (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
> p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
> - p6##_type gmock_p6, \
> - p7##_type gmock_p7) : p0(::testing::internal::move(gmock_p0)), \
> - p1(::testing::internal::move(gmock_p1)), \
> - p2(::testing::internal::move(gmock_p2)), \
> - p3(::testing::internal::move(gmock_p3)), \
> - p4(::testing::internal::move(gmock_p4)), \
> - p5(::testing::internal::move(gmock_p5)), \
> - p6(::testing::internal::move(gmock_p6)), \
> - p7(::testing::internal::move(gmock_p7))
> + p6##_type gmock_p6, p7##_type gmock_p7) :
> p0(::std::move(gmock_p0)), \
> + p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \
> + p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \
> + p5(::std::move(gmock_p5)), p6(::std::move(gmock_p6)), \
> + p7(::std::move(gmock_p7))
> #define GMOCK_INTERNAL_INIT_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5,
> p6, \
> p7, p8)\
> (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
> p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
> p6##_type gmock_p6, p7##_type gmock_p7, \
> - p8##_type gmock_p8) : p0(::testing::internal::move(gmock_p0)), \
> - p1(::testing::internal::move(gmock_p1)), \
> - p2(::testing::internal::move(gmock_p2)), \
> - p3(::testing::internal::move(gmock_p3)), \
> - p4(::testing::internal::move(gmock_p4)), \
> - p5(::testing::internal::move(gmock_p5)), \
> - p6(::testing::internal::move(gmock_p6)), \
> - p7(::testing::internal::move(gmock_p7)), \
> - p8(::testing::internal::move(gmock_p8))
> + p8##_type gmock_p8) : p0(::std::move(gmock_p0)), \
> + p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \
> + p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \
> + p5(::std::move(gmock_p5)), p6(::std::move(gmock_p6)), \
> + p7(::std::move(gmock_p7)), p8(::std::move(gmock_p8))
> #define GMOCK_INTERNAL_INIT_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5,
> p6, \
> p7, p8, p9)\
> (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
> p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
> p6##_type gmock_p6, p7##_type gmock_p7, p8##_type gmock_p8, \
> - p9##_type gmock_p9) : p0(::testing::internal::move(gmock_p0)), \
> - p1(::testing::internal::move(gmock_p1)), \
> - p2(::testing::internal::move(gmock_p2)), \
> - p3(::testing::internal::move(gmock_p3)), \
> - p4(::testing::internal::move(gmock_p4)), \
> - p5(::testing::internal::move(gmock_p5)), \
> - p6(::testing::internal::move(gmock_p6)), \
> - p7(::testing::internal::move(gmock_p7)), \
> - p8(::testing::internal::move(gmock_p8)), \
> - p9(::testing::internal::move(gmock_p9))
> + p9##_type gmock_p9) : p0(::std::move(gmock_p0)), \
> + p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \
> + p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \
> + p5(::std::move(gmock_p5)), p6(::std::move(gmock_p6)), \
> + p7(::std::move(gmock_p7)), p8(::std::move(gmock_p8)), \
> + p9(::std::move(gmock_p9))
>
> // Declares the fields for storing the value parameters.
> #define GMOCK_INTERNAL_DEFN_AND_0_VALUE_PARAMS()
> @@ -1380,10 +673,12 @@ DoAll(Action1 a1, Action2 a2, Action3 a3, Action4
> a4, Action5 a5, Action6 a6,
> typename arg3_type, typename arg4_type, typename arg5_type, \
> typename arg6_type, typename arg7_type, typename arg8_type, \
> typename arg9_type>\
> - return_type gmock_PerformImpl(const args_type& args, arg0_type
> arg0, \
> - arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4,
> \
> - arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8,
> \
> - arg9_type arg9) const;\
> + return_type gmock_PerformImpl(const args_type& args, \
> + const arg0_type& arg0, const arg1_type& arg1, \
> + const arg2_type& arg2, const arg3_type& arg3, \
> + const arg4_type& arg4, const arg5_type& arg5, \
> + const arg6_type& arg6, const arg7_type& arg7, \
> + const arg8_type& arg8, const arg9_type& arg9) const;\
> GMOCK_INTERNAL_DEFN_##value_params\
> private:\
> GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
> @@ -1441,10 +736,12 @@ DoAll(Action1 a1, Action2 a2, Action3 a3, Action4
> a4, Action5 a5, Action6 a6,
> typename arg3_type, typename arg4_type, typename arg5_type, \
> typename arg6_type, typename arg7_type, typename arg8_type, \
> typename arg9_type>\
> - return_type gmock_PerformImpl(const args_type& args, arg0_type
> arg0, \
> - arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4,
> \
> - arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8,
> \
> - arg9_type arg9) const;\
> + return_type gmock_PerformImpl(const args_type& args, \
> + const arg0_type& arg0, const arg1_type& arg1, \
> + const arg2_type& arg2, const arg3_type& arg3, \
> + const arg4_type& arg4, const arg5_type& arg5, \
> + const arg6_type& arg6, const arg7_type& arg7, \
> + const arg8_type& arg8, const arg9_type& arg9) const;\
> private:\
> GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
> };\
> @@ -1471,7 +768,7 @@ DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4,
> Action5 a5, Action6 a6,
> class name##ActionP {\
> public:\
> explicit name##ActionP(p0##_type gmock_p0) : \
> - p0(::testing::internal::forward<p0##_type>(gmock_p0)) {}\
> + p0(::std::forward<p0##_type>(gmock_p0)) {}\
> template <typename F>\
> class gmock_Impl : public ::testing::ActionInterface<F> {\
> public:\
> @@ -1480,7 +777,7 @@ DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4,
> Action5 a5, Action6 a6,
> typedef typename ::testing::internal::Function<F>::ArgumentTuple\
> args_type;\
> explicit gmock_Impl(p0##_type gmock_p0) : \
> - p0(::testing::internal::forward<p0##_type>(gmock_p0)) {}\
> + p0(::std::forward<p0##_type>(gmock_p0)) {}\
> virtual return_type Perform(const args_type& args) {\
> return ::testing::internal::ActionHelper<return_type,
> gmock_Impl>::\
> Perform(this, args);\
> @@ -1489,10 +786,12 @@ DoAll(Action1 a1, Action2 a2, Action3 a3, Action4
> a4, Action5 a5, Action6 a6,
> typename arg3_type, typename arg4_type, typename arg5_type, \
> typename arg6_type, typename arg7_type, typename arg8_type, \
> typename arg9_type>\
> - return_type gmock_PerformImpl(const args_type& args, arg0_type
> arg0, \
> - arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4,
> \
> - arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8,
> \
> - arg9_type arg9) const;\
> + return_type gmock_PerformImpl(const args_type& args, \
> + const arg0_type& arg0, const arg1_type& arg1, \
> + const arg2_type& arg2, const arg3_type& arg3, \
> + const arg4_type& arg4, const arg5_type& arg5, \
> + const arg6_type& arg6, const arg7_type& arg7, \
> + const arg8_type& arg8, const arg9_type& arg9) const;\
> p0##_type p0;\
> private:\
> GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
> @@ -1523,8 +822,8 @@ DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4,
> Action5 a5, Action6 a6,
> class name##ActionP2 {\
> public:\
> name##ActionP2(p0##_type gmock_p0, \
> - p1##_type gmock_p1) :
> p0(::testing::internal::forward<p0##_type>(gmock_p0)), \
> - p1(::testing::internal::forward<p1##_type>(gmock_p1)) {}\
> + p1##_type gmock_p1) : p0(::std::forward<p0##_type>(gmock_p0)), \
> + p1(::std::forward<p1##_type>(gmock_p1)) {}\
> template <typename F>\
> class gmock_Impl : public ::testing::ActionInterface<F> {\
> public:\
> @@ -1533,8 +832,8 @@ DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4,
> Action5 a5, Action6 a6,
> typedef typename ::testing::internal::Function<F>::ArgumentTuple\
> args_type;\
> gmock_Impl(p0##_type gmock_p0, \
> - p1##_type gmock_p1) :
> p0(::testing::internal::forward<p0##_type>(gmock_p0)), \
> - p1(::testing::internal::forward<p1##_type>(gmock_p1)) {}\
> + p1##_type gmock_p1) : p0(::std::forward<p0##_type>(gmock_p0)), \
> + p1(::std::forward<p1##_type>(gmock_p1)) {}\
> virtual return_type Perform(const args_type& args) {\
> return ::testing::internal::ActionHelper<return_type,
> gmock_Impl>::\
> Perform(this, args);\
> @@ -1543,10 +842,12 @@ DoAll(Action1 a1, Action2 a2, Action3 a3, Action4
> a4, Action5 a5, Action6 a6,
> typename arg3_type, typename arg4_type, typename arg5_type, \
> typename arg6_type, typename arg7_type, typename arg8_type, \
> typename arg9_type>\
> - return_type gmock_PerformImpl(const args_type& args, arg0_type
> arg0, \
> - arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4,
> \
> - arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8,
> \
> - arg9_type arg9) const;\
> + return_type gmock_PerformImpl(const args_type& args, \
> + const arg0_type& arg0, const arg1_type& arg1, \
> + const arg2_type& arg2, const arg3_type& arg3, \
> + const arg4_type& arg4, const arg5_type& arg5, \
> + const arg6_type& arg6, const arg7_type& arg7, \
> + const arg8_type& arg8, const arg9_type& arg9) const;\
> p0##_type p0;\
> p1##_type p1;\
> private:\
> @@ -1580,9 +881,9 @@ DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4,
> Action5 a5, Action6 a6,
> class name##ActionP3 {\
> public:\
> name##ActionP3(p0##_type gmock_p0, p1##_type gmock_p1, \
> - p2##_type gmock_p2) :
> p0(::testing::internal::forward<p0##_type>(gmock_p0)), \
> - p1(::testing::internal::forward<p1##_type>(gmock_p1)), \
> - p2(::testing::internal::forward<p2##_type>(gmock_p2)) {}\
> + p2##_type gmock_p2) : p0(::std::forward<p0##_type>(gmock_p0)), \
> + p1(::std::forward<p1##_type>(gmock_p1)), \
> + p2(::std::forward<p2##_type>(gmock_p2)) {}\
> template <typename F>\
> class gmock_Impl : public ::testing::ActionInterface<F> {\
> public:\
> @@ -1591,9 +892,9 @@ DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4,
> Action5 a5, Action6 a6,
> typedef typename ::testing::internal::Function<F>::ArgumentTuple\
> args_type;\
> gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, \
> - p2##_type gmock_p2) :
> p0(::testing::internal::forward<p0##_type>(gmock_p0)), \
> - p1(::testing::internal::forward<p1##_type>(gmock_p1)), \
> - p2(::testing::internal::forward<p2##_type>(gmock_p2)) {}\
> + p2##_type gmock_p2) : p0(::std::forward<p0##_type>(gmock_p0)), \
> + p1(::std::forward<p1##_type>(gmock_p1)), \
> + p2(::std::forward<p2##_type>(gmock_p2)) {}\
> virtual return_type Perform(const args_type& args) {\
> return ::testing::internal::ActionHelper<return_type,
> gmock_Impl>::\
> Perform(this, args);\
> @@ -1602,10 +903,12 @@ DoAll(Action1 a1, Action2 a2, Action3 a3, Action4
> a4, Action5 a5, Action6 a6,
> typename arg3_type, typename arg4_type, typename arg5_type, \
> typename arg6_type, typename arg7_type, typename arg8_type, \
> typename arg9_type>\
> - return_type gmock_PerformImpl(const args_type& args, arg0_type
> arg0, \
> - arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4,
> \
> - arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8,
> \
> - arg9_type arg9) const;\
> + return_type gmock_PerformImpl(const args_type& args, \
> + const arg0_type& arg0, const arg1_type& arg1, \
> + const arg2_type& arg2, const arg3_type& arg3, \
> + const arg4_type& arg4, const arg5_type& arg5, \
> + const arg6_type& arg6, const arg7_type& arg7, \
> + const arg8_type& arg8, const arg9_type& arg9) const;\
> p0##_type p0;\
> p1##_type p1;\
> p2##_type p2;\
> @@ -1644,10 +947,10 @@ DoAll(Action1 a1, Action2 a2, Action3 a3, Action4
> a4, Action5 a5, Action6 a6,
> public:\
> name##ActionP4(p0##_type gmock_p0, p1##_type gmock_p1, \
> p2##_type gmock_p2, \
> - p3##_type gmock_p3) :
> p0(::testing::internal::forward<p0##_type>(gmock_p0)), \
> - p1(::testing::internal::forward<p1##_type>(gmock_p1)), \
> - p2(::testing::internal::forward<p2##_type>(gmock_p2)), \
> - p3(::testing::internal::forward<p3##_type>(gmock_p3)) {}\
> + p3##_type gmock_p3) : p0(::std::forward<p0##_type>(gmock_p0)), \
> + p1(::std::forward<p1##_type>(gmock_p1)), \
> + p2(::std::forward<p2##_type>(gmock_p2)), \
> + p3(::std::forward<p3##_type>(gmock_p3)) {}\
> template <typename F>\
> class gmock_Impl : public ::testing::ActionInterface<F> {\
> public:\
> @@ -1656,10 +959,10 @@ DoAll(Action1 a1, Action2 a2, Action3 a3, Action4
> a4, Action5 a5, Action6 a6,
> typedef typename ::testing::internal::Function<F>::ArgumentTuple\
> args_type;\
> gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type
> gmock_p2, \
> - p3##_type gmock_p3) :
> p0(::testing::internal::forward<p0##_type>(gmock_p0)), \
> - p1(::testing::internal::forward<p1##_type>(gmock_p1)), \
> - p2(::testing::internal::forward<p2##_type>(gmock_p2)), \
> - p3(::testing::internal::forward<p3##_type>(gmock_p3)) {}\
> + p3##_type gmock_p3) : p0(::std::forward<p0##_type>(gmock_p0)), \
> + p1(::std::forward<p1##_type>(gmock_p1)), \
> + p2(::std::forward<p2##_type>(gmock_p2)), \
> + p3(::std::forward<p3##_type>(gmock_p3)) {}\
> virtual return_type Perform(const args_type& args) {\
> return ::testing::internal::ActionHelper<return_type,
> gmock_Impl>::\
> Perform(this, args);\
> @@ -1668,10 +971,12 @@ DoAll(Action1 a1, Action2 a2, Action3 a3, Action4
> a4, Action5 a5, Action6 a6,
> typename arg3_type, typename arg4_type, typename arg5_type, \
> typename arg6_type, typename arg7_type, typename arg8_type, \
> typename arg9_type>\
> - return_type gmock_PerformImpl(const args_type& args, arg0_type
> arg0, \
> - arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4,
> \
> - arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8,
> \
> - arg9_type arg9) const;\
> + return_type gmock_PerformImpl(const args_type& args, \
> + const arg0_type& arg0, const arg1_type& arg1, \
> + const arg2_type& arg2, const arg3_type& arg3, \
> + const arg4_type& arg4, const arg5_type& arg5, \
> + const arg6_type& arg6, const arg7_type& arg7, \
> + const arg8_type& arg8, const arg9_type& arg9) const;\
> p0##_type p0;\
> p1##_type p1;\
> p2##_type p2;\
> @@ -1716,11 +1021,11 @@ DoAll(Action1 a1, Action2 a2, Action3 a3, Action4
> a4, Action5 a5, Action6 a6,
> public:\
> name##ActionP5(p0##_type gmock_p0, p1##_type gmock_p1, \
> p2##_type gmock_p2, p3##_type gmock_p3, \
> - p4##_type gmock_p4) :
> p0(::testing::internal::forward<p0##_type>(gmock_p0)), \
> - p1(::testing::internal::forward<p1##_type>(gmock_p1)), \
> - p2(::testing::internal::forward<p2##_type>(gmock_p2)), \
> - p3(::testing::internal::forward<p3##_type>(gmock_p3)), \
> - p4(::testing::internal::forward<p4##_type>(gmock_p4)) {}\
> + p4##_type gmock_p4) : p0(::std::forward<p0##_type>(gmock_p0)), \
> + p1(::std::forward<p1##_type>(gmock_p1)), \
> + p2(::std::forward<p2##_type>(gmock_p2)), \
> + p3(::std::forward<p3##_type>(gmock_p3)), \
> + p4(::std::forward<p4##_type>(gmock_p4)) {}\
> template <typename F>\
> class gmock_Impl : public ::testing::ActionInterface<F> {\
> public:\
> @@ -1730,11 +1035,11 @@ DoAll(Action1 a1, Action2 a2, Action3 a3, Action4
> a4, Action5 a5, Action6 a6,
> args_type;\
> gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type
> gmock_p2, \
> p3##_type gmock_p3, \
> - p4##_type gmock_p4) :
> p0(::testing::internal::forward<p0##_type>(gmock_p0)), \
> - p1(::testing::internal::forward<p1##_type>(gmock_p1)), \
> - p2(::testing::internal::forward<p2##_type>(gmock_p2)), \
> - p3(::testing::internal::forward<p3##_type>(gmock_p3)), \
> - p4(::testing::internal::forward<p4##_type>(gmock_p4)) {}\
> + p4##_type gmock_p4) : p0(::std::forward<p0##_type>(gmock_p0)), \
> + p1(::std::forward<p1##_type>(gmock_p1)), \
> + p2(::std::forward<p2##_type>(gmock_p2)), \
> + p3(::std::forward<p3##_type>(gmock_p3)), \
> + p4(::std::forward<p4##_type>(gmock_p4)) {}\
> virtual return_type Perform(const args_type& args) {\
> return ::testing::internal::ActionHelper<return_type,
> gmock_Impl>::\
> Perform(this, args);\
> @@ -1743,10 +1048,12 @@ DoAll(Action1 a1, Action2 a2, Action3 a3, Action4
> a4, Action5 a5, Action6 a6,
> typename arg3_type, typename arg4_type, typename arg5_type, \
> typename arg6_type, typename arg7_type, typename arg8_type, \
> typename arg9_type>\
> - return_type gmock_PerformImpl(const args_type& args, arg0_type
> arg0, \
> - arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4,
> \
> - arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8,
> \
> - arg9_type arg9) const;\
> + return_type gmock_PerformImpl(const args_type& args, \
> + const arg0_type& arg0, const arg1_type& arg1, \
> + const arg2_type& arg2, const arg3_type& arg3, \
> + const arg4_type& arg4, const arg5_type& arg5, \
> + const arg6_type& arg6, const arg7_type& arg7, \
> + const arg8_type& arg8, const arg9_type& arg9) const;\
> p0##_type p0;\
> p1##_type p1;\
> p2##_type p2;\
> @@ -1793,12 +1100,12 @@ DoAll(Action1 a1, Action2 a2, Action3 a3, Action4
> a4, Action5 a5, Action6 a6,
> public:\
> name##ActionP6(p0##_type gmock_p0, p1##_type gmock_p1, \
> p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
> - p5##_type gmock_p5) :
> p0(::testing::internal::forward<p0##_type>(gmock_p0)), \
> - p1(::testing::internal::forward<p1##_type>(gmock_p1)), \
> - p2(::testing::internal::forward<p2##_type>(gmock_p2)), \
> - p3(::testing::internal::forward<p3##_type>(gmock_p3)), \
> - p4(::testing::internal::forward<p4##_type>(gmock_p4)), \
> - p5(::testing::internal::forward<p5##_type>(gmock_p5)) {}\
> + p5##_type gmock_p5) : p0(::std::forward<p0##_type>(gmock_p0)), \
> + p1(::std::forward<p1##_type>(gmock_p1)), \
> + p2(::std::forward<p2##_type>(gmock_p2)), \
> + p3(::std::forward<p3##_type>(gmock_p3)), \
> + p4(::std::forward<p4##_type>(gmock_p4)), \
> + p5(::std::forward<p5##_type>(gmock_p5)) {}\
> template <typename F>\
> class gmock_Impl : public ::testing::ActionInterface<F> {\
> public:\
> @@ -1808,12 +1115,12 @@ DoAll(Action1 a1, Action2 a2, Action3 a3, Action4
> a4, Action5 a5, Action6 a6,
> args_type;\
> gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type
> gmock_p2, \
> p3##_type gmock_p3, p4##_type gmock_p4, \
> - p5##_type gmock_p5) :
> p0(::testing::internal::forward<p0##_type>(gmock_p0)), \
> - p1(::testing::internal::forward<p1##_type>(gmock_p1)), \
> - p2(::testing::internal::forward<p2##_type>(gmock_p2)), \
> - p3(::testing::internal::forward<p3##_type>(gmock_p3)), \
> - p4(::testing::internal::forward<p4##_type>(gmock_p4)), \
> - p5(::testing::internal::forward<p5##_type>(gmock_p5)) {}\
> + p5##_type gmock_p5) : p0(::std::forward<p0##_type>(gmock_p0)), \
> + p1(::std::forward<p1##_type>(gmock_p1)), \
> + p2(::std::forward<p2##_type>(gmock_p2)), \
> + p3(::std::forward<p3##_type>(gmock_p3)), \
> + p4(::std::forward<p4##_type>(gmock_p4)), \
> + p5(::std::forward<p5##_type>(gmock_p5)) {}\
> virtual return_type Perform(const args_type& args) {\
> return ::testing::internal::ActionHelper<return_type,
> gmock_Impl>::\
> Perform(this, args);\
> @@ -1822,10 +1129,12 @@ DoAll(Action1 a1, Action2 a2, Action3 a3, Action4
> a4, Action5 a5, Action6 a6,
> typename arg3_type, typename arg4_type, typename arg5_type, \
> typename arg6_type, typename arg7_type, typename arg8_type, \
> typename arg9_type>\
> - return_type gmock_PerformImpl(const args_type& args, arg0_type
> arg0, \
> - arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4,
> \
> - arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8,
> \
> - arg9_type arg9) const;\
> + return_type gmock_PerformImpl(const args_type& args, \
> + const arg0_type& arg0, const arg1_type& arg1, \
> + const arg2_type& arg2, const arg3_type& arg3, \
> + const arg4_type& arg4, const arg5_type& arg5, \
> + const arg6_type& arg6, const arg7_type& arg7, \
> + const arg8_type& arg8, const arg9_type& arg9) const;\
> p0##_type p0;\
> p1##_type p1;\
> p2##_type p2;\
> @@ -1876,13 +1185,13 @@ DoAll(Action1 a1, Action2 a2, Action3 a3, Action4
> a4, Action5 a5, Action6 a6,
> name##ActionP7(p0##_type gmock_p0, p1##_type gmock_p1, \
> p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
> p5##_type gmock_p5, \
> - p6##_type gmock_p6) :
> p0(::testing::internal::forward<p0##_type>(gmock_p0)), \
> - p1(::testing::internal::forward<p1##_type>(gmock_p1)), \
> - p2(::testing::internal::forward<p2##_type>(gmock_p2)), \
> - p3(::testing::internal::forward<p3##_type>(gmock_p3)), \
> - p4(::testing::internal::forward<p4##_type>(gmock_p4)), \
> - p5(::testing::internal::forward<p5##_type>(gmock_p5)), \
> - p6(::testing::internal::forward<p6##_type>(gmock_p6)) {}\
> + p6##_type gmock_p6) : p0(::std::forward<p0##_type>(gmock_p0)), \
> + p1(::std::forward<p1##_type>(gmock_p1)), \
> + p2(::std::forward<p2##_type>(gmock_p2)), \
> + p3(::std::forward<p3##_type>(gmock_p3)), \
> + p4(::std::forward<p4##_type>(gmock_p4)), \
> + p5(::std::forward<p5##_type>(gmock_p5)), \
> + p6(::std::forward<p6##_type>(gmock_p6)) {}\
> template <typename F>\
> class gmock_Impl : public ::testing::ActionInterface<F> {\
> public:\
> @@ -1892,13 +1201,13 @@ DoAll(Action1 a1, Action2 a2, Action3 a3, Action4
> a4, Action5 a5, Action6 a6,
> args_type;\
> gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type
> gmock_p2, \
> p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
> - p6##_type gmock_p6) :
> p0(::testing::internal::forward<p0##_type>(gmock_p0)), \
> - p1(::testing::internal::forward<p1##_type>(gmock_p1)), \
> - p2(::testing::internal::forward<p2##_type>(gmock_p2)), \
> - p3(::testing::internal::forward<p3##_type>(gmock_p3)), \
> - p4(::testing::internal::forward<p4##_type>(gmock_p4)), \
> - p5(::testing::internal::forward<p5##_type>(gmock_p5)), \
> - p6(::testing::internal::forward<p6##_type>(gmock_p6)) {}\
> + p6##_type gmock_p6) : p0(::std::forward<p0##_type>(gmock_p0)), \
> + p1(::std::forward<p1##_type>(gmock_p1)), \
> + p2(::std::forward<p2##_type>(gmock_p2)), \
> + p3(::std::forward<p3##_type>(gmock_p3)), \
> + p4(::std::forward<p4##_type>(gmock_p4)), \
> + p5(::std::forward<p5##_type>(gmock_p5)), \
> + p6(::std::forward<p6##_type>(gmock_p6)) {}\
> virtual return_type Perform(const args_type& args) {\
> return ::testing::internal::ActionHelper<return_type,
> gmock_Impl>::\
> Perform(this, args);\
> @@ -1907,10 +1216,12 @@ DoAll(Action1 a1, Action2 a2, Action3 a3, Action4
> a4, Action5 a5, Action6 a6,
> typename arg3_type, typename arg4_type, typename arg5_type, \
> typename arg6_type, typename arg7_type, typename arg8_type, \
> typename arg9_type>\
> - return_type gmock_PerformImpl(const args_type& args, arg0_type
> arg0, \
> - arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4,
> \
> - arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8,
> \
> - arg9_type arg9) const;\
> + return_type gmock_PerformImpl(const args_type& args, \
> + const arg0_type& arg0, const arg1_type& arg1, \
> + const arg2_type& arg2, const arg3_type& arg3, \
> + const arg4_type& arg4, const arg5_type& arg5, \
> + const arg6_type& arg6, const arg7_type& arg7, \
> + const arg8_type& arg8, const arg9_type& arg9) const;\
> p0##_type p0;\
> p1##_type p1;\
> p2##_type p2;\
> @@ -1967,14 +1278,14 @@ DoAll(Action1 a1, Action2 a2, Action3 a3, Action4
> a4, Action5 a5, Action6 a6,
> name##ActionP8(p0##_type gmock_p0, p1##_type gmock_p1, \
> p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
> p5##_type gmock_p5, p6##_type gmock_p6, \
> - p7##_type gmock_p7) :
> p0(::testing::internal::forward<p0##_type>(gmock_p0)), \
> - p1(::testing::internal::forward<p1##_type>(gmock_p1)), \
> - p2(::testing::internal::forward<p2##_type>(gmock_p2)), \
> - p3(::testing::internal::forward<p3##_type>(gmock_p3)), \
> - p4(::testing::internal::forward<p4##_type>(gmock_p4)), \
> - p5(::testing::internal::forward<p5##_type>(gmock_p5)), \
> - p6(::testing::internal::forward<p6##_type>(gmock_p6)), \
> - p7(::testing::internal::forward<p7##_type>(gmock_p7)) {}\
> + p7##_type gmock_p7) : p0(::std::forward<p0##_type>(gmock_p0)), \
> + p1(::std::forward<p1##_type>(gmock_p1)), \
> + p2(::std::forward<p2##_type>(gmock_p2)), \
> + p3(::std::forward<p3##_type>(gmock_p3)), \
> + p4(::std::forward<p4##_type>(gmock_p4)), \
> + p5(::std::forward<p5##_type>(gmock_p5)), \
> + p6(::std::forward<p6##_type>(gmock_p6)), \
> + p7(::std::forward<p7##_type>(gmock_p7)) {}\
> template <typename F>\
> class gmock_Impl : public ::testing::ActionInterface<F> {\
> public:\
> @@ -1985,14 +1296,14 @@ DoAll(Action1 a1, Action2 a2, Action3 a3, Action4
> a4, Action5 a5, Action6 a6,
> gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type
> gmock_p2, \
> p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
> p6##_type gmock_p6, \
> - p7##_type gmock_p7) :
> p0(::testing::internal::forward<p0##_type>(gmock_p0)), \
> - p1(::testing::internal::forward<p1##_type>(gmock_p1)), \
> - p2(::testing::internal::forward<p2##_type>(gmock_p2)), \
> - p3(::testing::internal::forward<p3##_type>(gmock_p3)), \
> - p4(::testing::internal::forward<p4##_type>(gmock_p4)), \
> - p5(::testing::internal::forward<p5##_type>(gmock_p5)), \
> - p6(::testing::internal::forward<p6##_type>(gmock_p6)), \
> - p7(::testing::internal::forward<p7##_type>(gmock_p7)) {}\
> + p7##_type gmock_p7) : p0(::std::forward<p0##_type>(gmock_p0)), \
> + p1(::std::forward<p1##_type>(gmock_p1)), \
> + p2(::std::forward<p2##_type>(gmock_p2)), \
> + p3(::std::forward<p3##_type>(gmock_p3)), \
> + p4(::std::forward<p4##_type>(gmock_p4)), \
> + p5(::std::forward<p5##_type>(gmock_p5)), \
> + p6(::std::forward<p6##_type>(gmock_p6)), \
> + p7(::std::forward<p7##_type>(gmock_p7)) {}\
> virtual return_type Perform(const args_type& args) {\
> return ::testing::internal::ActionHelper<return_type,
> gmock_Impl>::\
> Perform(this, args);\
> @@ -2001,10 +1312,12 @@ DoAll(Action1 a1, Action2 a2, Action3 a3, Action4
> a4, Action5 a5, Action6 a6,
> typename arg3_type, typename arg4_type, typename arg5_type, \
> typename arg6_type, typename arg7_type, typename arg8_type, \
> typename arg9_type>\
> - return_type gmock_PerformImpl(const args_type& args, arg0_type
> arg0, \
> - arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4,
> \
> - arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8,
> \
> - arg9_type arg9) const;\
> + return_type gmock_PerformImpl(const args_type& args, \
> + const arg0_type& arg0, const arg1_type& arg1, \
> + const arg2_type& arg2, const arg3_type& arg3, \
> + const arg4_type& arg4, const arg5_type& arg5, \
> + const arg6_type& arg6, const arg7_type& arg7, \
> + const arg8_type& arg8, const arg9_type& arg9) const;\
> p0##_type p0;\
> p1##_type p1;\
> p2##_type p2;\
> @@ -2065,15 +1378,15 @@ DoAll(Action1 a1, Action2 a2, Action3 a3, Action4
> a4, Action5 a5, Action6 a6,
> name##ActionP9(p0##_type gmock_p0, p1##_type gmock_p1, \
> p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
> p5##_type gmock_p5, p6##_type gmock_p6, p7##_type gmock_p7, \
> - p8##_type gmock_p8) :
> p0(::testing::internal::forward<p0##_type>(gmock_p0)), \
> - p1(::testing::internal::forward<p1##_type>(gmock_p1)), \
> - p2(::testing::internal::forward<p2##_type>(gmock_p2)), \
> - p3(::testing::internal::forward<p3##_type>(gmock_p3)), \
> - p4(::testing::internal::forward<p4##_type>(gmock_p4)), \
> - p5(::testing::internal::forward<p5##_type>(gmock_p5)), \
> - p6(::testing::internal::forward<p6##_type>(gmock_p6)), \
> - p7(::testing::internal::forward<p7##_type>(gmock_p7)), \
> - p8(::testing::internal::forward<p8##_type>(gmock_p8)) {}\
> + p8##_type gmock_p8) : p0(::std::forward<p0##_type>(gmock_p0)), \
> + p1(::std::forward<p1##_type>(gmock_p1)), \
> + p2(::std::forward<p2##_type>(gmock_p2)), \
> + p3(::std::forward<p3##_type>(gmock_p3)), \
> + p4(::std::forward<p4##_type>(gmock_p4)), \
> + p5(::std::forward<p5##_type>(gmock_p5)), \
> + p6(::std::forward<p6##_type>(gmock_p6)), \
> + p7(::std::forward<p7##_type>(gmock_p7)), \
> + p8(::std::forward<p8##_type>(gmock_p8)) {}\
> template <typename F>\
> class gmock_Impl : public ::testing::ActionInterface<F> {\
> public:\
> @@ -2084,15 +1397,15 @@ DoAll(Action1 a1, Action2 a2, Action3 a3, Action4
> a4, Action5 a5, Action6 a6,
> gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type
> gmock_p2, \
> p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
> p6##_type gmock_p6, p7##_type gmock_p7, \
> - p8##_type gmock_p8) :
> p0(::testing::internal::forward<p0##_type>(gmock_p0)), \
> - p1(::testing::internal::forward<p1##_type>(gmock_p1)), \
> - p2(::testing::internal::forward<p2##_type>(gmock_p2)), \
> - p3(::testing::internal::forward<p3##_type>(gmock_p3)), \
> - p4(::testing::internal::forward<p4##_type>(gmock_p4)), \
> - p5(::testing::internal::forward<p5##_type>(gmock_p5)), \
> - p6(::testing::internal::forward<p6##_type>(gmock_p6)), \
> - p7(::testing::internal::forward<p7##_type>(gmock_p7)), \
> - p8(::testing::internal::forward<p8##_type>(gmock_p8)) {}\
> + p8##_type gmock_p8) : p0(::std::forward<p0##_type>(gmock_p0)), \
> + p1(::std::forward<p1##_type>(gmock_p1)), \
> + p2(::std::forward<p2##_type>(gmock_p2)), \
> + p3(::std::forward<p3##_type>(gmock_p3)), \
> + p4(::std::forward<p4##_type>(gmock_p4)), \
> + p5(::std::forward<p5##_type>(gmock_p5)), \
> + p6(::std::forward<p6##_type>(gmock_p6)), \
> + p7(::std::forward<p7##_type>(gmock_p7)), \
> + p8(::std::forward<p8##_type>(gmock_p8)) {}\
> virtual return_type Perform(const args_type& args) {\
> return ::testing::internal::ActionHelper<return_type,
> gmock_Impl>::\
> Perform(this, args);\
> @@ -2101,10 +1414,12 @@ DoAll(Action1 a1, Action2 a2, Action3 a3, Action4
> a4, Action5 a5, Action6 a6,
> typename arg3_type, typename arg4_type, typename arg5_type, \
> typename arg6_type, typename arg7_type, typename arg8_type, \
> typename arg9_type>\
> - return_type gmock_PerformImpl(const args_type& args, arg0_type
> arg0, \
> - arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4,
> \
> - arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8,
> \
> - arg9_type arg9) const;\
> + return_type gmock_PerformImpl(const args_type& args, \
> + const arg0_type& arg0, const arg1_type& arg1, \
> + const arg2_type& arg2, const arg3_type& arg3, \
> + const arg4_type& arg4, const arg5_type& arg5, \
> + const arg6_type& arg6, const arg7_type& arg7, \
> + const arg8_type& arg8, const arg9_type& arg9) const;\
> p0##_type p0;\
> p1##_type p1;\
> p2##_type p2;\
> @@ -2170,16 +1485,16 @@ DoAll(Action1 a1, Action2 a2, Action3 a3, Action4
> a4, Action5 a5, Action6 a6,
> p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
> p5##_type gmock_p5, p6##_type gmock_p6, p7##_type gmock_p7, \
> p8##_type gmock_p8, \
> - p9##_type gmock_p9) :
> p0(::testing::internal::forward<p0##_type>(gmock_p0)), \
> - p1(::testing::internal::forward<p1##_type>(gmock_p1)), \
> - p2(::testing::internal::forward<p2##_type>(gmock_p2)), \
> - p3(::testing::internal::forward<p3##_type>(gmock_p3)), \
> - p4(::testing::internal::forward<p4##_type>(gmock_p4)), \
> - p5(::testing::internal::forward<p5##_type>(gmock_p5)), \
> - p6(::testing::internal::forward<p6##_type>(gmock_p6)), \
> - p7(::testing::internal::forward<p7##_type>(gmock_p7)), \
> - p8(::testing::internal::forward<p8##_type>(gmock_p8)), \
> - p9(::testing::internal::forward<p9##_type>(gmock_p9)) {}\
> + p9##_type gmock_p9) : p0(::std::forward<p0##_type>(gmock_p0)), \
> + p1(::std::forward<p1##_type>(gmock_p1)), \
> + p2(::std::forward<p2##_type>(gmock_p2)), \
> + p3(::std::forward<p3##_type>(gmock_p3)), \
> + p4(::std::forward<p4##_type>(gmock_p4)), \
> + p5(::std::forward<p5##_type>(gmock_p5)), \
> + p6(::std::forward<p6##_type>(gmock_p6)), \
> + p7(::std::forward<p7##_type>(gmock_p7)), \
> + p8(::std::forward<p8##_type>(gmock_p8)), \
> + p9(::std::forward<p9##_type>(gmock_p9)) {}\
> template <typename F>\
> class gmock_Impl : public ::testing::ActionInterface<F> {\
> public:\
> @@ -2190,16 +1505,16 @@ DoAll(Action1 a1, Action2 a2, Action3 a3, Action4
> a4, Action5 a5, Action6 a6,
> gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type
> gmock_p2, \
> p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
> p6##_type gmock_p6, p7##_type gmock_p7, p8##_type gmock_p8, \
> - p9##_type gmock_p9) :
> p0(::testing::internal::forward<p0##_type>(gmock_p0)), \
> - p1(::testing::internal::forward<p1##_type>(gmock_p1)), \
> - p2(::testing::internal::forward<p2##_type>(gmock_p2)), \
> - p3(::testing::internal::forward<p3##_type>(gmock_p3)), \
> - p4(::testing::internal::forward<p4##_type>(gmock_p4)), \
> - p5(::testing::internal::forward<p5##_type>(gmock_p5)), \
> - p6(::testing::internal::forward<p6##_type>(gmock_p6)), \
> - p7(::testing::internal::forward<p7##_type>(gmock_p7)), \
> - p8(::testing::internal::forward<p8##_type>(gmock_p8)), \
> - p9(::testing::internal::forward<p9##_type>(gmock_p9)) {}\
> + p9##_type gmock_p9) : p0(::std::forward<p0##_type>(gmock_p0)), \
> + p1(::std::forward<p1##_type>(gmock_p1)), \
> + p2(::std::forward<p2##_type>(gmock_p2)), \
> + p3(::std::forward<p3##_type>(gmock_p3)), \
> + p4(::std::forward<p4##_type>(gmock_p4)), \
> + p5(::std::forward<p5##_type>(gmock_p5)), \
> + p6(::std::forward<p6##_type>(gmock_p6)), \
> + p7(::std::forward<p7##_type>(gmock_p7)), \
> + p8(::std::forward<p8##_type>(gmock_p8)), \
> + p9(::std::forward<p9##_type>(gmock_p9)) {}\
> virtual return_type Perform(const args_type& args) {\
> return ::testing::internal::ActionHelper<return_type,
> gmock_Impl>::\
> Perform(this, args);\
> @@ -2208,10 +1523,12 @@ DoAll(Action1 a1, Action2 a2, Action3 a3, Action4
> a4, Action5 a5, Action6 a6,
> typename arg3_type, typename arg4_type, typename arg5_type, \
> typename arg6_type, typename arg7_type, typename arg8_type, \
> typename arg9_type>\
> - return_type gmock_PerformImpl(const args_type& args, arg0_type
> arg0, \
> - arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4,
> \
> - arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8,
> \
> - arg9_type arg9) const;\
> + return_type gmock_PerformImpl(const args_type& args, \
> + const arg0_type& arg0, const arg1_type& arg1, \
> + const arg2_type& arg2, const arg3_type& arg3, \
> + const arg4_type& arg4, const arg5_type& arg5, \
> + const arg6_type& arg6, const arg7_type& arg7, \
> + const arg8_type& arg8, const arg9_type& arg9) const;\
> p0##_type p0;\
> p1##_type p1;\
> p2##_type p2;\
> @@ -2391,7 +1708,7 @@ ACTION_TEMPLATE(InvokeArgument,
> using internal::invoke_argument::InvokeArgumentAdl;
> return InvokeArgumentAdl<return_type>(
> internal::invoke_argument::AdlTag(),
> - ::testing::get<k>(args));
> + ::std::get<k>(args));
> }
>
> ACTION_TEMPLATE(InvokeArgument,
> @@ -2400,7 +1717,7 @@ ACTION_TEMPLATE(InvokeArgument,
> using internal::invoke_argument::InvokeArgumentAdl;
> return InvokeArgumentAdl<return_type>(
> internal::invoke_argument::AdlTag(),
> - ::testing::get<k>(args), p0);
> + ::std::get<k>(args), p0);
> }
>
> ACTION_TEMPLATE(InvokeArgument,
> @@ -2409,7 +1726,7 @@ ACTION_TEMPLATE(InvokeArgument,
> using internal::invoke_argument::InvokeArgumentAdl;
> return InvokeArgumentAdl<return_type>(
> internal::invoke_argument::AdlTag(),
> - ::testing::get<k>(args), p0, p1);
> + ::std::get<k>(args), p0, p1);
> }
>
> ACTION_TEMPLATE(InvokeArgument,
> @@ -2418,7 +1735,7 @@ ACTION_TEMPLATE(InvokeArgument,
> using internal::invoke_argument::InvokeArgumentAdl;
> return InvokeArgumentAdl<return_type>(
> internal::invoke_argument::AdlTag(),
> - ::testing::get<k>(args), p0, p1, p2);
> + ::std::get<k>(args), p0, p1, p2);
> }
>
> ACTION_TEMPLATE(InvokeArgument,
> @@ -2427,7 +1744,7 @@ ACTION_TEMPLATE(InvokeArgument,
> using internal::invoke_argument::InvokeArgumentAdl;
> return InvokeArgumentAdl<return_type>(
> internal::invoke_argument::AdlTag(),
> - ::testing::get<k>(args), p0, p1, p2, p3);
> + ::std::get<k>(args), p0, p1, p2, p3);
> }
>
> ACTION_TEMPLATE(InvokeArgument,
> @@ -2436,7 +1753,7 @@ ACTION_TEMPLATE(InvokeArgument,
> using internal::invoke_argument::InvokeArgumentAdl;
> return InvokeArgumentAdl<return_type>(
> internal::invoke_argument::AdlTag(),
> - ::testing::get<k>(args), p0, p1, p2, p3, p4);
> + ::std::get<k>(args), p0, p1, p2, p3, p4);
> }
>
> ACTION_TEMPLATE(InvokeArgument,
> @@ -2445,7 +1762,7 @@ ACTION_TEMPLATE(InvokeArgument,
> using internal::invoke_argument::InvokeArgumentAdl;
> return InvokeArgumentAdl<return_type>(
> internal::invoke_argument::AdlTag(),
> - ::testing::get<k>(args), p0, p1, p2, p3, p4, p5);
> + ::std::get<k>(args), p0, p1, p2, p3, p4, p5);
> }
>
> ACTION_TEMPLATE(InvokeArgument,
> @@ -2454,7 +1771,7 @@ ACTION_TEMPLATE(InvokeArgument,
> using internal::invoke_argument::InvokeArgumentAdl;
> return InvokeArgumentAdl<return_type>(
> internal::invoke_argument::AdlTag(),
> - ::testing::get<k>(args), p0, p1, p2, p3, p4, p5, p6);
> + ::std::get<k>(args), p0, p1, p2, p3, p4, p5, p6);
> }
>
> ACTION_TEMPLATE(InvokeArgument,
> @@ -2463,7 +1780,7 @@ ACTION_TEMPLATE(InvokeArgument,
> using internal::invoke_argument::InvokeArgumentAdl;
> return InvokeArgumentAdl<return_type>(
> internal::invoke_argument::AdlTag(),
> - ::testing::get<k>(args), p0, p1, p2, p3, p4, p5, p6, p7);
> + ::std::get<k>(args), p0, p1, p2, p3, p4, p5, p6, p7);
> }
>
> ACTION_TEMPLATE(InvokeArgument,
> @@ -2472,7 +1789,7 @@ ACTION_TEMPLATE(InvokeArgument,
> using internal::invoke_argument::InvokeArgumentAdl;
> return InvokeArgumentAdl<return_type>(
> internal::invoke_argument::AdlTag(),
> - ::testing::get<k>(args), p0, p1, p2, p3, p4, p5, p6, p7, p8);
> + ::std::get<k>(args), p0, p1, p2, p3, p4, p5, p6, p7, p8);
> }
>
> ACTION_TEMPLATE(InvokeArgument,
> @@ -2481,7 +1798,7 @@ ACTION_TEMPLATE(InvokeArgument,
> using internal::invoke_argument::InvokeArgumentAdl;
> return InvokeArgumentAdl<return_type>(
> internal::invoke_argument::AdlTag(),
> - ::testing::get<k>(args), p0, p1, p2, p3, p4, p5, p6, p7, p8, p9);
> + ::std::get<k>(args), p0, p1, p2, p3, p4, p5, p6, p7, p8, p9);
> }
>
> // Various overloads for ReturnNew<T>().
>
> diff --git
> a/llvm/utils/unittest/googlemock/include/gmock/gmock-generated-function-mockers.h
> b/llvm/utils/unittest/googlemock/include/gmock/gmock-generated-function-mockers.h
> index 53a71611f9261..d131bea8158b6 100644
> ---
> a/llvm/utils/unittest/googlemock/include/gmock/gmock-generated-function-mockers.h
> +++
> b/llvm/utils/unittest/googlemock/include/gmock/gmock-generated-function-mockers.h
> @@ -43,298 +43,14 @@
> #ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_FUNCTION_MOCKERS_H_
> #define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_FUNCTION_MOCKERS_H_
>
> +#include <functional>
> +#include <utility>
> +
> #include "gmock/gmock-spec-builders.h"
> #include "gmock/internal/gmock-internal-utils.h"
>
> -#if GTEST_HAS_STD_FUNCTION_
> -# include <functional>
> -#endif
> -
> namespace testing {
> namespace internal {
> -
> -template <typename F>
> -class FunctionMockerBase;
> -
> -// Note: class FunctionMocker really belongs to the ::testing
> -// namespace. However if we define it in ::testing, MSVC will
> -// complain when classes in ::testing::internal declare it as a
> -// friend class template. To workaround this compiler bug, we define
> -// FunctionMocker in ::testing::internal and import it into ::testing.
> -template <typename F>
> -class FunctionMocker;
> -
> -template <typename R>
> -class FunctionMocker<R()> : public
> - internal::FunctionMockerBase<R()> {
> - public:
> - typedef R F();
> - typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
> -
> - MockSpec<F> With() {
> - return MockSpec<F>(this, ::testing::make_tuple());
> - }
> -
> - R Invoke() {
> - // Even though gcc and MSVC don't enforce it, 'this->' is required
> - // by the C++ standard [14.6.4] here, as the base class type is
> - // dependent on the template argument (and thus shouldn't be
> - // looked into when resolving InvokeWith).
> - return this->InvokeWith(ArgumentTuple());
> - }
> -};
> -
> -template <typename R, typename A1>
> -class FunctionMocker<R(A1)> : public
> - internal::FunctionMockerBase<R(A1)> {
> - public:
> - typedef R F(A1);
> - typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
> -
> - MockSpec<F> With(const Matcher<A1>& m1) {
> - return MockSpec<F>(this, ::testing::make_tuple(m1));
> - }
> -
> - R Invoke(A1 a1) {
> - // Even though gcc and MSVC don't enforce it, 'this->' is required
> - // by the C++ standard [14.6.4] here, as the base class type is
> - // dependent on the template argument (and thus shouldn't be
> - // looked into when resolving InvokeWith).
> - return this->InvokeWith(ArgumentTuple(internal::forward<A1>(a1)));
> - }
> -};
> -
> -template <typename R, typename A1, typename A2>
> -class FunctionMocker<R(A1, A2)> : public
> - internal::FunctionMockerBase<R(A1, A2)> {
> - public:
> - typedef R F(A1, A2);
> - typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
> -
> - MockSpec<F> With(const Matcher<A1>& m1, const Matcher<A2>& m2) {
> - return MockSpec<F>(this, ::testing::make_tuple(m1, m2));
> - }
> -
> - R Invoke(A1 a1, A2 a2) {
> - // Even though gcc and MSVC don't enforce it, 'this->' is required
> - // by the C++ standard [14.6.4] here, as the base class type is
> - // dependent on the template argument (and thus shouldn't be
> - // looked into when resolving InvokeWith).
> - return this->InvokeWith(ArgumentTuple(internal::forward<A1>(a1),
> - internal::forward<A2>(a2)));
> - }
> -};
> -
> -template <typename R, typename A1, typename A2, typename A3>
> -class FunctionMocker<R(A1, A2, A3)> : public
> - internal::FunctionMockerBase<R(A1, A2, A3)> {
> - public:
> - typedef R F(A1, A2, A3);
> - typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
> -
> - MockSpec<F> With(const Matcher<A1>& m1, const Matcher<A2>& m2,
> - const Matcher<A3>& m3) {
> - return MockSpec<F>(this, ::testing::make_tuple(m1, m2, m3));
> - }
> -
> - R Invoke(A1 a1, A2 a2, A3 a3) {
> - // Even though gcc and MSVC don't enforce it, 'this->' is required
> - // by the C++ standard [14.6.4] here, as the base class type is
> - // dependent on the template argument (and thus shouldn't be
> - // looked into when resolving InvokeWith).
> - return this->InvokeWith(ArgumentTuple(internal::forward<A1>(a1),
> - internal::forward<A2>(a2), internal::forward<A3>(a3)));
> - }
> -};
> -
> -template <typename R, typename A1, typename A2, typename A3, typename A4>
> -class FunctionMocker<R(A1, A2, A3, A4)> : public
> - internal::FunctionMockerBase<R(A1, A2, A3, A4)> {
> - public:
> - typedef R F(A1, A2, A3, A4);
> - typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
> -
> - MockSpec<F> With(const Matcher<A1>& m1, const Matcher<A2>& m2,
> - const Matcher<A3>& m3, const Matcher<A4>& m4) {
> - return MockSpec<F>(this, ::testing::make_tuple(m1, m2, m3, m4));
> - }
> -
> - R Invoke(A1 a1, A2 a2, A3 a3, A4 a4) {
> - // Even though gcc and MSVC don't enforce it, 'this->' is required
> - // by the C++ standard [14.6.4] here, as the base class type is
> - // dependent on the template argument (and thus shouldn't be
> - // looked into when resolving InvokeWith).
> - return this->InvokeWith(ArgumentTuple(internal::forward<A1>(a1),
> - internal::forward<A2>(a2), internal::forward<A3>(a3),
> - internal::forward<A4>(a4)));
> - }
> -};
> -
> -template <typename R, typename A1, typename A2, typename A3, typename A4,
> - typename A5>
> -class FunctionMocker<R(A1, A2, A3, A4, A5)> : public
> - internal::FunctionMockerBase<R(A1, A2, A3, A4, A5)> {
> - public:
> - typedef R F(A1, A2, A3, A4, A5);
> - typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
> -
> - MockSpec<F> With(const Matcher<A1>& m1, const Matcher<A2>& m2,
> - const Matcher<A3>& m3, const Matcher<A4>& m4, const Matcher<A5>&
> m5) {
> - return MockSpec<F>(this, ::testing::make_tuple(m1, m2, m3, m4, m5));
> - }
> -
> - R Invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
> - // Even though gcc and MSVC don't enforce it, 'this->' is required
> - // by the C++ standard [14.6.4] here, as the base class type is
> - // dependent on the template argument (and thus shouldn't be
> - // looked into when resolving InvokeWith).
> - return this->InvokeWith(ArgumentTuple(internal::forward<A1>(a1),
> - internal::forward<A2>(a2), internal::forward<A3>(a3),
> - internal::forward<A4>(a4), internal::forward<A5>(a5)));
> - }
> -};
> -
> -template <typename R, typename A1, typename A2, typename A3, typename A4,
> - typename A5, typename A6>
> -class FunctionMocker<R(A1, A2, A3, A4, A5, A6)> : public
> - internal::FunctionMockerBase<R(A1, A2, A3, A4, A5, A6)> {
> - public:
> - typedef R F(A1, A2, A3, A4, A5, A6);
> - typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
> -
> - MockSpec<F> With(const Matcher<A1>& m1, const Matcher<A2>& m2,
> - const Matcher<A3>& m3, const Matcher<A4>& m4, const Matcher<A5>& m5,
> - const Matcher<A6>& m6) {
> - return MockSpec<F>(this, ::testing::make_tuple(m1, m2, m3, m4, m5,
> m6));
> - }
> -
> - R Invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
> - // Even though gcc and MSVC don't enforce it, 'this->' is required
> - // by the C++ standard [14.6.4] here, as the base class type is
> - // dependent on the template argument (and thus shouldn't be
> - // looked into when resolving InvokeWith).
> - return this->InvokeWith(ArgumentTuple(internal::forward<A1>(a1),
> - internal::forward<A2>(a2), internal::forward<A3>(a3),
> - internal::forward<A4>(a4), internal::forward<A5>(a5),
> - internal::forward<A6>(a6)));
> - }
> -};
> -
> -template <typename R, typename A1, typename A2, typename A3, typename A4,
> - typename A5, typename A6, typename A7>
> -class FunctionMocker<R(A1, A2, A3, A4, A5, A6, A7)> : public
> - internal::FunctionMockerBase<R(A1, A2, A3, A4, A5, A6, A7)> {
> - public:
> - typedef R F(A1, A2, A3, A4, A5, A6, A7);
> - typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
> -
> - MockSpec<F> With(const Matcher<A1>& m1, const Matcher<A2>& m2,
> - const Matcher<A3>& m3, const Matcher<A4>& m4, const Matcher<A5>& m5,
> - const Matcher<A6>& m6, const Matcher<A7>& m7) {
> - return MockSpec<F>(this, ::testing::make_tuple(m1, m2, m3, m4, m5,
> m6, m7));
> - }
> -
> - R Invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
> - // Even though gcc and MSVC don't enforce it, 'this->' is required
> - // by the C++ standard [14.6.4] here, as the base class type is
> - // dependent on the template argument (and thus shouldn't be
> - // looked into when resolving InvokeWith).
> - return this->InvokeWith(ArgumentTuple(internal::forward<A1>(a1),
> - internal::forward<A2>(a2), internal::forward<A3>(a3),
> - internal::forward<A4>(a4), internal::forward<A5>(a5),
> - internal::forward<A6>(a6), internal::forward<A7>(a7)));
> - }
> -};
> -
> -template <typename R, typename A1, typename A2, typename A3, typename A4,
> - typename A5, typename A6, typename A7, typename A8>
> -class FunctionMocker<R(A1, A2, A3, A4, A5, A6, A7, A8)> : public
> - internal::FunctionMockerBase<R(A1, A2, A3, A4, A5, A6, A7, A8)> {
> - public:
> - typedef R F(A1, A2, A3, A4, A5, A6, A7, A8);
> - typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
> -
> - MockSpec<F> With(const Matcher<A1>& m1, const Matcher<A2>& m2,
> - const Matcher<A3>& m3, const Matcher<A4>& m4, const Matcher<A5>& m5,
> - const Matcher<A6>& m6, const Matcher<A7>& m7, const Matcher<A8>&
> m8) {
> - return MockSpec<F>(this, ::testing::make_tuple(m1, m2, m3, m4, m5,
> m6, m7,
> - m8));
> - }
> -
> - R Invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
> - // Even though gcc and MSVC don't enforce it, 'this->' is required
> - // by the C++ standard [14.6.4] here, as the base class type is
> - // dependent on the template argument (and thus shouldn't be
> - // looked into when resolving InvokeWith).
> - return this->InvokeWith(ArgumentTuple(internal::forward<A1>(a1),
> - internal::forward<A2>(a2), internal::forward<A3>(a3),
> - internal::forward<A4>(a4), internal::forward<A5>(a5),
> - internal::forward<A6>(a6), internal::forward<A7>(a7),
> - internal::forward<A8>(a8)));
> - }
> -};
> -
> -template <typename R, typename A1, typename A2, typename A3, typename A4,
> - typename A5, typename A6, typename A7, typename A8, typename A9>
> -class FunctionMocker<R(A1, A2, A3, A4, A5, A6, A7, A8, A9)> : public
> - internal::FunctionMockerBase<R(A1, A2, A3, A4, A5, A6, A7, A8, A9)> {
> - public:
> - typedef R F(A1, A2, A3, A4, A5, A6, A7, A8, A9);
> - typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
> -
> - MockSpec<F> With(const Matcher<A1>& m1, const Matcher<A2>& m2,
> - const Matcher<A3>& m3, const Matcher<A4>& m4, const Matcher<A5>& m5,
> - const Matcher<A6>& m6, const Matcher<A7>& m7, const Matcher<A8>& m8,
> - const Matcher<A9>& m9) {
> - return MockSpec<F>(this, ::testing::make_tuple(m1, m2, m3, m4, m5,
> m6, m7,
> - m8, m9));
> - }
> -
> - R Invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
> {
> - // Even though gcc and MSVC don't enforce it, 'this->' is required
> - // by the C++ standard [14.6.4] here, as the base class type is
> - // dependent on the template argument (and thus shouldn't be
> - // looked into when resolving InvokeWith).
> - return this->InvokeWith(ArgumentTuple(internal::forward<A1>(a1),
> - internal::forward<A2>(a2), internal::forward<A3>(a3),
> - internal::forward<A4>(a4), internal::forward<A5>(a5),
> - internal::forward<A6>(a6), internal::forward<A7>(a7),
> - internal::forward<A8>(a8), internal::forward<A9>(a9)));
> - }
> -};
> -
> -template <typename R, typename A1, typename A2, typename A3, typename A4,
> - typename A5, typename A6, typename A7, typename A8, typename A9,
> - typename A10>
> -class FunctionMocker<R(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)> : public
> - internal::FunctionMockerBase<R(A1, A2, A3, A4, A5, A6, A7, A8, A9,
> A10)> {
> - public:
> - typedef R F(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10);
> - typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
> -
> - MockSpec<F> With(const Matcher<A1>& m1, const Matcher<A2>& m2,
> - const Matcher<A3>& m3, const Matcher<A4>& m4, const Matcher<A5>& m5,
> - const Matcher<A6>& m6, const Matcher<A7>& m7, const Matcher<A8>& m8,
> - const Matcher<A9>& m9, const Matcher<A10>& m10) {
> - return MockSpec<F>(this, ::testing::make_tuple(m1, m2, m3, m4, m5,
> m6, m7,
> - m8, m9, m10));
> - }
> -
> - R Invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9,
> - A10 a10) {
> - // Even though gcc and MSVC don't enforce it, 'this->' is required
> - // by the C++ standard [14.6.4] here, as the base class type is
> - // dependent on the template argument (and thus shouldn't be
> - // looked into when resolving InvokeWith).
> - return this->InvokeWith(ArgumentTuple(internal::forward<A1>(a1),
> - internal::forward<A2>(a2), internal::forward<A3>(a3),
> - internal::forward<A4>(a4), internal::forward<A5>(a5),
> - internal::forward<A6>(a6), internal::forward<A7>(a7),
> - internal::forward<A8>(a8), internal::forward<A9>(a9),
> - internal::forward<A10>(a10)));
> - }
> -};
> -
> // Removes the given pointer; this is a helper for the expectation setter
> method
> // for parameterless matchers.
> //
> @@ -407,7 +123,7 @@ using internal::FunctionMocker;
> // The type of argument N of the given function type.
> // INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
> #define GMOCK_ARG_(tn, N, ...) \
> - tn ::testing::internal::Function<__VA_ARGS__>::Argument##N
> + tn ::testing::internal::Function<__VA_ARGS__>::template Arg<N-1>::type
>
> // The matcher type for argument N of the given function type.
> // INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
> @@ -420,534 +136,467 @@ using internal::FunctionMocker;
> GTEST_CONCAT_TOKEN_(gmock##constness##arity##_##Method##_, __LINE__)
>
> // INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
> -#define GMOCK_METHOD0_(tn, constness, ct, Method, ...)
> \
> - GMOCK_RESULT_(tn, __VA_ARGS__) ct Method() constness {
> \
> - GTEST_COMPILE_ASSERT_(
> \
> - (::testing::tuple_size<tn ::testing::internal::Function<
> \
> - __VA_ARGS__>::ArgumentTuple>::value == 0),
> \
> - this_method_does_not_take_0_arguments);
> \
> - GMOCK_MOCKER_(0, constness, Method).SetOwnerAndName(this, #Method);
> \
> - return GMOCK_MOCKER_(0, constness, Method).Invoke();
> \
> - }
> \
> - ::testing::MockSpec<__VA_ARGS__> gmock_##Method() constness {
> \
> - GMOCK_MOCKER_(0, constness, Method).RegisterOwner(this);
> \
> - return GMOCK_MOCKER_(0, constness, Method).With();
> \
> - }
> \
> - ::testing::MockSpec<__VA_ARGS__> gmock_##Method(
> \
> - const ::testing::internal::WithoutMatchers&,
> \
> - constness ::testing::internal::Function<__VA_ARGS__>*) const {
> \
> - return ::testing::internal::AdjustConstness_##constness(this)
> \
> - ->gmock_##Method();
> \
> - }
> \
> +#define GMOCK_METHOD0_(tn, constness, ct, Method, ...) \
> + static_assert(0 == \
> + ::testing::internal::Function<__VA_ARGS__>::ArgumentCount, \
> + "MOCK_METHOD<N> must match argument count.");\
> + GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \
> + ) constness { \
> + GMOCK_MOCKER_(0, constness, Method).SetOwnerAndName(this, #Method); \
> + return GMOCK_MOCKER_(0, constness, Method).Invoke(); \
> + } \
> + ::testing::MockSpec<__VA_ARGS__> \
> + gmock_##Method() constness { \
> + GMOCK_MOCKER_(0, constness, Method).RegisterOwner(this); \
> + return GMOCK_MOCKER_(0, constness, Method).With(); \
> + } \
> + ::testing::MockSpec<__VA_ARGS__> gmock_##Method( \
> + const ::testing::internal::WithoutMatchers&, \
> + constness ::testing::internal::Function<__VA_ARGS__>* ) const { \
> + return ::testing::internal::AdjustConstness_##constness(this)-> \
> + gmock_##Method(); \
> + } \
> mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(0,
> constness, \
> - Method)
> + Method)
>
> // INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
> -#define GMOCK_METHOD1_(tn, constness, ct, Method, ...)
> \
> - GMOCK_RESULT_(tn, __VA_ARGS__)
> \
> - ct Method(GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1) constness {
> \
> - GTEST_COMPILE_ASSERT_(
> \
> - (::testing::tuple_size<tn ::testing::internal::Function<
> \
> - __VA_ARGS__>::ArgumentTuple>::value == 1),
> \
> - this_method_does_not_take_1_argument);
> \
> - GMOCK_MOCKER_(1, constness, Method).SetOwnerAndName(this, #Method);
> \
> - return GMOCK_MOCKER_(1, constness, Method)
> \
> - .Invoke(::testing::internal::forward<GMOCK_ARG_(tn, 1,
> __VA_ARGS__)>( \
> - gmock_a1));
> \
> - }
> \
> - ::testing::MockSpec<__VA_ARGS__> gmock_##Method(
> \
> - GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1) constness {
> \
> - GMOCK_MOCKER_(1, constness, Method).RegisterOwner(this);
> \
> - return GMOCK_MOCKER_(1, constness, Method).With(gmock_a1);
> \
> - }
> \
> - ::testing::MockSpec<__VA_ARGS__> gmock_##Method(
> \
> - const ::testing::internal::WithoutMatchers&,
> \
> - constness ::testing::internal::Function<__VA_ARGS__>*) const {
> \
> - return ::testing::internal::AdjustConstness_##constness(this)
> \
> - ->gmock_##Method(::testing::A<GMOCK_ARG_(tn, 1,
> __VA_ARGS__)>()); \
> - }
> \
> - mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(1,
> constness, \
> - Method)
> +#define GMOCK_METHOD1_(tn, constness, ct, Method, ...) \
> + static_assert(1 == \
> + ::testing::internal::Function<__VA_ARGS__>::ArgumentCount, \
> + "MOCK_METHOD<N> must match argument count.");\
> + GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \
> + GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1) constness { \
> + GMOCK_MOCKER_(1, constness, Method).SetOwnerAndName(this, #Method); \
> + return GMOCK_MOCKER_(1, constness, \
> + Method).Invoke(::std::forward<GMOCK_ARG_(tn, 1, \
> + __VA_ARGS__)>(gmock_a1)); \
> + } \
> + ::testing::MockSpec<__VA_ARGS__> \
> + gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1)
> constness { \
> + GMOCK_MOCKER_(1, constness, Method).RegisterOwner(this); \
> + return GMOCK_MOCKER_(1, constness, Method).With(gmock_a1); \
> + } \
> + ::testing::MockSpec<__VA_ARGS__> gmock_##Method( \
> + const ::testing::internal::WithoutMatchers&, \
> + constness ::testing::internal::Function<__VA_ARGS__>* ) const { \
> + return ::testing::internal::AdjustConstness_##constness(this)-> \
> + gmock_##Method(::testing::A<GMOCK_ARG_(tn, 1,
> __VA_ARGS__)>()); \
> + } \
> + mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(1,
> constness, \
> + Method)
>
> // INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
> -#define GMOCK_METHOD2_(tn, constness, ct, Method, ...)
> \
> - GMOCK_RESULT_(tn, __VA_ARGS__)
> \
> - ct Method(GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1,
> \
> - GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2) constness {
> \
> - GTEST_COMPILE_ASSERT_(
> \
> - (::testing::tuple_size<tn ::testing::internal::Function<
> \
> - __VA_ARGS__>::ArgumentTuple>::value == 2),
> \
> - this_method_does_not_take_2_arguments);
> \
> - GMOCK_MOCKER_(2, constness, Method).SetOwnerAndName(this, #Method);
> \
> - return GMOCK_MOCKER_(2, constness, Method)
> \
> - .Invoke(::testing::internal::forward<GMOCK_ARG_(tn, 1,
> __VA_ARGS__)>( \
> - gmock_a1),
> \
> - ::testing::internal::forward<GMOCK_ARG_(tn, 2,
> __VA_ARGS__)>( \
> - gmock_a2));
> \
> - }
> \
> - ::testing::MockSpec<__VA_ARGS__> gmock_##Method(
> \
> - GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1,
> \
> - GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2) constness {
> \
> - GMOCK_MOCKER_(2, constness, Method).RegisterOwner(this);
> \
> - return GMOCK_MOCKER_(2, constness, Method).With(gmock_a1, gmock_a2);
> \
> - }
> \
> - ::testing::MockSpec<__VA_ARGS__> gmock_##Method(
> \
> - const ::testing::internal::WithoutMatchers&,
> \
> - constness ::testing::internal::Function<__VA_ARGS__>*) const {
> \
> - return ::testing::internal::AdjustConstness_##constness(this)
> \
> - ->gmock_##Method(::testing::A<GMOCK_ARG_(tn, 1, __VA_ARGS__)>(),
> \
> - ::testing::A<GMOCK_ARG_(tn, 2,
> __VA_ARGS__)>()); \
> - }
> \
> - mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(2,
> constness, \
> - Method)
> +#define GMOCK_METHOD2_(tn, constness, ct, Method, ...) \
> + static_assert(2 == \
> + ::testing::internal::Function<__VA_ARGS__>::ArgumentCount, \
> + "MOCK_METHOD<N> must match argument count.");\
> + GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \
> + GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, GMOCK_ARG_(tn, 2, \
> + __VA_ARGS__) gmock_a2) constness { \
> + GMOCK_MOCKER_(2, constness, Method).SetOwnerAndName(this, #Method); \
> + return GMOCK_MOCKER_(2, constness, \
> + Method).Invoke(::std::forward<GMOCK_ARG_(tn, 1, \
> + __VA_ARGS__)>(gmock_a1), \
> + ::std::forward<GMOCK_ARG_(tn, 2, __VA_ARGS__)>(gmock_a2)); \
> + } \
> + ::testing::MockSpec<__VA_ARGS__> \
> + gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \
> + GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2)
> constness { \
> + GMOCK_MOCKER_(2, constness, Method).RegisterOwner(this); \
> + return GMOCK_MOCKER_(2, constness, Method).With(gmock_a1, gmock_a2); \
> + } \
> + ::testing::MockSpec<__VA_ARGS__> gmock_##Method( \
> + const ::testing::internal::WithoutMatchers&, \
> + constness ::testing::internal::Function<__VA_ARGS__>* ) const { \
> + return ::testing::internal::AdjustConstness_##constness(this)-> \
> + gmock_##Method(::testing::A<GMOCK_ARG_(tn, 1,
> __VA_ARGS__)>(), \
> + ::testing::A<GMOCK_ARG_(tn, 2, __VA_ARGS__)>()); \
> + } \
> + mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(2,
> constness, \
> + Method)
>
> // INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
> -#define GMOCK_METHOD3_(tn, constness, ct, Method, ...)
> \
> - GMOCK_RESULT_(tn, __VA_ARGS__)
> \
> - ct Method(GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1,
> \
> - GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2,
> \
> - GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3) constness {
> \
> - GTEST_COMPILE_ASSERT_(
> \
> - (::testing::tuple_size<tn ::testing::internal::Function<
> \
> - __VA_ARGS__>::ArgumentTuple>::value == 3),
> \
> - this_method_does_not_take_3_arguments);
> \
> - GMOCK_MOCKER_(3, constness, Method).SetOwnerAndName(this, #Method);
> \
> - return GMOCK_MOCKER_(3, constness, Method)
> \
> - .Invoke(::testing::internal::forward<GMOCK_ARG_(tn, 1,
> __VA_ARGS__)>( \
> - gmock_a1),
> \
> - ::testing::internal::forward<GMOCK_ARG_(tn, 2,
> __VA_ARGS__)>( \
> - gmock_a2),
> \
> - ::testing::internal::forward<GMOCK_ARG_(tn, 3,
> __VA_ARGS__)>( \
> - gmock_a3));
> \
> - }
> \
> - ::testing::MockSpec<__VA_ARGS__> gmock_##Method(
> \
> - GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1,
> \
> - GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2,
> \
> - GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3) constness {
> \
> - GMOCK_MOCKER_(3, constness, Method).RegisterOwner(this);
> \
> - return GMOCK_MOCKER_(3, constness, Method)
> \
> - .With(gmock_a1, gmock_a2, gmock_a3);
> \
> - }
> \
> - ::testing::MockSpec<__VA_ARGS__> gmock_##Method(
> \
> - const ::testing::internal::WithoutMatchers&,
> \
> - constness ::testing::internal::Function<__VA_ARGS__>*) const {
> \
> - return ::testing::internal::AdjustConstness_##constness(this)
> \
> - ->gmock_##Method(::testing::A<GMOCK_ARG_(tn, 1, __VA_ARGS__)>(),
> \
> - ::testing::A<GMOCK_ARG_(tn, 2, __VA_ARGS__)>(),
> \
> - ::testing::A<GMOCK_ARG_(tn, 3,
> __VA_ARGS__)>()); \
> - }
> \
> - mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(3,
> constness, \
> - Method)
> +#define GMOCK_METHOD3_(tn, constness, ct, Method, ...) \
> + static_assert(3 == \
> + ::testing::internal::Function<__VA_ARGS__>::ArgumentCount, \
> + "MOCK_METHOD<N> must match argument count.");\
> + GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \
> + GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, GMOCK_ARG_(tn, 2, \
> + __VA_ARGS__) gmock_a2, GMOCK_ARG_(tn, 3, \
> + __VA_ARGS__) gmock_a3) constness { \
> + GMOCK_MOCKER_(3, constness, Method).SetOwnerAndName(this, #Method); \
> + return GMOCK_MOCKER_(3, constness, \
> + Method).Invoke(::std::forward<GMOCK_ARG_(tn, 1, \
> + __VA_ARGS__)>(gmock_a1), \
> + ::std::forward<GMOCK_ARG_(tn, 2, __VA_ARGS__)>(gmock_a2), \
> + ::std::forward<GMOCK_ARG_(tn, 3, __VA_ARGS__)>(gmock_a3)); \
> + } \
> + ::testing::MockSpec<__VA_ARGS__> \
> + gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \
> + GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2, \
> + GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3)
> constness { \
> + GMOCK_MOCKER_(3, constness, Method).RegisterOwner(this); \
> + return GMOCK_MOCKER_(3, constness, Method).With(gmock_a1, gmock_a2, \
> + gmock_a3); \
> + } \
> + ::testing::MockSpec<__VA_ARGS__> gmock_##Method( \
> + const ::testing::internal::WithoutMatchers&, \
> + constness ::testing::internal::Function<__VA_ARGS__>* ) const { \
> + return ::testing::internal::AdjustConstness_##constness(this)-> \
> + gmock_##Method(::testing::A<GMOCK_ARG_(tn, 1,
> __VA_ARGS__)>(), \
> + ::testing::A<GMOCK_ARG_(tn, 2, __VA_ARGS__)>(), \
> + ::testing::A<GMOCK_ARG_(tn, 3, __VA_ARGS__)>()); \
> + } \
> + mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(3,
> constness, \
> + Method)
>
> // INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
> -#define GMOCK_METHOD4_(tn, constness, ct, Method, ...)
> \
> - GMOCK_RESULT_(tn, __VA_ARGS__)
> \
> - ct Method(GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1,
> \
> - GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2,
> \
> - GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3,
> \
> - GMOCK_ARG_(tn, 4, __VA_ARGS__) gmock_a4) constness {
> \
> - GTEST_COMPILE_ASSERT_(
> \
> - (::testing::tuple_size<tn ::testing::internal::Function<
> \
> - __VA_ARGS__>::ArgumentTuple>::value == 4),
> \
> - this_method_does_not_take_4_arguments);
> \
> - GMOCK_MOCKER_(4, constness, Method).SetOwnerAndName(this, #Method);
> \
> - return GMOCK_MOCKER_(4, constness, Method)
> \
> - .Invoke(::testing::internal::forward<GMOCK_ARG_(tn, 1,
> __VA_ARGS__)>( \
> - gmock_a1),
> \
> - ::testing::internal::forward<GMOCK_ARG_(tn, 2,
> __VA_ARGS__)>( \
> - gmock_a2),
> \
> - ::testing::internal::forward<GMOCK_ARG_(tn, 3,
> __VA_ARGS__)>( \
> - gmock_a3),
> \
> - ::testing::internal::forward<GMOCK_ARG_(tn, 4,
> __VA_ARGS__)>( \
> - gmock_a4));
> \
> - }
> \
> - ::testing::MockSpec<__VA_ARGS__> gmock_##Method(
> \
> - GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1,
> \
> - GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2,
> \
> - GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3,
> \
> - GMOCK_MATCHER_(tn, 4, __VA_ARGS__) gmock_a4) constness {
> \
> - GMOCK_MOCKER_(4, constness, Method).RegisterOwner(this);
> \
> - return GMOCK_MOCKER_(4, constness, Method)
> \
> - .With(gmock_a1, gmock_a2, gmock_a3, gmock_a4);
> \
> - }
> \
> - ::testing::MockSpec<__VA_ARGS__> gmock_##Method(
> \
> - const ::testing::internal::WithoutMatchers&,
> \
> - constness ::testing::internal::Function<__VA_ARGS__>*) const {
> \
> - return ::testing::internal::AdjustConstness_##constness(this)
> \
> - ->gmock_##Method(::testing::A<GMOCK_ARG_(tn, 1, __VA_ARGS__)>(),
> \
> - ::testing::A<GMOCK_ARG_(tn, 2, __VA_ARGS__)>(),
> \
> - ::testing::A<GMOCK_ARG_(tn, 3, __VA_ARGS__)>(),
> \
> - ::testing::A<GMOCK_ARG_(tn, 4,
> __VA_ARGS__)>()); \
> - }
> \
> - mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(4,
> constness, \
> - Method)
> +#define GMOCK_METHOD4_(tn, constness, ct, Method, ...) \
> + static_assert(4 == \
> + ::testing::internal::Function<__VA_ARGS__>::ArgumentCount, \
> + "MOCK_METHOD<N> must match argument count.");\
> + GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \
> + GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, GMOCK_ARG_(tn, 2, \
> + __VA_ARGS__) gmock_a2, GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3,
> \
> + GMOCK_ARG_(tn, 4, __VA_ARGS__) gmock_a4) constness { \
> + GMOCK_MOCKER_(4, constness, Method).SetOwnerAndName(this, #Method); \
> + return GMOCK_MOCKER_(4, constness, \
> + Method).Invoke(::std::forward<GMOCK_ARG_(tn, 1, \
> + __VA_ARGS__)>(gmock_a1), \
> + ::std::forward<GMOCK_ARG_(tn, 2, __VA_ARGS__)>(gmock_a2), \
> + ::std::forward<GMOCK_ARG_(tn, 3, __VA_ARGS__)>(gmock_a3), \
> + ::std::forward<GMOCK_ARG_(tn, 4, __VA_ARGS__)>(gmock_a4)); \
> + } \
> + ::testing::MockSpec<__VA_ARGS__> \
> + gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \
> + GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2, \
> + GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3, \
> + GMOCK_MATCHER_(tn, 4, __VA_ARGS__) gmock_a4)
> constness { \
> + GMOCK_MOCKER_(4, constness, Method).RegisterOwner(this); \
> + return GMOCK_MOCKER_(4, constness, Method).With(gmock_a1, gmock_a2, \
> + gmock_a3, gmock_a4); \
> + } \
> + ::testing::MockSpec<__VA_ARGS__> gmock_##Method( \
> + const ::testing::internal::WithoutMatchers&, \
> + constness ::testing::internal::Function<__VA_ARGS__>* ) const { \
> + return ::testing::internal::AdjustConstness_##constness(this)-> \
> + gmock_##Method(::testing::A<GMOCK_ARG_(tn, 1,
> __VA_ARGS__)>(), \
> + ::testing::A<GMOCK_ARG_(tn, 2, __VA_ARGS__)>(), \
> + ::testing::A<GMOCK_ARG_(tn, 3, __VA_ARGS__)>(), \
> + ::testing::A<GMOCK_ARG_(tn, 4, __VA_ARGS__)>()); \
> + } \
> + mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(4,
> constness, \
> + Method)
>
> // INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
> -#define GMOCK_METHOD5_(tn, constness, ct, Method, ...)
> \
> - GMOCK_RESULT_(tn, __VA_ARGS__)
> \
> - ct Method(GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1,
> \
> - GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2,
> \
> - GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3,
> \
> - GMOCK_ARG_(tn, 4, __VA_ARGS__) gmock_a4,
> \
> - GMOCK_ARG_(tn, 5, __VA_ARGS__) gmock_a5) constness {
> \
> - GTEST_COMPILE_ASSERT_(
> \
> - (::testing::tuple_size<tn ::testing::internal::Function<
> \
> - __VA_ARGS__>::ArgumentTuple>::value == 5),
> \
> - this_method_does_not_take_5_arguments);
> \
> - GMOCK_MOCKER_(5, constness, Method).SetOwnerAndName(this, #Method);
> \
> - return GMOCK_MOCKER_(5, constness, Method)
> \
> - .Invoke(::testing::internal::forward<GMOCK_ARG_(tn, 1,
> __VA_ARGS__)>( \
> - gmock_a1),
> \
> - ::testing::internal::forward<GMOCK_ARG_(tn, 2,
> __VA_ARGS__)>( \
> - gmock_a2),
> \
> - ::testing::internal::forward<GMOCK_ARG_(tn, 3,
> __VA_ARGS__)>( \
> - gmock_a3),
> \
> - ::testing::internal::forward<GMOCK_ARG_(tn, 4,
> __VA_ARGS__)>( \
> - gmock_a4),
> \
> - ::testing::internal::forward<GMOCK_ARG_(tn, 5,
> __VA_ARGS__)>( \
> - gmock_a5));
> \
> - }
> \
> - ::testing::MockSpec<__VA_ARGS__> gmock_##Method(
> \
> - GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1,
> \
> - GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2,
> \
> - GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3,
> \
> - GMOCK_MATCHER_(tn, 4, __VA_ARGS__) gmock_a4,
> \
> - GMOCK_MATCHER_(tn, 5, __VA_ARGS__) gmock_a5) constness {
> \
> - GMOCK_MOCKER_(5, constness, Method).RegisterOwner(this);
> \
> - return GMOCK_MOCKER_(5, constness, Method)
> \
> - .With(gmock_a1, gmock_a2, gmock_a3, gmock_a4, gmock_a5);
> \
> - }
> \
> - ::testing::MockSpec<__VA_ARGS__> gmock_##Method(
> \
> - const ::testing::internal::WithoutMatchers&,
> \
> - constness ::testing::internal::Function<__VA_ARGS__>*) const {
> \
> - return ::testing::internal::AdjustConstness_##constness(this)
> \
> - ->gmock_##Method(::testing::A<GMOCK_ARG_(tn, 1, __VA_ARGS__)>(),
> \
> - ::testing::A<GMOCK_ARG_(tn, 2, __VA_ARGS__)>(),
> \
> - ::testing::A<GMOCK_ARG_(tn, 3, __VA_ARGS__)>(),
> \
> - ::testing::A<GMOCK_ARG_(tn, 4, __VA_ARGS__)>(),
> \
> - ::testing::A<GMOCK_ARG_(tn, 5,
> __VA_ARGS__)>()); \
> - }
> \
> - mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(5,
> constness, \
> - Method)
> +#define GMOCK_METHOD5_(tn, constness, ct, Method, ...) \
> + static_assert(5 == \
> + ::testing::internal::Function<__VA_ARGS__>::ArgumentCount, \
> + "MOCK_METHOD<N> must match argument count.");\
> + GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \
> + GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, GMOCK_ARG_(tn, 2, \
> + __VA_ARGS__) gmock_a2, GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3,
> \
> + GMOCK_ARG_(tn, 4, __VA_ARGS__) gmock_a4, GMOCK_ARG_(tn, 5, \
> + __VA_ARGS__) gmock_a5) constness { \
> + GMOCK_MOCKER_(5, constness, Method).SetOwnerAndName(this, #Method); \
> + return GMOCK_MOCKER_(5, constness, \
> + Method).Invoke(::std::forward<GMOCK_ARG_(tn, 1, \
> + __VA_ARGS__)>(gmock_a1), \
> + ::std::forward<GMOCK_ARG_(tn, 2, __VA_ARGS__)>(gmock_a2), \
> + ::std::forward<GMOCK_ARG_(tn, 3, __VA_ARGS__)>(gmock_a3), \
> + ::std::forward<GMOCK_ARG_(tn, 4, __VA_ARGS__)>(gmock_a4), \
> + ::std::forward<GMOCK_ARG_(tn, 5, __VA_ARGS__)>(gmock_a5)); \
> + } \
> + ::testing::MockSpec<__VA_ARGS__> \
> + gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \
> + GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2, \
> + GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3, \
> + GMOCK_MATCHER_(tn, 4, __VA_ARGS__) gmock_a4, \
> + GMOCK_MATCHER_(tn, 5, __VA_ARGS__) gmock_a5)
> constness { \
> + GMOCK_MOCKER_(5, constness, Method).RegisterOwner(this); \
> + return GMOCK_MOCKER_(5, constness, Method).With(gmock_a1, gmock_a2, \
> + gmock_a3, gmock_a4, gmock_a5); \
> + } \
> + ::testing::MockSpec<__VA_ARGS__> gmock_##Method( \
> + const ::testing::internal::WithoutMatchers&, \
> + constness ::testing::internal::Function<__VA_ARGS__>* ) const { \
> + return ::testing::internal::AdjustConstness_##constness(this)-> \
> + gmock_##Method(::testing::A<GMOCK_ARG_(tn, 1,
> __VA_ARGS__)>(), \
> + ::testing::A<GMOCK_ARG_(tn, 2, __VA_ARGS__)>(), \
> + ::testing::A<GMOCK_ARG_(tn, 3, __VA_ARGS__)>(), \
> + ::testing::A<GMOCK_ARG_(tn, 4, __VA_ARGS__)>(), \
> + ::testing::A<GMOCK_ARG_(tn, 5, __VA_ARGS__)>()); \
> + } \
> + mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(5,
> constness, \
> + Method)
>
> // INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
> -#define GMOCK_METHOD6_(tn, constness, ct, Method, ...)
> \
> - GMOCK_RESULT_(tn, __VA_ARGS__)
> \
> - ct Method(GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1,
> \
> - GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2,
> \
> - GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3,
> \
> - GMOCK_ARG_(tn, 4, __VA_ARGS__) gmock_a4,
> \
> - GMOCK_ARG_(tn, 5, __VA_ARGS__) gmock_a5,
> \
> - GMOCK_ARG_(tn, 6, __VA_ARGS__) gmock_a6) constness {
> \
> - GTEST_COMPILE_ASSERT_(
> \
> - (::testing::tuple_size<tn ::testing::internal::Function<
> \
> - __VA_ARGS__>::ArgumentTuple>::value == 6),
> \
> - this_method_does_not_take_6_arguments);
> \
> - GMOCK_MOCKER_(6, constness, Method).SetOwnerAndName(this, #Method);
> \
> - return GMOCK_MOCKER_(6, constness, Method)
> \
> - .Invoke(::testing::internal::forward<GMOCK_ARG_(tn, 1,
> __VA_ARGS__)>( \
> - gmock_a1),
> \
> - ::testing::internal::forward<GMOCK_ARG_(tn, 2,
> __VA_ARGS__)>( \
> - gmock_a2),
> \
> - ::testing::internal::forward<GMOCK_ARG_(tn, 3,
> __VA_ARGS__)>( \
> - gmock_a3),
> \
> - ::testing::internal::forward<GMOCK_ARG_(tn, 4,
> __VA_ARGS__)>( \
> - gmock_a4),
> \
> - ::testing::internal::forward<GMOCK_ARG_(tn, 5,
> __VA_ARGS__)>( \
> - gmock_a5),
> \
> - ::testing::internal::forward<GMOCK_ARG_(tn, 6,
> __VA_ARGS__)>( \
> - gmock_a6));
> \
> - }
> \
> - ::testing::MockSpec<__VA_ARGS__> gmock_##Method(
> \
> - GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1,
> \
> - GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2,
> \
> - GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3,
> \
> - GMOCK_MATCHER_(tn, 4, __VA_ARGS__) gmock_a4,
> \
> - GMOCK_MATCHER_(tn, 5, __VA_ARGS__) gmock_a5,
> \
> - GMOCK_MATCHER_(tn, 6, __VA_ARGS__) gmock_a6) constness {
> \
> - GMOCK_MOCKER_(6, constness, Method).RegisterOwner(this);
> \
> - return GMOCK_MOCKER_(6, constness, Method)
> \
> - .With(gmock_a1, gmock_a2, gmock_a3, gmock_a4, gmock_a5,
> gmock_a6); \
> - }
> \
> - ::testing::MockSpec<__VA_ARGS__> gmock_##Method(
> \
> - const ::testing::internal::WithoutMatchers&,
> \
> - constness ::testing::internal::Function<__VA_ARGS__>*) const {
> \
> - return ::testing::internal::AdjustConstness_##constness(this)
> \
> - ->gmock_##Method(::testing::A<GMOCK_ARG_(tn, 1, __VA_ARGS__)>(),
> \
> - ::testing::A<GMOCK_ARG_(tn, 2, __VA_ARGS__)>(),
> \
> - ::testing::A<GMOCK_ARG_(tn, 3, __VA_ARGS__)>(),
> \
> - ::testing::A<GMOCK_ARG_(tn, 4, __VA_ARGS__)>(),
> \
> - ::testing::A<GMOCK_ARG_(tn, 5, __VA_ARGS__)>(),
> \
> - ::testing::A<GMOCK_ARG_(tn, 6,
> __VA_ARGS__)>()); \
> - }
> \
> - mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(6,
> constness, \
> - Method)
> +#define GMOCK_METHOD6_(tn, constness, ct, Method, ...) \
> + static_assert(6 == \
> + ::testing::internal::Function<__VA_ARGS__>::ArgumentCount, \
> + "MOCK_METHOD<N> must match argument count.");\
> + GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \
> + GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, GMOCK_ARG_(tn, 2, \
> + __VA_ARGS__) gmock_a2, GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3,
> \
> + GMOCK_ARG_(tn, 4, __VA_ARGS__) gmock_a4, GMOCK_ARG_(tn, 5, \
> + __VA_ARGS__) gmock_a5, GMOCK_ARG_(tn, 6, \
> + __VA_ARGS__) gmock_a6) constness { \
> + GMOCK_MOCKER_(6, constness, Method).SetOwnerAndName(this, #Method); \
> + return GMOCK_MOCKER_(6, constness, \
> + Method).Invoke(::std::forward<GMOCK_ARG_(tn, 1, \
> + __VA_ARGS__)>(gmock_a1), \
> + ::std::forward<GMOCK_ARG_(tn, 2, __VA_ARGS__)>(gmock_a2), \
> + ::std::forward<GMOCK_ARG_(tn, 3, __VA_ARGS__)>(gmock_a3), \
> + ::std::forward<GMOCK_ARG_(tn, 4, __VA_ARGS__)>(gmock_a4), \
> + ::std::forward<GMOCK_ARG_(tn, 5, __VA_ARGS__)>(gmock_a5), \
> + ::std::forward<GMOCK_ARG_(tn, 6, __VA_ARGS__)>(gmock_a6)); \
> + } \
> + ::testing::MockSpec<__VA_ARGS__> \
> + gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \
> + GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2, \
> + GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3, \
> + GMOCK_MATCHER_(tn, 4, __VA_ARGS__) gmock_a4, \
> + GMOCK_MATCHER_(tn, 5, __VA_ARGS__) gmock_a5, \
> + GMOCK_MATCHER_(tn, 6, __VA_ARGS__) gmock_a6)
> constness { \
> + GMOCK_MOCKER_(6, constness, Method).RegisterOwner(this); \
> + return GMOCK_MOCKER_(6, constness, Method).With(gmock_a1, gmock_a2, \
> + gmock_a3, gmock_a4, gmock_a5, gmock_a6); \
> + } \
> + ::testing::MockSpec<__VA_ARGS__> gmock_##Method( \
> + const ::testing::internal::WithoutMatchers&, \
> + constness ::testing::internal::Function<__VA_ARGS__>* ) const { \
> + return ::testing::internal::AdjustConstness_##constness(this)-> \
> + gmock_##Method(::testing::A<GMOCK_ARG_(tn, 1,
> __VA_ARGS__)>(), \
> + ::testing::A<GMOCK_ARG_(tn, 2, __VA_ARGS__)>(), \
> + ::testing::A<GMOCK_ARG_(tn, 3, __VA_ARGS__)>(), \
> + ::testing::A<GMOCK_ARG_(tn, 4, __VA_ARGS__)>(), \
> + ::testing::A<GMOCK_ARG_(tn, 5, __VA_ARGS__)>(), \
> + ::testing::A<GMOCK_ARG_(tn, 6, __VA_ARGS__)>()); \
> + } \
> + mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(6,
> constness, \
> + Method)
>
> // INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
> -#define GMOCK_METHOD7_(tn, constness, ct, Method, ...)
> \
> - GMOCK_RESULT_(tn, __VA_ARGS__)
> \
> - ct Method(GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1,
> \
> - GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2,
> \
> - GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3,
> \
> - GMOCK_ARG_(tn, 4, __VA_ARGS__) gmock_a4,
> \
> - GMOCK_ARG_(tn, 5, __VA_ARGS__) gmock_a5,
> \
> - GMOCK_ARG_(tn, 6, __VA_ARGS__) gmock_a6,
> \
> - GMOCK_ARG_(tn, 7, __VA_ARGS__) gmock_a7) constness {
> \
> - GTEST_COMPILE_ASSERT_(
> \
> - (::testing::tuple_size<tn ::testing::internal::Function<
> \
> - __VA_ARGS__>::ArgumentTuple>::value == 7),
> \
> - this_method_does_not_take_7_arguments);
> \
> - GMOCK_MOCKER_(7, constness, Method).SetOwnerAndName(this, #Method);
> \
> - return GMOCK_MOCKER_(7, constness, Method)
> \
> - .Invoke(::testing::internal::forward<GMOCK_ARG_(tn, 1,
> __VA_ARGS__)>( \
> - gmock_a1),
> \
> - ::testing::internal::forward<GMOCK_ARG_(tn, 2,
> __VA_ARGS__)>( \
> - gmock_a2),
> \
> - ::testing::internal::forward<GMOCK_ARG_(tn, 3,
> __VA_ARGS__)>( \
> - gmock_a3),
> \
> - ::testing::internal::forward<GMOCK_ARG_(tn, 4,
> __VA_ARGS__)>( \
> - gmock_a4),
> \
> - ::testing::internal::forward<GMOCK_ARG_(tn, 5,
> __VA_ARGS__)>( \
> - gmock_a5),
> \
> - ::testing::internal::forward<GMOCK_ARG_(tn, 6,
> __VA_ARGS__)>( \
> - gmock_a6),
> \
> - ::testing::internal::forward<GMOCK_ARG_(tn, 7,
> __VA_ARGS__)>( \
> - gmock_a7));
> \
> - }
> \
> - ::testing::MockSpec<__VA_ARGS__> gmock_##Method(
> \
> - GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1,
> \
> - GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2,
> \
> - GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3,
> \
> - GMOCK_MATCHER_(tn, 4, __VA_ARGS__) gmock_a4,
> \
> - GMOCK_MATCHER_(tn, 5, __VA_ARGS__) gmock_a5,
> \
> - GMOCK_MATCHER_(tn, 6, __VA_ARGS__) gmock_a6,
> \
> - GMOCK_MATCHER_(tn, 7, __VA_ARGS__) gmock_a7) constness {
> \
> - GMOCK_MOCKER_(7, constness, Method).RegisterOwner(this);
> \
> - return GMOCK_MOCKER_(7, constness, Method)
> \
> - .With(gmock_a1, gmock_a2, gmock_a3, gmock_a4, gmock_a5,
> gmock_a6, \
> - gmock_a7);
> \
> - }
> \
> - ::testing::MockSpec<__VA_ARGS__> gmock_##Method(
> \
> - const ::testing::internal::WithoutMatchers&,
> \
> - constness ::testing::internal::Function<__VA_ARGS__>*) const {
> \
> - return ::testing::internal::AdjustConstness_##constness(this)
> \
> - ->gmock_##Method(::testing::A<GMOCK_ARG_(tn, 1, __VA_ARGS__)>(),
> \
> - ::testing::A<GMOCK_ARG_(tn, 2, __VA_ARGS__)>(),
> \
> - ::testing::A<GMOCK_ARG_(tn, 3, __VA_ARGS__)>(),
> \
> - ::testing::A<GMOCK_ARG_(tn, 4, __VA_ARGS__)>(),
> \
> - ::testing::A<GMOCK_ARG_(tn, 5, __VA_ARGS__)>(),
> \
> - ::testing::A<GMOCK_ARG_(tn, 6, __VA_ARGS__)>(),
> \
> - ::testing::A<GMOCK_ARG_(tn, 7,
> __VA_ARGS__)>()); \
> - }
> \
> - mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(7,
> constness, \
> - Method)
> +#define GMOCK_METHOD7_(tn, constness, ct, Method, ...) \
> + static_assert(7 == \
> + ::testing::internal::Function<__VA_ARGS__>::ArgumentCount, \
> + "MOCK_METHOD<N> must match argument count.");\
> + GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \
> + GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, GMOCK_ARG_(tn, 2, \
> + __VA_ARGS__) gmock_a2, GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3,
> \
> + GMOCK_ARG_(tn, 4, __VA_ARGS__) gmock_a4, GMOCK_ARG_(tn, 5, \
> + __VA_ARGS__) gmock_a5, GMOCK_ARG_(tn, 6, __VA_ARGS__) gmock_a6,
> \
> + GMOCK_ARG_(tn, 7, __VA_ARGS__) gmock_a7) constness { \
> + GMOCK_MOCKER_(7, constness, Method).SetOwnerAndName(this, #Method); \
> + return GMOCK_MOCKER_(7, constness, \
> + Method).Invoke(::std::forward<GMOCK_ARG_(tn, 1, \
> + __VA_ARGS__)>(gmock_a1), \
> + ::std::forward<GMOCK_ARG_(tn, 2, __VA_ARGS__)>(gmock_a2), \
> + ::std::forward<GMOCK_ARG_(tn, 3, __VA_ARGS__)>(gmock_a3), \
> + ::std::forward<GMOCK_ARG_(tn, 4, __VA_ARGS__)>(gmock_a4), \
> + ::std::forward<GMOCK_ARG_(tn, 5, __VA_ARGS__)>(gmock_a5), \
> + ::std::forward<GMOCK_ARG_(tn, 6, __VA_ARGS__)>(gmock_a6), \
> + ::std::forward<GMOCK_ARG_(tn, 7, __VA_ARGS__)>(gmock_a7)); \
> + } \
> + ::testing::MockSpec<__VA_ARGS__> \
> + gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \
> + GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2, \
> + GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3, \
> + GMOCK_MATCHER_(tn, 4, __VA_ARGS__) gmock_a4, \
> + GMOCK_MATCHER_(tn, 5, __VA_ARGS__) gmock_a5, \
> + GMOCK_MATCHER_(tn, 6, __VA_ARGS__) gmock_a6, \
> + GMOCK_MATCHER_(tn, 7, __VA_ARGS__) gmock_a7)
> constness { \
> + GMOCK_MOCKER_(7, constness, Method).RegisterOwner(this); \
> + return GMOCK_MOCKER_(7, constness, Method).With(gmock_a1, gmock_a2, \
> + gmock_a3, gmock_a4, gmock_a5, gmock_a6, gmock_a7); \
> + } \
> + ::testing::MockSpec<__VA_ARGS__> gmock_##Method( \
> + const ::testing::internal::WithoutMatchers&, \
> + constness ::testing::internal::Function<__VA_ARGS__>* ) const { \
> + return ::testing::internal::AdjustConstness_##constness(this)-> \
> + gmock_##Method(::testing::A<GMOCK_ARG_(tn, 1,
> __VA_ARGS__)>(), \
> + ::testing::A<GMOCK_ARG_(tn, 2, __VA_ARGS__)>(), \
> + ::testing::A<GMOCK_ARG_(tn, 3, __VA_ARGS__)>(), \
> + ::testing::A<GMOCK_ARG_(tn, 4, __VA_ARGS__)>(), \
> + ::testing::A<GMOCK_ARG_(tn, 5, __VA_ARGS__)>(), \
> + ::testing::A<GMOCK_ARG_(tn, 6, __VA_ARGS__)>(), \
> + ::testing::A<GMOCK_ARG_(tn, 7, __VA_ARGS__)>()); \
> + } \
> + mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(7,
> constness, \
> + Method)
>
> // INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
> -#define GMOCK_METHOD8_(tn, constness, ct, Method, ...)
> \
> - GMOCK_RESULT_(tn, __VA_ARGS__)
> \
> - ct Method(GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1,
> \
> - GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2,
> \
> - GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3,
> \
> - GMOCK_ARG_(tn, 4, __VA_ARGS__) gmock_a4,
> \
> - GMOCK_ARG_(tn, 5, __VA_ARGS__) gmock_a5,
> \
> - GMOCK_ARG_(tn, 6, __VA_ARGS__) gmock_a6,
> \
> - GMOCK_ARG_(tn, 7, __VA_ARGS__) gmock_a7,
> \
> - GMOCK_ARG_(tn, 8, __VA_ARGS__) gmock_a8) constness {
> \
> - GTEST_COMPILE_ASSERT_(
> \
> - (::testing::tuple_size<tn ::testing::internal::Function<
> \
> - __VA_ARGS__>::ArgumentTuple>::value == 8),
> \
> - this_method_does_not_take_8_arguments);
> \
> - GMOCK_MOCKER_(8, constness, Method).SetOwnerAndName(this, #Method);
> \
> - return GMOCK_MOCKER_(8, constness, Method)
> \
> - .Invoke(::testing::internal::forward<GMOCK_ARG_(tn, 1,
> __VA_ARGS__)>( \
> - gmock_a1),
> \
> - ::testing::internal::forward<GMOCK_ARG_(tn, 2,
> __VA_ARGS__)>( \
> - gmock_a2),
> \
> - ::testing::internal::forward<GMOCK_ARG_(tn, 3,
> __VA_ARGS__)>( \
> - gmock_a3),
> \
> - ::testing::internal::forward<GMOCK_ARG_(tn, 4,
> __VA_ARGS__)>( \
> - gmock_a4),
> \
> - ::testing::internal::forward<GMOCK_ARG_(tn, 5,
> __VA_ARGS__)>( \
> - gmock_a5),
> \
> - ::testing::internal::forward<GMOCK_ARG_(tn, 6,
> __VA_ARGS__)>( \
> - gmock_a6),
> \
> - ::testing::internal::forward<GMOCK_ARG_(tn, 7,
> __VA_ARGS__)>( \
> - gmock_a7),
> \
> - ::testing::internal::forward<GMOCK_ARG_(tn, 8,
> __VA_ARGS__)>( \
> - gmock_a8));
> \
> - }
> \
> - ::testing::MockSpec<__VA_ARGS__> gmock_##Method(
> \
> - GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1,
> \
> - GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2,
> \
> - GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3,
> \
> - GMOCK_MATCHER_(tn, 4, __VA_ARGS__) gmock_a4,
> \
> - GMOCK_MATCHER_(tn, 5, __VA_ARGS__) gmock_a5,
> \
> - GMOCK_MATCHER_(tn, 6, __VA_ARGS__) gmock_a6,
> \
> - GMOCK_MATCHER_(tn, 7, __VA_ARGS__) gmock_a7,
> \
> - GMOCK_MATCHER_(tn, 8, __VA_ARGS__) gmock_a8) constness {
> \
> - GMOCK_MOCKER_(8, constness, Method).RegisterOwner(this);
> \
> - return GMOCK_MOCKER_(8, constness, Method)
> \
> - .With(gmock_a1, gmock_a2, gmock_a3, gmock_a4, gmock_a5,
> gmock_a6, \
> - gmock_a7, gmock_a8);
> \
> - }
> \
> - ::testing::MockSpec<__VA_ARGS__> gmock_##Method(
> \
> - const ::testing::internal::WithoutMatchers&,
> \
> - constness ::testing::internal::Function<__VA_ARGS__>*) const {
> \
> - return ::testing::internal::AdjustConstness_##constness(this)
> \
> - ->gmock_##Method(::testing::A<GMOCK_ARG_(tn, 1, __VA_ARGS__)>(),
> \
> - ::testing::A<GMOCK_ARG_(tn, 2, __VA_ARGS__)>(),
> \
> - ::testing::A<GMOCK_ARG_(tn, 3, __VA_ARGS__)>(),
> \
> - ::testing::A<GMOCK_ARG_(tn, 4, __VA_ARGS__)>(),
> \
> - ::testing::A<GMOCK_ARG_(tn, 5, __VA_ARGS__)>(),
> \
> - ::testing::A<GMOCK_ARG_(tn, 6, __VA_ARGS__)>(),
> \
> - ::testing::A<GMOCK_ARG_(tn, 7, __VA_ARGS__)>(),
> \
> - ::testing::A<GMOCK_ARG_(tn, 8,
> __VA_ARGS__)>()); \
> - }
> \
> - mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(8,
> constness, \
> - Method)
> +#define GMOCK_METHOD8_(tn, constness, ct, Method, ...) \
> + static_assert(8 == \
> + ::testing::internal::Function<__VA_ARGS__>::ArgumentCount, \
> + "MOCK_METHOD<N> must match argument count.");\
> + GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \
> + GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, GMOCK_ARG_(tn, 2, \
> + __VA_ARGS__) gmock_a2, GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3,
> \
> + GMOCK_ARG_(tn, 4, __VA_ARGS__) gmock_a4, GMOCK_ARG_(tn, 5, \
> + __VA_ARGS__) gmock_a5, GMOCK_ARG_(tn, 6, __VA_ARGS__) gmock_a6,
> \
> + GMOCK_ARG_(tn, 7, __VA_ARGS__) gmock_a7, GMOCK_ARG_(tn, 8, \
> + __VA_ARGS__) gmock_a8) constness { \
> + GMOCK_MOCKER_(8, constness, Method).SetOwnerAndName(this, #Method); \
> + return GMOCK_MOCKER_(8, constness, \
> + Method).Invoke(::std::forward<GMOCK_ARG_(tn, 1, \
> + __VA_ARGS__)>(gmock_a1), \
> + ::std::forward<GMOCK_ARG_(tn, 2, __VA_ARGS__)>(gmock_a2), \
> + ::std::forward<GMOCK_ARG_(tn, 3, __VA_ARGS__)>(gmock_a3), \
> + ::std::forward<GMOCK_ARG_(tn, 4, __VA_ARGS__)>(gmock_a4), \
> + ::std::forward<GMOCK_ARG_(tn, 5, __VA_ARGS__)>(gmock_a5), \
> + ::std::forward<GMOCK_ARG_(tn, 6, __VA_ARGS__)>(gmock_a6), \
> + ::std::forward<GMOCK_ARG_(tn, 7, __VA_ARGS__)>(gmock_a7), \
> + ::std::forward<GMOCK_ARG_(tn, 8, __VA_ARGS__)>(gmock_a8)); \
> + } \
> + ::testing::MockSpec<__VA_ARGS__> \
> + gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \
> + GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2, \
> + GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3, \
> + GMOCK_MATCHER_(tn, 4, __VA_ARGS__) gmock_a4, \
> + GMOCK_MATCHER_(tn, 5, __VA_ARGS__) gmock_a5, \
> + GMOCK_MATCHER_(tn, 6, __VA_ARGS__) gmock_a6, \
> + GMOCK_MATCHER_(tn, 7, __VA_ARGS__) gmock_a7, \
> + GMOCK_MATCHER_(tn, 8, __VA_ARGS__) gmock_a8)
> constness { \
> + GMOCK_MOCKER_(8, constness, Method).RegisterOwner(this); \
> + return GMOCK_MOCKER_(8, constness, Method).With(gmock_a1, gmock_a2, \
> + gmock_a3, gmock_a4, gmock_a5, gmock_a6, gmock_a7, gmock_a8); \
> + } \
> + ::testing::MockSpec<__VA_ARGS__> gmock_##Method( \
> + const ::testing::internal::WithoutMatchers&, \
> + constness ::testing::internal::Function<__VA_ARGS__>* ) const { \
> + return ::testing::internal::AdjustConstness_##constness(this)-> \
> + gmock_##Method(::testing::A<GMOCK_ARG_(tn, 1,
> __VA_ARGS__)>(), \
> + ::testing::A<GMOCK_ARG_(tn, 2, __VA_ARGS__)>(), \
> + ::testing::A<GMOCK_ARG_(tn, 3, __VA_ARGS__)>(), \
> + ::testing::A<GMOCK_ARG_(tn, 4, __VA_ARGS__)>(), \
> + ::testing::A<GMOCK_ARG_(tn, 5, __VA_ARGS__)>(), \
> + ::testing::A<GMOCK_ARG_(tn, 6, __VA_ARGS__)>(), \
> + ::testing::A<GMOCK_ARG_(tn, 7, __VA_ARGS__)>(), \
> + ::testing::A<GMOCK_ARG_(tn, 8, __VA_ARGS__)>()); \
> + } \
> + mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(8,
> constness, \
> + Method)
>
> // INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
> -#define GMOCK_METHOD9_(tn, constness, ct, Method, ...)
> \
> - GMOCK_RESULT_(tn, __VA_ARGS__)
> \
> - ct Method(GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1,
> \
> - GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2,
> \
> - GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3,
> \
> - GMOCK_ARG_(tn, 4, __VA_ARGS__) gmock_a4,
> \
> - GMOCK_ARG_(tn, 5, __VA_ARGS__) gmock_a5,
> \
> - GMOCK_ARG_(tn, 6, __VA_ARGS__) gmock_a6,
> \
> - GMOCK_ARG_(tn, 7, __VA_ARGS__) gmock_a7,
> \
> - GMOCK_ARG_(tn, 8, __VA_ARGS__) gmock_a8,
> \
> - GMOCK_ARG_(tn, 9, __VA_ARGS__) gmock_a9) constness {
> \
> - GTEST_COMPILE_ASSERT_(
> \
> - (::testing::tuple_size<tn ::testing::internal::Function<
> \
> - __VA_ARGS__>::ArgumentTuple>::value == 9),
> \
> - this_method_does_not_take_9_arguments);
> \
> - GMOCK_MOCKER_(9, constness, Method).SetOwnerAndName(this, #Method);
> \
> - return GMOCK_MOCKER_(9, constness, Method)
> \
> - .Invoke(::testing::internal::forward<GMOCK_ARG_(tn, 1,
> __VA_ARGS__)>( \
> - gmock_a1),
> \
> - ::testing::internal::forward<GMOCK_ARG_(tn, 2,
> __VA_ARGS__)>( \
> - gmock_a2),
> \
> - ::testing::internal::forward<GMOCK_ARG_(tn, 3,
> __VA_ARGS__)>( \
> - gmock_a3),
> \
> - ::testing::internal::forward<GMOCK_ARG_(tn, 4,
> __VA_ARGS__)>( \
> - gmock_a4),
> \
> - ::testing::internal::forward<GMOCK_ARG_(tn, 5,
> __VA_ARGS__)>( \
> - gmock_a5),
> \
> - ::testing::internal::forward<GMOCK_ARG_(tn, 6,
> __VA_ARGS__)>( \
> - gmock_a6),
> \
> - ::testing::internal::forward<GMOCK_ARG_(tn, 7,
> __VA_ARGS__)>( \
> - gmock_a7),
> \
> - ::testing::internal::forward<GMOCK_ARG_(tn, 8,
> __VA_ARGS__)>( \
> - gmock_a8),
> \
> - ::testing::internal::forward<GMOCK_ARG_(tn, 9,
> __VA_ARGS__)>( \
> - gmock_a9));
> \
> - }
> \
> - ::testing::MockSpec<__VA_ARGS__> gmock_##Method(
> \
> - GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1,
> \
> - GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2,
> \
> - GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3,
> \
> - GMOCK_MATCHER_(tn, 4, __VA_ARGS__) gmock_a4,
> \
> - GMOCK_MATCHER_(tn, 5, __VA_ARGS__) gmock_a5,
> \
> - GMOCK_MATCHER_(tn, 6, __VA_ARGS__) gmock_a6,
> \
> - GMOCK_MATCHER_(tn, 7, __VA_ARGS__) gmock_a7,
> \
> - GMOCK_MATCHER_(tn, 8, __VA_ARGS__) gmock_a8,
> \
> - GMOCK_MATCHER_(tn, 9, __VA_ARGS__) gmock_a9) constness {
> \
> - GMOCK_MOCKER_(9, constness, Method).RegisterOwner(this);
> \
> - return GMOCK_MOCKER_(9, constness, Method)
> \
> - .With(gmock_a1, gmock_a2, gmock_a3, gmock_a4, gmock_a5,
> gmock_a6, \
> - gmock_a7, gmock_a8, gmock_a9);
> \
> - }
> \
> - ::testing::MockSpec<__VA_ARGS__> gmock_##Method(
> \
> - const ::testing::internal::WithoutMatchers&,
> \
> - constness ::testing::internal::Function<__VA_ARGS__>*) const {
> \
> - return ::testing::internal::AdjustConstness_##constness(this)
> \
> - ->gmock_##Method(::testing::A<GMOCK_ARG_(tn, 1, __VA_ARGS__)>(),
> \
> - ::testing::A<GMOCK_ARG_(tn, 2, __VA_ARGS__)>(),
> \
> - ::testing::A<GMOCK_ARG_(tn, 3, __VA_ARGS__)>(),
> \
> - ::testing::A<GMOCK_ARG_(tn, 4, __VA_ARGS__)>(),
> \
> - ::testing::A<GMOCK_ARG_(tn, 5, __VA_ARGS__)>(),
> \
> - ::testing::A<GMOCK_ARG_(tn, 6, __VA_ARGS__)>(),
> \
> - ::testing::A<GMOCK_ARG_(tn, 7, __VA_ARGS__)>(),
> \
> - ::testing::A<GMOCK_ARG_(tn, 8, __VA_ARGS__)>(),
> \
> - ::testing::A<GMOCK_ARG_(tn, 9,
> __VA_ARGS__)>()); \
> - }
> \
> - mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(9,
> constness, \
> - Method)
> +#define GMOCK_METHOD9_(tn, constness, ct, Method, ...) \
> + static_assert(9 == \
> + ::testing::internal::Function<__VA_ARGS__>::ArgumentCount, \
> + "MOCK_METHOD<N> must match argument count.");\
> + GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \
> + GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, GMOCK_ARG_(tn, 2, \
> + __VA_ARGS__) gmock_a2, GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3,
> \
> + GMOCK_ARG_(tn, 4, __VA_ARGS__) gmock_a4, GMOCK_ARG_(tn, 5, \
> + __VA_ARGS__) gmock_a5, GMOCK_ARG_(tn, 6, __VA_ARGS__) gmock_a6,
> \
> + GMOCK_ARG_(tn, 7, __VA_ARGS__) gmock_a7, GMOCK_ARG_(tn, 8, \
> + __VA_ARGS__) gmock_a8, GMOCK_ARG_(tn, 9, \
> + __VA_ARGS__) gmock_a9) constness { \
> + GMOCK_MOCKER_(9, constness, Method).SetOwnerAndName(this, #Method); \
> + return GMOCK_MOCKER_(9, constness, \
> + Method).Invoke(::std::forward<GMOCK_ARG_(tn, 1, \
> + __VA_ARGS__)>(gmock_a1), \
> + ::std::forward<GMOCK_ARG_(tn, 2, __VA_ARGS__)>(gmock_a2), \
> + ::std::forward<GMOCK_ARG_(tn, 3, __VA_ARGS__)>(gmock_a3), \
> + ::std::forward<GMOCK_ARG_(tn, 4, __VA_ARGS__)>(gmock_a4), \
> + ::std::forward<GMOCK_ARG_(tn, 5, __VA_ARGS__)>(gmock_a5), \
> + ::std::forward<GMOCK_ARG_(tn, 6, __VA_ARGS__)>(gmock_a6), \
> + ::std::forward<GMOCK_ARG_(tn, 7, __VA_ARGS__)>(gmock_a7), \
> + ::std::forward<GMOCK_ARG_(tn, 8, __VA_ARGS__)>(gmock_a8), \
> + ::std::forward<GMOCK_ARG_(tn, 9, __VA_ARGS__)>(gmock_a9)); \
> + } \
> + ::testing::MockSpec<__VA_ARGS__> \
> + gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \
> + GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2, \
> + GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3, \
> + GMOCK_MATCHER_(tn, 4, __VA_ARGS__) gmock_a4, \
> + GMOCK_MATCHER_(tn, 5, __VA_ARGS__) gmock_a5, \
> + GMOCK_MATCHER_(tn, 6, __VA_ARGS__) gmock_a6, \
> + GMOCK_MATCHER_(tn, 7, __VA_ARGS__) gmock_a7, \
> + GMOCK_MATCHER_(tn, 8, __VA_ARGS__) gmock_a8, \
> + GMOCK_MATCHER_(tn, 9, __VA_ARGS__) gmock_a9)
> constness { \
> + GMOCK_MOCKER_(9, constness, Method).RegisterOwner(this); \
> + return GMOCK_MOCKER_(9, constness, Method).With(gmock_a1, gmock_a2, \
> + gmock_a3, gmock_a4, gmock_a5, gmock_a6, gmock_a7, gmock_a8, \
> + gmock_a9); \
> + } \
> + ::testing::MockSpec<__VA_ARGS__> gmock_##Method( \
> + const ::testing::internal::WithoutMatchers&, \
> + constness ::testing::internal::Function<__VA_ARGS__>* ) const { \
> + return ::testing::internal::AdjustConstness_##constness(this)-> \
> + gmock_##Method(::testing::A<GMOCK_ARG_(tn, 1,
> __VA_ARGS__)>(), \
> + ::testing::A<GMOCK_ARG_(tn, 2, __VA_ARGS__)>(), \
> + ::testing::A<GMOCK_ARG_(tn, 3, __VA_ARGS__)>(), \
> + ::testing::A<GMOCK_ARG_(tn, 4, __VA_ARGS__)>(), \
> + ::testing::A<GMOCK_ARG_(tn, 5, __VA_ARGS__)>(), \
> + ::testing::A<GMOCK_ARG_(tn, 6, __VA_ARGS__)>(), \
> + ::testing::A<GMOCK_ARG_(tn, 7, __VA_ARGS__)>(), \
> + ::testing::A<GMOCK_ARG_(tn, 8, __VA_ARGS__)>(), \
> + ::testing::A<GMOCK_ARG_(tn, 9, __VA_ARGS__)>()); \
> + } \
> + mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(9,
> constness, \
> + Method)
>
> // INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
> -#define GMOCK_METHOD10_(tn, constness, ct, Method, ...)
> \
> - GMOCK_RESULT_(tn, __VA_ARGS__)
> \
> - ct Method(GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1,
> \
> - GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2,
> \
> - GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3,
> \
> - GMOCK_ARG_(tn, 4, __VA_ARGS__) gmock_a4,
> \
> - GMOCK_ARG_(tn, 5, __VA_ARGS__) gmock_a5,
> \
> - GMOCK_ARG_(tn, 6, __VA_ARGS__) gmock_a6,
> \
> - GMOCK_ARG_(tn, 7, __VA_ARGS__) gmock_a7,
> \
> - GMOCK_ARG_(tn, 8, __VA_ARGS__) gmock_a8,
> \
> - GMOCK_ARG_(tn, 9, __VA_ARGS__) gmock_a9,
> \
> - GMOCK_ARG_(tn, 10, __VA_ARGS__) gmock_a10) constness {
> \
> - GTEST_COMPILE_ASSERT_(
> \
> - (::testing::tuple_size<tn ::testing::internal::Function<
> \
> - __VA_ARGS__>::ArgumentTuple>::value == 10),
> \
> - this_method_does_not_take_10_arguments);
> \
> - GMOCK_MOCKER_(10, constness, Method).SetOwnerAndName(this, #Method);
> \
> - return GMOCK_MOCKER_(10, constness, Method)
> \
> - .Invoke(::testing::internal::forward<GMOCK_ARG_(tn, 1,
> __VA_ARGS__)>( \
> - gmock_a1),
> \
> - ::testing::internal::forward<GMOCK_ARG_(tn, 2,
> __VA_ARGS__)>( \
> - gmock_a2),
> \
> - ::testing::internal::forward<GMOCK_ARG_(tn, 3,
> __VA_ARGS__)>( \
> - gmock_a3),
> \
> - ::testing::internal::forward<GMOCK_ARG_(tn, 4,
> __VA_ARGS__)>( \
> - gmock_a4),
> \
> - ::testing::internal::forward<GMOCK_ARG_(tn, 5,
> __VA_ARGS__)>( \
> - gmock_a5),
> \
> - ::testing::internal::forward<GMOCK_ARG_(tn, 6,
> __VA_ARGS__)>( \
> - gmock_a6),
> \
> - ::testing::internal::forward<GMOCK_ARG_(tn, 7,
> __VA_ARGS__)>( \
> - gmock_a7),
> \
> - ::testing::internal::forward<GMOCK_ARG_(tn, 8,
> __VA_ARGS__)>( \
> - gmock_a8),
> \
> - ::testing::internal::forward<GMOCK_ARG_(tn, 9,
> __VA_ARGS__)>( \
> - gmock_a9),
> \
> - ::testing::internal::forward<GMOCK_ARG_(tn, 10,
> __VA_ARGS__)>( \
> - gmock_a10));
> \
> - }
> \
> - ::testing::MockSpec<__VA_ARGS__> gmock_##Method(
> \
> - GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1,
> \
> - GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2,
> \
> - GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3,
> \
> - GMOCK_MATCHER_(tn, 4, __VA_ARGS__) gmock_a4,
> \
> - GMOCK_MATCHER_(tn, 5, __VA_ARGS__) gmock_a5,
> \
> - GMOCK_MATCHER_(tn, 6, __VA_ARGS__) gmock_a6,
> \
> - GMOCK_MATCHER_(tn, 7, __VA_ARGS__) gmock_a7,
> \
> - GMOCK_MATCHER_(tn, 8, __VA_ARGS__) gmock_a8,
> \
> - GMOCK_MATCHER_(tn, 9, __VA_ARGS__) gmock_a9,
> \
> - GMOCK_MATCHER_(tn, 10, __VA_ARGS__) gmock_a10) constness {
> \
> - GMOCK_MOCKER_(10, constness, Method).RegisterOwner(this);
> \
> - return GMOCK_MOCKER_(10, constness, Method)
> \
> - .With(gmock_a1, gmock_a2, gmock_a3, gmock_a4, gmock_a5,
> gmock_a6, \
> - gmock_a7, gmock_a8, gmock_a9, gmock_a10);
> \
> - }
> \
> - ::testing::MockSpec<__VA_ARGS__> gmock_##Method(
> \
> - const ::testing::internal::WithoutMatchers&,
> \
> - constness ::testing::internal::Function<__VA_ARGS__>*) const {
> \
> - return ::testing::internal::AdjustConstness_##constness(this)
> \
> - ->gmock_##Method(::testing::A<GMOCK_ARG_(tn, 1, __VA_ARGS__)>(),
> \
> - ::testing::A<GMOCK_ARG_(tn, 2, __VA_ARGS__)>(),
> \
> - ::testing::A<GMOCK_ARG_(tn, 3, __VA_ARGS__)>(),
> \
> - ::testing::A<GMOCK_ARG_(tn, 4, __VA_ARGS__)>(),
> \
> - ::testing::A<GMOCK_ARG_(tn, 5, __VA_ARGS__)>(),
> \
> - ::testing::A<GMOCK_ARG_(tn, 6, __VA_ARGS__)>(),
> \
> - ::testing::A<GMOCK_ARG_(tn, 7, __VA_ARGS__)>(),
> \
> - ::testing::A<GMOCK_ARG_(tn, 8, __VA_ARGS__)>(),
> \
> - ::testing::A<GMOCK_ARG_(tn, 9, __VA_ARGS__)>(),
> \
> - ::testing::A<GMOCK_ARG_(tn, 10,
> __VA_ARGS__)>()); \
> - }
> \
> - mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(10,
> constness, \
> - Method)
> +#define GMOCK_METHOD10_(tn, constness, ct, Method, ...) \
> + static_assert(10 == \
> + ::testing::internal::Function<__VA_ARGS__>::ArgumentCount, \
> + "MOCK_METHOD<N> must match argument count.");\
> + GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \
> + GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, GMOCK_ARG_(tn, 2, \
> + __VA_ARGS__) gmock_a2, GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3,
> \
> + GMOCK_ARG_(tn, 4, __VA_ARGS__) gmock_a4, GMOCK_ARG_(tn, 5, \
> + __VA_ARGS__) gmock_a5, GMOCK_ARG_(tn, 6, __VA_ARGS__) gmock_a6,
> \
> + GMOCK_ARG_(tn, 7, __VA_ARGS__) gmock_a7, GMOCK_ARG_(tn, 8, \
> + __VA_ARGS__) gmock_a8, GMOCK_ARG_(tn, 9, __VA_ARGS__) gmock_a9,
> \
> + GMOCK_ARG_(tn, 10, __VA_ARGS__) gmock_a10) constness { \
> + GMOCK_MOCKER_(10, constness, Method).SetOwnerAndName(this, #Method); \
> + return GMOCK_MOCKER_(10, constness, \
> + Method).Invoke(::std::forward<GMOCK_ARG_(tn, 1, \
> + __VA_ARGS__)>(gmock_a1), \
> + ::std::forward<GMOCK_ARG_(tn, 2, __VA_ARGS__)>(gmock_a2), \
> + ::std::forward<GMOCK_ARG_(tn, 3, __VA_ARGS__)>(gmock_a3), \
> + ::std::forward<GMOCK_ARG_(tn, 4, __VA_ARGS__)>(gmock_a4), \
> + ::std::forward<GMOCK_ARG_(tn, 5, __VA_ARGS__)>(gmock_a5), \
> + ::std::forward<GMOCK_ARG_(tn, 6, __VA_ARGS__)>(gmock_a6), \
> + ::std::forward<GMOCK_ARG_(tn, 7, __VA_ARGS__)>(gmock_a7), \
> + ::std::forward<GMOCK_ARG_(tn, 8, __VA_ARGS__)>(gmock_a8), \
> + ::std::forward<GMOCK_ARG_(tn, 9, __VA_ARGS__)>(gmock_a9), \
> + ::std::forward<GMOCK_ARG_(tn, 10, __VA_ARGS__)>(gmock_a10)); \
> + } \
> + ::testing::MockSpec<__VA_ARGS__> \
> + gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \
> + GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2, \
> + GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3, \
> + GMOCK_MATCHER_(tn, 4, __VA_ARGS__) gmock_a4, \
> + GMOCK_MATCHER_(tn, 5, __VA_ARGS__) gmock_a5, \
> + GMOCK_MATCHER_(tn, 6, __VA_ARGS__) gmock_a6, \
> + GMOCK_MATCHER_(tn, 7, __VA_ARGS__) gmock_a7, \
> + GMOCK_MATCHER_(tn, 8, __VA_ARGS__) gmock_a8, \
> + GMOCK_MATCHER_(tn, 9, __VA_ARGS__) gmock_a9, \
> + GMOCK_MATCHER_(tn, 10, \
> + __VA_ARGS__) gmock_a10) constness { \
> + GMOCK_MOCKER_(10, constness, Method).RegisterOwner(this); \
> + return GMOCK_MOCKER_(10, constness, Method).With(gmock_a1, gmock_a2, \
> + gmock_a3, gmock_a4, gmock_a5, gmock_a6, gmock_a7, gmock_a8,
> gmock_a9, \
> + gmock_a10); \
> + } \
> + ::testing::MockSpec<__VA_ARGS__> gmock_##Method( \
> + const ::testing::internal::WithoutMatchers&, \
> + constness ::testing::internal::Function<__VA_ARGS__>* ) const { \
> + return ::testing::internal::AdjustConstness_##constness(this)-> \
> + gmock_##Method(::testing::A<GMOCK_ARG_(tn, 1,
> __VA_ARGS__)>(), \
> + ::testing::A<GMOCK_ARG_(tn, 2, __VA_ARGS__)>(), \
> + ::testing::A<GMOCK_ARG_(tn, 3, __VA_ARGS__)>(), \
> + ::testing::A<GMOCK_ARG_(tn, 4, __VA_ARGS__)>(), \
> + ::testing::A<GMOCK_ARG_(tn, 5, __VA_ARGS__)>(), \
> + ::testing::A<GMOCK_ARG_(tn, 6, __VA_ARGS__)>(), \
> + ::testing::A<GMOCK_ARG_(tn, 7, __VA_ARGS__)>(), \
> + ::testing::A<GMOCK_ARG_(tn, 8, __VA_ARGS__)>(), \
> + ::testing::A<GMOCK_ARG_(tn, 9, __VA_ARGS__)>(), \
> + ::testing::A<GMOCK_ARG_(tn, 10, __VA_ARGS__)>()); \
> + } \
> + mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(10,
> constness, \
> + Method)
>
> #define MOCK_METHOD0(m, ...) GMOCK_METHOD0_(, , , m, __VA_ARGS__)
> #define MOCK_METHOD1(m, ...) GMOCK_METHOD1_(, , , m, __VA_ARGS__)
> @@ -1100,283 +749,6 @@ using internal::FunctionMocker;
> #define MOCK_CONST_METHOD10_T_WITH_CALLTYPE(ct, m, ...) \
> GMOCK_METHOD10_(typename, const, ct, m, __VA_ARGS__)
>
> -// A MockFunction<F> class has one mock method whose type is F. It is
> -// useful when you just want your test code to emit some messages and
> -// have Google Mock verify the right messages are sent (and perhaps at
> -// the right times). For example, if you are exercising code:
> -//
> -// Foo(1);
> -// Foo(2);
> -// Foo(3);
> -//
> -// and want to verify that Foo(1) and Foo(3) both invoke
> -// mock.Bar("a"), but Foo(2) doesn't invoke anything, you can write:
> -//
> -// TEST(FooTest, InvokesBarCorrectly) {
> -// MyMock mock;
> -// MockFunction<void(string check_point_name)> check;
> -// {
> -// InSequence s;
> -//
> -// EXPECT_CALL(mock, Bar("a"));
> -// EXPECT_CALL(check, Call("1"));
> -// EXPECT_CALL(check, Call("2"));
> -// EXPECT_CALL(mock, Bar("a"));
> -// }
> -// Foo(1);
> -// check.Call("1");
> -// Foo(2);
> -// check.Call("2");
> -// Foo(3);
> -// }
> -//
> -// The expectation spec says that the first Bar("a") must happen
> -// before check point "1", the second Bar("a") must happen after check
> -// point "2", and nothing should happen between the two check
> -// points. The explicit check points make it easy to tell which
> -// Bar("a") is called by which call to Foo().
> -//
> -// MockFunction<F> can also be used to exercise code that accepts
> -// std::function<F> callbacks. To do so, use AsStdFunction() method
> -// to create std::function proxy forwarding to original object's Call.
> -// Example:
> -//
> -// TEST(FooTest, RunsCallbackWithBarArgument) {
> -// MockFunction<int(string)> callback;
> -// EXPECT_CALL(callback, Call("bar")).WillOnce(Return(1));
> -// Foo(callback.AsStdFunction());
> -// }
> -template <typename F>
> -class MockFunction;
> -
> -template <typename R>
> -class MockFunction<R()> {
> - public:
> - MockFunction() {}
> -
> - MOCK_METHOD0_T(Call, R());
> -
> -#if GTEST_HAS_STD_FUNCTION_
> - ::std::function<R()> AsStdFunction() {
> - return [this]() -> R {
> - return this->Call();
> - };
> - }
> -#endif // GTEST_HAS_STD_FUNCTION_
> -
> - private:
> - GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
> -};
> -
> -template <typename R, typename A0>
> -class MockFunction<R(A0)> {
> - public:
> - MockFunction() {}
> -
> - MOCK_METHOD1_T(Call, R(A0));
> -
> -#if GTEST_HAS_STD_FUNCTION_
> - ::std::function<R(A0)> AsStdFunction() {
> - return [this](A0 a0) -> R {
> - return this->Call(::std::move(a0));
> - };
> - }
> -#endif // GTEST_HAS_STD_FUNCTION_
> -
> - private:
> - GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
> -};
> -
> -template <typename R, typename A0, typename A1>
> -class MockFunction<R(A0, A1)> {
> - public:
> - MockFunction() {}
> -
> - MOCK_METHOD2_T(Call, R(A0, A1));
> -
> -#if GTEST_HAS_STD_FUNCTION_
> - ::std::function<R(A0, A1)> AsStdFunction() {
> - return [this](A0 a0, A1 a1) -> R {
> - return this->Call(::std::move(a0), ::std::move(a1));
> - };
> - }
> -#endif // GTEST_HAS_STD_FUNCTION_
> -
> - private:
> - GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
> -};
> -
> -template <typename R, typename A0, typename A1, typename A2>
> -class MockFunction<R(A0, A1, A2)> {
> - public:
> - MockFunction() {}
> -
> - MOCK_METHOD3_T(Call, R(A0, A1, A2));
> -
> -#if GTEST_HAS_STD_FUNCTION_
> - ::std::function<R(A0, A1, A2)> AsStdFunction() {
> - return [this](A0 a0, A1 a1, A2 a2) -> R {
> - return this->Call(::std::move(a0), ::std::move(a1),
> ::std::move(a2));
> - };
> - }
> -#endif // GTEST_HAS_STD_FUNCTION_
> -
> - private:
> - GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
> -};
> -
> -template <typename R, typename A0, typename A1, typename A2, typename A3>
> -class MockFunction<R(A0, A1, A2, A3)> {
> - public:
> - MockFunction() {}
> -
> - MOCK_METHOD4_T(Call, R(A0, A1, A2, A3));
> -
> -#if GTEST_HAS_STD_FUNCTION_
> - ::std::function<R(A0, A1, A2, A3)> AsStdFunction() {
> - return [this](A0 a0, A1 a1, A2 a2, A3 a3) -> R {
> - return this->Call(::std::move(a0), ::std::move(a1), ::std::move(a2),
> - ::std::move(a3));
> - };
> - }
> -#endif // GTEST_HAS_STD_FUNCTION_
> -
> - private:
> - GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
> -};
> -
> -template <typename R, typename A0, typename A1, typename A2, typename A3,
> - typename A4>
> -class MockFunction<R(A0, A1, A2, A3, A4)> {
> - public:
> - MockFunction() {}
> -
> - MOCK_METHOD5_T(Call, R(A0, A1, A2, A3, A4));
> -
> -#if GTEST_HAS_STD_FUNCTION_
> - ::std::function<R(A0, A1, A2, A3, A4)> AsStdFunction() {
> - return [this](A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) -> R {
> - return this->Call(::std::move(a0), ::std::move(a1), ::std::move(a2),
> - ::std::move(a3), ::std::move(a4));
> - };
> - }
> -#endif // GTEST_HAS_STD_FUNCTION_
> -
> - private:
> - GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
> -};
> -
> -template <typename R, typename A0, typename A1, typename A2, typename A3,
> - typename A4, typename A5>
> -class MockFunction<R(A0, A1, A2, A3, A4, A5)> {
> - public:
> - MockFunction() {}
> -
> - MOCK_METHOD6_T(Call, R(A0, A1, A2, A3, A4, A5));
> -
> -#if GTEST_HAS_STD_FUNCTION_
> - ::std::function<R(A0, A1, A2, A3, A4, A5)> AsStdFunction() {
> - return [this](A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) -> R {
> - return this->Call(::std::move(a0), ::std::move(a1), ::std::move(a2),
> - ::std::move(a3), ::std::move(a4), ::std::move(a5));
> - };
> - }
> -#endif // GTEST_HAS_STD_FUNCTION_
> -
> - private:
> - GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
> -};
> -
> -template <typename R, typename A0, typename A1, typename A2, typename A3,
> - typename A4, typename A5, typename A6>
> -class MockFunction<R(A0, A1, A2, A3, A4, A5, A6)> {
> - public:
> - MockFunction() {}
> -
> - MOCK_METHOD7_T(Call, R(A0, A1, A2, A3, A4, A5, A6));
> -
> -#if GTEST_HAS_STD_FUNCTION_
> - ::std::function<R(A0, A1, A2, A3, A4, A5, A6)> AsStdFunction() {
> - return [this](A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) -> R {
> - return this->Call(::std::move(a0), ::std::move(a1), ::std::move(a2),
> - ::std::move(a3), ::std::move(a4), ::std::move(a5),
> ::std::move(a6));
> - };
> - }
> -#endif // GTEST_HAS_STD_FUNCTION_
> -
> - private:
> - GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
> -};
> -
> -template <typename R, typename A0, typename A1, typename A2, typename A3,
> - typename A4, typename A5, typename A6, typename A7>
> -class MockFunction<R(A0, A1, A2, A3, A4, A5, A6, A7)> {
> - public:
> - MockFunction() {}
> -
> - MOCK_METHOD8_T(Call, R(A0, A1, A2, A3, A4, A5, A6, A7));
> -
> -#if GTEST_HAS_STD_FUNCTION_
> - ::std::function<R(A0, A1, A2, A3, A4, A5, A6, A7)> AsStdFunction() {
> - return [this](A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
> -> R {
> - return this->Call(::std::move(a0), ::std::move(a1), ::std::move(a2),
> - ::std::move(a3), ::std::move(a4), ::std::move(a5),
> ::std::move(a6),
> - ::std::move(a7));
> - };
> - }
> -#endif // GTEST_HAS_STD_FUNCTION_
> -
> - private:
> - GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
> -};
> -
> -template <typename R, typename A0, typename A1, typename A2, typename A3,
> - typename A4, typename A5, typename A6, typename A7, typename A8>
> -class MockFunction<R(A0, A1, A2, A3, A4, A5, A6, A7, A8)> {
> - public:
> - MockFunction() {}
> -
> - MOCK_METHOD9_T(Call, R(A0, A1, A2, A3, A4, A5, A6, A7, A8));
> -
> -#if GTEST_HAS_STD_FUNCTION_
> - ::std::function<R(A0, A1, A2, A3, A4, A5, A6, A7, A8)> AsStdFunction() {
> - return [this](A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7,
> - A8 a8) -> R {
> - return this->Call(::std::move(a0), ::std::move(a1), ::std::move(a2),
> - ::std::move(a3), ::std::move(a4), ::std::move(a5),
> ::std::move(a6),
> - ::std::move(a7), ::std::move(a8));
> - };
> - }
> -#endif // GTEST_HAS_STD_FUNCTION_
> -
> - private:
> - GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
> -};
> -
> -template <typename R, typename A0, typename A1, typename A2, typename A3,
> - typename A4, typename A5, typename A6, typename A7, typename A8,
> - typename A9>
> -class MockFunction<R(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> {
> - public:
> - MockFunction() {}
> -
> - MOCK_METHOD10_T(Call, R(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9));
> -
> -#if GTEST_HAS_STD_FUNCTION_
> - ::std::function<R(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)>
> AsStdFunction() {
> - return [this](A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7,
> - A8 a8, A9 a9) -> R {
> - return this->Call(::std::move(a0), ::std::move(a1), ::std::move(a2),
> - ::std::move(a3), ::std::move(a4), ::std::move(a5),
> ::std::move(a6),
> - ::std::move(a7), ::std::move(a8), ::std::move(a9));
> - };
> - }
> -#endif // GTEST_HAS_STD_FUNCTION_
> -
> - private:
> - GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
> -};
> -
> } // namespace testing
>
> #endif // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_FUNCTION_MOCKERS_H_
>
> diff --git
> a/llvm/utils/unittest/googlemock/include/gmock/gmock-generated-matchers.h
> b/llvm/utils/unittest/googlemock/include/gmock/gmock-generated-matchers.h
> index 94460cbe77819..48ea9358d7c67 100644
> ---
> a/llvm/utils/unittest/googlemock/include/gmock/gmock-generated-matchers.h
> +++
> b/llvm/utils/unittest/googlemock/include/gmock/gmock-generated-matchers.h
> @@ -45,1131 +45,10 @@
> #include <iterator>
> #include <sstream>
> #include <string>
> +#include <utility>
> #include <vector>
> #include "gmock/gmock-matchers.h"
>
> -namespace testing {
> -namespace internal {
> -
> -// The type of the i-th (0-based) field of Tuple.
> -#define GMOCK_FIELD_TYPE_(Tuple, i) \
> - typename ::testing::tuple_element<i, Tuple>::type
> -
> -// TupleFields<Tuple, k0, ..., kn> is for selecting fields from a
> -// tuple of type Tuple. It has two members:
> -//
> -// type: a tuple type whose i-th field is the ki-th field of Tuple.
> -// GetSelectedFields(t): returns fields k0, ..., and kn of t as a tuple.
> -//
> -// For example, in class TupleFields<tuple<bool, char, int>, 2, 0>, we
> have:
> -//
> -// type is tuple<int, bool>, and
> -// GetSelectedFields(make_tuple(true, 'a', 42)) is (42, true).
> -
> -template <class Tuple, int k0 = -1, int k1 = -1, int k2 = -1, int k3 = -1,
> - int k4 = -1, int k5 = -1, int k6 = -1, int k7 = -1, int k8 = -1,
> - int k9 = -1>
> -class TupleFields;
> -
> -// This generic version is used when there are 10 selectors.
> -template <class Tuple, int k0, int k1, int k2, int k3, int k4, int k5,
> int k6,
> - int k7, int k8, int k9>
> -class TupleFields {
> - public:
> - typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
> - GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2),
> - GMOCK_FIELD_TYPE_(Tuple, k3), GMOCK_FIELD_TYPE_(Tuple, k4),
> - GMOCK_FIELD_TYPE_(Tuple, k5), GMOCK_FIELD_TYPE_(Tuple, k6),
> - GMOCK_FIELD_TYPE_(Tuple, k7), GMOCK_FIELD_TYPE_(Tuple, k8),
> - GMOCK_FIELD_TYPE_(Tuple, k9)> type;
> - static type GetSelectedFields(const Tuple& t) {
> - return type(get<k0>(t), get<k1>(t), get<k2>(t), get<k3>(t),
> get<k4>(t),
> - get<k5>(t), get<k6>(t), get<k7>(t), get<k8>(t), get<k9>(t));
> - }
> -};
> -
> -// The following specialization is used for 0 ~ 9 selectors.
> -
> -template <class Tuple>
> -class TupleFields<Tuple, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1> {
> - public:
> - typedef ::testing::tuple<> type;
> - static type GetSelectedFields(const Tuple& /* t */) {
> - return type();
> - }
> -};
> -
> -template <class Tuple, int k0>
> -class TupleFields<Tuple, k0, -1, -1, -1, -1, -1, -1, -1, -1, -1> {
> - public:
> - typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0)> type;
> - static type GetSelectedFields(const Tuple& t) {
> - return type(get<k0>(t));
> - }
> -};
> -
> -template <class Tuple, int k0, int k1>
> -class TupleFields<Tuple, k0, k1, -1, -1, -1, -1, -1, -1, -1, -1> {
> - public:
> - typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
> - GMOCK_FIELD_TYPE_(Tuple, k1)> type;
> - static type GetSelectedFields(const Tuple& t) {
> - return type(get<k0>(t), get<k1>(t));
> - }
> -};
> -
> -template <class Tuple, int k0, int k1, int k2>
> -class TupleFields<Tuple, k0, k1, k2, -1, -1, -1, -1, -1, -1, -1> {
> - public:
> - typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
> - GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2)> type;
> - static type GetSelectedFields(const Tuple& t) {
> - return type(get<k0>(t), get<k1>(t), get<k2>(t));
> - }
> -};
> -
> -template <class Tuple, int k0, int k1, int k2, int k3>
> -class TupleFields<Tuple, k0, k1, k2, k3, -1, -1, -1, -1, -1, -1> {
> - public:
> - typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
> - GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2),
> - GMOCK_FIELD_TYPE_(Tuple, k3)> type;
> - static type GetSelectedFields(const Tuple& t) {
> - return type(get<k0>(t), get<k1>(t), get<k2>(t), get<k3>(t));
> - }
> -};
> -
> -template <class Tuple, int k0, int k1, int k2, int k3, int k4>
> -class TupleFields<Tuple, k0, k1, k2, k3, k4, -1, -1, -1, -1, -1> {
> - public:
> - typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
> - GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2),
> - GMOCK_FIELD_TYPE_(Tuple, k3), GMOCK_FIELD_TYPE_(Tuple, k4)> type;
> - static type GetSelectedFields(const Tuple& t) {
> - return type(get<k0>(t), get<k1>(t), get<k2>(t), get<k3>(t),
> get<k4>(t));
> - }
> -};
> -
> -template <class Tuple, int k0, int k1, int k2, int k3, int k4, int k5>
> -class TupleFields<Tuple, k0, k1, k2, k3, k4, k5, -1, -1, -1, -1> {
> - public:
> - typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
> - GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2),
> - GMOCK_FIELD_TYPE_(Tuple, k3), GMOCK_FIELD_TYPE_(Tuple, k4),
> - GMOCK_FIELD_TYPE_(Tuple, k5)> type;
> - static type GetSelectedFields(const Tuple& t) {
> - return type(get<k0>(t), get<k1>(t), get<k2>(t), get<k3>(t),
> get<k4>(t),
> - get<k5>(t));
> - }
> -};
> -
> -template <class Tuple, int k0, int k1, int k2, int k3, int k4, int k5,
> int k6>
> -class TupleFields<Tuple, k0, k1, k2, k3, k4, k5, k6, -1, -1, -1> {
> - public:
> - typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
> - GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2),
> - GMOCK_FIELD_TYPE_(Tuple, k3), GMOCK_FIELD_TYPE_(Tuple, k4),
> - GMOCK_FIELD_TYPE_(Tuple, k5), GMOCK_FIELD_TYPE_(Tuple, k6)> type;
> - static type GetSelectedFields(const Tuple& t) {
> - return type(get<k0>(t), get<k1>(t), get<k2>(t), get<k3>(t),
> get<k4>(t),
> - get<k5>(t), get<k6>(t));
> - }
> -};
> -
> -template <class Tuple, int k0, int k1, int k2, int k3, int k4, int k5,
> int k6,
> - int k7>
> -class TupleFields<Tuple, k0, k1, k2, k3, k4, k5, k6, k7, -1, -1> {
> - public:
> - typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
> - GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2),
> - GMOCK_FIELD_TYPE_(Tuple, k3), GMOCK_FIELD_TYPE_(Tuple, k4),
> - GMOCK_FIELD_TYPE_(Tuple, k5), GMOCK_FIELD_TYPE_(Tuple, k6),
> - GMOCK_FIELD_TYPE_(Tuple, k7)> type;
> - static type GetSelectedFields(const Tuple& t) {
> - return type(get<k0>(t), get<k1>(t), get<k2>(t), get<k3>(t),
> get<k4>(t),
> - get<k5>(t), get<k6>(t), get<k7>(t));
> - }
> -};
> -
> -template <class Tuple, int k0, int k1, int k2, int k3, int k4, int k5,
> int k6,
> - int k7, int k8>
> -class TupleFields<Tuple, k0, k1, k2, k3, k4, k5, k6, k7, k8, -1> {
> - public:
> - typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
> - GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2),
> - GMOCK_FIELD_TYPE_(Tuple, k3), GMOCK_FIELD_TYPE_(Tuple, k4),
> - GMOCK_FIELD_TYPE_(Tuple, k5), GMOCK_FIELD_TYPE_(Tuple, k6),
> - GMOCK_FIELD_TYPE_(Tuple, k7), GMOCK_FIELD_TYPE_(Tuple, k8)> type;
> - static type GetSelectedFields(const Tuple& t) {
> - return type(get<k0>(t), get<k1>(t), get<k2>(t), get<k3>(t),
> get<k4>(t),
> - get<k5>(t), get<k6>(t), get<k7>(t), get<k8>(t));
> - }
> -};
> -
> -#undef GMOCK_FIELD_TYPE_
> -
> -// Implements the Args() matcher.
> -template <class ArgsTuple, int k0 = -1, int k1 = -1, int k2 = -1, int k3
> = -1,
> - int k4 = -1, int k5 = -1, int k6 = -1, int k7 = -1, int k8 = -1,
> - int k9 = -1>
> -class ArgsMatcherImpl : public MatcherInterface<ArgsTuple> {
> - public:
> - // ArgsTuple may have top-level const or reference modifiers.
> - typedef GTEST_REMOVE_REFERENCE_AND_CONST_(ArgsTuple) RawArgsTuple;
> - typedef typename internal::TupleFields<RawArgsTuple, k0, k1, k2, k3,
> k4, k5,
> - k6, k7, k8, k9>::type SelectedArgs;
> - typedef Matcher<const SelectedArgs&> MonomorphicInnerMatcher;
> -
> - template <typename InnerMatcher>
> - explicit ArgsMatcherImpl(const InnerMatcher& inner_matcher)
> - : inner_matcher_(SafeMatcherCast<const
> SelectedArgs&>(inner_matcher)) {}
> -
> - virtual bool MatchAndExplain(ArgsTuple args,
> - MatchResultListener* listener) const {
> - const SelectedArgs& selected_args = GetSelectedArgs(args);
> - if (!listener->IsInterested())
> - return inner_matcher_.Matches(selected_args);
> -
> - PrintIndices(listener->stream());
> - *listener << "are " << PrintToString(selected_args);
> -
> - StringMatchResultListener inner_listener;
> - const bool match = inner_matcher_.MatchAndExplain(selected_args,
> - &inner_listener);
> - PrintIfNotEmpty(inner_listener.str(), listener->stream());
> - return match;
> - }
> -
> - virtual void DescribeTo(::std::ostream* os) const {
> - *os << "are a tuple ";
> - PrintIndices(os);
> - inner_matcher_.DescribeTo(os);
> - }
> -
> - virtual void DescribeNegationTo(::std::ostream* os) const {
> - *os << "are a tuple ";
> - PrintIndices(os);
> - inner_matcher_.DescribeNegationTo(os);
> - }
> -
> - private:
> - static SelectedArgs GetSelectedArgs(ArgsTuple args) {
> - return TupleFields<RawArgsTuple, k0, k1, k2, k3, k4, k5, k6, k7, k8,
> - k9>::GetSelectedFields(args);
> - }
> -
> - // Prints the indices of the selected fields.
> - static void PrintIndices(::std::ostream* os) {
> - *os << "whose fields (";
> - const int indices[10] = { k0, k1, k2, k3, k4, k5, k6, k7, k8, k9 };
> - for (int i = 0; i < 10; i++) {
> - if (indices[i] < 0)
> - break;
> -
> - if (i >= 1)
> - *os << ", ";
> -
> - *os << "#" << indices[i];
> - }
> - *os << ") ";
> - }
> -
> - const MonomorphicInnerMatcher inner_matcher_;
> -
> - GTEST_DISALLOW_ASSIGN_(ArgsMatcherImpl);
> -};
> -
> -template <class InnerMatcher, int k0 = -1, int k1 = -1, int k2 = -1,
> - int k3 = -1, int k4 = -1, int k5 = -1, int k6 = -1, int k7 = -1,
> - int k8 = -1, int k9 = -1>
> -class ArgsMatcher {
> - public:
> - explicit ArgsMatcher(const InnerMatcher& inner_matcher)
> - : inner_matcher_(inner_matcher) {}
> -
> - template <typename ArgsTuple>
> - operator Matcher<ArgsTuple>() const {
> - return MakeMatcher(new ArgsMatcherImpl<ArgsTuple, k0, k1, k2, k3, k4,
> k5,
> - k6, k7, k8, k9>(inner_matcher_));
> - }
> -
> - private:
> - const InnerMatcher inner_matcher_;
> -
> - GTEST_DISALLOW_ASSIGN_(ArgsMatcher);
> -};
> -
> -// A set of metafunctions for computing the result type of AllOf.
> -// AllOf(m1, ..., mN) returns
> -// AllOfResultN<decltype(m1), ..., decltype(mN)>::type.
> -
> -// Although AllOf isn't defined for one argument, AllOfResult1 is defined
> -// to simplify the implementation.
> -template <typename M1>
> -struct AllOfResult1 {
> - typedef M1 type;
> -};
> -
> -template <typename M1, typename M2>
> -struct AllOfResult2 {
> - typedef BothOfMatcher<
> - typename AllOfResult1<M1>::type,
> - typename AllOfResult1<M2>::type
> - > type;
> -};
> -
> -template <typename M1, typename M2, typename M3>
> -struct AllOfResult3 {
> - typedef BothOfMatcher<
> - typename AllOfResult1<M1>::type,
> - typename AllOfResult2<M2, M3>::type
> - > type;
> -};
> -
> -template <typename M1, typename M2, typename M3, typename M4>
> -struct AllOfResult4 {
> - typedef BothOfMatcher<
> - typename AllOfResult2<M1, M2>::type,
> - typename AllOfResult2<M3, M4>::type
> - > type;
> -};
> -
> -template <typename M1, typename M2, typename M3, typename M4, typename M5>
> -struct AllOfResult5 {
> - typedef BothOfMatcher<
> - typename AllOfResult2<M1, M2>::type,
> - typename AllOfResult3<M3, M4, M5>::type
> - > type;
> -};
> -
> -template <typename M1, typename M2, typename M3, typename M4, typename M5,
> - typename M6>
> -struct AllOfResult6 {
> - typedef BothOfMatcher<
> - typename AllOfResult3<M1, M2, M3>::type,
> - typename AllOfResult3<M4, M5, M6>::type
> - > type;
> -};
> -
> -template <typename M1, typename M2, typename M3, typename M4, typename M5,
> - typename M6, typename M7>
> -struct AllOfResult7 {
> - typedef BothOfMatcher<
> - typename AllOfResult3<M1, M2, M3>::type,
> - typename AllOfResult4<M4, M5, M6, M7>::type
> - > type;
> -};
> -
> -template <typename M1, typename M2, typename M3, typename M4, typename M5,
> - typename M6, typename M7, typename M8>
> -struct AllOfResult8 {
> - typedef BothOfMatcher<
> - typename AllOfResult4<M1, M2, M3, M4>::type,
> - typename AllOfResult4<M5, M6, M7, M8>::type
> - > type;
> -};
> -
> -template <typename M1, typename M2, typename M3, typename M4, typename M5,
> - typename M6, typename M7, typename M8, typename M9>
> -struct AllOfResult9 {
> - typedef BothOfMatcher<
> - typename AllOfResult4<M1, M2, M3, M4>::type,
> - typename AllOfResult5<M5, M6, M7, M8, M9>::type
> - > type;
> -};
> -
> -template <typename M1, typename M2, typename M3, typename M4, typename M5,
> - typename M6, typename M7, typename M8, typename M9, typename M10>
> -struct AllOfResult10 {
> - typedef BothOfMatcher<
> - typename AllOfResult5<M1, M2, M3, M4, M5>::type,
> - typename AllOfResult5<M6, M7, M8, M9, M10>::type
> - > type;
> -};
> -
> -// A set of metafunctions for computing the result type of AnyOf.
> -// AnyOf(m1, ..., mN) returns
> -// AnyOfResultN<decltype(m1), ..., decltype(mN)>::type.
> -
> -// Although AnyOf isn't defined for one argument, AnyOfResult1 is defined
> -// to simplify the implementation.
> -template <typename M1>
> -struct AnyOfResult1 {
> - typedef M1 type;
> -};
> -
> -template <typename M1, typename M2>
> -struct AnyOfResult2 {
> - typedef EitherOfMatcher<
> - typename AnyOfResult1<M1>::type,
> - typename AnyOfResult1<M2>::type
> - > type;
> -};
> -
> -template <typename M1, typename M2, typename M3>
> -struct AnyOfResult3 {
> - typedef EitherOfMatcher<
> - typename AnyOfResult1<M1>::type,
> - typename AnyOfResult2<M2, M3>::type
> - > type;
> -};
> -
> -template <typename M1, typename M2, typename M3, typename M4>
> -struct AnyOfResult4 {
> - typedef EitherOfMatcher<
> - typename AnyOfResult2<M1, M2>::type,
> - typename AnyOfResult2<M3, M4>::type
> - > type;
> -};
> -
> -template <typename M1, typename M2, typename M3, typename M4, typename M5>
> -struct AnyOfResult5 {
> - typedef EitherOfMatcher<
> - typename AnyOfResult2<M1, M2>::type,
> - typename AnyOfResult3<M3, M4, M5>::type
> - > type;
> -};
> -
> -template <typename M1, typename M2, typename M3, typename M4, typename M5,
> - typename M6>
> -struct AnyOfResult6 {
> - typedef EitherOfMatcher<
> - typename AnyOfResult3<M1, M2, M3>::type,
> - typename AnyOfResult3<M4, M5, M6>::type
> - > type;
> -};
> -
> -template <typename M1, typename M2, typename M3, typename M4, typename M5,
> - typename M6, typename M7>
> -struct AnyOfResult7 {
> - typedef EitherOfMatcher<
> - typename AnyOfResult3<M1, M2, M3>::type,
> - typename AnyOfResult4<M4, M5, M6, M7>::type
> - > type;
> -};
> -
> -template <typename M1, typename M2, typename M3, typename M4, typename M5,
> - typename M6, typename M7, typename M8>
> -struct AnyOfResult8 {
> - typedef EitherOfMatcher<
> - typename AnyOfResult4<M1, M2, M3, M4>::type,
> - typename AnyOfResult4<M5, M6, M7, M8>::type
> - > type;
> -};
> -
> -template <typename M1, typename M2, typename M3, typename M4, typename M5,
> - typename M6, typename M7, typename M8, typename M9>
> -struct AnyOfResult9 {
> - typedef EitherOfMatcher<
> - typename AnyOfResult4<M1, M2, M3, M4>::type,
> - typename AnyOfResult5<M5, M6, M7, M8, M9>::type
> - > type;
> -};
> -
> -template <typename M1, typename M2, typename M3, typename M4, typename M5,
> - typename M6, typename M7, typename M8, typename M9, typename M10>
> -struct AnyOfResult10 {
> - typedef EitherOfMatcher<
> - typename AnyOfResult5<M1, M2, M3, M4, M5>::type,
> - typename AnyOfResult5<M6, M7, M8, M9, M10>::type
> - > type;
> -};
> -
> -} // namespace internal
> -
> -// Args<N1, N2, ..., Nk>(a_matcher) matches a tuple if the selected
> -// fields of it matches a_matcher. C++ doesn't support default
> -// arguments for function templates, so we have to overload it.
> -template <typename InnerMatcher>
> -inline internal::ArgsMatcher<InnerMatcher>
> -Args(const InnerMatcher& matcher) {
> - return internal::ArgsMatcher<InnerMatcher>(matcher);
> -}
> -
> -template <int k1, typename InnerMatcher>
> -inline internal::ArgsMatcher<InnerMatcher, k1>
> -Args(const InnerMatcher& matcher) {
> - return internal::ArgsMatcher<InnerMatcher, k1>(matcher);
> -}
> -
> -template <int k1, int k2, typename InnerMatcher>
> -inline internal::ArgsMatcher<InnerMatcher, k1, k2>
> -Args(const InnerMatcher& matcher) {
> - return internal::ArgsMatcher<InnerMatcher, k1, k2>(matcher);
> -}
> -
> -template <int k1, int k2, int k3, typename InnerMatcher>
> -inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3>
> -Args(const InnerMatcher& matcher) {
> - return internal::ArgsMatcher<InnerMatcher, k1, k2, k3>(matcher);
> -}
> -
> -template <int k1, int k2, int k3, int k4, typename InnerMatcher>
> -inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4>
> -Args(const InnerMatcher& matcher) {
> - return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4>(matcher);
> -}
> -
> -template <int k1, int k2, int k3, int k4, int k5, typename InnerMatcher>
> -inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5>
> -Args(const InnerMatcher& matcher) {
> - return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5>(matcher);
> -}
> -
> -template <int k1, int k2, int k3, int k4, int k5, int k6, typename
> InnerMatcher>
> -inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6>
> -Args(const InnerMatcher& matcher) {
> - return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5,
> k6>(matcher);
> -}
> -
> -template <int k1, int k2, int k3, int k4, int k5, int k6, int k7,
> - typename InnerMatcher>
> -inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7>
> -Args(const InnerMatcher& matcher) {
> - return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6,
> - k7>(matcher);
> -}
> -
> -template <int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8,
> - typename InnerMatcher>
> -inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8>
> -Args(const InnerMatcher& matcher) {
> - return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7,
> - k8>(matcher);
> -}
> -
> -template <int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8,
> - int k9, typename InnerMatcher>
> -inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7,
> k8, k9>
> -Args(const InnerMatcher& matcher) {
> - return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7,
> k8,
> - k9>(matcher);
> -}
> -
> -template <int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8,
> - int k9, int k10, typename InnerMatcher>
> -inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7,
> k8, k9,
> - k10>
> -Args(const InnerMatcher& matcher) {
> - return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7,
> k8,
> - k9, k10>(matcher);
> -}
> -
> -// ElementsAre(e_1, e_2, ... e_n) matches an STL-style container with
> -// n elements, where the i-th element in the container must
> -// match the i-th argument in the list. Each argument of
> -// ElementsAre() can be either a value or a matcher. We support up to
> -// 10 arguments.
> -//
> -// The use of DecayArray in the implementation allows ElementsAre()
> -// to accept string literals, whose type is const char[N], but we
> -// want to treat them as const char*.
> -//
> -// NOTE: Since ElementsAre() cares about the order of the elements, it
> -// must not be used with containers whose elements's order is
> -// undefined (e.g. hash_map).
> -
> -inline internal::ElementsAreMatcher<
> - ::testing::tuple<> >
> -ElementsAre() {
> - typedef ::testing::tuple<> Args;
> - return internal::ElementsAreMatcher<Args>(Args());
> -}
> -
> -template <typename T1>
> -inline internal::ElementsAreMatcher<
> - ::testing::tuple<
> - typename internal::DecayArray<T1>::type> >
> -ElementsAre(const T1& e1) {
> - typedef ::testing::tuple<
> - typename internal::DecayArray<T1>::type> Args;
> - return internal::ElementsAreMatcher<Args>(Args(e1));
> -}
> -
> -template <typename T1, typename T2>
> -inline internal::ElementsAreMatcher<
> - ::testing::tuple<
> - typename internal::DecayArray<T1>::type,
> - typename internal::DecayArray<T2>::type> >
> -ElementsAre(const T1& e1, const T2& e2) {
> - typedef ::testing::tuple<
> - typename internal::DecayArray<T1>::type,
> - typename internal::DecayArray<T2>::type> Args;
> - return internal::ElementsAreMatcher<Args>(Args(e1, e2));
> -}
> -
> -template <typename T1, typename T2, typename T3>
> -inline internal::ElementsAreMatcher<
> - ::testing::tuple<
> - typename internal::DecayArray<T1>::type,
> - typename internal::DecayArray<T2>::type,
> - typename internal::DecayArray<T3>::type> >
> -ElementsAre(const T1& e1, const T2& e2, const T3& e3) {
> - typedef ::testing::tuple<
> - typename internal::DecayArray<T1>::type,
> - typename internal::DecayArray<T2>::type,
> - typename internal::DecayArray<T3>::type> Args;
> - return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3));
> -}
> -
> -template <typename T1, typename T2, typename T3, typename T4>
> -inline internal::ElementsAreMatcher<
> - ::testing::tuple<
> - typename internal::DecayArray<T1>::type,
> - typename internal::DecayArray<T2>::type,
> - typename internal::DecayArray<T3>::type,
> - typename internal::DecayArray<T4>::type> >
> -ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4) {
> - typedef ::testing::tuple<
> - typename internal::DecayArray<T1>::type,
> - typename internal::DecayArray<T2>::type,
> - typename internal::DecayArray<T3>::type,
> - typename internal::DecayArray<T4>::type> Args;
> - return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4));
> -}
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5>
> -inline internal::ElementsAreMatcher<
> - ::testing::tuple<
> - typename internal::DecayArray<T1>::type,
> - typename internal::DecayArray<T2>::type,
> - typename internal::DecayArray<T3>::type,
> - typename internal::DecayArray<T4>::type,
> - typename internal::DecayArray<T5>::type> >
> -ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
> - const T5& e5) {
> - typedef ::testing::tuple<
> - typename internal::DecayArray<T1>::type,
> - typename internal::DecayArray<T2>::type,
> - typename internal::DecayArray<T3>::type,
> - typename internal::DecayArray<T4>::type,
> - typename internal::DecayArray<T5>::type> Args;
> - return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5));
> -}
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6>
> -inline internal::ElementsAreMatcher<
> - ::testing::tuple<
> - typename internal::DecayArray<T1>::type,
> - typename internal::DecayArray<T2>::type,
> - typename internal::DecayArray<T3>::type,
> - typename internal::DecayArray<T4>::type,
> - typename internal::DecayArray<T5>::type,
> - typename internal::DecayArray<T6>::type> >
> -ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
> - const T5& e5, const T6& e6) {
> - typedef ::testing::tuple<
> - typename internal::DecayArray<T1>::type,
> - typename internal::DecayArray<T2>::type,
> - typename internal::DecayArray<T3>::type,
> - typename internal::DecayArray<T4>::type,
> - typename internal::DecayArray<T5>::type,
> - typename internal::DecayArray<T6>::type> Args;
> - return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5, e6));
> -}
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7>
> -inline internal::ElementsAreMatcher<
> - ::testing::tuple<
> - typename internal::DecayArray<T1>::type,
> - typename internal::DecayArray<T2>::type,
> - typename internal::DecayArray<T3>::type,
> - typename internal::DecayArray<T4>::type,
> - typename internal::DecayArray<T5>::type,
> - typename internal::DecayArray<T6>::type,
> - typename internal::DecayArray<T7>::type> >
> -ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
> - const T5& e5, const T6& e6, const T7& e7) {
> - typedef ::testing::tuple<
> - typename internal::DecayArray<T1>::type,
> - typename internal::DecayArray<T2>::type,
> - typename internal::DecayArray<T3>::type,
> - typename internal::DecayArray<T4>::type,
> - typename internal::DecayArray<T5>::type,
> - typename internal::DecayArray<T6>::type,
> - typename internal::DecayArray<T7>::type> Args;
> - return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5, e6,
> e7));
> -}
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8>
> -inline internal::ElementsAreMatcher<
> - ::testing::tuple<
> - typename internal::DecayArray<T1>::type,
> - typename internal::DecayArray<T2>::type,
> - typename internal::DecayArray<T3>::type,
> - typename internal::DecayArray<T4>::type,
> - typename internal::DecayArray<T5>::type,
> - typename internal::DecayArray<T6>::type,
> - typename internal::DecayArray<T7>::type,
> - typename internal::DecayArray<T8>::type> >
> -ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
> - const T5& e5, const T6& e6, const T7& e7, const T8& e8) {
> - typedef ::testing::tuple<
> - typename internal::DecayArray<T1>::type,
> - typename internal::DecayArray<T2>::type,
> - typename internal::DecayArray<T3>::type,
> - typename internal::DecayArray<T4>::type,
> - typename internal::DecayArray<T5>::type,
> - typename internal::DecayArray<T6>::type,
> - typename internal::DecayArray<T7>::type,
> - typename internal::DecayArray<T8>::type> Args;
> - return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5, e6,
> e7,
> - e8));
> -}
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9>
> -inline internal::ElementsAreMatcher<
> - ::testing::tuple<
> - typename internal::DecayArray<T1>::type,
> - typename internal::DecayArray<T2>::type,
> - typename internal::DecayArray<T3>::type,
> - typename internal::DecayArray<T4>::type,
> - typename internal::DecayArray<T5>::type,
> - typename internal::DecayArray<T6>::type,
> - typename internal::DecayArray<T7>::type,
> - typename internal::DecayArray<T8>::type,
> - typename internal::DecayArray<T9>::type> >
> -ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
> - const T5& e5, const T6& e6, const T7& e7, const T8& e8, const T9& e9)
> {
> - typedef ::testing::tuple<
> - typename internal::DecayArray<T1>::type,
> - typename internal::DecayArray<T2>::type,
> - typename internal::DecayArray<T3>::type,
> - typename internal::DecayArray<T4>::type,
> - typename internal::DecayArray<T5>::type,
> - typename internal::DecayArray<T6>::type,
> - typename internal::DecayArray<T7>::type,
> - typename internal::DecayArray<T8>::type,
> - typename internal::DecayArray<T9>::type> Args;
> - return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5, e6,
> e7,
> - e8, e9));
> -}
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10>
> -inline internal::ElementsAreMatcher<
> - ::testing::tuple<
> - typename internal::DecayArray<T1>::type,
> - typename internal::DecayArray<T2>::type,
> - typename internal::DecayArray<T3>::type,
> - typename internal::DecayArray<T4>::type,
> - typename internal::DecayArray<T5>::type,
> - typename internal::DecayArray<T6>::type,
> - typename internal::DecayArray<T7>::type,
> - typename internal::DecayArray<T8>::type,
> - typename internal::DecayArray<T9>::type,
> - typename internal::DecayArray<T10>::type> >
> -ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
> - const T5& e5, const T6& e6, const T7& e7, const T8& e8, const T9& e9,
> - const T10& e10) {
> - typedef ::testing::tuple<
> - typename internal::DecayArray<T1>::type,
> - typename internal::DecayArray<T2>::type,
> - typename internal::DecayArray<T3>::type,
> - typename internal::DecayArray<T4>::type,
> - typename internal::DecayArray<T5>::type,
> - typename internal::DecayArray<T6>::type,
> - typename internal::DecayArray<T7>::type,
> - typename internal::DecayArray<T8>::type,
> - typename internal::DecayArray<T9>::type,
> - typename internal::DecayArray<T10>::type> Args;
> - return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5, e6,
> e7,
> - e8, e9, e10));
> -}
> -
> -// UnorderedElementsAre(e_1, e_2, ..., e_n) is an ElementsAre extension
> -// that matches n elements in any order. We support up to n=10 arguments.
> -//
> -// If you have >10 elements, consider UnorderedElementsAreArray() or
> -// UnorderedPointwise() instead.
> -
> -inline internal::UnorderedElementsAreMatcher<
> - ::testing::tuple<> >
> -UnorderedElementsAre() {
> - typedef ::testing::tuple<> Args;
> - return internal::UnorderedElementsAreMatcher<Args>(Args());
> -}
> -
> -template <typename T1>
> -inline internal::UnorderedElementsAreMatcher<
> - ::testing::tuple<
> - typename internal::DecayArray<T1>::type> >
> -UnorderedElementsAre(const T1& e1) {
> - typedef ::testing::tuple<
> - typename internal::DecayArray<T1>::type> Args;
> - return internal::UnorderedElementsAreMatcher<Args>(Args(e1));
> -}
> -
> -template <typename T1, typename T2>
> -inline internal::UnorderedElementsAreMatcher<
> - ::testing::tuple<
> - typename internal::DecayArray<T1>::type,
> - typename internal::DecayArray<T2>::type> >
> -UnorderedElementsAre(const T1& e1, const T2& e2) {
> - typedef ::testing::tuple<
> - typename internal::DecayArray<T1>::type,
> - typename internal::DecayArray<T2>::type> Args;
> - return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2));
> -}
> -
> -template <typename T1, typename T2, typename T3>
> -inline internal::UnorderedElementsAreMatcher<
> - ::testing::tuple<
> - typename internal::DecayArray<T1>::type,
> - typename internal::DecayArray<T2>::type,
> - typename internal::DecayArray<T3>::type> >
> -UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3) {
> - typedef ::testing::tuple<
> - typename internal::DecayArray<T1>::type,
> - typename internal::DecayArray<T2>::type,
> - typename internal::DecayArray<T3>::type> Args;
> - return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3));
> -}
> -
> -template <typename T1, typename T2, typename T3, typename T4>
> -inline internal::UnorderedElementsAreMatcher<
> - ::testing::tuple<
> - typename internal::DecayArray<T1>::type,
> - typename internal::DecayArray<T2>::type,
> - typename internal::DecayArray<T3>::type,
> - typename internal::DecayArray<T4>::type> >
> -UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4&
> e4) {
> - typedef ::testing::tuple<
> - typename internal::DecayArray<T1>::type,
> - typename internal::DecayArray<T2>::type,
> - typename internal::DecayArray<T3>::type,
> - typename internal::DecayArray<T4>::type> Args;
> - return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3,
> e4));
> -}
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5>
> -inline internal::UnorderedElementsAreMatcher<
> - ::testing::tuple<
> - typename internal::DecayArray<T1>::type,
> - typename internal::DecayArray<T2>::type,
> - typename internal::DecayArray<T3>::type,
> - typename internal::DecayArray<T4>::type,
> - typename internal::DecayArray<T5>::type> >
> -UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4&
> e4,
> - const T5& e5) {
> - typedef ::testing::tuple<
> - typename internal::DecayArray<T1>::type,
> - typename internal::DecayArray<T2>::type,
> - typename internal::DecayArray<T3>::type,
> - typename internal::DecayArray<T4>::type,
> - typename internal::DecayArray<T5>::type> Args;
> - return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4,
> e5));
> -}
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6>
> -inline internal::UnorderedElementsAreMatcher<
> - ::testing::tuple<
> - typename internal::DecayArray<T1>::type,
> - typename internal::DecayArray<T2>::type,
> - typename internal::DecayArray<T3>::type,
> - typename internal::DecayArray<T4>::type,
> - typename internal::DecayArray<T5>::type,
> - typename internal::DecayArray<T6>::type> >
> -UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4&
> e4,
> - const T5& e5, const T6& e6) {
> - typedef ::testing::tuple<
> - typename internal::DecayArray<T1>::type,
> - typename internal::DecayArray<T2>::type,
> - typename internal::DecayArray<T3>::type,
> - typename internal::DecayArray<T4>::type,
> - typename internal::DecayArray<T5>::type,
> - typename internal::DecayArray<T6>::type> Args;
> - return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4,
> e5,
> - e6));
> -}
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7>
> -inline internal::UnorderedElementsAreMatcher<
> - ::testing::tuple<
> - typename internal::DecayArray<T1>::type,
> - typename internal::DecayArray<T2>::type,
> - typename internal::DecayArray<T3>::type,
> - typename internal::DecayArray<T4>::type,
> - typename internal::DecayArray<T5>::type,
> - typename internal::DecayArray<T6>::type,
> - typename internal::DecayArray<T7>::type> >
> -UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4&
> e4,
> - const T5& e5, const T6& e6, const T7& e7) {
> - typedef ::testing::tuple<
> - typename internal::DecayArray<T1>::type,
> - typename internal::DecayArray<T2>::type,
> - typename internal::DecayArray<T3>::type,
> - typename internal::DecayArray<T4>::type,
> - typename internal::DecayArray<T5>::type,
> - typename internal::DecayArray<T6>::type,
> - typename internal::DecayArray<T7>::type> Args;
> - return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4,
> e5,
> - e6, e7));
> -}
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8>
> -inline internal::UnorderedElementsAreMatcher<
> - ::testing::tuple<
> - typename internal::DecayArray<T1>::type,
> - typename internal::DecayArray<T2>::type,
> - typename internal::DecayArray<T3>::type,
> - typename internal::DecayArray<T4>::type,
> - typename internal::DecayArray<T5>::type,
> - typename internal::DecayArray<T6>::type,
> - typename internal::DecayArray<T7>::type,
> - typename internal::DecayArray<T8>::type> >
> -UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4&
> e4,
> - const T5& e5, const T6& e6, const T7& e7, const T8& e8) {
> - typedef ::testing::tuple<
> - typename internal::DecayArray<T1>::type,
> - typename internal::DecayArray<T2>::type,
> - typename internal::DecayArray<T3>::type,
> - typename internal::DecayArray<T4>::type,
> - typename internal::DecayArray<T5>::type,
> - typename internal::DecayArray<T6>::type,
> - typename internal::DecayArray<T7>::type,
> - typename internal::DecayArray<T8>::type> Args;
> - return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4,
> e5,
> - e6, e7, e8));
> -}
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9>
> -inline internal::UnorderedElementsAreMatcher<
> - ::testing::tuple<
> - typename internal::DecayArray<T1>::type,
> - typename internal::DecayArray<T2>::type,
> - typename internal::DecayArray<T3>::type,
> - typename internal::DecayArray<T4>::type,
> - typename internal::DecayArray<T5>::type,
> - typename internal::DecayArray<T6>::type,
> - typename internal::DecayArray<T7>::type,
> - typename internal::DecayArray<T8>::type,
> - typename internal::DecayArray<T9>::type> >
> -UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4&
> e4,
> - const T5& e5, const T6& e6, const T7& e7, const T8& e8, const T9& e9)
> {
> - typedef ::testing::tuple<
> - typename internal::DecayArray<T1>::type,
> - typename internal::DecayArray<T2>::type,
> - typename internal::DecayArray<T3>::type,
> - typename internal::DecayArray<T4>::type,
> - typename internal::DecayArray<T5>::type,
> - typename internal::DecayArray<T6>::type,
> - typename internal::DecayArray<T7>::type,
> - typename internal::DecayArray<T8>::type,
> - typename internal::DecayArray<T9>::type> Args;
> - return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4,
> e5,
> - e6, e7, e8, e9));
> -}
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10>
> -inline internal::UnorderedElementsAreMatcher<
> - ::testing::tuple<
> - typename internal::DecayArray<T1>::type,
> - typename internal::DecayArray<T2>::type,
> - typename internal::DecayArray<T3>::type,
> - typename internal::DecayArray<T4>::type,
> - typename internal::DecayArray<T5>::type,
> - typename internal::DecayArray<T6>::type,
> - typename internal::DecayArray<T7>::type,
> - typename internal::DecayArray<T8>::type,
> - typename internal::DecayArray<T9>::type,
> - typename internal::DecayArray<T10>::type> >
> -UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4&
> e4,
> - const T5& e5, const T6& e6, const T7& e7, const T8& e8, const T9& e9,
> - const T10& e10) {
> - typedef ::testing::tuple<
> - typename internal::DecayArray<T1>::type,
> - typename internal::DecayArray<T2>::type,
> - typename internal::DecayArray<T3>::type,
> - typename internal::DecayArray<T4>::type,
> - typename internal::DecayArray<T5>::type,
> - typename internal::DecayArray<T6>::type,
> - typename internal::DecayArray<T7>::type,
> - typename internal::DecayArray<T8>::type,
> - typename internal::DecayArray<T9>::type,
> - typename internal::DecayArray<T10>::type> Args;
> - return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4,
> e5,
> - e6, e7, e8, e9, e10));
> -}
> -
> -// AllOf(m1, m2, ..., mk) matches any value that matches all of the given
> -// sub-matchers. AllOf is called fully qualified to prevent ADL from
> firing.
> -
> -template <typename M1, typename M2>
> -inline typename internal::AllOfResult2<M1, M2>::type
> -AllOf(M1 m1, M2 m2) {
> - return typename internal::AllOfResult2<M1, M2>::type(
> - m1,
> - m2);
> -}
> -
> -template <typename M1, typename M2, typename M3>
> -inline typename internal::AllOfResult3<M1, M2, M3>::type
> -AllOf(M1 m1, M2 m2, M3 m3) {
> - return typename internal::AllOfResult3<M1, M2, M3>::type(
> - m1,
> - ::testing::AllOf(m2, m3));
> -}
> -
> -template <typename M1, typename M2, typename M3, typename M4>
> -inline typename internal::AllOfResult4<M1, M2, M3, M4>::type
> -AllOf(M1 m1, M2 m2, M3 m3, M4 m4) {
> - return typename internal::AllOfResult4<M1, M2, M3, M4>::type(
> - ::testing::AllOf(m1, m2),
> - ::testing::AllOf(m3, m4));
> -}
> -
> -template <typename M1, typename M2, typename M3, typename M4, typename M5>
> -inline typename internal::AllOfResult5<M1, M2, M3, M4, M5>::type
> -AllOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5) {
> - return typename internal::AllOfResult5<M1, M2, M3, M4, M5>::type(
> - ::testing::AllOf(m1, m2),
> - ::testing::AllOf(m3, m4, m5));
> -}
> -
> -template <typename M1, typename M2, typename M3, typename M4, typename M5,
> - typename M6>
> -inline typename internal::AllOfResult6<M1, M2, M3, M4, M5, M6>::type
> -AllOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6) {
> - return typename internal::AllOfResult6<M1, M2, M3, M4, M5, M6>::type(
> - ::testing::AllOf(m1, m2, m3),
> - ::testing::AllOf(m4, m5, m6));
> -}
> -
> -template <typename M1, typename M2, typename M3, typename M4, typename M5,
> - typename M6, typename M7>
> -inline typename internal::AllOfResult7<M1, M2, M3, M4, M5, M6, M7>::type
> -AllOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7) {
> - return typename internal::AllOfResult7<M1, M2, M3, M4, M5, M6,
> M7>::type(
> - ::testing::AllOf(m1, m2, m3),
> - ::testing::AllOf(m4, m5, m6, m7));
> -}
> -
> -template <typename M1, typename M2, typename M3, typename M4, typename M5,
> - typename M6, typename M7, typename M8>
> -inline typename internal::AllOfResult8<M1, M2, M3, M4, M5, M6, M7,
> M8>::type
> -AllOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8) {
> - return typename internal::AllOfResult8<M1, M2, M3, M4, M5, M6, M7,
> M8>::type(
> - ::testing::AllOf(m1, m2, m3, m4),
> - ::testing::AllOf(m5, m6, m7, m8));
> -}
> -
> -template <typename M1, typename M2, typename M3, typename M4, typename M5,
> - typename M6, typename M7, typename M8, typename M9>
> -inline typename internal::AllOfResult9<M1, M2, M3, M4, M5, M6, M7, M8,
> M9>::type
> -AllOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8, M9 m9) {
> - return typename internal::AllOfResult9<M1, M2, M3, M4, M5, M6, M7, M8,
> - M9>::type(
> - ::testing::AllOf(m1, m2, m3, m4),
> - ::testing::AllOf(m5, m6, m7, m8, m9));
> -}
> -
> -template <typename M1, typename M2, typename M3, typename M4, typename M5,
> - typename M6, typename M7, typename M8, typename M9, typename M10>
> -inline typename internal::AllOfResult10<M1, M2, M3, M4, M5, M6, M7, M8,
> M9,
> - M10>::type
> -AllOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8, M9 m9, M10
> m10) {
> - return typename internal::AllOfResult10<M1, M2, M3, M4, M5, M6, M7, M8,
> M9,
> - M10>::type(
> - ::testing::AllOf(m1, m2, m3, m4, m5),
> - ::testing::AllOf(m6, m7, m8, m9, m10));
> -}
> -
> -// AnyOf(m1, m2, ..., mk) matches any value that matches any of the given
> -// sub-matchers. AnyOf is called fully qualified to prevent ADL from
> firing.
> -
> -template <typename M1, typename M2>
> -inline typename internal::AnyOfResult2<M1, M2>::type
> -AnyOf(M1 m1, M2 m2) {
> - return typename internal::AnyOfResult2<M1, M2>::type(
> - m1,
> - m2);
> -}
> -
> -template <typename M1, typename M2, typename M3>
> -inline typename internal::AnyOfResult3<M1, M2, M3>::type
> -AnyOf(M1 m1, M2 m2, M3 m3) {
> - return typename internal::AnyOfResult3<M1, M2, M3>::type(
> - m1,
> - ::testing::AnyOf(m2, m3));
> -}
> -
> -template <typename M1, typename M2, typename M3, typename M4>
> -inline typename internal::AnyOfResult4<M1, M2, M3, M4>::type
> -AnyOf(M1 m1, M2 m2, M3 m3, M4 m4) {
> - return typename internal::AnyOfResult4<M1, M2, M3, M4>::type(
> - ::testing::AnyOf(m1, m2),
> - ::testing::AnyOf(m3, m4));
> -}
> -
> -template <typename M1, typename M2, typename M3, typename M4, typename M5>
> -inline typename internal::AnyOfResult5<M1, M2, M3, M4, M5>::type
> -AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5) {
> - return typename internal::AnyOfResult5<M1, M2, M3, M4, M5>::type(
> - ::testing::AnyOf(m1, m2),
> - ::testing::AnyOf(m3, m4, m5));
> -}
> -
> -template <typename M1, typename M2, typename M3, typename M4, typename M5,
> - typename M6>
> -inline typename internal::AnyOfResult6<M1, M2, M3, M4, M5, M6>::type
> -AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6) {
> - return typename internal::AnyOfResult6<M1, M2, M3, M4, M5, M6>::type(
> - ::testing::AnyOf(m1, m2, m3),
> - ::testing::AnyOf(m4, m5, m6));
> -}
> -
> -template <typename M1, typename M2, typename M3, typename M4, typename M5,
> - typename M6, typename M7>
> -inline typename internal::AnyOfResult7<M1, M2, M3, M4, M5, M6, M7>::type
> -AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7) {
> - return typename internal::AnyOfResult7<M1, M2, M3, M4, M5, M6,
> M7>::type(
> - ::testing::AnyOf(m1, m2, m3),
> - ::testing::AnyOf(m4, m5, m6, m7));
> -}
> -
> -template <typename M1, typename M2, typename M3, typename M4, typename M5,
> - typename M6, typename M7, typename M8>
> -inline typename internal::AnyOfResult8<M1, M2, M3, M4, M5, M6, M7,
> M8>::type
> -AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8) {
> - return typename internal::AnyOfResult8<M1, M2, M3, M4, M5, M6, M7,
> M8>::type(
> - ::testing::AnyOf(m1, m2, m3, m4),
> - ::testing::AnyOf(m5, m6, m7, m8));
> -}
> -
> -template <typename M1, typename M2, typename M3, typename M4, typename M5,
> - typename M6, typename M7, typename M8, typename M9>
> -inline typename internal::AnyOfResult9<M1, M2, M3, M4, M5, M6, M7, M8,
> M9>::type
> -AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8, M9 m9) {
> - return typename internal::AnyOfResult9<M1, M2, M3, M4, M5, M6, M7, M8,
> - M9>::type(
> - ::testing::AnyOf(m1, m2, m3, m4),
> - ::testing::AnyOf(m5, m6, m7, m8, m9));
> -}
> -
> -template <typename M1, typename M2, typename M3, typename M4, typename M5,
> - typename M6, typename M7, typename M8, typename M9, typename M10>
> -inline typename internal::AnyOfResult10<M1, M2, M3, M4, M5, M6, M7, M8,
> M9,
> - M10>::type
> -AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8, M9 m9, M10
> m10) {
> - return typename internal::AnyOfResult10<M1, M2, M3, M4, M5, M6, M7, M8,
> M9,
> - M10>::type(
> - ::testing::AnyOf(m1, m2, m3, m4, m5),
> - ::testing::AnyOf(m6, m7, m8, m9, m10));
> -}
> -
> -} // namespace testing
> -
> -
> // The MATCHER* family of macros can be used in a namespace scope to
> // define custom matchers easily.
> //
> @@ -1373,18 +252,15 @@ AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7
> m7, M8 m8, M9 m9, M10 m10) {
> // overloading matchers based on parameter types (as opposed to just
> // based on the number of parameters).
> //
> -// MATCHER*() can only be used in a namespace scope. The reason is
> -// that C++ doesn't yet allow function-local types to be used to
> -// instantiate templates. The up-coming C++0x standard will fix this.
> -// Once that's done, we'll consider supporting using MATCHER*() inside
> -// a function.
> +// MATCHER*() can only be used in a namespace scope as templates cannot be
> +// declared inside of a local class.
> //
> // More Information
> // ================
> //
> // To learn more about using these macros, please search for 'MATCHER'
> // on
> -//
> https://github.com/google/googletest/blob/master/googlemock/docs/CookBook.md
> +//
> https://github.com/google/googletest/blob/master/googlemock/docs/cook_book.md
>
> #define MATCHER(name, description)\
> class name##Matcher {\
> @@ -1407,12 +283,13 @@ AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7
> m7, M8 m8, M9 m9, M10 m10) {
> private:\
> ::std::string FormatDescription(bool negation) const {\
> ::std::string gmock_description = (description);\
> - if (!gmock_description.empty())\
> + if (!gmock_description.empty()) {\
> return gmock_description;\
> + }\
> return ::testing::internal::FormatMatcherDescription(\
> negation, #name, \
> ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
> - ::testing::tuple<>()));\
> + ::std::tuple<>()));\
> }\
> };\
> template <typename arg_type>\
> @@ -1442,7 +319,7 @@ AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7
> m7, M8 m8, M9 m9, M10 m10) {
> GTEST_REFERENCE_TO_CONST_(arg_type)> {\
> public:\
> explicit gmock_Impl(p0##_type gmock_p0)\
> - : p0(::testing::internal::move(gmock_p0)) {}\
> + : p0(::std::move(gmock_p0)) {}\
> virtual bool MatchAndExplain(\
> GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
> ::testing::MatchResultListener* result_listener) const;\
> @@ -1456,12 +333,13 @@ AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7
> m7, M8 m8, M9 m9, M10 m10) {
> private:\
> ::std::string FormatDescription(bool negation) const {\
> ::std::string gmock_description = (description);\
> - if (!gmock_description.empty())\
> + if (!gmock_description.empty()) {\
> return gmock_description;\
> + }\
> return ::testing::internal::FormatMatcherDescription(\
> negation, #name, \
> ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
> - ::testing::tuple<p0##_type>(p0)));\
> + ::std::tuple<p0##_type>(p0)));\
> }\
> };\
> template <typename arg_type>\
> @@ -1469,8 +347,7 @@ AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7
> m7, M8 m8, M9 m9, M10 m10) {
> return ::testing::Matcher<arg_type>(\
> new gmock_Impl<arg_type>(p0));\
> }\
> - explicit name##MatcherP(p0##_type gmock_p0) : \
> - p0(::testing::internal::move(gmock_p0)) {\
> + explicit name##MatcherP(p0##_type gmock_p0) :
> p0(::std::move(gmock_p0)) {\
> }\
> p0##_type const p0;\
> private:\
> @@ -1495,8 +372,7 @@ AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7
> m7, M8 m8, M9 m9, M10 m10) {
> GTEST_REFERENCE_TO_CONST_(arg_type)> {\
> public:\
> gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1)\
> - : p0(::testing::internal::move(gmock_p0)), \
> - p1(::testing::internal::move(gmock_p1)) {}\
> + : p0(::std::move(gmock_p0)), p1(::std::move(gmock_p1)) {}\
> virtual bool MatchAndExplain(\
> GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
> ::testing::MatchResultListener* result_listener) const;\
> @@ -1511,12 +387,13 @@ AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7
> m7, M8 m8, M9 m9, M10 m10) {
> private:\
> ::std::string FormatDescription(bool negation) const {\
> ::std::string gmock_description = (description);\
> - if (!gmock_description.empty())\
> + if (!gmock_description.empty()) {\
> return gmock_description;\
> + }\
> return ::testing::internal::FormatMatcherDescription(\
> negation, #name, \
> ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
> - ::testing::tuple<p0##_type, p1##_type>(p0, p1)));\
> + ::std::tuple<p0##_type, p1##_type>(p0, p1)));\
> }\
> };\
> template <typename arg_type>\
> @@ -1525,8 +402,8 @@ AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7
> m7, M8 m8, M9 m9, M10 m10) {
> new gmock_Impl<arg_type>(p0, p1));\
> }\
> name##MatcherP2(p0##_type gmock_p0, \
> - p1##_type gmock_p1) : p0(::testing::internal::move(gmock_p0)), \
> - p1(::testing::internal::move(gmock_p1)) {\
> + p1##_type gmock_p1) : p0(::std::move(gmock_p0)), \
> + p1(::std::move(gmock_p1)) {\
> }\
> p0##_type const p0;\
> p1##_type const p1;\
> @@ -1554,9 +431,8 @@ AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7
> m7, M8 m8, M9 m9, M10 m10) {
> GTEST_REFERENCE_TO_CONST_(arg_type)> {\
> public:\
> gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type
> gmock_p2)\
> - : p0(::testing::internal::move(gmock_p0)), \
> - p1(::testing::internal::move(gmock_p1)), \
> - p2(::testing::internal::move(gmock_p2)) {}\
> + : p0(::std::move(gmock_p0)), p1(::std::move(gmock_p1)), \
> + p2(::std::move(gmock_p2)) {}\
> virtual bool MatchAndExplain(\
> GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
> ::testing::MatchResultListener* result_listener) const;\
> @@ -1572,13 +448,13 @@ AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7
> m7, M8 m8, M9 m9, M10 m10) {
> private:\
> ::std::string FormatDescription(bool negation) const {\
> ::std::string gmock_description = (description);\
> - if (!gmock_description.empty())\
> + if (!gmock_description.empty()) {\
> return gmock_description;\
> + }\
> return ::testing::internal::FormatMatcherDescription(\
> negation, #name, \
> ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
> - ::testing::tuple<p0##_type, p1##_type, p2##_type>(p0, p1,
> \
> - p2)));\
> + ::std::tuple<p0##_type, p1##_type, p2##_type>(p0, p1,
> p2)));\
> }\
> };\
> template <typename arg_type>\
> @@ -1587,9 +463,8 @@ AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7
> m7, M8 m8, M9 m9, M10 m10) {
> new gmock_Impl<arg_type>(p0, p1, p2));\
> }\
> name##MatcherP3(p0##_type gmock_p0, p1##_type gmock_p1, \
> - p2##_type gmock_p2) : p0(::testing::internal::move(gmock_p0)), \
> - p1(::testing::internal::move(gmock_p1)), \
> - p2(::testing::internal::move(gmock_p2)) {\
> + p2##_type gmock_p2) : p0(::std::move(gmock_p0)), \
> + p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)) {\
> }\
> p0##_type const p0;\
> p1##_type const p1;\
> @@ -1620,10 +495,8 @@ AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7
> m7, M8 m8, M9 m9, M10 m10) {
> public:\
> gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type
> gmock_p2, \
> p3##_type gmock_p3)\
> - : p0(::testing::internal::move(gmock_p0)), \
> - p1(::testing::internal::move(gmock_p1)), \
> - p2(::testing::internal::move(gmock_p2)), \
> - p3(::testing::internal::move(gmock_p3)) {}\
> + : p0(::std::move(gmock_p0)), p1(::std::move(gmock_p1)), \
> + p2(::std::move(gmock_p2)), p3(::std::move(gmock_p3)) {}\
> virtual bool MatchAndExplain(\
> GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
> ::testing::MatchResultListener* result_listener) const;\
> @@ -1640,13 +513,14 @@ AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7
> m7, M8 m8, M9 m9, M10 m10) {
> private:\
> ::std::string FormatDescription(bool negation) const {\
> ::std::string gmock_description = (description);\
> - if (!gmock_description.empty())\
> + if (!gmock_description.empty()) {\
> return gmock_description;\
> + }\
> return ::testing::internal::FormatMatcherDescription(\
> negation, #name, \
> ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
> - ::testing::tuple<p0##_type, p1##_type, p2##_type, \
> - p3##_type>(p0, p1, p2, p3)));\
> + ::std::tuple<p0##_type, p1##_type, p2##_type,
> p3##_type>(p0, \
> + p1, p2, p3)));\
> }\
> };\
> template <typename arg_type>\
> @@ -1655,11 +529,9 @@ AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7
> m7, M8 m8, M9 m9, M10 m10) {
> new gmock_Impl<arg_type>(p0, p1, p2, p3));\
> }\
> name##MatcherP4(p0##_type gmock_p0, p1##_type gmock_p1, \
> - p2##_type gmock_p2, \
> - p3##_type gmock_p3) : p0(::testing::internal::move(gmock_p0)), \
> - p1(::testing::internal::move(gmock_p1)), \
> - p2(::testing::internal::move(gmock_p2)), \
> - p3(::testing::internal::move(gmock_p3)) {\
> + p2##_type gmock_p2, p3##_type gmock_p3) :
> p0(::std::move(gmock_p0)), \
> + p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \
> + p3(::std::move(gmock_p3)) {\
> }\
> p0##_type const p0;\
> p1##_type const p1;\
> @@ -1695,11 +567,9 @@ AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7
> m7, M8 m8, M9 m9, M10 m10) {
> public:\
> gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type
> gmock_p2, \
> p3##_type gmock_p3, p4##_type gmock_p4)\
> - : p0(::testing::internal::move(gmock_p0)), \
> - p1(::testing::internal::move(gmock_p1)), \
> - p2(::testing::internal::move(gmock_p2)), \
> - p3(::testing::internal::move(gmock_p3)), \
> - p4(::testing::internal::move(gmock_p4)) {}\
> + : p0(::std::move(gmock_p0)), p1(::std::move(gmock_p1)), \
> + p2(::std::move(gmock_p2)), p3(::std::move(gmock_p3)), \
> + p4(::std::move(gmock_p4)) {}\
> virtual bool MatchAndExplain(\
> GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
> ::testing::MatchResultListener* result_listener) const;\
> @@ -1717,12 +587,13 @@ AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7
> m7, M8 m8, M9 m9, M10 m10) {
> private:\
> ::std::string FormatDescription(bool negation) const {\
> ::std::string gmock_description = (description);\
> - if (!gmock_description.empty())\
> + if (!gmock_description.empty()) {\
> return gmock_description;\
> + }\
> return ::testing::internal::FormatMatcherDescription(\
> negation, #name, \
> ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
> - ::testing::tuple<p0##_type, p1##_type, p2##_type,
> p3##_type, \
> + ::std::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \
> p4##_type>(p0, p1, p2, p3, p4)));\
> }\
> };\
> @@ -1733,11 +604,9 @@ AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7
> m7, M8 m8, M9 m9, M10 m10) {
> }\
> name##MatcherP5(p0##_type gmock_p0, p1##_type gmock_p1, \
> p2##_type gmock_p2, p3##_type gmock_p3, \
> - p4##_type gmock_p4) : p0(::testing::internal::move(gmock_p0)), \
> - p1(::testing::internal::move(gmock_p1)), \
> - p2(::testing::internal::move(gmock_p2)), \
> - p3(::testing::internal::move(gmock_p3)), \
> - p4(::testing::internal::move(gmock_p4)) {\
> + p4##_type gmock_p4) : p0(::std::move(gmock_p0)), \
> + p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \
> + p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)) {\
> }\
> p0##_type const p0;\
> p1##_type const p1;\
> @@ -1774,12 +643,9 @@ AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7
> m7, M8 m8, M9 m9, M10 m10) {
> public:\
> gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type
> gmock_p2, \
> p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5)\
> - : p0(::testing::internal::move(gmock_p0)), \
> - p1(::testing::internal::move(gmock_p1)), \
> - p2(::testing::internal::move(gmock_p2)), \
> - p3(::testing::internal::move(gmock_p3)), \
> - p4(::testing::internal::move(gmock_p4)), \
> - p5(::testing::internal::move(gmock_p5)) {}\
> + : p0(::std::move(gmock_p0)), p1(::std::move(gmock_p1)), \
> + p2(::std::move(gmock_p2)), p3(::std::move(gmock_p3)), \
> + p4(::std::move(gmock_p4)), p5(::std::move(gmock_p5)) {}\
> virtual bool MatchAndExplain(\
> GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
> ::testing::MatchResultListener* result_listener) const;\
> @@ -1798,12 +664,13 @@ AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7
> m7, M8 m8, M9 m9, M10 m10) {
> private:\
> ::std::string FormatDescription(bool negation) const {\
> ::std::string gmock_description = (description);\
> - if (!gmock_description.empty())\
> + if (!gmock_description.empty()) {\
> return gmock_description;\
> + }\
> return ::testing::internal::FormatMatcherDescription(\
> negation, #name, \
> ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
> - ::testing::tuple<p0##_type, p1##_type, p2##_type,
> p3##_type, \
> + ::std::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \
> p4##_type, p5##_type>(p0, p1, p2, p3, p4, p5)));\
> }\
> };\
> @@ -1814,12 +681,10 @@ AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7
> m7, M8 m8, M9 m9, M10 m10) {
> }\
> name##MatcherP6(p0##_type gmock_p0, p1##_type gmock_p1, \
> p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
> - p5##_type gmock_p5) : p0(::testing::internal::move(gmock_p0)), \
> - p1(::testing::internal::move(gmock_p1)), \
> - p2(::testing::internal::move(gmock_p2)), \
> - p3(::testing::internal::move(gmock_p3)), \
> - p4(::testing::internal::move(gmock_p4)), \
> - p5(::testing::internal::move(gmock_p5)) {\
> + p5##_type gmock_p5) : p0(::std::move(gmock_p0)), \
> + p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \
> + p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \
> + p5(::std::move(gmock_p5)) {\
> }\
> p0##_type const p0;\
> p1##_type const p1;\
> @@ -1859,13 +724,10 @@ AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7
> m7, M8 m8, M9 m9, M10 m10) {
> gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type
> gmock_p2, \
> p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
> p6##_type gmock_p6)\
> - : p0(::testing::internal::move(gmock_p0)), \
> - p1(::testing::internal::move(gmock_p1)), \
> - p2(::testing::internal::move(gmock_p2)), \
> - p3(::testing::internal::move(gmock_p3)), \
> - p4(::testing::internal::move(gmock_p4)), \
> - p5(::testing::internal::move(gmock_p5)), \
> - p6(::testing::internal::move(gmock_p6)) {}\
> + : p0(::std::move(gmock_p0)), p1(::std::move(gmock_p1)), \
> + p2(::std::move(gmock_p2)), p3(::std::move(gmock_p3)), \
> + p4(::std::move(gmock_p4)), p5(::std::move(gmock_p5)), \
> + p6(::std::move(gmock_p6)) {}\
> virtual bool MatchAndExplain(\
> GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
> ::testing::MatchResultListener* result_listener) const;\
> @@ -1885,12 +747,13 @@ AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7
> m7, M8 m8, M9 m9, M10 m10) {
> private:\
> ::std::string FormatDescription(bool negation) const {\
> ::std::string gmock_description = (description);\
> - if (!gmock_description.empty())\
> + if (!gmock_description.empty()) {\
> return gmock_description;\
> + }\
> return ::testing::internal::FormatMatcherDescription(\
> negation, #name, \
> ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
> - ::testing::tuple<p0##_type, p1##_type, p2##_type,
> p3##_type, \
> + ::std::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \
> p4##_type, p5##_type, p6##_type>(p0, p1, p2, p3, p4,
> p5, \
> p6)));\
> }\
> @@ -1902,14 +765,10 @@ AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7
> m7, M8 m8, M9 m9, M10 m10) {
> }\
> name##MatcherP7(p0##_type gmock_p0, p1##_type gmock_p1, \
> p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
> - p5##_type gmock_p5, \
> - p6##_type gmock_p6) : p0(::testing::internal::move(gmock_p0)), \
> - p1(::testing::internal::move(gmock_p1)), \
> - p2(::testing::internal::move(gmock_p2)), \
> - p3(::testing::internal::move(gmock_p3)), \
> - p4(::testing::internal::move(gmock_p4)), \
> - p5(::testing::internal::move(gmock_p5)), \
> - p6(::testing::internal::move(gmock_p6)) {\
> + p5##_type gmock_p5, p6##_type gmock_p6) :
> p0(::std::move(gmock_p0)), \
> + p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \
> + p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \
> + p5(::std::move(gmock_p5)), p6(::std::move(gmock_p6)) {\
> }\
> p0##_type const p0;\
> p1##_type const p1;\
> @@ -1953,14 +812,10 @@ AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7
> m7, M8 m8, M9 m9, M10 m10) {
> gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type
> gmock_p2, \
> p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
> p6##_type gmock_p6, p7##_type gmock_p7)\
> - : p0(::testing::internal::move(gmock_p0)), \
> - p1(::testing::internal::move(gmock_p1)), \
> - p2(::testing::internal::move(gmock_p2)), \
> - p3(::testing::internal::move(gmock_p3)), \
> - p4(::testing::internal::move(gmock_p4)), \
> - p5(::testing::internal::move(gmock_p5)), \
> - p6(::testing::internal::move(gmock_p6)), \
> - p7(::testing::internal::move(gmock_p7)) {}\
> + : p0(::std::move(gmock_p0)), p1(::std::move(gmock_p1)), \
> + p2(::std::move(gmock_p2)), p3(::std::move(gmock_p3)), \
> + p4(::std::move(gmock_p4)), p5(::std::move(gmock_p5)), \
> + p6(::std::move(gmock_p6)), p7(::std::move(gmock_p7)) {}\
> virtual bool MatchAndExplain(\
> GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
> ::testing::MatchResultListener* result_listener) const;\
> @@ -1981,12 +836,13 @@ AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7
> m7, M8 m8, M9 m9, M10 m10) {
> private:\
> ::std::string FormatDescription(bool negation) const {\
> ::std::string gmock_description = (description);\
> - if (!gmock_description.empty())\
> + if (!gmock_description.empty()) {\
> return gmock_description;\
> + }\
> return ::testing::internal::FormatMatcherDescription(\
> negation, #name, \
> ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
> - ::testing::tuple<p0##_type, p1##_type, p2##_type,
> p3##_type, \
> + ::std::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \
> p4##_type, p5##_type, p6##_type, p7##_type>(p0, p1,
> p2, \
> p3, p4, p5, p6, p7)));\
> }\
> @@ -1999,14 +855,11 @@ AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7
> m7, M8 m8, M9 m9, M10 m10) {
> name##MatcherP8(p0##_type gmock_p0, p1##_type gmock_p1, \
> p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
> p5##_type gmock_p5, p6##_type gmock_p6, \
> - p7##_type gmock_p7) : p0(::testing::internal::move(gmock_p0)), \
> - p1(::testing::internal::move(gmock_p1)), \
> - p2(::testing::internal::move(gmock_p2)), \
> - p3(::testing::internal::move(gmock_p3)), \
> - p4(::testing::internal::move(gmock_p4)), \
> - p5(::testing::internal::move(gmock_p5)), \
> - p6(::testing::internal::move(gmock_p6)), \
> - p7(::testing::internal::move(gmock_p7)) {\
> + p7##_type gmock_p7) : p0(::std::move(gmock_p0)), \
> + p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \
> + p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \
> + p5(::std::move(gmock_p5)), p6(::std::move(gmock_p6)), \
> + p7(::std::move(gmock_p7)) {\
> }\
> p0##_type const p0;\
> p1##_type const p1;\
> @@ -2053,15 +906,11 @@ AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7
> m7, M8 m8, M9 m9, M10 m10) {
> gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type
> gmock_p2, \
> p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
> p6##_type gmock_p6, p7##_type gmock_p7, p8##_type gmock_p8)\
> - : p0(::testing::internal::move(gmock_p0)), \
> - p1(::testing::internal::move(gmock_p1)), \
> - p2(::testing::internal::move(gmock_p2)), \
> - p3(::testing::internal::move(gmock_p3)), \
> - p4(::testing::internal::move(gmock_p4)), \
> - p5(::testing::internal::move(gmock_p5)), \
> - p6(::testing::internal::move(gmock_p6)), \
> - p7(::testing::internal::move(gmock_p7)), \
> - p8(::testing::internal::move(gmock_p8)) {}\
> + : p0(::std::move(gmock_p0)), p1(::std::move(gmock_p1)), \
> + p2(::std::move(gmock_p2)), p3(::std::move(gmock_p3)), \
> + p4(::std::move(gmock_p4)), p5(::std::move(gmock_p5)), \
> + p6(::std::move(gmock_p6)), p7(::std::move(gmock_p7)), \
> + p8(::std::move(gmock_p8)) {}\
> virtual bool MatchAndExplain(\
> GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
> ::testing::MatchResultListener* result_listener) const;\
> @@ -2083,12 +932,13 @@ AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7
> m7, M8 m8, M9 m9, M10 m10) {
> private:\
> ::std::string FormatDescription(bool negation) const {\
> ::std::string gmock_description = (description);\
> - if (!gmock_description.empty())\
> + if (!gmock_description.empty()) {\
> return gmock_description;\
> + }\
> return ::testing::internal::FormatMatcherDescription(\
> negation, #name, \
> ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
> - ::testing::tuple<p0##_type, p1##_type, p2##_type,
> p3##_type, \
> + ::std::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \
> p4##_type, p5##_type, p6##_type, p7##_type, \
> p8##_type>(p0, p1, p2, p3, p4, p5, p6, p7, p8)));\
> }\
> @@ -2101,15 +951,11 @@ AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7
> m7, M8 m8, M9 m9, M10 m10) {
> name##MatcherP9(p0##_type gmock_p0, p1##_type gmock_p1, \
> p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
> p5##_type gmock_p5, p6##_type gmock_p6, p7##_type gmock_p7, \
> - p8##_type gmock_p8) : p0(::testing::internal::move(gmock_p0)), \
> - p1(::testing::internal::move(gmock_p1)), \
> - p2(::testing::internal::move(gmock_p2)), \
> - p3(::testing::internal::move(gmock_p3)), \
> - p4(::testing::internal::move(gmock_p4)), \
> - p5(::testing::internal::move(gmock_p5)), \
> - p6(::testing::internal::move(gmock_p6)), \
> - p7(::testing::internal::move(gmock_p7)), \
> - p8(::testing::internal::move(gmock_p8)) {\
> + p8##_type gmock_p8) : p0(::std::move(gmock_p0)), \
> + p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \
> + p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \
> + p5(::std::move(gmock_p5)), p6(::std::move(gmock_p6)), \
> + p7(::std::move(gmock_p7)), p8(::std::move(gmock_p8)) {\
> }\
> p0##_type const p0;\
> p1##_type const p1;\
> @@ -2160,16 +1006,11 @@ AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7
> m7, M8 m8, M9 m9, M10 m10) {
> p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
> p6##_type gmock_p6, p7##_type gmock_p7, p8##_type gmock_p8, \
> p9##_type gmock_p9)\
> - : p0(::testing::internal::move(gmock_p0)), \
> - p1(::testing::internal::move(gmock_p1)), \
> - p2(::testing::internal::move(gmock_p2)), \
> - p3(::testing::internal::move(gmock_p3)), \
> - p4(::testing::internal::move(gmock_p4)), \
> - p5(::testing::internal::move(gmock_p5)), \
> - p6(::testing::internal::move(gmock_p6)), \
> - p7(::testing::internal::move(gmock_p7)), \
> - p8(::testing::internal::move(gmock_p8)), \
> - p9(::testing::internal::move(gmock_p9)) {}\
> + : p0(::std::move(gmock_p0)), p1(::std::move(gmock_p1)), \
> + p2(::std::move(gmock_p2)), p3(::std::move(gmock_p3)), \
> + p4(::std::move(gmock_p4)), p5(::std::move(gmock_p5)), \
> + p6(::std::move(gmock_p6)), p7(::std::move(gmock_p7)), \
> + p8(::std::move(gmock_p8)), p9(::std::move(gmock_p9)) {}\
> virtual bool MatchAndExplain(\
> GTEST_REFERENCE_TO_CONST_(arg_type) arg,\
> ::testing::MatchResultListener* result_listener) const;\
> @@ -2192,12 +1033,13 @@ AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7
> m7, M8 m8, M9 m9, M10 m10) {
> private:\
> ::std::string FormatDescription(bool negation) const {\
> ::std::string gmock_description = (description);\
> - if (!gmock_description.empty())\
> + if (!gmock_description.empty()) {\
> return gmock_description;\
> + }\
> return ::testing::internal::FormatMatcherDescription(\
> negation, #name, \
> ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
> - ::testing::tuple<p0##_type, p1##_type, p2##_type,
> p3##_type, \
> + ::std::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \
> p4##_type, p5##_type, p6##_type, p7##_type,
> p8##_type, \
> p9##_type>(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)));\
> }\
> @@ -2210,17 +1052,12 @@ AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7
> m7, M8 m8, M9 m9, M10 m10) {
> name##MatcherP10(p0##_type gmock_p0, p1##_type gmock_p1, \
> p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
> p5##_type gmock_p5, p6##_type gmock_p6, p7##_type gmock_p7, \
> - p8##_type gmock_p8, \
> - p9##_type gmock_p9) : p0(::testing::internal::move(gmock_p0)), \
> - p1(::testing::internal::move(gmock_p1)), \
> - p2(::testing::internal::move(gmock_p2)), \
> - p3(::testing::internal::move(gmock_p3)), \
> - p4(::testing::internal::move(gmock_p4)), \
> - p5(::testing::internal::move(gmock_p5)), \
> - p6(::testing::internal::move(gmock_p6)), \
> - p7(::testing::internal::move(gmock_p7)), \
> - p8(::testing::internal::move(gmock_p8)), \
> - p9(::testing::internal::move(gmock_p9)) {\
> + p8##_type gmock_p8, p9##_type gmock_p9) :
> p0(::std::move(gmock_p0)), \
> + p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \
> + p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \
> + p5(::std::move(gmock_p5)), p6(::std::move(gmock_p6)), \
> + p7(::std::move(gmock_p7)), p8(::std::move(gmock_p8)), \
> + p9(::std::move(gmock_p9)) {\
> }\
> p0##_type const p0;\
> p1##_type const p1;\
>
> diff --git
> a/llvm/utils/unittest/googlemock/include/gmock/gmock-generated-nice-strict.h
> b/llvm/utils/unittest/googlemock/include/gmock/gmock-generated-nice-strict.h
> deleted file mode 100644
> index fe3ee69cef925..0000000000000
> ---
> a/llvm/utils/unittest/googlemock/include/gmock/gmock-generated-nice-strict.h
> +++ /dev/null
> @@ -1,461 +0,0 @@
> -// This file was GENERATED by command:
> -// pump.py gmock-generated-nice-strict.h.pump
> -// DO NOT EDIT BY HAND!!!
> -
> -// Copyright 2008, Google Inc.
> -// All rights reserved.
> -//
> -// Redistribution and use in source and binary forms, with or without
> -// modification, are permitted provided that the following conditions are
> -// met:
> -//
> -// * Redistributions of source code must retain the above copyright
> -// notice, this list of conditions and the following disclaimer.
> -// * Redistributions in binary form must reproduce the above
> -// copyright notice, this list of conditions and the following disclaimer
> -// in the documentation and/or other materials provided with the
> -// distribution.
> -// * Neither the name of Google Inc. nor the names of its
> -// contributors may be used to endorse or promote products derived from
> -// this software without specific prior written permission.
> -//
> -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
> -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
> -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
> -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
> -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
> -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
> -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
> -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
> -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
> -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
> -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
> -
> -
> -// Implements class templates NiceMock, NaggyMock, and StrictMock.
> -//
> -// Given a mock class MockFoo that is created using Google Mock,
> -// NiceMock<MockFoo> is a subclass of MockFoo that allows
> -// uninteresting calls (i.e. calls to mock methods that have no
> -// EXPECT_CALL specs), NaggyMock<MockFoo> is a subclass of MockFoo
> -// that prints a warning when an uninteresting call occurs, and
> -// StrictMock<MockFoo> is a subclass of MockFoo that treats all
> -// uninteresting calls as errors.
> -//
> -// Currently a mock is naggy by default, so MockFoo and
> -// NaggyMock<MockFoo> behave like the same. However, we will soon
> -// switch the default behavior of mocks to be nice, as that in general
> -// leads to more maintainable tests. When that happens, MockFoo will
> -// stop behaving like NaggyMock<MockFoo> and start behaving like
> -// NiceMock<MockFoo>.
> -//
> -// NiceMock, NaggyMock, and StrictMock "inherit" the constructors of
> -// their respective base class. Therefore you can write
> -// NiceMock<MockFoo>(5, "a") to construct a nice mock where MockFoo
> -// has a constructor that accepts (int, const char*), for example.
> -//
> -// A known limitation is that NiceMock<MockFoo>, NaggyMock<MockFoo>,
> -// and StrictMock<MockFoo> only works for mock methods defined using
> -// the MOCK_METHOD* family of macros DIRECTLY in the MockFoo class.
> -// If a mock method is defined in a base class of MockFoo, the "nice"
> -// or "strict" modifier may not affect it, depending on the compiler.
> -// In particular, nesting NiceMock, NaggyMock, and StrictMock is NOT
> -// supported.
> -
> -// GOOGLETEST_CM0002 DO NOT DELETE
> -
> -// IWYU pragma: private, include "gmock/gmock.h"
> -
> -#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_NICE_STRICT_H_
> -#define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_NICE_STRICT_H_
> -
> -#include "gmock/gmock-spec-builders.h"
> -#include "gmock/internal/gmock-port.h"
> -
> -namespace testing {
> -
> -template <class MockClass>
> -class NiceMock : public MockClass {
> - public:
> - NiceMock() : MockClass() {
> - ::testing::Mock::AllowUninterestingCalls(
> - internal::ImplicitCast_<MockClass*>(this));
> - }
> -
> -#if GTEST_LANG_CXX11
> - // Ideally, we would inherit base class's constructors through a using
> - // declaration, which would preserve their visibility. However, many
> existing
> - // tests rely on the fact that current implementation reexports
> protected
> - // constructors as public. These tests would need to be cleaned up
> first.
> -
> - // Single argument constructor is special-cased so that it can be
> - // made explicit.
> - template <typename A>
> - explicit NiceMock(A&& arg) : MockClass(std::forward<A>(arg)) {
> - ::testing::Mock::AllowUninterestingCalls(
> - internal::ImplicitCast_<MockClass*>(this));
> - }
> -
> - template <typename A1, typename A2, typename... An>
> - NiceMock(A1&& arg1, A2&& arg2, An&&... args)
> - : MockClass(std::forward<A1>(arg1), std::forward<A2>(arg2),
> - std::forward<An>(args)...) {
> - ::testing::Mock::AllowUninterestingCalls(
> - internal::ImplicitCast_<MockClass*>(this));
> - }
> -#else
> - // C++98 doesn't have variadic templates, so we have to define one
> - // for each arity.
> - template <typename A1>
> - explicit NiceMock(const A1& a1) : MockClass(a1) {
> - ::testing::Mock::AllowUninterestingCalls(
> - internal::ImplicitCast_<MockClass*>(this));
> - }
> - template <typename A1, typename A2>
> - NiceMock(const A1& a1, const A2& a2) : MockClass(a1, a2) {
> - ::testing::Mock::AllowUninterestingCalls(
> - internal::ImplicitCast_<MockClass*>(this));
> - }
> -
> - template <typename A1, typename A2, typename A3>
> - NiceMock(const A1& a1, const A2& a2, const A3& a3) : MockClass(a1, a2,
> a3) {
> - ::testing::Mock::AllowUninterestingCalls(
> - internal::ImplicitCast_<MockClass*>(this));
> - }
> -
> - template <typename A1, typename A2, typename A3, typename A4>
> - NiceMock(const A1& a1, const A2& a2, const A3& a3,
> - const A4& a4) : MockClass(a1, a2, a3, a4) {
> - ::testing::Mock::AllowUninterestingCalls(
> - internal::ImplicitCast_<MockClass*>(this));
> - }
> -
> - template <typename A1, typename A2, typename A3, typename A4, typename
> A5>
> - NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
> - const A5& a5) : MockClass(a1, a2, a3, a4, a5) {
> - ::testing::Mock::AllowUninterestingCalls(
> - internal::ImplicitCast_<MockClass*>(this));
> - }
> -
> - template <typename A1, typename A2, typename A3, typename A4, typename
> A5,
> - typename A6>
> - NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
> - const A5& a5, const A6& a6) : MockClass(a1, a2, a3, a4, a5, a6) {
> - ::testing::Mock::AllowUninterestingCalls(
> - internal::ImplicitCast_<MockClass*>(this));
> - }
> -
> - template <typename A1, typename A2, typename A3, typename A4, typename
> A5,
> - typename A6, typename A7>
> - NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
> - const A5& a5, const A6& a6, const A7& a7) : MockClass(a1, a2, a3,
> a4, a5,
> - a6, a7) {
> - ::testing::Mock::AllowUninterestingCalls(
> - internal::ImplicitCast_<MockClass*>(this));
> - }
> -
> - template <typename A1, typename A2, typename A3, typename A4, typename
> A5,
> - typename A6, typename A7, typename A8>
> - NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
> - const A5& a5, const A6& a6, const A7& a7, const A8& a8) :
> MockClass(a1,
> - a2, a3, a4, a5, a6, a7, a8) {
> - ::testing::Mock::AllowUninterestingCalls(
> - internal::ImplicitCast_<MockClass*>(this));
> - }
> -
> - template <typename A1, typename A2, typename A3, typename A4, typename
> A5,
> - typename A6, typename A7, typename A8, typename A9>
> - NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
> - const A5& a5, const A6& a6, const A7& a7, const A8& a8,
> - const A9& a9) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9) {
> - ::testing::Mock::AllowUninterestingCalls(
> - internal::ImplicitCast_<MockClass*>(this));
> - }
> -
> - template <typename A1, typename A2, typename A3, typename A4, typename
> A5,
> - typename A6, typename A7, typename A8, typename A9, typename A10>
> - NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
> - const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9&
> a9,
> - const A10& a10) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9,
> a10) {
> - ::testing::Mock::AllowUninterestingCalls(
> - internal::ImplicitCast_<MockClass*>(this));
> - }
> -
> -#endif // GTEST_LANG_CXX11
> -
> - ~NiceMock() {
> - ::testing::Mock::UnregisterCallReaction(
> - internal::ImplicitCast_<MockClass*>(this));
> - }
> -
> - private:
> - GTEST_DISALLOW_COPY_AND_ASSIGN_(NiceMock);
> -};
> -
> -template <class MockClass>
> -class NaggyMock : public MockClass {
> - public:
> - NaggyMock() : MockClass() {
> - ::testing::Mock::WarnUninterestingCalls(
> - internal::ImplicitCast_<MockClass*>(this));
> - }
> -
> -#if GTEST_LANG_CXX11
> - // Ideally, we would inherit base class's constructors through a using
> - // declaration, which would preserve their visibility. However, many
> existing
> - // tests rely on the fact that current implementation reexports
> protected
> - // constructors as public. These tests would need to be cleaned up
> first.
> -
> - // Single argument constructor is special-cased so that it can be
> - // made explicit.
> - template <typename A>
> - explicit NaggyMock(A&& arg) : MockClass(std::forward<A>(arg)) {
> - ::testing::Mock::WarnUninterestingCalls(
> - internal::ImplicitCast_<MockClass*>(this));
> - }
> -
> - template <typename A1, typename A2, typename... An>
> - NaggyMock(A1&& arg1, A2&& arg2, An&&... args)
> - : MockClass(std::forward<A1>(arg1), std::forward<A2>(arg2),
> - std::forward<An>(args)...) {
> - ::testing::Mock::WarnUninterestingCalls(
> - internal::ImplicitCast_<MockClass*>(this));
> - }
> -#else
> - // C++98 doesn't have variadic templates, so we have to define one
> - // for each arity.
> - template <typename A1>
> - explicit NaggyMock(const A1& a1) : MockClass(a1) {
> - ::testing::Mock::WarnUninterestingCalls(
> - internal::ImplicitCast_<MockClass*>(this));
> - }
> - template <typename A1, typename A2>
> - NaggyMock(const A1& a1, const A2& a2) : MockClass(a1, a2) {
> - ::testing::Mock::WarnUninterestingCalls(
> - internal::ImplicitCast_<MockClass*>(this));
> - }
> -
> - template <typename A1, typename A2, typename A3>
> - NaggyMock(const A1& a1, const A2& a2, const A3& a3) : MockClass(a1, a2,
> a3) {
> - ::testing::Mock::WarnUninterestingCalls(
> - internal::ImplicitCast_<MockClass*>(this));
> - }
> -
> - template <typename A1, typename A2, typename A3, typename A4>
> - NaggyMock(const A1& a1, const A2& a2, const A3& a3,
> - const A4& a4) : MockClass(a1, a2, a3, a4) {
> - ::testing::Mock::WarnUninterestingCalls(
> - internal::ImplicitCast_<MockClass*>(this));
> - }
> -
> - template <typename A1, typename A2, typename A3, typename A4, typename
> A5>
> - NaggyMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
> - const A5& a5) : MockClass(a1, a2, a3, a4, a5) {
> - ::testing::Mock::WarnUninterestingCalls(
> - internal::ImplicitCast_<MockClass*>(this));
> - }
> -
> - template <typename A1, typename A2, typename A3, typename A4, typename
> A5,
> - typename A6>
> - NaggyMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
> - const A5& a5, const A6& a6) : MockClass(a1, a2, a3, a4, a5, a6) {
> - ::testing::Mock::WarnUninterestingCalls(
> - internal::ImplicitCast_<MockClass*>(this));
> - }
> -
> - template <typename A1, typename A2, typename A3, typename A4, typename
> A5,
> - typename A6, typename A7>
> - NaggyMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
> - const A5& a5, const A6& a6, const A7& a7) : MockClass(a1, a2, a3,
> a4, a5,
> - a6, a7) {
> - ::testing::Mock::WarnUninterestingCalls(
> - internal::ImplicitCast_<MockClass*>(this));
> - }
> -
> - template <typename A1, typename A2, typename A3, typename A4, typename
> A5,
> - typename A6, typename A7, typename A8>
> - NaggyMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
> - const A5& a5, const A6& a6, const A7& a7, const A8& a8) :
> MockClass(a1,
> - a2, a3, a4, a5, a6, a7, a8) {
> - ::testing::Mock::WarnUninterestingCalls(
> - internal::ImplicitCast_<MockClass*>(this));
> - }
> -
> - template <typename A1, typename A2, typename A3, typename A4, typename
> A5,
> - typename A6, typename A7, typename A8, typename A9>
> - NaggyMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
> - const A5& a5, const A6& a6, const A7& a7, const A8& a8,
> - const A9& a9) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9) {
> - ::testing::Mock::WarnUninterestingCalls(
> - internal::ImplicitCast_<MockClass*>(this));
> - }
> -
> - template <typename A1, typename A2, typename A3, typename A4, typename
> A5,
> - typename A6, typename A7, typename A8, typename A9, typename A10>
> - NaggyMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
> - const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9&
> a9,
> - const A10& a10) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9,
> a10) {
> - ::testing::Mock::WarnUninterestingCalls(
> - internal::ImplicitCast_<MockClass*>(this));
> - }
> -
> -#endif // GTEST_LANG_CXX11
> -
> - ~NaggyMock() {
> - ::testing::Mock::UnregisterCallReaction(
> - internal::ImplicitCast_<MockClass*>(this));
> - }
> -
> - private:
> - GTEST_DISALLOW_COPY_AND_ASSIGN_(NaggyMock);
> -};
> -
> -template <class MockClass>
> -class StrictMock : public MockClass {
> - public:
> - StrictMock() : MockClass() {
> - ::testing::Mock::FailUninterestingCalls(
> - internal::ImplicitCast_<MockClass*>(this));
> - }
> -
> -#if GTEST_LANG_CXX11
> - // Ideally, we would inherit base class's constructors through a using
> - // declaration, which would preserve their visibility. However, many
> existing
> - // tests rely on the fact that current implementation reexports
> protected
> - // constructors as public. These tests would need to be cleaned up
> first.
> -
> - // Single argument constructor is special-cased so that it can be
> - // made explicit.
> - template <typename A>
> - explicit StrictMock(A&& arg) : MockClass(std::forward<A>(arg)) {
> - ::testing::Mock::FailUninterestingCalls(
> - internal::ImplicitCast_<MockClass*>(this));
> - }
> -
> - template <typename A1, typename A2, typename... An>
> - StrictMock(A1&& arg1, A2&& arg2, An&&... args)
> - : MockClass(std::forward<A1>(arg1), std::forward<A2>(arg2),
> - std::forward<An>(args)...) {
> - ::testing::Mock::FailUninterestingCalls(
> - internal::ImplicitCast_<MockClass*>(this));
> - }
> -#else
> - // C++98 doesn't have variadic templates, so we have to define one
> - // for each arity.
> - template <typename A1>
> - explicit StrictMock(const A1& a1) : MockClass(a1) {
> - ::testing::Mock::FailUninterestingCalls(
> - internal::ImplicitCast_<MockClass*>(this));
> - }
> - template <typename A1, typename A2>
> - StrictMock(const A1& a1, const A2& a2) : MockClass(a1, a2) {
> - ::testing::Mock::FailUninterestingCalls(
> - internal::ImplicitCast_<MockClass*>(this));
> - }
> -
> - template <typename A1, typename A2, typename A3>
> - StrictMock(const A1& a1, const A2& a2, const A3& a3) : MockClass(a1,
> a2, a3) {
> - ::testing::Mock::FailUninterestingCalls(
> - internal::ImplicitCast_<MockClass*>(this));
> - }
> -
> - template <typename A1, typename A2, typename A3, typename A4>
> - StrictMock(const A1& a1, const A2& a2, const A3& a3,
> - const A4& a4) : MockClass(a1, a2, a3, a4) {
> - ::testing::Mock::FailUninterestingCalls(
> - internal::ImplicitCast_<MockClass*>(this));
> - }
> -
> - template <typename A1, typename A2, typename A3, typename A4, typename
> A5>
> - StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
> - const A5& a5) : MockClass(a1, a2, a3, a4, a5) {
> - ::testing::Mock::FailUninterestingCalls(
> - internal::ImplicitCast_<MockClass*>(this));
> - }
> -
> - template <typename A1, typename A2, typename A3, typename A4, typename
> A5,
> - typename A6>
> - StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
> - const A5& a5, const A6& a6) : MockClass(a1, a2, a3, a4, a5, a6) {
> - ::testing::Mock::FailUninterestingCalls(
> - internal::ImplicitCast_<MockClass*>(this));
> - }
> -
> - template <typename A1, typename A2, typename A3, typename A4, typename
> A5,
> - typename A6, typename A7>
> - StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
> - const A5& a5, const A6& a6, const A7& a7) : MockClass(a1, a2, a3,
> a4, a5,
> - a6, a7) {
> - ::testing::Mock::FailUninterestingCalls(
> - internal::ImplicitCast_<MockClass*>(this));
> - }
> -
> - template <typename A1, typename A2, typename A3, typename A4, typename
> A5,
> - typename A6, typename A7, typename A8>
> - StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
> - const A5& a5, const A6& a6, const A7& a7, const A8& a8) :
> MockClass(a1,
> - a2, a3, a4, a5, a6, a7, a8) {
> - ::testing::Mock::FailUninterestingCalls(
> - internal::ImplicitCast_<MockClass*>(this));
> - }
> -
> - template <typename A1, typename A2, typename A3, typename A4, typename
> A5,
> - typename A6, typename A7, typename A8, typename A9>
> - StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
> - const A5& a5, const A6& a6, const A7& a7, const A8& a8,
> - const A9& a9) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9) {
> - ::testing::Mock::FailUninterestingCalls(
> - internal::ImplicitCast_<MockClass*>(this));
> - }
> -
> - template <typename A1, typename A2, typename A3, typename A4, typename
> A5,
> - typename A6, typename A7, typename A8, typename A9, typename A10>
> - StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
> - const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9&
> a9,
> - const A10& a10) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9,
> a10) {
> - ::testing::Mock::FailUninterestingCalls(
> - internal::ImplicitCast_<MockClass*>(this));
> - }
> -
> -#endif // GTEST_LANG_CXX11
> -
> - ~StrictMock() {
> - ::testing::Mock::UnregisterCallReaction(
> - internal::ImplicitCast_<MockClass*>(this));
> - }
> -
> - private:
> - GTEST_DISALLOW_COPY_AND_ASSIGN_(StrictMock);
> -};
> -
> -// The following specializations catch some (relatively more common)
> -// user errors of nesting nice and strict mocks. They do NOT catch
> -// all possible errors.
> -
> -// These specializations are declared but not defined, as NiceMock,
> -// NaggyMock, and StrictMock cannot be nested.
> -
> -template <typename MockClass>
> -class NiceMock<NiceMock<MockClass> >;
> -template <typename MockClass>
> -class NiceMock<NaggyMock<MockClass> >;
> -template <typename MockClass>
> -class NiceMock<StrictMock<MockClass> >;
> -
> -template <typename MockClass>
> -class NaggyMock<NiceMock<MockClass> >;
> -template <typename MockClass>
> -class NaggyMock<NaggyMock<MockClass> >;
> -template <typename MockClass>
> -class NaggyMock<StrictMock<MockClass> >;
> -
> -template <typename MockClass>
> -class StrictMock<NiceMock<MockClass> >;
> -template <typename MockClass>
> -class StrictMock<NaggyMock<MockClass> >;
> -template <typename MockClass>
> -class StrictMock<StrictMock<MockClass> >;
> -
> -} // namespace testing
> -
> -#endif // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_NICE_STRICT_H_
>
> diff --git
> a/llvm/utils/unittest/googlemock/include/gmock/gmock-matchers.h
> b/llvm/utils/unittest/googlemock/include/gmock/gmock-matchers.h
> index 92a77fc2c11ed..8c604cf14f150 100644
> --- a/llvm/utils/unittest/googlemock/include/gmock/gmock-matchers.h
> +++ b/llvm/utils/unittest/googlemock/include/gmock/gmock-matchers.h
> @@ -33,6 +33,9 @@
> // This file implements some commonly used argument matchers. More
> // matchers can be defined by the user implementing the
> // MatcherInterface<T> interface if necessary.
> +//
> +// See googletest/include/gtest/gtest-matchers.h for the definition of
> class
> +// Matcher, class MatcherInterface, and others.
>
> // GOOGLETEST_CM0002 DO NOT DELETE
>
> @@ -43,21 +46,32 @@
>
> #include <math.h>
> #include <algorithm>
> +#include <initializer_list>
> #include <iterator>
> #include <limits>
> +#include <memory>
> #include <ostream> // NOLINT
> #include <sstream>
> #include <string>
> +#include <type_traits>
> #include <utility>
> #include <vector>
> -#include "gtest/gtest.h"
> #include "gmock/internal/gmock-internal-utils.h"
> #include "gmock/internal/gmock-port.h"
> +#include "gtest/gtest.h"
>
> -#if GTEST_HAS_STD_INITIALIZER_LIST_
> -# include <initializer_list> // NOLINT -- must be after gtest.h
> +// MSVC warning C5046 is new as of VS2017 version 15.8.
> +#if defined(_MSC_VER) && _MSC_VER >= 1915
> +#define GMOCK_MAYBE_5046_ 5046
> +#else
> +#define GMOCK_MAYBE_5046_
> #endif
>
> +GTEST_DISABLE_MSC_WARNINGS_PUSH_(
> + 4251 GMOCK_MAYBE_5046_ /* class A needs to have dll-interface to be
> used by
> + clients of class B */
> + /* Symbol involving type with internal linkage not defined */)
> +
> #ifdef __clang__
> #if __has_warning("-Wdeprecated-copy")
> #pragma clang diagnostic push
> @@ -65,11 +79,6 @@
> #endif
> #endif
>
> -GTEST_DISABLE_MSC_WARNINGS_PUSH_(
> - 4251 5046 /* class A needs to have dll-interface to be used by
> clients of
> - class B */
> - /* Symbol involving type with internal linkage not defined */)
> -
> namespace testing {
>
> // To implement a matcher Foo for type T, define:
> @@ -84,145 +93,6 @@ namespace testing {
> // ownership management as Matcher objects can now be copied like
> // plain values.
>
> -// MatchResultListener is an abstract class. Its << operator can be
> -// used by a matcher to explain why a value matches or doesn't match.
> -//
> -// FIXME: add method
> -// bool InterestedInWhy(bool result) const;
> -// to indicate whether the listener is interested in why the match
> -// result is 'result'.
> -class MatchResultListener {
> - public:
> - // Creates a listener object with the given underlying ostream. The
> - // listener does not own the ostream, and does not dereference it
> - // in the constructor or destructor.
> - explicit MatchResultListener(::std::ostream* os) : stream_(os) {}
> - virtual ~MatchResultListener() = 0; // Makes this class abstract.
> -
> - // Streams x to the underlying ostream; does nothing if the ostream
> - // is NULL.
> - template <typename T>
> - MatchResultListener& operator<<(const T& x) {
> - if (stream_ != NULL)
> - *stream_ << x;
> - return *this;
> - }
> -
> - // Returns the underlying ostream.
> - ::std::ostream* stream() { return stream_; }
> -
> - // Returns true iff the listener is interested in an explanation of
> - // the match result. A matcher's MatchAndExplain() method can use
> - // this information to avoid generating the explanation when no one
> - // intends to hear it.
> - bool IsInterested() const { return stream_ != NULL; }
> -
> - private:
> - ::std::ostream* const stream_;
> -
> - GTEST_DISALLOW_COPY_AND_ASSIGN_(MatchResultListener);
> -};
> -
> -inline MatchResultListener::~MatchResultListener() {
> -}
> -
> -// An instance of a subclass of this knows how to describe itself as a
> -// matcher.
> -class MatcherDescriberInterface {
> - public:
> - virtual ~MatcherDescriberInterface() {}
> -
> - // Describes this matcher to an ostream. The function should print
> - // a verb phrase that describes the property a value matching this
> - // matcher should have. The subject of the verb phrase is the value
> - // being matched. For example, the DescribeTo() method of the Gt(7)
> - // matcher prints "is greater than 7".
> - virtual void DescribeTo(::std::ostream* os) const = 0;
> -
> - // Describes the negation of this matcher to an ostream. For
> - // example, if the description of this matcher is "is greater than
> - // 7", the negated description could be "is not greater than 7".
> - // You are not required to override this when implementing
> - // MatcherInterface, but it is highly advised so that your matcher
> - // can produce good error messages.
> - virtual void DescribeNegationTo(::std::ostream* os) const {
> - *os << "not (";
> - DescribeTo(os);
> - *os << ")";
> - }
> -};
> -
> -// The implementation of a matcher.
> -template <typename T>
> -class MatcherInterface : public MatcherDescriberInterface {
> - public:
> - // Returns true iff the matcher matches x; also explains the match
> - // result to 'listener' if necessary (see the next paragraph), in
> - // the form of a non-restrictive relative clause ("which ...",
> - // "whose ...", etc) that describes x. For example, the
> - // MatchAndExplain() method of the Pointee(...) matcher should
> - // generate an explanation like "which points to ...".
> - //
> - // Implementations of MatchAndExplain() should add an explanation of
> - // the match result *if and only if* they can provide additional
> - // information that's not already present (or not obvious) in the
> - // print-out of x and the matcher's description. Whether the match
> - // succeeds is not a factor in deciding whether an explanation is
> - // needed, as sometimes the caller needs to print a failure message
> - // when the match succeeds (e.g. when the matcher is used inside
> - // Not()).
> - //
> - // For example, a "has at least 10 elements" matcher should explain
> - // what the actual element count is, regardless of the match result,
> - // as it is useful information to the reader; on the other hand, an
> - // "is empty" matcher probably only needs to explain what the actual
> - // size is when the match fails, as it's redundant to say that the
> - // size is 0 when the value is already known to be empty.
> - //
> - // You should override this method when defining a new matcher.
> - //
> - // It's the responsibility of the caller (Google Mock) to guarantee
> - // that 'listener' is not NULL. This helps to simplify a matcher's
> - // implementation when it doesn't care about the performance, as it
> - // can talk to 'listener' without checking its validity first.
> - // However, in order to implement dummy listeners efficiently,
> - // listener->stream() may be NULL.
> - virtual bool MatchAndExplain(T x, MatchResultListener* listener) const
> = 0;
> -
> - // Inherits these methods from MatcherDescriberInterface:
> - // virtual void DescribeTo(::std::ostream* os) const = 0;
> - // virtual void DescribeNegationTo(::std::ostream* os) const;
> -};
> -
> -namespace internal {
> -
> -// Converts a MatcherInterface<T> to a MatcherInterface<const T&>.
> -template <typename T>
> -class MatcherInterfaceAdapter : public MatcherInterface<const T&> {
> - public:
> - explicit MatcherInterfaceAdapter(const MatcherInterface<T>* impl)
> - : impl_(impl) {}
> - virtual ~MatcherInterfaceAdapter() { delete impl_; }
> -
> - virtual void DescribeTo(::std::ostream* os) const {
> impl_->DescribeTo(os); }
> -
> - virtual void DescribeNegationTo(::std::ostream* os) const {
> - impl_->DescribeNegationTo(os);
> - }
> -
> - virtual bool MatchAndExplain(const T& x,
> - MatchResultListener* listener) const {
> - return impl_->MatchAndExplain(x, listener);
> - }
> -
> - private:
> - const MatcherInterface<T>* const impl_;
> -
> - GTEST_DISALLOW_COPY_AND_ASSIGN_(MatcherInterfaceAdapter);
> -};
> -
> -} // namespace internal
> -
> // A match result listener that stores the explanation in a string.
> class StringMatchResultListener : public MatchResultListener {
> public:
> @@ -240,409 +110,6 @@ class StringMatchResultListener : public
> MatchResultListener {
> GTEST_DISALLOW_COPY_AND_ASSIGN_(StringMatchResultListener);
> };
>
> -namespace internal {
> -
> -struct AnyEq {
> - template <typename A, typename B>
> - bool operator()(const A& a, const B& b) const { return a == b; }
> -};
> -struct AnyNe {
> - template <typename A, typename B>
> - bool operator()(const A& a, const B& b) const { return a != b; }
> -};
> -struct AnyLt {
> - template <typename A, typename B>
> - bool operator()(const A& a, const B& b) const { return a < b; }
> -};
> -struct AnyGt {
> - template <typename A, typename B>
> - bool operator()(const A& a, const B& b) const { return a > b; }
> -};
> -struct AnyLe {
> - template <typename A, typename B>
> - bool operator()(const A& a, const B& b) const { return a <= b; }
> -};
> -struct AnyGe {
> - template <typename A, typename B>
> - bool operator()(const A& a, const B& b) const { return a >= b; }
> -};
> -
> -// A match result listener that ignores the explanation.
> -class DummyMatchResultListener : public MatchResultListener {
> - public:
> - DummyMatchResultListener() : MatchResultListener(NULL) {}
> -
> - private:
> - GTEST_DISALLOW_COPY_AND_ASSIGN_(DummyMatchResultListener);
> -};
> -
> -// A match result listener that forwards the explanation to a given
> -// ostream. The
> diff erence between this and MatchResultListener is
> -// that the former is concrete.
> -class StreamMatchResultListener : public MatchResultListener {
> - public:
> - explicit StreamMatchResultListener(::std::ostream* os)
> - : MatchResultListener(os) {}
> -
> - private:
> - GTEST_DISALLOW_COPY_AND_ASSIGN_(StreamMatchResultListener);
> -};
> -
> -// An internal class for implementing Matcher<T>, which will derive
> -// from it. We put functionalities common to all Matcher<T>
> -// specializations here to avoid code duplication.
> -template <typename T>
> -class MatcherBase {
> - public:
> - // Returns true iff the matcher matches x; also explains the match
> - // result to 'listener'.
> - bool MatchAndExplain(GTEST_REFERENCE_TO_CONST_(T) x,
> - MatchResultListener* listener) const {
> - return impl_->MatchAndExplain(x, listener);
> - }
> -
> - // Returns true iff this matcher matches x.
> - bool Matches(GTEST_REFERENCE_TO_CONST_(T) x) const {
> - DummyMatchResultListener dummy;
> - return MatchAndExplain(x, &dummy);
> - }
> -
> - // Describes this matcher to an ostream.
> - void DescribeTo(::std::ostream* os) const { impl_->DescribeTo(os); }
> -
> - // Describes the negation of this matcher to an ostream.
> - void DescribeNegationTo(::std::ostream* os) const {
> - impl_->DescribeNegationTo(os);
> - }
> -
> - // Explains why x matches, or doesn't match, the matcher.
> - void ExplainMatchResultTo(GTEST_REFERENCE_TO_CONST_(T) x,
> - ::std::ostream* os) const {
> - StreamMatchResultListener listener(os);
> - MatchAndExplain(x, &listener);
> - }
> -
> - // Returns the describer for this matcher object; retains ownership
> - // of the describer, which is only guaranteed to be alive when
> - // this matcher object is alive.
> - const MatcherDescriberInterface* GetDescriber() const {
> - return impl_.get();
> - }
> -
> - protected:
> - MatcherBase() {}
> -
> - // Constructs a matcher from its implementation.
> - explicit MatcherBase(
> - const MatcherInterface<GTEST_REFERENCE_TO_CONST_(T)>* impl)
> - : impl_(impl) {}
> -
> - template <typename U>
> - explicit MatcherBase(
> - const MatcherInterface<U>* impl,
> - typename internal::EnableIf<
> - !internal::IsSame<U,
> GTEST_REFERENCE_TO_CONST_(U)>::value>::type* =
> - NULL)
> - : impl_(new internal::MatcherInterfaceAdapter<U>(impl)) {}
> -
> - virtual ~MatcherBase() {}
> -
> - private:
> - // shared_ptr (util/gtl/shared_ptr.h) and linked_ptr have similar
> - // interfaces. The former dynamically allocates a chunk of memory
> - // to hold the reference count, while the latter tracks all
> - // references using a circular linked list without allocating
> - // memory. It has been observed that linked_ptr performs better in
> - // typical scenarios. However, shared_ptr can out-perform
> - // linked_ptr when there are many more uses of the copy constructor
> - // than the default constructor.
> - //
> - // If performance becomes a problem, we should see if using
> - // shared_ptr helps.
> - ::testing::internal::linked_ptr<
> - const MatcherInterface<GTEST_REFERENCE_TO_CONST_(T)> >
> - impl_;
> -};
> -
> -} // namespace internal
> -
> -// A Matcher<T> is a copyable and IMMUTABLE (except by assignment)
> -// object that can check whether a value of type T matches. The
> -// implementation of Matcher<T> is just a linked_ptr to const
> -// MatcherInterface<T>, so copying is fairly cheap. Don't inherit
> -// from Matcher!
> -template <typename T>
> -class Matcher : public internal::MatcherBase<T> {
> - public:
> - // Constructs a null matcher. Needed for storing Matcher objects in STL
> - // containers. A default-constructed matcher is not yet initialized.
> You
> - // cannot use it until a valid value has been assigned to it.
> - explicit Matcher() {} // NOLINT
> -
> - // Constructs a matcher from its implementation.
> - explicit Matcher(const MatcherInterface<GTEST_REFERENCE_TO_CONST_(T)>*
> impl)
> - : internal::MatcherBase<T>(impl) {}
> -
> - template <typename U>
> - explicit Matcher(const MatcherInterface<U>* impl,
> - typename internal::EnableIf<!internal::IsSame<
> - U, GTEST_REFERENCE_TO_CONST_(U)>::value>::type* =
> NULL)
> - : internal::MatcherBase<T>(impl) {}
> -
> - // Implicit constructor here allows people to write
> - // EXPECT_CALL(foo, Bar(5)) instead of EXPECT_CALL(foo, Bar(Eq(5)))
> sometimes
> - Matcher(T value); // NOLINT
> -};
> -
> -// The following two specializations allow the user to write str
> -// instead of Eq(str) and "foo" instead of Eq("foo") when a std::string
> -// matcher is expected.
> -template <>
> -class GTEST_API_ Matcher<const std::string&>
> - : public internal::MatcherBase<const std::string&> {
> - public:
> - Matcher() {}
> -
> - explicit Matcher(const MatcherInterface<const std::string&>* impl)
> - : internal::MatcherBase<const std::string&>(impl) {}
> -
> - // Allows the user to write str instead of Eq(str) sometimes, where
> - // str is a std::string object.
> - Matcher(const std::string& s); // NOLINT
> -
> -#if GTEST_HAS_GLOBAL_STRING
> - // Allows the user to write str instead of Eq(str) sometimes, where
> - // str is a ::string object.
> - Matcher(const ::string& s); // NOLINT
> -#endif // GTEST_HAS_GLOBAL_STRING
> -
> - // Allows the user to write "foo" instead of Eq("foo") sometimes.
> - Matcher(const char* s); // NOLINT
> -};
> -
> -template <>
> -class GTEST_API_ Matcher<std::string>
> - : public internal::MatcherBase<std::string> {
> - public:
> - Matcher() {}
> -
> - explicit Matcher(const MatcherInterface<const std::string&>* impl)
> - : internal::MatcherBase<std::string>(impl) {}
> - explicit Matcher(const MatcherInterface<std::string>* impl)
> - : internal::MatcherBase<std::string>(impl) {}
> -
> - // Allows the user to write str instead of Eq(str) sometimes, where
> - // str is a string object.
> - Matcher(const std::string& s); // NOLINT
> -
> -#if GTEST_HAS_GLOBAL_STRING
> - // Allows the user to write str instead of Eq(str) sometimes, where
> - // str is a ::string object.
> - Matcher(const ::string& s); // NOLINT
> -#endif // GTEST_HAS_GLOBAL_STRING
> -
> - // Allows the user to write "foo" instead of Eq("foo") sometimes.
> - Matcher(const char* s); // NOLINT
> -};
> -
> -#if GTEST_HAS_GLOBAL_STRING
> -// The following two specializations allow the user to write str
> -// instead of Eq(str) and "foo" instead of Eq("foo") when a ::string
> -// matcher is expected.
> -template <>
> -class GTEST_API_ Matcher<const ::string&>
> - : public internal::MatcherBase<const ::string&> {
> - public:
> - Matcher() {}
> -
> - explicit Matcher(const MatcherInterface<const ::string&>* impl)
> - : internal::MatcherBase<const ::string&>(impl) {}
> -
> - // Allows the user to write str instead of Eq(str) sometimes, where
> - // str is a std::string object.
> - Matcher(const std::string& s); // NOLINT
> -
> - // Allows the user to write str instead of Eq(str) sometimes, where
> - // str is a ::string object.
> - Matcher(const ::string& s); // NOLINT
> -
> - // Allows the user to write "foo" instead of Eq("foo") sometimes.
> - Matcher(const char* s); // NOLINT
> -};
> -
> -template <>
> -class GTEST_API_ Matcher< ::string>
> - : public internal::MatcherBase< ::string> {
> - public:
> - Matcher() {}
> -
> - explicit Matcher(const MatcherInterface<const ::string&>* impl)
> - : internal::MatcherBase< ::string>(impl) {}
> - explicit Matcher(const MatcherInterface< ::string>* impl)
> - : internal::MatcherBase< ::string>(impl) {}
> -
> - // Allows the user to write str instead of Eq(str) sometimes, where
> - // str is a std::string object.
> - Matcher(const std::string& s); // NOLINT
> -
> - // Allows the user to write str instead of Eq(str) sometimes, where
> - // str is a ::string object.
> - Matcher(const ::string& s); // NOLINT
> -
> - // Allows the user to write "foo" instead of Eq("foo") sometimes.
> - Matcher(const char* s); // NOLINT
> -};
> -#endif // GTEST_HAS_GLOBAL_STRING
> -
> -#if GTEST_HAS_ABSL
> -// The following two specializations allow the user to write str
> -// instead of Eq(str) and "foo" instead of Eq("foo") when a
> absl::string_view
> -// matcher is expected.
> -template <>
> -class GTEST_API_ Matcher<const absl::string_view&>
> - : public internal::MatcherBase<const absl::string_view&> {
> - public:
> - Matcher() {}
> -
> - explicit Matcher(const MatcherInterface<const absl::string_view&>* impl)
> - : internal::MatcherBase<const absl::string_view&>(impl) {}
> -
> - // Allows the user to write str instead of Eq(str) sometimes, where
> - // str is a std::string object.
> - Matcher(const std::string& s); // NOLINT
> -
> -#if GTEST_HAS_GLOBAL_STRING
> - // Allows the user to write str instead of Eq(str) sometimes, where
> - // str is a ::string object.
> - Matcher(const ::string& s); // NOLINT
> -#endif // GTEST_HAS_GLOBAL_STRING
> -
> - // Allows the user to write "foo" instead of Eq("foo") sometimes.
> - Matcher(const char* s); // NOLINT
> -
> - // Allows the user to pass absl::string_views directly.
> - Matcher(absl::string_view s); // NOLINT
> -};
> -
> -template <>
> -class GTEST_API_ Matcher<absl::string_view>
> - : public internal::MatcherBase<absl::string_view> {
> - public:
> - Matcher() {}
> -
> - explicit Matcher(const MatcherInterface<const absl::string_view&>* impl)
> - : internal::MatcherBase<absl::string_view>(impl) {}
> - explicit Matcher(const MatcherInterface<absl::string_view>* impl)
> - : internal::MatcherBase<absl::string_view>(impl) {}
> -
> - // Allows the user to write str instead of Eq(str) sometimes, where
> - // str is a std::string object.
> - Matcher(const std::string& s); // NOLINT
> -
> -#if GTEST_HAS_GLOBAL_STRING
> - // Allows the user to write str instead of Eq(str) sometimes, where
> - // str is a ::string object.
> - Matcher(const ::string& s); // NOLINT
> -#endif // GTEST_HAS_GLOBAL_STRING
> -
> - // Allows the user to write "foo" instead of Eq("foo") sometimes.
> - Matcher(const char* s); // NOLINT
> -
> - // Allows the user to pass absl::string_views directly.
> - Matcher(absl::string_view s); // NOLINT
> -};
> -#endif // GTEST_HAS_ABSL
> -
> -// Prints a matcher in a human-readable format.
> -template <typename T>
> -std::ostream& operator<<(std::ostream& os, const Matcher<T>& matcher) {
> - matcher.DescribeTo(&os);
> - return os;
> -}
> -
> -// The PolymorphicMatcher class template makes it easy to implement a
> -// polymorphic matcher (i.e. a matcher that can match values of more
> -// than one type, e.g. Eq(n) and NotNull()).
> -//
> -// To define a polymorphic matcher, a user should provide an Impl
> -// class that has a DescribeTo() method and a DescribeNegationTo()
> -// method, and define a member function (or member function template)
> -//
> -// bool MatchAndExplain(const Value& value,
> -// MatchResultListener* listener) const;
> -//
> -// See the definition of NotNull() for a complete example.
> -template <class Impl>
> -class PolymorphicMatcher {
> - public:
> - explicit PolymorphicMatcher(const Impl& an_impl) : impl_(an_impl) {}
> -
> - // Returns a mutable reference to the underlying matcher
> - // implementation object.
> - Impl& mutable_impl() { return impl_; }
> -
> - // Returns an immutable reference to the underlying matcher
> - // implementation object.
> - const Impl& impl() const { return impl_; }
> -
> - template <typename T>
> - operator Matcher<T>() const {
> - return Matcher<T>(new
> MonomorphicImpl<GTEST_REFERENCE_TO_CONST_(T)>(impl_));
> - }
> -
> - private:
> - template <typename T>
> - class MonomorphicImpl : public MatcherInterface<T> {
> - public:
> - explicit MonomorphicImpl(const Impl& impl) : impl_(impl) {}
> -
> - virtual void DescribeTo(::std::ostream* os) const {
> - impl_.DescribeTo(os);
> - }
> -
> - virtual void DescribeNegationTo(::std::ostream* os) const {
> - impl_.DescribeNegationTo(os);
> - }
> -
> - virtual bool MatchAndExplain(T x, MatchResultListener* listener)
> const {
> - return impl_.MatchAndExplain(x, listener);
> - }
> -
> - private:
> - const Impl impl_;
> -
> - GTEST_DISALLOW_ASSIGN_(MonomorphicImpl);
> - };
> -
> - Impl impl_;
> -
> - GTEST_DISALLOW_ASSIGN_(PolymorphicMatcher);
> -};
> -
> -// Creates a matcher from its implementation. This is easier to use
> -// than the Matcher<T> constructor as it doesn't require you to
> -// explicitly write the template argument, e.g.
> -//
> -// MakeMatcher(foo);
> -// vs
> -// Matcher<const string&>(foo);
> -template <typename T>
> -inline Matcher<T> MakeMatcher(const MatcherInterface<T>* impl) {
> - return Matcher<T>(impl);
> -}
> -
> -// Creates a polymorphic matcher from its implementation. This is
> -// easier to use than the PolymorphicMatcher<Impl> constructor as it
> -// doesn't require you to explicitly write the template argument, e.g.
> -//
> -// MakePolymorphicMatcher(foo);
> -// vs
> -// PolymorphicMatcher<TypeOfFoo>(foo);
> -template <class Impl>
> -inline PolymorphicMatcher<Impl> MakePolymorphicMatcher(const Impl& impl) {
> - return PolymorphicMatcher<Impl>(impl);
> -}
> -
> // Anything inside the 'internal' namespace IS INTERNAL IMPLEMENTATION
> // and MUST NOT BE USED IN USER CODE!!!
> namespace internal {
> @@ -674,19 +141,16 @@ class MatcherCastImpl {
> // polymorphic_matcher_or_value to Matcher<T> because it won't trigger
> // a user-defined conversion from M to T if one exists (assuming M is
> // a value).
> - return CastImpl(
> - polymorphic_matcher_or_value,
> - BooleanConstant<
> - internal::ImplicitlyConvertible<M, Matcher<T> >::value>(),
> - BooleanConstant<
> - internal::ImplicitlyConvertible<M, T>::value>());
> + return CastImpl(polymorphic_matcher_or_value,
> + std::is_convertible<M, Matcher<T>>{},
> + std::is_convertible<M, T>{});
> }
>
> private:
> template <bool Ignore>
> static Matcher<T> CastImpl(const M& polymorphic_matcher_or_value,
> - BooleanConstant<true> /*
> convertible_to_matcher */,
> - BooleanConstant<Ignore>) {
> + std::true_type /* convertible_to_matcher */,
> + bool_constant<Ignore>) {
> // M is implicitly convertible to Matcher<T>, which means that either
> // M is a polymorphic matcher or Matcher<T> has an implicit
> constructor
> // from M. In both cases using the implicit conversion will produce a
> @@ -701,9 +165,9 @@ class MatcherCastImpl {
> // M can't be implicitly converted to Matcher<T>, so M isn't a
> polymorphic
> // matcher. It's a value of a type implicitly convertible to T. Use
> direct
> // initialization to create a matcher.
> - static Matcher<T> CastImpl(
> - const M& value, BooleanConstant<false> /* convertible_to_matcher */,
> - BooleanConstant<true> /* convertible_to_T */) {
> + static Matcher<T> CastImpl(const M& value,
> + std::false_type /* convertible_to_matcher */,
> + std::true_type /* convertible_to_T */) {
> return Matcher<T>(ImplicitCast_<T>(value));
> }
>
> @@ -717,9 +181,9 @@ class MatcherCastImpl {
> // (e.g. std::pair<const int, int> vs. std::pair<int, int>).
> //
> // We don't define this method inline as we need the declaration of
> Eq().
> - static Matcher<T> CastImpl(
> - const M& value, BooleanConstant<false> /* convertible_to_matcher */,
> - BooleanConstant<false> /* convertible_to_T */);
> + static Matcher<T> CastImpl(const M& value,
> + std::false_type /* convertible_to_matcher */,
> + std::false_type /* convertible_to_T */);
> };
>
> // This more specialized version is used when MatcherCast()'s argument
> @@ -739,8 +203,7 @@ class MatcherCastImpl<T, Matcher<U> > {
> : source_matcher_(source_matcher) {}
>
> // We delegate the matching logic to the source matcher.
> - virtual bool MatchAndExplain(T x, MatchResultListener* listener)
> const {
> -#if GTEST_LANG_CXX11
> + bool MatchAndExplain(T x, MatchResultListener* listener) const
> override {
> using FromType = typename std::remove_cv<typename
> std::remove_pointer<
> typename std::remove_reference<T>::type>::type>::type;
> using ToType = typename std::remove_cv<typename std::remove_pointer<
> @@ -754,16 +217,15 @@ class MatcherCastImpl<T, Matcher<U> > {
> std::is_same<FromType, ToType>::value ||
> !std::is_base_of<FromType, ToType>::value,
> "Can't implicitly convert from <base> to <derived>");
> -#endif // GTEST_LANG_CXX11
>
> return source_matcher_.MatchAndExplain(static_cast<U>(x), listener);
> }
>
> - virtual void DescribeTo(::std::ostream* os) const {
> + void DescribeTo(::std::ostream* os) const override {
> source_matcher_.DescribeTo(os);
> }
>
> - virtual void DescribeNegationTo(::std::ostream* os) const {
> + void DescribeNegationTo(::std::ostream* os) const override {
> source_matcher_.DescribeNegationTo(os);
> }
>
> @@ -795,11 +257,8 @@ inline Matcher<T> MatcherCast(const M& matcher) {
>
> // Implements SafeMatcherCast().
> //
> -// We use an intermediate class to do the actual safe casting as Nokia's
> -// Symbian compiler cannot decide between
> -// template <T, M> ... (M) and
> -// template <T, U> ... (const Matcher<U>&)
> -// for function templates but can for member function templates.
> +// FIXME: The intermediate SafeMatcherCastImpl class was introduced as a
> +// workaround for a compiler bug, and can now be removed.
> template <typename T>
> class SafeMatcherCastImpl {
> public:
> @@ -822,12 +281,12 @@ class SafeMatcherCastImpl {
> template <typename U>
> static inline Matcher<T> Cast(const Matcher<U>& matcher) {
> // Enforce that T can be implicitly converted to U.
> - GTEST_COMPILE_ASSERT_((internal::ImplicitlyConvertible<T, U>::value),
> - T_must_be_implicitly_convertible_to_U);
> + GTEST_COMPILE_ASSERT_((std::is_convertible<T, U>::value),
> + "T must be implicitly convertible to U");
> // Enforce that we are not converting a non-reference type T to a
> reference
> // type U.
> GTEST_COMPILE_ASSERT_(
> - internal::is_reference<T>::value ||
> !internal::is_reference<U>::value,
> + std::is_reference<T>::value || !std::is_reference<U>::value,
> cannot_convert_non_reference_arg_to_reference);
> // In case both T and U are arithmetic types, enforce that the
> // conversion is not lossy.
> @@ -859,7 +318,7 @@ namespace internal {
> // If the explanation is not empty, prints it to the ostream.
> inline void PrintIfNotEmpty(const std::string& explanation,
> ::std::ostream* os) {
> - if (explanation != "" && os != NULL) {
> + if (explanation != "" && os != nullptr) {
> *os << ", " << explanation;
> }
> }
> @@ -908,13 +367,13 @@ template <size_t N>
> class TuplePrefix {
> public:
> // TuplePrefix<N>::Matches(matcher_tuple, value_tuple) returns true
> - // iff the first N fields of matcher_tuple matches the first N
> - // fields of value_tuple, respectively.
> + // if and only if the first N fields of matcher_tuple matches
> + // the first N fields of value_tuple, respectively.
> template <typename MatcherTuple, typename ValueTuple>
> static bool Matches(const MatcherTuple& matcher_tuple,
> const ValueTuple& value_tuple) {
> - return TuplePrefix<N - 1>::Matches(matcher_tuple, value_tuple)
> - && get<N - 1>(matcher_tuple).Matches(get<N - 1>(value_tuple));
> + return TuplePrefix<N - 1>::Matches(matcher_tuple, value_tuple) &&
> + std::get<N - 1>(matcher_tuple).Matches(std::get<N -
> 1>(value_tuple));
> }
>
> // TuplePrefix<N>::ExplainMatchFailuresTo(matchers, values, os)
> @@ -930,16 +389,14 @@ class TuplePrefix {
>
> // Then describes the failure (if any) in the (N - 1)-th (0-based)
> // field.
> - typename tuple_element<N - 1, MatcherTuple>::type matcher =
> - get<N - 1>(matchers);
> - typedef typename tuple_element<N - 1, ValueTuple>::type Value;
> - GTEST_REFERENCE_TO_CONST_(Value) value = get<N - 1>(values);
> + typename std::tuple_element<N - 1, MatcherTuple>::type matcher =
> + std::get<N - 1>(matchers);
> + typedef typename std::tuple_element<N - 1, ValueTuple>::type Value;
> + const Value& value = std::get<N - 1>(values);
> StringMatchResultListener listener;
> if (!matcher.MatchAndExplain(value, &listener)) {
> - // FIXME: include in the message the name of the parameter
> - // as used in MOCK_METHOD*() when possible.
> *os << " Expected arg #" << N - 1 << ": ";
> - get<N - 1>(matchers).DescribeTo(os);
> + std::get<N - 1>(matchers).DescribeTo(os);
> *os << "\n Actual: ";
> // We remove the reference in type Value to prevent the
> // universal printer from printing the address of value, which
> @@ -969,8 +426,8 @@ class TuplePrefix<0> {
> ::std::ostream* /* os */) {}
> };
>
> -// TupleMatches(matcher_tuple, value_tuple) returns true iff all
> -// matchers in matcher_tuple match the corresponding fields in
> +// TupleMatches(matcher_tuple, value_tuple) returns true if and only if
> +// all matchers in matcher_tuple match the corresponding fields in
> // value_tuple. It is a compiler error if matcher_tuple and
> // value_tuple have
> diff erent number of fields or incompatible field
> // types.
> @@ -979,11 +436,11 @@ bool TupleMatches(const MatcherTuple& matcher_tuple,
> const ValueTuple& value_tuple) {
> // Makes sure that matcher_tuple and value_tuple have the same
> // number of fields.
> - GTEST_COMPILE_ASSERT_(tuple_size<MatcherTuple>::value ==
> - tuple_size<ValueTuple>::value,
> + GTEST_COMPILE_ASSERT_(std::tuple_size<MatcherTuple>::value ==
> + std::tuple_size<ValueTuple>::value,
> matcher_and_value_have_
> diff erent_numbers_of_fields);
> - return TuplePrefix<tuple_size<ValueTuple>::value>::
> - Matches(matcher_tuple, value_tuple);
> + return
> TuplePrefix<std::tuple_size<ValueTuple>::value>::Matches(matcher_tuple,
> +
> value_tuple);
> }
>
> // Describes failures in matching matchers against values. If there
> @@ -992,7 +449,7 @@ template <typename MatcherTuple, typename ValueTuple>
> void ExplainMatchFailureTupleTo(const MatcherTuple& matchers,
> const ValueTuple& values,
> ::std::ostream* os) {
> - TuplePrefix<tuple_size<MatcherTuple>::value>::ExplainMatchFailuresTo(
> +
> TuplePrefix<std::tuple_size<MatcherTuple>::value>::ExplainMatchFailuresTo(
> matchers, values, os);
> }
>
> @@ -1003,7 +460,7 @@ void ExplainMatchFailureTupleTo(const MatcherTuple&
> matchers,
> template <typename Tuple, typename Func, typename OutIter>
> class TransformTupleValuesHelper {
> private:
> - typedef ::testing::tuple_size<Tuple> TupleSize;
> + typedef ::std::tuple_size<Tuple> TupleSize;
>
> public:
> // For each member of tuple 't', taken in order, evaluates '*out++ =
> f(t)'.
> @@ -1016,7 +473,7 @@ class TransformTupleValuesHelper {
> template <typename Tup, size_t kRemainingSize>
> struct IterateOverTuple {
> OutIter operator() (Func f, const Tup& t, OutIter out) const {
> - *out++ = f(::testing::get<TupleSize::value - kRemainingSize>(t));
> + *out++ = f(::std::get<TupleSize::value - kRemainingSize>(t));
> return IterateOverTuple<Tup, kRemainingSize - 1>()(f, t, out);
> }
> };
> @@ -1038,14 +495,14 @@ OutIter TransformTupleValues(Func f, const Tuple&
> t, OutIter out) {
>
> // Implements A<T>().
> template <typename T>
> -class AnyMatcherImpl : public
> MatcherInterface<GTEST_REFERENCE_TO_CONST_(T)> {
> +class AnyMatcherImpl : public MatcherInterface<const T&> {
> public:
> - virtual bool MatchAndExplain(GTEST_REFERENCE_TO_CONST_(T) /* x */,
> - MatchResultListener* /* listener */) const
> {
> + bool MatchAndExplain(const T& /* x */,
> + MatchResultListener* /* listener */) const
> override {
> return true;
> }
> - virtual void DescribeTo(::std::ostream* os) const { *os << "is
> anything"; }
> - virtual void DescribeNegationTo(::std::ostream* os) const {
> + void DescribeTo(::std::ostream* os) const override { *os << "is
> anything"; }
> + void DescribeNegationTo(::std::ostream* os) const override {
> // This is mostly for completeness' safe, as it's not very useful
> // to write Not(A<bool>()). However we cannot completely rule out
> // such a possibility, and it doesn't hurt to be prepared.
> @@ -1063,99 +520,6 @@ class AnythingMatcher {
> operator Matcher<T>() const { return A<T>(); }
> };
>
> -// Implements a matcher that compares a given value with a
> -// pre-supplied value using one of the ==, <=, <, etc, operators. The
> -// two values being compared don't have to have the same type.
> -//
> -// The matcher defined here is polymorphic (for example, Eq(5) can be
> -// used to match an int, a short, a double, etc). Therefore we use
> -// a template type conversion operator in the implementation.
> -//
> -// The following template definition assumes that the Rhs parameter is
> -// a "bare" type (i.e. neither 'const T' nor 'T&').
> -template <typename D, typename Rhs, typename Op>
> -class ComparisonBase {
> - public:
> - explicit ComparisonBase(const Rhs& rhs) : rhs_(rhs) {}
> - template <typename Lhs>
> - operator Matcher<Lhs>() const {
> - return MakeMatcher(new Impl<Lhs>(rhs_));
> - }
> -
> - private:
> - template <typename Lhs>
> - class Impl : public MatcherInterface<Lhs> {
> - public:
> - explicit Impl(const Rhs& rhs) : rhs_(rhs) {}
> - virtual bool MatchAndExplain(
> - Lhs lhs, MatchResultListener* /* listener */) const {
> - return Op()(lhs, rhs_);
> - }
> - virtual void DescribeTo(::std::ostream* os) const {
> - *os << D::Desc() << " ";
> - UniversalPrint(rhs_, os);
> - }
> - virtual void DescribeNegationTo(::std::ostream* os) const {
> - *os << D::NegatedDesc() << " ";
> - UniversalPrint(rhs_, os);
> - }
> - private:
> - Rhs rhs_;
> - GTEST_DISALLOW_ASSIGN_(Impl);
> - };
> - Rhs rhs_;
> - GTEST_DISALLOW_ASSIGN_(ComparisonBase);
> -};
> -
> -template <typename Rhs>
> -class EqMatcher : public ComparisonBase<EqMatcher<Rhs>, Rhs, AnyEq> {
> - public:
> - explicit EqMatcher(const Rhs& rhs)
> - : ComparisonBase<EqMatcher<Rhs>, Rhs, AnyEq>(rhs) { }
> - static const char* Desc() { return "is equal to"; }
> - static const char* NegatedDesc() { return "isn't equal to"; }
> -};
> -template <typename Rhs>
> -class NeMatcher : public ComparisonBase<NeMatcher<Rhs>, Rhs, AnyNe> {
> - public:
> - explicit NeMatcher(const Rhs& rhs)
> - : ComparisonBase<NeMatcher<Rhs>, Rhs, AnyNe>(rhs) { }
> - static const char* Desc() { return "isn't equal to"; }
> - static const char* NegatedDesc() { return "is equal to"; }
> -};
> -template <typename Rhs>
> -class LtMatcher : public ComparisonBase<LtMatcher<Rhs>, Rhs, AnyLt> {
> - public:
> - explicit LtMatcher(const Rhs& rhs)
> - : ComparisonBase<LtMatcher<Rhs>, Rhs, AnyLt>(rhs) { }
> - static const char* Desc() { return "is <"; }
> - static const char* NegatedDesc() { return "isn't <"; }
> -};
> -template <typename Rhs>
> -class GtMatcher : public ComparisonBase<GtMatcher<Rhs>, Rhs, AnyGt> {
> - public:
> - explicit GtMatcher(const Rhs& rhs)
> - : ComparisonBase<GtMatcher<Rhs>, Rhs, AnyGt>(rhs) { }
> - static const char* Desc() { return "is >"; }
> - static const char* NegatedDesc() { return "isn't >"; }
> -};
> -template <typename Rhs>
> -class LeMatcher : public ComparisonBase<LeMatcher<Rhs>, Rhs, AnyLe> {
> - public:
> - explicit LeMatcher(const Rhs& rhs)
> - : ComparisonBase<LeMatcher<Rhs>, Rhs, AnyLe>(rhs) { }
> - static const char* Desc() { return "is <="; }
> - static const char* NegatedDesc() { return "isn't <="; }
> -};
> -template <typename Rhs>
> -class GeMatcher : public ComparisonBase<GeMatcher<Rhs>, Rhs, AnyGe> {
> - public:
> - explicit GeMatcher(const Rhs& rhs)
> - : ComparisonBase<GeMatcher<Rhs>, Rhs, AnyGe>(rhs) { }
> - static const char* Desc() { return "is >="; }
> - static const char* NegatedDesc() { return "isn't >="; }
> -};
> -
> // Implements the polymorphic IsNull() matcher, which matches any raw or
> smart
> // pointer that is NULL.
> class IsNullMatcher {
> @@ -1163,11 +527,7 @@ class IsNullMatcher {
> template <typename Pointer>
> bool MatchAndExplain(const Pointer& p,
> MatchResultListener* /* listener */) const {
> -#if GTEST_LANG_CXX11
> return p == nullptr;
> -#else // GTEST_LANG_CXX11
> - return GetRawPointer(p) == NULL;
> -#endif // GTEST_LANG_CXX11
> }
>
> void DescribeTo(::std::ostream* os) const { *os << "is NULL"; }
> @@ -1183,11 +543,7 @@ class NotNullMatcher {
> template <typename Pointer>
> bool MatchAndExplain(const Pointer& p,
> MatchResultListener* /* listener */) const {
> -#if GTEST_LANG_CXX11
> return p != nullptr;
> -#else // GTEST_LANG_CXX11
> - return GetRawPointer(p) != NULL;
> -#endif // GTEST_LANG_CXX11
> }
>
> void DescribeTo(::std::ostream* os) const { *os << "isn't NULL"; }
> @@ -1243,18 +599,18 @@ class RefMatcher<T&> {
>
> // MatchAndExplain() takes a Super& (as opposed to const Super&)
> // in order to match the interface MatcherInterface<Super&>.
> - virtual bool MatchAndExplain(
> - Super& x, MatchResultListener* listener) const {
> + bool MatchAndExplain(Super& x,
> + MatchResultListener* listener) const override {
> *listener << "which is located @" << static_cast<const void*>(&x);
> return &x == &object_;
> }
>
> - virtual void DescribeTo(::std::ostream* os) const {
> + void DescribeTo(::std::ostream* os) const override {
> *os << "references the variable ";
> UniversalPrinter<Super&>::Print(object_, os);
> }
>
> - virtual void DescribeNegationTo(::std::ostream* os) const {
> + void DescribeNegationTo(::std::ostream* os) const override {
> *os << "does not reference the variable ";
> UniversalPrinter<Super&>::Print(object_, os);
> }
> @@ -1316,12 +672,9 @@ class StrEqualityMatcher {
> #if GTEST_HAS_ABSL
> bool MatchAndExplain(const absl::string_view& s,
> MatchResultListener* listener) const {
> - if (s.data() == NULL) {
> - return !expect_eq_;
> - }
> // This should fail to compile if absl::string_view is used with wide
> // strings.
> - const StringType& str = string(s);
> + const StringType& str = std::string(s);
> return MatchAndExplain(str, listener);
> }
> #endif // GTEST_HAS_ABSL
> @@ -1333,7 +686,7 @@ class StrEqualityMatcher {
> // wchar_t*
> template <typename CharType>
> bool MatchAndExplain(CharType* s, MatchResultListener* listener) const {
> - if (s == NULL) {
> + if (s == nullptr) {
> return !expect_eq_;
> }
> return MatchAndExplain(StringType(s), listener);
> @@ -1389,12 +742,9 @@ class HasSubstrMatcher {
> #if GTEST_HAS_ABSL
> bool MatchAndExplain(const absl::string_view& s,
> MatchResultListener* listener) const {
> - if (s.data() == NULL) {
> - return false;
> - }
> // This should fail to compile if absl::string_view is used with wide
> // strings.
> - const StringType& str = string(s);
> + const StringType& str = std::string(s);
> return MatchAndExplain(str, listener);
> }
> #endif // GTEST_HAS_ABSL
> @@ -1406,7 +756,7 @@ class HasSubstrMatcher {
> // wchar_t*
> template <typename CharType>
> bool MatchAndExplain(CharType* s, MatchResultListener* listener) const {
> - return s != NULL && MatchAndExplain(StringType(s), listener);
> + return s != nullptr && MatchAndExplain(StringType(s), listener);
> }
>
> // Matches anything that can convert to StringType.
> @@ -1449,12 +799,9 @@ class StartsWithMatcher {
> #if GTEST_HAS_ABSL
> bool MatchAndExplain(const absl::string_view& s,
> MatchResultListener* listener) const {
> - if (s.data() == NULL) {
> - return false;
> - }
> // This should fail to compile if absl::string_view is used with wide
> // strings.
> - const StringType& str = string(s);
> + const StringType& str = std::string(s);
> return MatchAndExplain(str, listener);
> }
> #endif // GTEST_HAS_ABSL
> @@ -1466,7 +813,7 @@ class StartsWithMatcher {
> // wchar_t*
> template <typename CharType>
> bool MatchAndExplain(CharType* s, MatchResultListener* listener) const {
> - return s != NULL && MatchAndExplain(StringType(s), listener);
> + return s != nullptr && MatchAndExplain(StringType(s), listener);
> }
>
> // Matches anything that can convert to StringType.
> @@ -1508,12 +855,9 @@ class EndsWithMatcher {
> #if GTEST_HAS_ABSL
> bool MatchAndExplain(const absl::string_view& s,
> MatchResultListener* listener) const {
> - if (s.data() == NULL) {
> - return false;
> - }
> // This should fail to compile if absl::string_view is used with wide
> // strings.
> - const StringType& str = string(s);
> + const StringType& str = std::string(s);
> return MatchAndExplain(str, listener);
> }
> #endif // GTEST_HAS_ABSL
> @@ -1525,7 +869,7 @@ class EndsWithMatcher {
> // wchar_t*
> template <typename CharType>
> bool MatchAndExplain(CharType* s, MatchResultListener* listener) const {
> - return s != NULL && MatchAndExplain(StringType(s), listener);
> + return s != nullptr && MatchAndExplain(StringType(s), listener);
> }
>
> // Matches anything that can convert to StringType.
> @@ -1556,80 +900,24 @@ class EndsWithMatcher {
> GTEST_DISALLOW_ASSIGN_(EndsWithMatcher);
> };
>
> -// Implements polymorphic matchers MatchesRegex(regex) and
> -// ContainsRegex(regex), which can be used as a Matcher<T> as long as
> -// T can be converted to a string.
> -class MatchesRegexMatcher {
> - public:
> - MatchesRegexMatcher(const RE* regex, bool full_match)
> - : regex_(regex), full_match_(full_match) {}
> -
> -#if GTEST_HAS_ABSL
> - bool MatchAndExplain(const absl::string_view& s,
> - MatchResultListener* listener) const {
> - return s.data() && MatchAndExplain(string(s), listener);
> - }
> -#endif // GTEST_HAS_ABSL
> -
> - // Accepts pointer types, particularly:
> - // const char*
> - // char*
> - // const wchar_t*
> - // wchar_t*
> - template <typename CharType>
> - bool MatchAndExplain(CharType* s, MatchResultListener* listener) const {
> - return s != NULL && MatchAndExplain(std::string(s), listener);
> - }
> -
> - // Matches anything that can convert to std::string.
> - //
> - // This is a template, not just a plain function with const
> std::string&,
> - // because absl::string_view has some interfering non-explicit
> constructors.
> - template <class MatcheeStringType>
> - bool MatchAndExplain(const MatcheeStringType& s,
> - MatchResultListener* /* listener */) const {
> - const std::string& s2(s);
> - return full_match_ ? RE::FullMatch(s2, *regex_) :
> - RE::PartialMatch(s2, *regex_);
> - }
> -
> - void DescribeTo(::std::ostream* os) const {
> - *os << (full_match_ ? "matches" : "contains")
> - << " regular expression ";
> - UniversalPrinter<std::string>::Print(regex_->pattern(), os);
> - }
> -
> - void DescribeNegationTo(::std::ostream* os) const {
> - *os << "doesn't " << (full_match_ ? "match" : "contain")
> - << " regular expression ";
> - UniversalPrinter<std::string>::Print(regex_->pattern(), os);
> - }
> -
> - private:
> - const internal::linked_ptr<const RE> regex_;
> - const bool full_match_;
> -
> - GTEST_DISALLOW_ASSIGN_(MatchesRegexMatcher);
> -};
> -
> // Implements a matcher that compares the two fields of a 2-tuple
> // using one of the ==, <=, <, etc, operators. The two fields being
> // compared don't have to have the same type.
> //
> // The matcher defined here is polymorphic (for example, Eq() can be
> -// used to match a tuple<int, short>, a tuple<const long&, double>,
> +// used to match a std::tuple<int, short>, a std::tuple<const long&,
> double>,
> // etc). Therefore we use a template type conversion operator in the
> // implementation.
> template <typename D, typename Op>
> class PairMatchBase {
> public:
> template <typename T1, typename T2>
> - operator Matcher< ::testing::tuple<T1, T2> >() const {
> - return MakeMatcher(new Impl< ::testing::tuple<T1, T2> >);
> + operator Matcher<::std::tuple<T1, T2>>() const {
> + return Matcher<::std::tuple<T1, T2>>(new Impl<const ::std::tuple<T1,
> T2>&>);
> }
> template <typename T1, typename T2>
> - operator Matcher<const ::testing::tuple<T1, T2>&>() const {
> - return MakeMatcher(new Impl<const ::testing::tuple<T1, T2>&>);
> + operator Matcher<const ::std::tuple<T1, T2>&>() const {
> + return MakeMatcher(new Impl<const ::std::tuple<T1, T2>&>);
> }
>
> private:
> @@ -1640,15 +928,14 @@ class PairMatchBase {
> template <typename Tuple>
> class Impl : public MatcherInterface<Tuple> {
> public:
> - virtual bool MatchAndExplain(
> - Tuple args,
> - MatchResultListener* /* listener */) const {
> - return Op()(::testing::get<0>(args), ::testing::get<1>(args));
> + bool MatchAndExplain(Tuple args,
> + MatchResultListener* /* listener */) const
> override {
> + return Op()(::std::get<0>(args), ::std::get<1>(args));
> }
> - virtual void DescribeTo(::std::ostream* os) const {
> + void DescribeTo(::std::ostream* os) const override {
> *os << "are " << GetDesc;
> }
> - virtual void DescribeNegationTo(::std::ostream* os) const {
> + void DescribeNegationTo(::std::ostream* os) const override {
> *os << "aren't " << GetDesc;
> }
> };
> @@ -1684,21 +971,21 @@ class Ge2Matcher : public PairMatchBase<Ge2Matcher,
> AnyGe> {
> // will prevent
> diff erent instantiations of NotMatcher from sharing
> // the same NotMatcherImpl<T> class.
> template <typename T>
> -class NotMatcherImpl : public
> MatcherInterface<GTEST_REFERENCE_TO_CONST_(T)> {
> +class NotMatcherImpl : public MatcherInterface<const T&> {
> public:
> explicit NotMatcherImpl(const Matcher<T>& matcher)
> : matcher_(matcher) {}
>
> - virtual bool MatchAndExplain(GTEST_REFERENCE_TO_CONST_(T) x,
> - MatchResultListener* listener) const {
> + bool MatchAndExplain(const T& x,
> + MatchResultListener* listener) const override {
> return !matcher_.MatchAndExplain(x, listener);
> }
>
> - virtual void DescribeTo(::std::ostream* os) const {
> + void DescribeTo(::std::ostream* os) const override {
> matcher_.DescribeNegationTo(os);
> }
>
> - virtual void DescribeNegationTo(::std::ostream* os) const {
> + void DescribeNegationTo(::std::ostream* os) const override {
> matcher_.DescribeTo(os);
> }
>
> @@ -1733,13 +1020,12 @@ class NotMatcher {
> // that will prevent
> diff erent instantiations of BothOfMatcher from
> // sharing the same BothOfMatcherImpl<T> class.
> template <typename T>
> -class AllOfMatcherImpl
> - : public MatcherInterface<GTEST_REFERENCE_TO_CONST_(T)> {
> +class AllOfMatcherImpl : public MatcherInterface<const T&> {
> public:
> explicit AllOfMatcherImpl(std::vector<Matcher<T> > matchers)
> - : matchers_(internal::move(matchers)) {}
> + : matchers_(std::move(matchers)) {}
>
> - virtual void DescribeTo(::std::ostream* os) const {
> + void DescribeTo(::std::ostream* os) const override {
> *os << "(";
> for (size_t i = 0; i < matchers_.size(); ++i) {
> if (i != 0) *os << ") and (";
> @@ -1748,7 +1034,7 @@ class AllOfMatcherImpl
> *os << ")";
> }
>
> - virtual void DescribeNegationTo(::std::ostream* os) const {
> + void DescribeNegationTo(::std::ostream* os) const override {
> *os << "(";
> for (size_t i = 0; i < matchers_.size(); ++i) {
> if (i != 0) *os << ") or (";
> @@ -1757,8 +1043,8 @@ class AllOfMatcherImpl
> *os << ")";
> }
>
> - virtual bool MatchAndExplain(GTEST_REFERENCE_TO_CONST_(T) x,
> - MatchResultListener* listener) const {
> + bool MatchAndExplain(const T& x,
> + MatchResultListener* listener) const override {
> // If either matcher1_ or matcher2_ doesn't match x, we only need
> // to explain why one of them fails.
> std::string all_match_result;
> @@ -1792,7 +1078,6 @@ class AllOfMatcherImpl
> GTEST_DISALLOW_ASSIGN_(AllOfMatcherImpl);
> };
>
> -#if GTEST_LANG_CXX11
> // VariadicMatcher is used for the variadic implementation of
> // AllOf(m_1, m_2, ...) and AnyOf(m_1, m_2, ...).
> // CombiningMatcher<T> is used to recursively combine the provided
> matchers
> @@ -1812,7 +1097,7 @@ class VariadicMatcher {
> operator Matcher<T>() const {
> std::vector<Matcher<T> > values;
> CreateVariadicMatcher<T>(&values, std::integral_constant<size_t,
> 0>());
> - return Matcher<T>(new CombiningMatcher<T>(internal::move(values)));
> + return Matcher<T>(new CombiningMatcher<T>(std::move(values)));
> }
>
> private:
> @@ -1828,7 +1113,7 @@ class VariadicMatcher {
> std::vector<Matcher<T> >*,
> std::integral_constant<size_t, sizeof...(Args)>) const {}
>
> - tuple<Args...> matchers_;
> + std::tuple<Args...> matchers_;
>
> GTEST_DISALLOW_ASSIGN_(VariadicMatcher);
> };
> @@ -1836,46 +1121,17 @@ class VariadicMatcher {
> template <typename... Args>
> using AllOfMatcher = VariadicMatcher<AllOfMatcherImpl, Args...>;
>
> -#endif // GTEST_LANG_CXX11
> -
> -// Used for implementing the AllOf(m_1, ..., m_n) matcher, which
> -// matches a value that matches all of the matchers m_1, ..., and m_n.
> -template <typename Matcher1, typename Matcher2>
> -class BothOfMatcher {
> - public:
> - BothOfMatcher(Matcher1 matcher1, Matcher2 matcher2)
> - : matcher1_(matcher1), matcher2_(matcher2) {}
> -
> - // This template type conversion operator allows a
> - // BothOfMatcher<Matcher1, Matcher2> object to match any type that
> - // both Matcher1 and Matcher2 can match.
> - template <typename T>
> - operator Matcher<T>() const {
> - std::vector<Matcher<T> > values;
> - values.push_back(SafeMatcherCast<T>(matcher1_));
> - values.push_back(SafeMatcherCast<T>(matcher2_));
> - return Matcher<T>(new AllOfMatcherImpl<T>(internal::move(values)));
> - }
> -
> - private:
> - Matcher1 matcher1_;
> - Matcher2 matcher2_;
> -
> - GTEST_DISALLOW_ASSIGN_(BothOfMatcher);
> -};
> -
> // Implements the AnyOf(m1, m2) matcher for a particular argument type
> // T. We do not nest it inside the AnyOfMatcher class template, as
> // that will prevent
> diff erent instantiations of AnyOfMatcher from
> // sharing the same EitherOfMatcherImpl<T> class.
> template <typename T>
> -class AnyOfMatcherImpl
> - : public MatcherInterface<GTEST_REFERENCE_TO_CONST_(T)> {
> +class AnyOfMatcherImpl : public MatcherInterface<const T&> {
> public:
> explicit AnyOfMatcherImpl(std::vector<Matcher<T> > matchers)
> - : matchers_(internal::move(matchers)) {}
> + : matchers_(std::move(matchers)) {}
>
> - virtual void DescribeTo(::std::ostream* os) const {
> + void DescribeTo(::std::ostream* os) const override {
> *os << "(";
> for (size_t i = 0; i < matchers_.size(); ++i) {
> if (i != 0) *os << ") or (";
> @@ -1884,7 +1140,7 @@ class AnyOfMatcherImpl
> *os << ")";
> }
>
> - virtual void DescribeNegationTo(::std::ostream* os) const {
> + void DescribeNegationTo(::std::ostream* os) const override {
> *os << "(";
> for (size_t i = 0; i < matchers_.size(); ++i) {
> if (i != 0) *os << ") and (";
> @@ -1893,8 +1149,8 @@ class AnyOfMatcherImpl
> *os << ")";
> }
>
> - virtual bool MatchAndExplain(GTEST_REFERENCE_TO_CONST_(T) x,
> - MatchResultListener* listener) const {
> + bool MatchAndExplain(const T& x,
> + MatchResultListener* listener) const override {
> std::string no_match_result;
>
> // If either matcher1_ or matcher2_ matches x, we just need to
> @@ -1928,40 +1184,41 @@ class AnyOfMatcherImpl
> GTEST_DISALLOW_ASSIGN_(AnyOfMatcherImpl);
> };
>
> -#if GTEST_LANG_CXX11
> // AnyOfMatcher is used for the variadic implementation of AnyOf(m_1,
> m_2, ...).
> template <typename... Args>
> using AnyOfMatcher = VariadicMatcher<AnyOfMatcherImpl, Args...>;
>
> -#endif // GTEST_LANG_CXX11
> -
> -// Used for implementing the AnyOf(m_1, ..., m_n) matcher, which
> -// matches a value that matches at least one of the matchers m_1, ...,
> -// and m_n.
> -template <typename Matcher1, typename Matcher2>
> -class EitherOfMatcher {
> +// Wrapper for implementation of Any/AllOfArray().
> +template <template <class> class MatcherImpl, typename T>
> +class SomeOfArrayMatcher {
> public:
> - EitherOfMatcher(Matcher1 matcher1, Matcher2 matcher2)
> - : matcher1_(matcher1), matcher2_(matcher2) {}
> + // Constructs the matcher from a sequence of element values or
> + // element matchers.
> + template <typename Iter>
> + SomeOfArrayMatcher(Iter first, Iter last) : matchers_(first, last) {}
>
> - // This template type conversion operator allows a
> - // EitherOfMatcher<Matcher1, Matcher2> object to match any type that
> - // both Matcher1 and Matcher2 can match.
> - template <typename T>
> - operator Matcher<T>() const {
> - std::vector<Matcher<T> > values;
> - values.push_back(SafeMatcherCast<T>(matcher1_));
> - values.push_back(SafeMatcherCast<T>(matcher2_));
> - return Matcher<T>(new AnyOfMatcherImpl<T>(internal::move(values)));
> + template <typename U>
> + operator Matcher<U>() const { // NOLINT
> + using RawU = typename std::decay<U>::type;
> + std::vector<Matcher<RawU>> matchers;
> + for (const auto& matcher : matchers_) {
> + matchers.push_back(MatcherCast<RawU>(matcher));
> + }
> + return Matcher<U>(new MatcherImpl<RawU>(std::move(matchers)));
> }
>
> private:
> - Matcher1 matcher1_;
> - Matcher2 matcher2_;
> + const ::std::vector<T> matchers_;
>
> - GTEST_DISALLOW_ASSIGN_(EitherOfMatcher);
> + GTEST_DISALLOW_ASSIGN_(SomeOfArrayMatcher);
> };
>
> +template <typename T>
> +using AllOfArrayMatcher = SomeOfArrayMatcher<AllOfMatcherImpl, T>;
> +
> +template <typename T>
> +using AnyOfArrayMatcher = SomeOfArrayMatcher<AnyOfMatcherImpl, T>;
> +
> // Used for implementing Truly(pred), which turns a predicate into a
> // matcher.
> template <typename Predicate>
> @@ -2044,7 +1301,7 @@ class MatcherAsPredicate {
> template <typename M>
> class PredicateFormatterFromMatcher {
> public:
> - explicit PredicateFormatterFromMatcher(M m) :
> matcher_(internal::move(m)) {}
> + explicit PredicateFormatterFromMatcher(M m) : matcher_(std::move(m)) {}
>
> // This template () operator allows a PredicateFormatterFromMatcher
> // object to act as a predicate-formatter suitable for using with
> @@ -2063,14 +1320,24 @@ class PredicateFormatterFromMatcher {
> // We don't write MatcherCast<const T&> either, as that allows
> // potentially unsafe downcasting of the matcher argument.
> const Matcher<const T&> matcher = SafeMatcherCast<const T&>(matcher_);
> - StringMatchResultListener listener;
> - if (MatchPrintAndExplain(x, matcher, &listener))
> +
> + // The expected path here is that the matcher should match (i.e. that
> most
> + // tests pass) so optimize for this case.
> + if (matcher.Matches(x)) {
> return AssertionSuccess();
> + }
>
> ::std::stringstream ss;
> ss << "Value of: " << value_text << "\n"
> << "Expected: ";
> matcher.DescribeTo(&ss);
> +
> + // Rerun the matcher to "PrintAndExain" the failure.
> + StringMatchResultListener listener;
> + if (MatchPrintAndExplain(x, matcher, &listener)) {
> + ss << "\n The matcher failed on the initial attempt; but passed
> when "
> + "rerun to generate the explanation.";
> + }
> ss << "\n Actual: " << listener.str();
> return AssertionFailure() << ss.str();
> }
> @@ -2088,7 +1355,7 @@ class PredicateFormatterFromMatcher {
> template <typename M>
> inline PredicateFormatterFromMatcher<M>
> MakePredicateFormatterFromMatcher(M matcher) {
> - return PredicateFormatterFromMatcher<M>(internal::move(matcher));
> + return PredicateFormatterFromMatcher<M>(std::move(matcher));
> }
>
> // Implements the polymorphic floating point equality matcher, which
> matches
> @@ -2129,8 +1396,8 @@ class FloatingEqMatcher {
> nan_eq_nan_(nan_eq_nan),
> max_abs_error_(max_abs_error) {}
>
> - virtual bool MatchAndExplain(T value,
> - MatchResultListener* listener) const {
> + bool MatchAndExplain(T value,
> + MatchResultListener* listener) const override {
> const FloatingPoint<FloatType> actual(value), expected(expected_);
>
> // Compares NaNs first, if nan_eq_nan_ is true.
> @@ -2164,7 +1431,7 @@ class FloatingEqMatcher {
> }
> }
>
> - virtual void DescribeTo(::std::ostream* os) const {
> + void DescribeTo(::std::ostream* os) const override {
> // os->precision() returns the previously set precision, which we
> // store to restore the ostream to its original configuration
> // after outputting.
> @@ -2185,7 +1452,7 @@ class FloatingEqMatcher {
> os->precision(old_precision);
> }
>
> - virtual void DescribeNegationTo(::std::ostream* os) const {
> + void DescribeNegationTo(::std::ostream* os) const override {
> // As before, get original precision.
> const ::std::streamsize old_precision = os->precision(
> ::std::numeric_limits<FloatType>::digits10 + 2);
> @@ -2269,14 +1536,14 @@ class FloatingEq2Matcher {
> }
>
> template <typename T1, typename T2>
> - operator Matcher< ::testing::tuple<T1, T2> >() const {
> + operator Matcher<::std::tuple<T1, T2>>() const {
> return MakeMatcher(
> - new Impl< ::testing::tuple<T1, T2> >(max_abs_error_,
> nan_eq_nan_));
> + new Impl<::std::tuple<T1, T2>>(max_abs_error_, nan_eq_nan_));
> }
> template <typename T1, typename T2>
> - operator Matcher<const ::testing::tuple<T1, T2>&>() const {
> + operator Matcher<const ::std::tuple<T1, T2>&>() const {
> return MakeMatcher(
> - new Impl<const ::testing::tuple<T1, T2>&>(max_abs_error_,
> nan_eq_nan_));
> + new Impl<const ::std::tuple<T1, T2>&>(max_abs_error_,
> nan_eq_nan_));
> }
>
> private:
> @@ -2291,23 +1558,23 @@ class FloatingEq2Matcher {
> max_abs_error_(max_abs_error),
> nan_eq_nan_(nan_eq_nan) {}
>
> - virtual bool MatchAndExplain(Tuple args,
> - MatchResultListener* listener) const {
> + bool MatchAndExplain(Tuple args,
> + MatchResultListener* listener) const override {
> if (max_abs_error_ == -1) {
> - FloatingEqMatcher<FloatType> fm(::testing::get<0>(args),
> nan_eq_nan_);
> - return static_cast<Matcher<FloatType> >(fm).MatchAndExplain(
> - ::testing::get<1>(args), listener);
> + FloatingEqMatcher<FloatType> fm(::std::get<0>(args), nan_eq_nan_);
> + return static_cast<Matcher<FloatType>>(fm).MatchAndExplain(
> + ::std::get<1>(args), listener);
> } else {
> - FloatingEqMatcher<FloatType> fm(::testing::get<0>(args),
> nan_eq_nan_,
> + FloatingEqMatcher<FloatType> fm(::std::get<0>(args), nan_eq_nan_,
> max_abs_error_);
> - return static_cast<Matcher<FloatType> >(fm).MatchAndExplain(
> - ::testing::get<1>(args), listener);
> + return static_cast<Matcher<FloatType>>(fm).MatchAndExplain(
> + ::std::get<1>(args), listener);
> }
> }
> - virtual void DescribeTo(::std::ostream* os) const {
> + void DescribeTo(::std::ostream* os) const override {
> *os << "are " << GetDesc;
> }
> - virtual void DescribeNegationTo(::std::ostream* os) const {
> + void DescribeNegationTo(::std::ostream* os) const override {
> *os << "aren't " << GetDesc;
> }
>
> @@ -2341,8 +1608,7 @@ class PointeeMatcher {
> // enough for implementing the DescribeTo() method of Pointee().
> template <typename Pointer>
> operator Matcher<Pointer>() const {
> - return Matcher<Pointer>(
> - new Impl<GTEST_REFERENCE_TO_CONST_(Pointer)>(matcher_));
> + return Matcher<Pointer>(new Impl<const Pointer&>(matcher_));
> }
>
> private:
> @@ -2350,26 +1616,25 @@ class PointeeMatcher {
> template <typename Pointer>
> class Impl : public MatcherInterface<Pointer> {
> public:
> - typedef typename PointeeOf<GTEST_REMOVE_CONST_( // NOLINT
> - GTEST_REMOVE_REFERENCE_(Pointer))>::type Pointee;
> + typedef typename PointeeOf<typename std::remove_const<
> + typename std::remove_reference<Pointer>::type>::type>::type
> Pointee;
>
> explicit Impl(const InnerMatcher& matcher)
> : matcher_(MatcherCast<const Pointee&>(matcher)) {}
>
> - virtual void DescribeTo(::std::ostream* os) const {
> + void DescribeTo(::std::ostream* os) const override {
> *os << "points to a value that ";
> matcher_.DescribeTo(os);
> }
>
> - virtual void DescribeNegationTo(::std::ostream* os) const {
> + void DescribeNegationTo(::std::ostream* os) const override {
> *os << "does not point to a value that ";
> matcher_.DescribeTo(os);
> }
>
> - virtual bool MatchAndExplain(Pointer pointer,
> - MatchResultListener* listener) const {
> - if (GetRawPointer(pointer) == NULL)
> - return false;
> + bool MatchAndExplain(Pointer pointer,
> + MatchResultListener* listener) const override {
> + if (GetRawPointer(pointer) == nullptr) return false;
>
> *listener << "which points to ";
> return MatchPrintAndExplain(*pointer, matcher_, listener);
> @@ -2434,7 +1699,6 @@ class WhenDynamicCastToMatcher : public
> WhenDynamicCastToMatcherBase<To> {
>
> template <typename From>
> bool MatchAndExplain(From from, MatchResultListener* listener) const {
> - // FIXME: Add more detail on failures. ie did the dyn_cast fail?
> To to = dynamic_cast<To>(from);
> return MatchPrintAndExplain(to, this->matcher_, listener);
> }
> @@ -2452,7 +1716,7 @@ class WhenDynamicCastToMatcher<To&> : public
> WhenDynamicCastToMatcherBase<To&> {
> bool MatchAndExplain(From& from, MatchResultListener* listener) const {
> // We don't want an std::bad_cast here, so do the cast with pointers.
> To* to = dynamic_cast<To*>(&from);
> - if (to == NULL) {
> + if (to == nullptr) {
> *listener << "which cannot be dynamic_cast to " <<
> this->GetToName();
> return false;
> }
> @@ -2488,32 +1752,30 @@ class FieldMatcher {
>
> template <typename T>
> bool MatchAndExplain(const T& value, MatchResultListener* listener)
> const {
> + // FIXME: The dispatch on std::is_pointer was introduced as a
> workaround for
> + // a compiler bug, and can now be removed.
> return MatchAndExplainImpl(
> - typename ::testing::internal::
> - is_pointer<GTEST_REMOVE_CONST_(T)>::type(),
> + typename std::is_pointer<typename
> std::remove_const<T>::type>::type(),
> value, listener);
> }
>
> private:
> - // The first argument of MatchAndExplainImpl() is needed to help
> - // Symbian's C++ compiler choose which overload to use. Its type is
> - // true_type iff the Field() matcher is used to match a pointer.
> - bool MatchAndExplainImpl(false_type /* is_not_pointer */, const Class&
> obj,
> + bool MatchAndExplainImpl(std::false_type /* is_not_pointer */,
> + const Class& obj,
> MatchResultListener* listener) const {
> *listener << whose_field_ << "is ";
> return MatchPrintAndExplain(obj.*field_, matcher_, listener);
> }
>
> - bool MatchAndExplainImpl(true_type /* is_pointer */, const Class* p,
> + bool MatchAndExplainImpl(std::true_type /* is_pointer */, const Class*
> p,
> MatchResultListener* listener) const {
> - if (p == NULL)
> - return false;
> + if (p == nullptr) return false;
>
> *listener << "which points to an object ";
> // Since *p has a field, it must be a class/struct/union type and
> // thus cannot be a pointer. Therefore we pass false_type() as
> // the first argument.
> - return MatchAndExplainImpl(false_type(), *p, listener);
> + return MatchAndExplainImpl(std::false_type(), *p, listener);
> }
>
> const FieldType Class::*field_;
> @@ -2534,11 +1796,7 @@ class FieldMatcher {
> template <typename Class, typename PropertyType, typename Property>
> class PropertyMatcher {
> public:
> - // The property may have a reference type, so 'const PropertyType&'
> - // may cause double references and fail to compile. That's why we
> - // need GTEST_REFERENCE_TO_CONST, which works regardless of
> - // PropertyType being a reference or not.
> - typedef GTEST_REFERENCE_TO_CONST_(PropertyType) RefToConstProperty;
> + typedef const PropertyType& RefToConstProperty;
>
> PropertyMatcher(Property property, const Matcher<RefToConstProperty>&
> matcher)
> : property_(property),
> @@ -2564,41 +1822,30 @@ class PropertyMatcher {
> template <typename T>
> bool MatchAndExplain(const T&value, MatchResultListener* listener)
> const {
> return MatchAndExplainImpl(
> - typename ::testing::internal::
> - is_pointer<GTEST_REMOVE_CONST_(T)>::type(),
> + typename std::is_pointer<typename
> std::remove_const<T>::type>::type(),
> value, listener);
> }
>
> private:
> - // The first argument of MatchAndExplainImpl() is needed to help
> - // Symbian's C++ compiler choose which overload to use. Its type is
> - // true_type iff the Property() matcher is used to match a pointer.
> - bool MatchAndExplainImpl(false_type /* is_not_pointer */, const Class&
> obj,
> + bool MatchAndExplainImpl(std::false_type /* is_not_pointer */,
> + const Class& obj,
> MatchResultListener* listener) const {
> *listener << whose_property_ << "is ";
> // Cannot pass the return value (for example, int) to
> MatchPrintAndExplain,
> // which takes a non-const reference as argument.
> -#if defined(_PREFAST_ ) && _MSC_VER == 1800
> - // Workaround bug in VC++ 2013's /analyze parser.
> - //
> https://connect.microsoft.com/VisualStudio/feedback/details/1106363/internal-compiler-error-with-analyze-due-to-failure-to-infer-move
> - posix::Abort(); // To make sure it is never run.
> - return false;
> -#else
> RefToConstProperty result = (obj.*property_)();
> return MatchPrintAndExplain(result, matcher_, listener);
> -#endif
> }
>
> - bool MatchAndExplainImpl(true_type /* is_pointer */, const Class* p,
> + bool MatchAndExplainImpl(std::true_type /* is_pointer */, const Class*
> p,
> MatchResultListener* listener) const {
> - if (p == NULL)
> - return false;
> + if (p == nullptr) return false;
>
> *listener << "which points to an object ";
> // Since *p has a property method, it must be a class/struct/union
> // type and thus cannot be a pointer. Therefore we pass
> // false_type() as the first argument.
> - return MatchAndExplainImpl(false_type(), *p, listener);
> + return MatchAndExplainImpl(std::false_type(), *p, listener);
> }
>
> Property property_;
> @@ -2619,14 +1866,10 @@ struct CallableTraits {
>
> static void CheckIsValid(Functor /* functor */) {}
>
> -#if GTEST_LANG_CXX11
> template <typename T>
> - static auto Invoke(Functor f, T arg) -> decltype(f(arg)) { return
> f(arg); }
> -#else
> - typedef typename Functor::result_type ResultType;
> - template <typename T>
> - static ResultType Invoke(Functor f, T arg) { return f(arg); }
> -#endif
> + static auto Invoke(Functor f, const T& arg) -> decltype(f(arg)) {
> + return f(arg);
> + }
> };
>
> // Specialization for function pointers.
> @@ -2636,7 +1879,7 @@ struct CallableTraits<ResType(*)(ArgType)> {
> typedef ResType(*StorageType)(ArgType);
>
> static void CheckIsValid(ResType(*f)(ArgType)) {
> - GTEST_CHECK_(f != NULL)
> + GTEST_CHECK_(f != nullptr)
> << "NULL function pointer is passed into ResultOf().";
> }
> template <typename T>
> @@ -2651,13 +1894,13 @@ template <typename Callable, typename InnerMatcher>
> class ResultOfMatcher {
> public:
> ResultOfMatcher(Callable callable, InnerMatcher matcher)
> - : callable_(internal::move(callable)),
> matcher_(internal::move(matcher)) {
> + : callable_(std::move(callable)), matcher_(std::move(matcher)) {
> CallableTraits<Callable>::CheckIsValid(callable_);
> }
>
> template <typename T>
> operator Matcher<T>() const {
> - return Matcher<T>(new Impl<T>(callable_, matcher_));
> + return Matcher<T>(new Impl<const T&>(callable_, matcher_));
> }
>
> private:
> @@ -2665,29 +1908,25 @@ class ResultOfMatcher {
>
> template <typename T>
> class Impl : public MatcherInterface<T> {
> -#if GTEST_LANG_CXX11
> using ResultType = decltype(CallableTraits<Callable>::template
> Invoke<T>(
> std::declval<CallableStorageType>(), std::declval<T>()));
> -#else
> - typedef typename CallableTraits<Callable>::ResultType ResultType;
> -#endif
>
> public:
> template <typename M>
> Impl(const CallableStorageType& callable, const M& matcher)
> : callable_(callable), matcher_(MatcherCast<ResultType>(matcher))
> {}
>
> - virtual void DescribeTo(::std::ostream* os) const {
> + void DescribeTo(::std::ostream* os) const override {
> *os << "is mapped by the given callable to a value that ";
> matcher_.DescribeTo(os);
> }
>
> - virtual void DescribeNegationTo(::std::ostream* os) const {
> + void DescribeNegationTo(::std::ostream* os) const override {
> *os << "is mapped by the given callable to a value that ";
> matcher_.DescribeNegationTo(os);
> }
>
> - virtual bool MatchAndExplain(T obj, MatchResultListener* listener)
> const {
> + bool MatchAndExplain(T obj, MatchResultListener* listener) const
> override {
> *listener << "which is mapped by the given callable to ";
> // Cannot pass the return value directly to MatchPrintAndExplain,
> which
> // takes a non-const reference as argument.
> @@ -2726,29 +1965,27 @@ class SizeIsMatcher {
>
> template <typename Container>
> operator Matcher<Container>() const {
> - return MakeMatcher(new Impl<Container>(size_matcher_));
> + return Matcher<Container>(new Impl<const Container&>(size_matcher_));
> }
>
> template <typename Container>
> class Impl : public MatcherInterface<Container> {
> public:
> - typedef internal::StlContainerView<
> - GTEST_REMOVE_REFERENCE_AND_CONST_(Container)> ContainerView;
> - typedef typename ContainerView::type::size_type SizeType;
> + using SizeType = decltype(std::declval<Container>().size());
> explicit Impl(const SizeMatcher& size_matcher)
> : size_matcher_(MatcherCast<SizeType>(size_matcher)) {}
>
> - virtual void DescribeTo(::std::ostream* os) const {
> + void DescribeTo(::std::ostream* os) const override {
> *os << "size ";
> size_matcher_.DescribeTo(os);
> }
> - virtual void DescribeNegationTo(::std::ostream* os) const {
> + void DescribeNegationTo(::std::ostream* os) const override {
> *os << "size ";
> size_matcher_.DescribeNegationTo(os);
> }
>
> - virtual bool MatchAndExplain(Container container,
> - MatchResultListener* listener) const {
> + bool MatchAndExplain(Container container,
> + MatchResultListener* listener) const override {
> SizeType size = container.size();
> StringMatchResultListener size_listener;
> const bool result = size_matcher_.MatchAndExplain(size,
> &size_listener);
> @@ -2778,42 +2015,37 @@ class BeginEndDistanceIsMatcher {
>
> template <typename Container>
> operator Matcher<Container>() const {
> - return MakeMatcher(new Impl<Container>(distance_matcher_));
> + return Matcher<Container>(new Impl<const
> Container&>(distance_matcher_));
> }
>
> template <typename Container>
> class Impl : public MatcherInterface<Container> {
> - public:
> - typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer;
> - typedef internal::StlContainerView<RawContainer> View;
> - typedef typename View::type StlContainer;
> - typedef typename View::const_reference StlContainerReference;
> - typedef decltype(std::begin(
> - std::declval<StlContainerReference>()))
> StlContainerConstIterator;
> - typedef typename std::iterator_traits<
> - StlContainerConstIterator>::
> diff erence_type DistanceType;
> -
> - explicit Impl(const DistanceMatcher &distance_matcher)
> - : distance_matcher_(MatcherCast<DistanceType>(distance_matcher))
> {}
> -
> - virtual void DescribeTo(::std::ostream *os) const {
> - *os << "distance between begin() and end() ";
> - distance_matcher_.DescribeTo(os);
> + public:
> + typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer;
> + typedef internal::StlContainerView<RawContainer> View;
> + typedef typename View::type StlContainer;
> + typedef typename View::const_reference StlContainerReference;
> + typedef decltype(std::begin(
> + std::declval<StlContainerReference>())) StlContainerConstIterator;
> + typedef typename std::iterator_traits<
> + StlContainerConstIterator>::
> diff erence_type DistanceType;
> + explicit Impl(const DistanceMatcher& distance_matcher)
> + : distance_matcher_(MatcherCast<DistanceType>(distance_matcher))
> {}
> +
> + void DescribeTo(::std::ostream* os) const override {
> + *os << "distance between begin() and end() ";
> + distance_matcher_.DescribeTo(os);
> }
> - virtual void DescribeNegationTo(::std::ostream* os) const {
> + void DescribeNegationTo(::std::ostream* os) const override {
> *os << "distance between begin() and end() ";
> distance_matcher_.DescribeNegationTo(os);
> }
>
> - virtual bool MatchAndExplain(Container container,
> - MatchResultListener* listener) const {
> -#if GTEST_HAS_STD_BEGIN_AND_END_
> + bool MatchAndExplain(Container container,
> + MatchResultListener* listener) const override {
> using std::begin;
> using std::end;
> DistanceType distance = std::distance(begin(container),
> end(container));
> -#else
> - DistanceType distance = std::distance(container.begin(),
> container.end());
> -#endif
> StringMatchResultListener distance_listener;
> const bool result =
> distance_matcher_.MatchAndExplain(distance, &distance_listener);
> @@ -2850,15 +2082,15 @@ class ContainerEqMatcher {
> typedef typename View::type StlContainer;
> typedef typename View::const_reference StlContainerReference;
>
> + static_assert(!std::is_const<Container>::value,
> + "Container type must not be const");
> + static_assert(!std::is_reference<Container>::value,
> + "Container type must not be a reference");
> +
> // We make a copy of expected in case the elements in it are modified
> // after this matcher is created.
> explicit ContainerEqMatcher(const Container& expected)
> - : expected_(View::Copy(expected)) {
> - // Makes sure the user doesn't instantiate this class template
> - // with a const or reference type.
> - (void)testing::StaticAssertTypeEq<Container,
> - GTEST_REMOVE_REFERENCE_AND_CONST_(Container)>();
> - }
> + : expected_(View::Copy(expected)) {}
>
> void DescribeTo(::std::ostream* os) const {
> *os << "equals ";
> @@ -2872,9 +2104,8 @@ class ContainerEqMatcher {
> template <typename LhsContainer>
> bool MatchAndExplain(const LhsContainer& lhs,
> MatchResultListener* listener) const {
> - // GTEST_REMOVE_CONST_() is needed to work around an MSVC 8.0 bug
> - // that causes LhsContainer to be a const type sometimes.
> - typedef internal::StlContainerView<GTEST_REMOVE_CONST_(LhsContainer)>
> + typedef internal::StlContainerView<
> + typename std::remove_const<LhsContainer>::type>
> LhsView;
> typedef typename LhsView::type LhsStlContainer;
> StlContainerReference lhs_stl_container =
> LhsView::ConstReference(lhs);
> @@ -2882,7 +2113,7 @@ class ContainerEqMatcher {
> return true;
>
> ::std::ostream* const os = listener->stream();
> - if (os != NULL) {
> + if (os != nullptr) {
> // Something is
> diff erent. Check for extra values first.
> bool printed_header = false;
> for (typename LhsStlContainer::const_iterator it =
> @@ -2962,18 +2193,18 @@ class WhenSortedByMatcher {
> Impl(const Comparator& comparator, const ContainerMatcher& matcher)
> : comparator_(comparator), matcher_(matcher) {}
>
> - virtual void DescribeTo(::std::ostream* os) const {
> + void DescribeTo(::std::ostream* os) const override {
> *os << "(when sorted) ";
> matcher_.DescribeTo(os);
> }
>
> - virtual void DescribeNegationTo(::std::ostream* os) const {
> + void DescribeNegationTo(::std::ostream* os) const override {
> *os << "(when sorted) ";
> matcher_.DescribeNegationTo(os);
> }
>
> - virtual bool MatchAndExplain(LhsContainer lhs,
> - MatchResultListener* listener) const {
> + bool MatchAndExplain(LhsContainer lhs,
> + MatchResultListener* listener) const override {
> LhsStlContainerReference lhs_stl_container =
> LhsView::ConstReference(lhs);
> ::std::vector<LhsValue> sorted_container(lhs_stl_container.begin(),
> lhs_stl_container.end());
> @@ -3012,7 +2243,7 @@ class WhenSortedByMatcher {
> };
>
> // Implements Pointwise(tuple_matcher, rhs_container). tuple_matcher
> -// must be able to be safely cast to Matcher<tuple<const T1&, const
> +// must be able to be safely cast to Matcher<std::tuple<const T1&, const
> // T2&> >, where T1 and T2 are the types of elements in the LHS
> // container and the RHS container respectively.
> template <typename TupleMatcher, typename RhsContainer>
> @@ -3026,15 +2257,15 @@ class PointwiseMatcher {
> typedef typename RhsView::type RhsStlContainer;
> typedef typename RhsStlContainer::value_type RhsValue;
>
> + static_assert(!std::is_const<RhsContainer>::value,
> + "RhsContainer type must not be const");
> + static_assert(!std::is_reference<RhsContainer>::value,
> + "RhsContainer type must not be a reference");
> +
> // Like ContainerEq, we make a copy of rhs in case the elements in
> // it are modified after this matcher is created.
> PointwiseMatcher(const TupleMatcher& tuple_matcher, const RhsContainer&
> rhs)
> - : tuple_matcher_(tuple_matcher), rhs_(RhsView::Copy(rhs)) {
> - // Makes sure the user doesn't instantiate this class template
> - // with a const or reference type.
> - (void)testing::StaticAssertTypeEq<RhsContainer,
> - GTEST_REMOVE_REFERENCE_AND_CONST_(RhsContainer)>();
> - }
> + : tuple_matcher_(tuple_matcher), rhs_(RhsView::Copy(rhs)) {}
>
> template <typename LhsContainer>
> operator Matcher<LhsContainer>() const {
> @@ -3042,7 +2273,8 @@ class PointwiseMatcher {
>
> !IsHashTable<GTEST_REMOVE_REFERENCE_AND_CONST_(LhsContainer)>::value,
> use_UnorderedPointwise_with_hash_tables);
>
> - return MakeMatcher(new Impl<LhsContainer>(tuple_matcher_, rhs_));
> + return Matcher<LhsContainer>(
> + new Impl<const LhsContainer&>(tuple_matcher_, rhs_));
> }
>
> template <typename LhsContainer>
> @@ -3057,21 +2289,21 @@ class PointwiseMatcher {
> // reference, as they may be expensive to copy. We must use tuple
> // instead of pair here, as a pair cannot hold references (C++ 98,
> // 20.2.2 [lib.pairs]).
> - typedef ::testing::tuple<const LhsValue&, const RhsValue&>
> InnerMatcherArg;
> + typedef ::std::tuple<const LhsValue&, const RhsValue&>
> InnerMatcherArg;
>
> Impl(const TupleMatcher& tuple_matcher, const RhsStlContainer& rhs)
> // mono_tuple_matcher_ holds a monomorphic version of the tuple
> matcher.
> :
> mono_tuple_matcher_(SafeMatcherCast<InnerMatcherArg>(tuple_matcher)),
> rhs_(rhs) {}
>
> - virtual void DescribeTo(::std::ostream* os) const {
> + void DescribeTo(::std::ostream* os) const override {
> *os << "contains " << rhs_.size()
> << " values, where each value and its corresponding value in ";
> UniversalPrinter<RhsStlContainer>::Print(rhs_, os);
> *os << " ";
> mono_tuple_matcher_.DescribeTo(os);
> }
> - virtual void DescribeNegationTo(::std::ostream* os) const {
> + void DescribeNegationTo(::std::ostream* os) const override {
> *os << "doesn't contain exactly " << rhs_.size()
> << " values, or contains a value x at some index i"
> << " where x and the i-th value of ";
> @@ -3080,8 +2312,8 @@ class PointwiseMatcher {
> mono_tuple_matcher_.DescribeNegationTo(os);
> }
>
> - virtual bool MatchAndExplain(LhsContainer lhs,
> - MatchResultListener* listener) const {
> + bool MatchAndExplain(LhsContainer lhs,
> + MatchResultListener* listener) const override {
> LhsStlContainerReference lhs_stl_container =
> LhsView::ConstReference(lhs);
> const size_t actual_size = lhs_stl_container.size();
> if (actual_size != rhs_.size()) {
> @@ -3188,18 +2420,18 @@ class ContainsMatcherImpl : public
> QuantifierMatcherImpl<Container> {
> : QuantifierMatcherImpl<Container>(inner_matcher) {}
>
> // Describes what this matcher does.
> - virtual void DescribeTo(::std::ostream* os) const {
> + void DescribeTo(::std::ostream* os) const override {
> *os << "contains at least one element that ";
> this->inner_matcher_.DescribeTo(os);
> }
>
> - virtual void DescribeNegationTo(::std::ostream* os) const {
> + void DescribeNegationTo(::std::ostream* os) const override {
> *os << "doesn't contain any element that ";
> this->inner_matcher_.DescribeTo(os);
> }
>
> - virtual bool MatchAndExplain(Container container,
> - MatchResultListener* listener) const {
> + bool MatchAndExplain(Container container,
> + MatchResultListener* listener) const override {
> return this->MatchAndExplainImpl(false, container, listener);
> }
>
> @@ -3217,18 +2449,18 @@ class EachMatcherImpl : public
> QuantifierMatcherImpl<Container> {
> : QuantifierMatcherImpl<Container>(inner_matcher) {}
>
> // Describes what this matcher does.
> - virtual void DescribeTo(::std::ostream* os) const {
> + void DescribeTo(::std::ostream* os) const override {
> *os << "only contains elements that ";
> this->inner_matcher_.DescribeTo(os);
> }
>
> - virtual void DescribeNegationTo(::std::ostream* os) const {
> + void DescribeNegationTo(::std::ostream* os) const override {
> *os << "contains some element that ";
> this->inner_matcher_.DescribeNegationTo(os);
> }
>
> - virtual bool MatchAndExplain(Container container,
> - MatchResultListener* listener) const {
> + bool MatchAndExplain(Container container,
> + MatchResultListener* listener) const override {
> return this->MatchAndExplainImpl(true, container, listener);
> }
>
> @@ -3244,7 +2476,8 @@ class ContainsMatcher {
>
> template <typename Container>
> operator Matcher<Container>() const {
> - return MakeMatcher(new
> ContainsMatcherImpl<Container>(inner_matcher_));
> + return Matcher<Container>(
> + new ContainsMatcherImpl<const Container&>(inner_matcher_));
> }
>
> private:
> @@ -3261,7 +2494,8 @@ class EachMatcher {
>
> template <typename Container>
> operator Matcher<Container>() const {
> - return MakeMatcher(new EachMatcherImpl<Container>(inner_matcher_));
> + return Matcher<Container>(
> + new EachMatcherImpl<const Container&>(inner_matcher_));
> }
>
> private:
> @@ -3274,7 +2508,6 @@ struct Rank1 {};
> struct Rank0 : Rank1 {};
>
> namespace pair_getters {
> -#if GTEST_LANG_CXX11
> using std::get;
> template <typename T>
> auto First(T& x, Rank1) -> decltype(get<0>(x)) { // NOLINT
> @@ -3293,25 +2526,6 @@ template <typename T>
> auto Second(T& x, Rank0) -> decltype((x.second)) { // NOLINT
> return x.second;
> }
> -#else
> -template <typename T>
> -typename T::first_type& First(T& x, Rank0) { // NOLINT
> - return x.first;
> -}
> -template <typename T>
> -const typename T::first_type& First(const T& x, Rank0) {
> - return x.first;
> -}
> -
> -template <typename T>
> -typename T::second_type& Second(T& x, Rank0) { // NOLINT
> - return x.second;
> -}
> -template <typename T>
> -const typename T::second_type& Second(const T& x, Rank0) {
> - return x.second;
> -}
> -#endif // GTEST_LANG_CXX11
> } // namespace pair_getters
>
> // Implements Key(inner_matcher) for the given argument pair type.
> @@ -3330,9 +2544,10 @@ class KeyMatcherImpl : public
> MatcherInterface<PairType> {
> testing::SafeMatcherCast<const KeyType&>(inner_matcher)) {
> }
>
> - // Returns true iff 'key_value.first' (the key) matches the inner
> matcher.
> - virtual bool MatchAndExplain(PairType key_value,
> - MatchResultListener* listener) const {
> + // Returns true if and only if 'key_value.first' (the key) matches the
> inner
> + // matcher.
> + bool MatchAndExplain(PairType key_value,
> + MatchResultListener* listener) const override {
> StringMatchResultListener inner_listener;
> const bool match = inner_matcher_.MatchAndExplain(
> pair_getters::First(key_value, Rank0()), &inner_listener);
> @@ -3344,13 +2559,13 @@ class KeyMatcherImpl : public
> MatcherInterface<PairType> {
> }
>
> // Describes what this matcher does.
> - virtual void DescribeTo(::std::ostream* os) const {
> + void DescribeTo(::std::ostream* os) const override {
> *os << "has a key that ";
> inner_matcher_.DescribeTo(os);
> }
>
> // Describes what the negation of this matcher does.
> - virtual void DescribeNegationTo(::std::ostream* os) const {
> + void DescribeNegationTo(::std::ostream* os) const override {
> *os << "doesn't have a key that ";
> inner_matcher_.DescribeTo(os);
> }
> @@ -3369,7 +2584,8 @@ class KeyMatcher {
>
> template <typename PairType>
> operator Matcher<PairType>() const {
> - return MakeMatcher(new KeyMatcherImpl<PairType>(matcher_for_key_));
> + return Matcher<PairType>(
> + new KeyMatcherImpl<const PairType&>(matcher_for_key_));
> }
>
> private:
> @@ -3396,7 +2612,7 @@ class PairMatcherImpl : public
> MatcherInterface<PairType> {
> }
>
> // Describes what this matcher does.
> - virtual void DescribeTo(::std::ostream* os) const {
> + void DescribeTo(::std::ostream* os) const override {
> *os << "has a first field that ";
> first_matcher_.DescribeTo(os);
> *os << ", and has a second field that ";
> @@ -3404,17 +2620,17 @@ class PairMatcherImpl : public
> MatcherInterface<PairType> {
> }
>
> // Describes what the negation of this matcher does.
> - virtual void DescribeNegationTo(::std::ostream* os) const {
> + void DescribeNegationTo(::std::ostream* os) const override {
> *os << "has a first field that ";
> first_matcher_.DescribeNegationTo(os);
> *os << ", or has a second field that ";
> second_matcher_.DescribeNegationTo(os);
> }
>
> - // Returns true iff 'a_pair.first' matches first_matcher and
> 'a_pair.second'
> - // matches second_matcher.
> - virtual bool MatchAndExplain(PairType a_pair,
> - MatchResultListener* listener) const {
> + // Returns true if and only if 'a_pair.first' matches first_matcher and
> + // 'a_pair.second' matches second_matcher.
> + bool MatchAndExplain(PairType a_pair,
> + MatchResultListener* listener) const override {
> if (!listener->IsInterested()) {
> // If the listener is not interested, we don't need to construct the
> // explanation.
> @@ -3474,9 +2690,8 @@ class PairMatcher {
>
> template <typename PairType>
> operator Matcher<PairType> () const {
> - return MakeMatcher(
> - new PairMatcherImpl<PairType>(
> - first_matcher_, second_matcher_));
> + return Matcher<PairType>(
> + new PairMatcherImpl<const PairType&>(first_matcher_,
> second_matcher_));
> }
>
> private:
> @@ -3509,7 +2724,7 @@ class ElementsAreMatcherImpl : public
> MatcherInterface<Container> {
> }
>
> // Describes what this matcher does.
> - virtual void DescribeTo(::std::ostream* os) const {
> + void DescribeTo(::std::ostream* os) const override {
> if (count() == 0) {
> *os << "is empty";
> } else if (count() == 1) {
> @@ -3528,7 +2743,7 @@ class ElementsAreMatcherImpl : public
> MatcherInterface<Container> {
> }
>
> // Describes what the negation of this matcher does.
> - virtual void DescribeNegationTo(::std::ostream* os) const {
> + void DescribeNegationTo(::std::ostream* os) const override {
> if (count() == 0) {
> *os << "isn't empty";
> return;
> @@ -3544,8 +2759,8 @@ class ElementsAreMatcherImpl : public
> MatcherInterface<Container> {
> }
> }
>
> - virtual bool MatchAndExplain(Container container,
> - MatchResultListener* listener) const {
> + bool MatchAndExplain(Container container,
> + MatchResultListener* listener) const override {
> // To work with stream-like "containers", we must only walk
> // through the elements in one pass.
>
> @@ -3749,6 +2964,7 @@ class UnorderedElementsAreMatcherImpl
> public:
> typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer;
> typedef internal::StlContainerView<RawContainer> View;
> + typedef typename View::type StlContainer;
> typedef typename View::const_reference StlContainerReference;
> typedef decltype(std::begin(
> std::declval<StlContainerReference>())) StlContainerConstIterator;
> @@ -3766,17 +2982,17 @@ class UnorderedElementsAreMatcherImpl
> }
>
> // Describes what this matcher does.
> - virtual void DescribeTo(::std::ostream* os) const {
> + void DescribeTo(::std::ostream* os) const override {
> return UnorderedElementsAreMatcherImplBase::DescribeToImpl(os);
> }
>
> // Describes what the negation of this matcher does.
> - virtual void DescribeNegationTo(::std::ostream* os) const {
> + void DescribeNegationTo(::std::ostream* os) const override {
> return
> UnorderedElementsAreMatcherImplBase::DescribeNegationToImpl(os);
> }
>
> - virtual bool MatchAndExplain(Container container,
> - MatchResultListener* listener) const {
> + bool MatchAndExplain(Container container,
> + MatchResultListener* listener) const override {
> StlContainerReference stl_container = View::ConstReference(container);
> ::std::vector<std::string> element_printouts;
> MatchMatrix matrix =
> @@ -3864,11 +3080,13 @@ class UnorderedElementsAreMatcher {
> decltype(*std::declval<StlContainerConstIterator &>())>::type
> Element;
> typedef ::std::vector<Matcher<const Element&> > MatcherVec;
> MatcherVec matchers;
> - matchers.reserve(::testing::tuple_size<MatcherTuple>::value);
> + matchers.reserve(::std::tuple_size<MatcherTuple>::value);
> TransformTupleValues(CastAndAppendTransform<const Element&>(),
> matchers_,
> ::std::back_inserter(matchers));
> - return MakeMatcher(new UnorderedElementsAreMatcherImpl<Container>(
> - UnorderedMatcherRequire::ExactMatch, matchers.begin(),
> matchers.end()));
> + return Matcher<Container>(
> + new UnorderedElementsAreMatcherImpl<const Container&>(
> + UnorderedMatcherRequire::ExactMatch, matchers.begin(),
> + matchers.end()));
> }
>
> private:
> @@ -3886,7 +3104,7 @@ class ElementsAreMatcher {
> operator Matcher<Container>() const {
> GTEST_COMPILE_ASSERT_(
> !IsHashTable<GTEST_REMOVE_REFERENCE_AND_CONST_(Container)>::value
> ||
> - ::testing::tuple_size<MatcherTuple>::value < 2,
> + ::std::tuple_size<MatcherTuple>::value < 2,
> use_UnorderedElementsAre_with_hash_tables);
>
> typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer;
> @@ -3898,11 +3116,11 @@ class ElementsAreMatcher {
> decltype(*std::declval<StlContainerConstIterator &>())>::type
> Element;
> typedef ::std::vector<Matcher<const Element&> > MatcherVec;
> MatcherVec matchers;
> - matchers.reserve(::testing::tuple_size<MatcherTuple>::value);
> + matchers.reserve(::std::tuple_size<MatcherTuple>::value);
> TransformTupleValues(CastAndAppendTransform<const Element&>(),
> matchers_,
> ::std::back_inserter(matchers));
> - return MakeMatcher(new ElementsAreMatcherImpl<Container>(
> - matchers.begin(), matchers.end()));
> + return Matcher<Container>(new ElementsAreMatcherImpl<const
> Container&>(
> + matchers.begin(), matchers.end()));
> }
>
> private:
> @@ -3921,8 +3139,9 @@ class UnorderedElementsAreArrayMatcher {
>
> template <typename Container>
> operator Matcher<Container>() const {
> - return MakeMatcher(new UnorderedElementsAreMatcherImpl<Container>(
> - match_flags_, matchers_.begin(), matchers_.end()));
> + return Matcher<Container>(
> + new UnorderedElementsAreMatcherImpl<const Container&>(
> + match_flags_, matchers_.begin(), matchers_.end()));
> }
>
> private:
> @@ -3945,7 +3164,7 @@ class ElementsAreArrayMatcher {
> !IsHashTable<GTEST_REMOVE_REFERENCE_AND_CONST_(Container)>::value,
> use_UnorderedElementsAreArray_with_hash_tables);
>
> - return MakeMatcher(new ElementsAreMatcherImpl<Container>(
> + return Matcher<Container>(new ElementsAreMatcherImpl<const
> Container&>(
> matchers_.begin(), matchers_.end()));
> }
>
> @@ -3957,8 +3176,8 @@ class ElementsAreArrayMatcher {
>
> // Given a 2-tuple matcher tm of type Tuple2Matcher and a value second
> // of type Second, BoundSecondMatcher<Tuple2Matcher, Second>(tm,
> -// second) is a polymorphic matcher that matches a value x iff tm
> -// matches tuple (x, second). Useful for implementing
> +// second) is a polymorphic matcher that matches a value x if and only if
> +// tm matches tuple (x, second). Useful for implementing
> // UnorderedPointwise() in terms of UnorderedElementsAreArray().
> //
> // BoundSecondMatcher is copyable and assignable, as we need to put
> @@ -3991,20 +3210,20 @@ class BoundSecondMatcher {
> template <typename T>
> class Impl : public MatcherInterface<T> {
> public:
> - typedef ::testing::tuple<T, Second> ArgTuple;
> + typedef ::std::tuple<T, Second> ArgTuple;
>
> Impl(const Tuple2Matcher& tm, const Second& second)
> : mono_tuple2_matcher_(SafeMatcherCast<const ArgTuple&>(tm)),
> second_value_(second) {}
>
> - virtual void DescribeTo(::std::ostream* os) const {
> + void DescribeTo(::std::ostream* os) const override {
> *os << "and ";
> UniversalPrint(second_value_, os);
> *os << " ";
> mono_tuple2_matcher_.DescribeTo(os);
> }
>
> - virtual bool MatchAndExplain(T x, MatchResultListener* listener)
> const {
> + bool MatchAndExplain(T x, MatchResultListener* listener) const
> override {
> return mono_tuple2_matcher_.MatchAndExplain(ArgTuple(x,
> second_value_),
> listener);
> }
> @@ -4022,8 +3241,8 @@ class BoundSecondMatcher {
>
> // Given a 2-tuple matcher tm and a value second,
> // MatcherBindSecond(tm, second) returns a matcher that matches a
> -// value x iff tm matches tuple (x, second). Useful for implementing
> -// UnorderedPointwise() in terms of UnorderedElementsAreArray().
> +// value x if and only if tm matches tuple (x, second). Useful for
> +// implementing UnorderedPointwise() in terms of
> UnorderedElementsAreArray().
> template <typename Tuple2Matcher, typename Second>
> BoundSecondMatcher<Tuple2Matcher, Second> MatcherBindSecond(
> const Tuple2Matcher& tm, const Second& second) {
> @@ -4048,7 +3267,7 @@ class OptionalMatcher {
>
> template <typename Optional>
> operator Matcher<Optional>() const {
> - return MakeMatcher(new Impl<Optional>(value_matcher_));
> + return Matcher<Optional>(new Impl<const Optional&>(value_matcher_));
> }
>
> template <typename Optional>
> @@ -4059,18 +3278,18 @@ class OptionalMatcher {
> explicit Impl(const ValueMatcher& value_matcher)
> : value_matcher_(MatcherCast<ValueType>(value_matcher)) {}
>
> - virtual void DescribeTo(::std::ostream* os) const {
> + void DescribeTo(::std::ostream* os) const override {
> *os << "value ";
> value_matcher_.DescribeTo(os);
> }
>
> - virtual void DescribeNegationTo(::std::ostream* os) const {
> + void DescribeNegationTo(::std::ostream* os) const override {
> *os << "value ";
> value_matcher_.DescribeNegationTo(os);
> }
>
> - virtual bool MatchAndExplain(Optional optional,
> - MatchResultListener* listener) const {
> + bool MatchAndExplain(Optional optional,
> + MatchResultListener* listener) const override {
> if (!optional) {
> *listener << "which is not engaged";
> return false;
> @@ -4106,11 +3325,12 @@ template <typename T>
> class VariantMatcher {
> public:
> explicit VariantMatcher(::testing::Matcher<const T&> matcher)
> - : matcher_(internal::move(matcher)) {}
> + : matcher_(std::move(matcher)) {}
>
> template <typename Variant>
> bool MatchAndExplain(const Variant& value,
> ::testing::MatchResultListener* listener) const {
> + using std::get;
> if (!listener->IsInterested()) {
> return holds_alternative<T>(value) &&
> matcher_.Matches(get<T>(value));
> }
> @@ -4173,11 +3393,11 @@ class AnyCastMatcher {
> ::testing::MatchResultListener* listener) const {
> if (!listener->IsInterested()) {
> const T* ptr = any_cast<T>(&value);
> - return ptr != NULL && matcher_.Matches(*ptr);
> + return ptr != nullptr && matcher_.Matches(*ptr);
> }
>
> const T* elem = any_cast<T>(&value);
> - if (elem == NULL) {
> + if (elem == nullptr) {
> *listener << "whose value is not of type '" << GetTypeName() << "'";
> return false;
> }
> @@ -4215,6 +3435,80 @@ class AnyCastMatcher {
> };
>
> } // namespace any_cast_matcher
> +
> +// Implements the Args() matcher.
> +template <class ArgsTuple, size_t... k>
> +class ArgsMatcherImpl : public MatcherInterface<ArgsTuple> {
> + public:
> + using RawArgsTuple = typename std::decay<ArgsTuple>::type;
> + using SelectedArgs =
> + std::tuple<typename std::tuple_element<k, RawArgsTuple>::type...>;
> + using MonomorphicInnerMatcher = Matcher<const SelectedArgs&>;
> +
> + template <typename InnerMatcher>
> + explicit ArgsMatcherImpl(const InnerMatcher& inner_matcher)
> + : inner_matcher_(SafeMatcherCast<const
> SelectedArgs&>(inner_matcher)) {}
> +
> + bool MatchAndExplain(ArgsTuple args,
> + MatchResultListener* listener) const override {
> + // Workaround spurious C4100 on MSVC<=15.7 when k is empty.
> + (void)args;
> + const SelectedArgs& selected_args =
> + std::forward_as_tuple(std::get<k>(args)...);
> + if (!listener->IsInterested()) return
> inner_matcher_.Matches(selected_args);
> +
> + PrintIndices(listener->stream());
> + *listener << "are " << PrintToString(selected_args);
> +
> + StringMatchResultListener inner_listener;
> + const bool match =
> + inner_matcher_.MatchAndExplain(selected_args, &inner_listener);
> + PrintIfNotEmpty(inner_listener.str(), listener->stream());
> + return match;
> + }
> +
> + void DescribeTo(::std::ostream* os) const override {
> + *os << "are a tuple ";
> + PrintIndices(os);
> + inner_matcher_.DescribeTo(os);
> + }
> +
> + void DescribeNegationTo(::std::ostream* os) const override {
> + *os << "are a tuple ";
> + PrintIndices(os);
> + inner_matcher_.DescribeNegationTo(os);
> + }
> +
> + private:
> + // Prints the indices of the selected fields.
> + static void PrintIndices(::std::ostream* os) {
> + *os << "whose fields (";
> + const char* sep = "";
> + // Workaround spurious C4189 on MSVC<=15.7 when k is empty.
> + (void)sep;
> + const char* dummy[] = {"", (*os << sep << "#" << k, sep = ", ")...};
> + (void)dummy;
> + *os << ") ";
> + }
> +
> + MonomorphicInnerMatcher inner_matcher_;
> +};
> +
> +template <class InnerMatcher, size_t... k>
> +class ArgsMatcher {
> + public:
> + explicit ArgsMatcher(InnerMatcher inner_matcher)
> + : inner_matcher_(std::move(inner_matcher)) {}
> +
> + template <typename ArgsTuple>
> + operator Matcher<ArgsTuple>() const { // NOLINT
> + return MakeMatcher(new ArgsMatcherImpl<ArgsTuple,
> k...>(inner_matcher_));
> + }
> +
> + private:
> + InnerMatcher inner_matcher_;
> +};
> +
> } // namespace internal
>
> // ElementsAreArray(iterator_first, iterator_last)
> @@ -4258,13 +3552,11 @@ ElementsAreArray(const Container& container) {
> return ElementsAreArray(container.begin(), container.end());
> }
>
> -#if GTEST_HAS_STD_INITIALIZER_LIST_
> template <typename T>
> inline internal::ElementsAreArrayMatcher<T>
> ElementsAreArray(::std::initializer_list<T> xs) {
> return ElementsAreArray(xs.begin(), xs.end());
> }
> -#endif
>
> // UnorderedElementsAreArray(iterator_first, iterator_last)
> // UnorderedElementsAreArray(pointer, count)
> @@ -4307,13 +3599,11 @@ UnorderedElementsAreArray(const Container&
> container) {
> return UnorderedElementsAreArray(container.begin(), container.end());
> }
>
> -#if GTEST_HAS_STD_INITIALIZER_LIST_
> template <typename T>
> inline internal::UnorderedElementsAreArrayMatcher<T>
> UnorderedElementsAreArray(::std::initializer_list<T> xs) {
> return UnorderedElementsAreArray(xs.begin(), xs.end());
> }
> -#endif
>
> // _ is a matcher that matches anything of any type.
> //
> @@ -4335,70 +3625,13 @@ inline Matcher<T> A() {
> template <typename T>
> inline Matcher<T> An() { return A<T>(); }
>
> -// Creates a polymorphic matcher that matches anything equal to x.
> -// Note: if the parameter of Eq() were declared as const T&, Eq("foo")
> -// wouldn't compile.
> -template <typename T>
> -inline internal::EqMatcher<T> Eq(T x) { return internal::EqMatcher<T>(x);
> }
> -
> -// Constructs a Matcher<T> from a 'value' of type T. The constructed
> -// matcher matches any value that's equal to 'value'.
> -template <typename T>
> -Matcher<T>::Matcher(T value) { *this = Eq(value); }
> -
> template <typename T, typename M>
> Matcher<T> internal::MatcherCastImpl<T, M>::CastImpl(
> - const M& value,
> - internal::BooleanConstant<false> /* convertible_to_matcher */,
> - internal::BooleanConstant<false> /* convertible_to_T */) {
> + const M& value, std::false_type /* convertible_to_matcher */,
> + std::false_type /* convertible_to_T */) {
> return Eq(value);
> }
>
> -// Creates a monomorphic matcher that matches anything with type Lhs
> -// and equal to rhs. A user may need to use this instead of Eq(...)
> -// in order to resolve an overloading ambiguity.
> -//
> -// TypedEq<T>(x) is just a convenient short-hand for Matcher<T>(Eq(x))
> -// or Matcher<T>(x), but more readable than the latter.
> -//
> -// We could define similar monomorphic matchers for other comparison
> -// operations (e.g. TypedLt, TypedGe, and etc), but decided not to do
> -// it yet as those are used much less than Eq() in practice. A user
> -// can always write Matcher<T>(Lt(5)) to be explicit about the type,
> -// for example.
> -template <typename Lhs, typename Rhs>
> -inline Matcher<Lhs> TypedEq(const Rhs& rhs) { return Eq(rhs); }
> -
> -// Creates a polymorphic matcher that matches anything >= x.
> -template <typename Rhs>
> -inline internal::GeMatcher<Rhs> Ge(Rhs x) {
> - return internal::GeMatcher<Rhs>(x);
> -}
> -
> -// Creates a polymorphic matcher that matches anything > x.
> -template <typename Rhs>
> -inline internal::GtMatcher<Rhs> Gt(Rhs x) {
> - return internal::GtMatcher<Rhs>(x);
> -}
> -
> -// Creates a polymorphic matcher that matches anything <= x.
> -template <typename Rhs>
> -inline internal::LeMatcher<Rhs> Le(Rhs x) {
> - return internal::LeMatcher<Rhs>(x);
> -}
> -
> -// Creates a polymorphic matcher that matches anything < x.
> -template <typename Rhs>
> -inline internal::LtMatcher<Rhs> Lt(Rhs x) {
> - return internal::LtMatcher<Rhs>(x);
> -}
> -
> -// Creates a polymorphic matcher that matches anything != x.
> -template <typename Rhs>
> -inline internal::NeMatcher<Rhs> Ne(Rhs x) {
> - return internal::NeMatcher<Rhs>(x);
> -}
> -
> // Creates a polymorphic matcher that matches any NULL pointer.
> inline PolymorphicMatcher<internal::IsNullMatcher > IsNull() {
> return MakePolymorphicMatcher(internal::IsNullMatcher());
> @@ -4500,7 +3733,7 @@ WhenDynamicCastTo(const Matcher<To>& inner_matcher) {
> // Creates a matcher that matches an object whose given field matches
> // 'matcher'. For example,
> // Field(&Foo::number, Ge(5))
> -// matches a Foo object x iff x.number >= 5.
> +// matches a Foo object x if and only if x.number >= 5.
> template <typename Class, typename FieldType, typename FieldMatcher>
> inline PolymorphicMatcher<
> internal::FieldMatcher<Class, FieldType> > Field(
> @@ -4527,7 +3760,7 @@ inline
> PolymorphicMatcher<internal::FieldMatcher<Class, FieldType> > Field(
> // Creates a matcher that matches an object whose given property
> // matches 'matcher'. For example,
> // Property(&Foo::str, StartsWith("hi"))
> -// matches a Foo object x iff x.str() starts with "hi".
> +// matches a Foo object x if and only if x.str() starts with "hi".
> template <typename Class, typename PropertyType, typename PropertyMatcher>
> inline PolymorphicMatcher<internal::PropertyMatcher<
> Class, PropertyType, PropertyType (Class::*)() const> >
> @@ -4536,8 +3769,7 @@ Property(PropertyType (Class::*property)() const,
> return MakePolymorphicMatcher(
> internal::PropertyMatcher<Class, PropertyType,
> PropertyType (Class::*)() const>(
> - property,
> - MatcherCast<GTEST_REFERENCE_TO_CONST_(PropertyType)>(matcher)));
> + property, MatcherCast<const PropertyType&>(matcher)));
> // The call to MatcherCast() is required for supporting inner
> // matchers of compatible types. For example, it allows
> // Property(&Foo::bar, m)
> @@ -4555,11 +3787,9 @@ Property(const std::string& property_name,
> return MakePolymorphicMatcher(
> internal::PropertyMatcher<Class, PropertyType,
> PropertyType (Class::*)() const>(
> - property_name, property,
> - MatcherCast<GTEST_REFERENCE_TO_CONST_(PropertyType)>(matcher)));
> + property_name, property, MatcherCast<const
> PropertyType&>(matcher)));
> }
>
> -#if GTEST_LANG_CXX11
> // The same as above but for reference-qualified member functions.
> template <typename Class, typename PropertyType, typename PropertyMatcher>
> inline PolymorphicMatcher<internal::PropertyMatcher<
> @@ -4568,9 +3798,8 @@ Property(PropertyType (Class::*property)() const &,
> const PropertyMatcher& matcher) {
> return MakePolymorphicMatcher(
> internal::PropertyMatcher<Class, PropertyType,
> - PropertyType (Class::*)() const &>(
> - property,
> - MatcherCast<GTEST_REFERENCE_TO_CONST_(PropertyType)>(matcher)));
> + PropertyType (Class::*)() const&>(
> + property, MatcherCast<const PropertyType&>(matcher)));
> }
>
> // Three-argument form for reference-qualified member functions.
> @@ -4582,17 +3811,14 @@ Property(const std::string& property_name,
> const PropertyMatcher& matcher) {
> return MakePolymorphicMatcher(
> internal::PropertyMatcher<Class, PropertyType,
> - PropertyType (Class::*)() const &>(
> - property_name, property,
> - MatcherCast<GTEST_REFERENCE_TO_CONST_(PropertyType)>(matcher)));
> + PropertyType (Class::*)() const&>(
> + property_name, property, MatcherCast<const
> PropertyType&>(matcher)));
> }
> -#endif
>
> -// Creates a matcher that matches an object iff the result of applying
> -// a callable to x matches 'matcher'.
> -// For example,
> +// Creates a matcher that matches an object if and only if the result of
> +// applying a callable to x matches 'matcher'. For example,
> // ResultOf(f, StartsWith("hi"))
> -// matches a Foo object x iff f(x) starts with "hi".
> +// matches a Foo object x if and only if f(x) starts with "hi".
> // `callable` parameter can be a function, function pointer, or a
> functor. It is
> // required to keep no state affecting the results of the calls on it and
> make
> // no assumptions about how many calls will be made. Any state it keeps
> must be
> @@ -4601,7 +3827,7 @@ template <typename Callable, typename InnerMatcher>
> internal::ResultOfMatcher<Callable, InnerMatcher> ResultOf(
> Callable callable, InnerMatcher matcher) {
> return internal::ResultOfMatcher<Callable, InnerMatcher>(
> - internal::move(callable), internal::move(matcher));
> + std::move(callable), std::move(matcher));
> }
>
> // String matchers.
> @@ -4655,29 +3881,7 @@ inline
> PolymorphicMatcher<internal::EndsWithMatcher<std::string> > EndsWith(
> return
> MakePolymorphicMatcher(internal::EndsWithMatcher<std::string>(suffix));
> }
>
> -// Matches a string that fully matches regular expression 'regex'.
> -// The matcher takes ownership of 'regex'.
> -inline PolymorphicMatcher<internal::MatchesRegexMatcher> MatchesRegex(
> - const internal::RE* regex) {
> - return MakePolymorphicMatcher(internal::MatchesRegexMatcher(regex,
> true));
> -}
> -inline PolymorphicMatcher<internal::MatchesRegexMatcher> MatchesRegex(
> - const std::string& regex) {
> - return MatchesRegex(new internal::RE(regex));
> -}
> -
> -// Matches a string that contains regular expression 'regex'.
> -// The matcher takes ownership of 'regex'.
> -inline PolymorphicMatcher<internal::MatchesRegexMatcher> ContainsRegex(
> - const internal::RE* regex) {
> - return MakePolymorphicMatcher(internal::MatchesRegexMatcher(regex,
> false));
> -}
> -inline PolymorphicMatcher<internal::MatchesRegexMatcher> ContainsRegex(
> - const std::string& regex) {
> - return ContainsRegex(new internal::RE(regex));
> -}
> -
> -#if GTEST_HAS_GLOBAL_WSTRING || GTEST_HAS_STD_WSTRING
> +#if GTEST_HAS_STD_WSTRING
> // Wide string matchers.
>
> // Matches a string equal to str.
> @@ -4730,7 +3934,7 @@ inline
> PolymorphicMatcher<internal::EndsWithMatcher<std::wstring> > EndsWith(
> internal::EndsWithMatcher<std::wstring>(suffix));
> }
>
> -#endif // GTEST_HAS_GLOBAL_WSTRING || GTEST_HAS_STD_WSTRING
> +#endif // GTEST_HAS_STD_WSTRING
>
> // Creates a polymorphic matcher that matches a 2-tuple where the
> // first field == the second field.
> @@ -4852,12 +4056,12 @@ BeginEndDistanceIs(const DistanceMatcher&
> distance_matcher) {
> // values that are included in one container but not the other. (Duplicate
> // values and order
> diff erences are not explained.)
> template <typename Container>
> -inline PolymorphicMatcher<internal::ContainerEqMatcher< // NOLINT
> - GTEST_REMOVE_CONST_(Container)> >
> - ContainerEq(const Container& rhs) {
> +inline PolymorphicMatcher<internal::ContainerEqMatcher<
> + typename std::remove_const<Container>::type>>
> +ContainerEq(const Container& rhs) {
> // This following line is for working around a bug in MSVC 8.0,
> // which causes Container to be a const type sometimes.
> - typedef GTEST_REMOVE_CONST_(Container) RawContainer;
> + typedef typename std::remove_const<Container>::type RawContainer;
> return MakePolymorphicMatcher(
> internal::ContainerEqMatcher<RawContainer>(rhs));
> }
> @@ -4885,22 +4089,21 @@ WhenSorted(const ContainerMatcher&
> container_matcher) {
> // Matches an STL-style container or a native array that contains the
> // same number of elements as in rhs, where its i-th element and rhs's
> // i-th element (as a pair) satisfy the given pair matcher, for all i.
> -// TupleMatcher must be able to be safely cast to Matcher<tuple<const
> +// TupleMatcher must be able to be safely cast to Matcher<std::tuple<const
> // T1&, const T2&> >, where T1 and T2 are the types of elements in the
> // LHS container and the RHS container respectively.
> template <typename TupleMatcher, typename Container>
> inline internal::PointwiseMatcher<TupleMatcher,
> - GTEST_REMOVE_CONST_(Container)>
> + typename
> std::remove_const<Container>::type>
> Pointwise(const TupleMatcher& tuple_matcher, const Container& rhs) {
> // This following line is for working around a bug in MSVC 8.0,
> // which causes Container to be a const type sometimes (e.g. when
> // rhs is a const int[])..
> - typedef GTEST_REMOVE_CONST_(Container) RawContainer;
> + typedef typename std::remove_const<Container>::type RawContainer;
> return internal::PointwiseMatcher<TupleMatcher, RawContainer>(
> tuple_matcher, rhs);
> }
>
> -#if GTEST_HAS_STD_INITIALIZER_LIST_
>
> // Supports the Pointwise(m, {a, b, c}) syntax.
> template <typename TupleMatcher, typename T>
> @@ -4909,14 +4112,13 @@ inline internal::PointwiseMatcher<TupleMatcher,
> std::vector<T> > Pointwise(
> return Pointwise(tuple_matcher, std::vector<T>(rhs));
> }
>
> -#endif // GTEST_HAS_STD_INITIALIZER_LIST_
>
> // UnorderedPointwise(pair_matcher, rhs) matches an STL-style
> // container or a native array that contains the same number of
> // elements as in rhs, where in some permutation of the container, its
> // i-th element and rhs's i-th element (as a pair) satisfy the given
> // pair matcher, for all i. Tuple2Matcher must be able to be safely
> -// cast to Matcher<tuple<const T1&, const T2&> >, where T1 and T2 are
> +// cast to Matcher<std::tuple<const T1&, const T2&> >, where T1 and T2 are
> // the types of elements in the LHS container and the RHS container
> // respectively.
> //
> @@ -4925,14 +4127,15 @@ inline internal::PointwiseMatcher<TupleMatcher,
> std::vector<T> > Pointwise(
> template <typename Tuple2Matcher, typename RhsContainer>
> inline internal::UnorderedElementsAreArrayMatcher<
> typename internal::BoundSecondMatcher<
> - Tuple2Matcher, typename
> internal::StlContainerView<GTEST_REMOVE_CONST_(
> - RhsContainer)>::type::value_type> >
> + Tuple2Matcher,
> + typename internal::StlContainerView<
> + typename
> std::remove_const<RhsContainer>::type>::type::value_type>>
> UnorderedPointwise(const Tuple2Matcher& tuple2_matcher,
> const RhsContainer& rhs_container) {
> // This following line is for working around a bug in MSVC 8.0,
> // which causes RhsContainer to be a const type sometimes (e.g. when
> // rhs_container is a const int[]).
> - typedef GTEST_REMOVE_CONST_(RhsContainer) RawRhsContainer;
> + typedef typename std::remove_const<RhsContainer>::type RawRhsContainer;
>
> // RhsView allows the same code to handle RhsContainer being a
> // STL-style container and it being a native C-style array.
> @@ -4954,7 +4157,6 @@ UnorderedPointwise(const Tuple2Matcher&
> tuple2_matcher,
> return UnorderedElementsAreArray(matchers);
> }
>
> -#if GTEST_HAS_STD_INITIALIZER_LIST_
>
> // Supports the UnorderedPointwise(m, {a, b, c}) syntax.
> template <typename Tuple2Matcher, typename T>
> @@ -4965,7 +4167,6 @@ UnorderedPointwise(const Tuple2Matcher&
> tuple2_matcher,
> return UnorderedPointwise(tuple2_matcher, std::vector<T>(rhs));
> }
>
> -#endif // GTEST_HAS_STD_INITIALIZER_LIST_
>
> // Matches an STL-style container or a native array that contains at
> // least one element matching the given value or matcher.
> @@ -5045,13 +4246,11 @@ IsSupersetOf(const Container& container) {
> return IsSupersetOf(container.begin(), container.end());
> }
>
> -#if GTEST_HAS_STD_INITIALIZER_LIST_
> template <typename T>
> inline internal::UnorderedElementsAreArrayMatcher<T> IsSupersetOf(
> ::std::initializer_list<T> xs) {
> return IsSupersetOf(xs.begin(), xs.end());
> }
> -#endif
>
> // IsSubsetOf(iterator_first, iterator_last)
> // IsSubsetOf(pointer, count)
> @@ -5104,13 +4303,11 @@ IsSubsetOf(const Container& container) {
> return IsSubsetOf(container.begin(), container.end());
> }
>
> -#if GTEST_HAS_STD_INITIALIZER_LIST_
> template <typename T>
> inline internal::UnorderedElementsAreArrayMatcher<T> IsSubsetOf(
> ::std::initializer_list<T> xs) {
> return IsSubsetOf(xs.begin(), xs.end());
> }
> -#endif
>
> // Matches an STL-style container or a native array that contains only
> // elements matching the given value or matcher.
> @@ -5171,7 +4368,7 @@ inline internal::MatcherAsPredicate<M> Matches(M
> matcher) {
> return internal::MatcherAsPredicate<M>(matcher);
> }
>
> -// Returns true iff the value matches the matcher.
> +// Returns true if and only if the value matches the matcher.
> template <typename T, typename M>
> inline bool Value(const T& value, M matcher) {
> return testing::Matches(matcher)(value);
> @@ -5207,9 +4404,25 @@ std::string DescribeMatcher(const M& matcher, bool
> negation = false) {
> return ss.str();
> }
>
> -#if GTEST_LANG_CXX11
> -// Define variadic matcher versions. They are overloaded in
> -// gmock-generated-matchers.h for the cases supported by pre C++11
> compilers.
> +template <typename... Args>
> +internal::ElementsAreMatcher<
> + std::tuple<typename std::decay<const Args&>::type...>>
> +ElementsAre(const Args&... matchers) {
> + return internal::ElementsAreMatcher<
> + std::tuple<typename std::decay<const Args&>::type...>>(
> + std::make_tuple(matchers...));
> +}
> +
> +template <typename... Args>
> +internal::UnorderedElementsAreMatcher<
> + std::tuple<typename std::decay<const Args&>::type...>>
> +UnorderedElementsAre(const Args&... matchers) {
> + return internal::UnorderedElementsAreMatcher<
> + std::tuple<typename std::decay<const Args&>::type...>>(
> + std::make_tuple(matchers...));
> +}
> +
> +// Define variadic matcher versions.
> template <typename... Args>
> internal::AllOfMatcher<typename std::decay<const Args&>::type...> AllOf(
> const Args&... matchers) {
> @@ -5224,24 +4437,97 @@ internal::AnyOfMatcher<typename std::decay<const
> Args&>::type...> AnyOf(
> matchers...);
> }
>
> -template <typename... Args>
> -internal::ElementsAreMatcher<tuple<typename std::decay<const
> Args&>::type...>>
> -ElementsAre(const Args&... matchers) {
> - return internal::ElementsAreMatcher<
> - tuple<typename std::decay<const Args&>::type...>>(
> - make_tuple(matchers...));
> +// AnyOfArray(array)
> +// AnyOfArray(pointer, count)
> +// AnyOfArray(container)
> +// AnyOfArray({ e1, e2, ..., en })
> +// AnyOfArray(iterator_first, iterator_last)
> +//
> +// AnyOfArray() verifies whether a given value matches any member of a
> +// collection of matchers.
> +//
> +// AllOfArray(array)
> +// AllOfArray(pointer, count)
> +// AllOfArray(container)
> +// AllOfArray({ e1, e2, ..., en })
> +// AllOfArray(iterator_first, iterator_last)
> +//
> +// AllOfArray() verifies whether a given value matches all members of a
> +// collection of matchers.
> +//
> +// The matchers can be specified as an array, a pointer and count, a
> container,
> +// an initializer list, or an STL iterator range. In each of these cases,
> the
> +// underlying matchers can be either values or matchers.
> +
> +template <typename Iter>
> +inline internal::AnyOfArrayMatcher<
> + typename ::std::iterator_traits<Iter>::value_type>
> +AnyOfArray(Iter first, Iter last) {
> + return internal::AnyOfArrayMatcher<
> + typename ::std::iterator_traits<Iter>::value_type>(first, last);
> }
>
> -template <typename... Args>
> -internal::UnorderedElementsAreMatcher<
> - tuple<typename std::decay<const Args&>::type...>>
> -UnorderedElementsAre(const Args&... matchers) {
> - return internal::UnorderedElementsAreMatcher<
> - tuple<typename std::decay<const Args&>::type...>>(
> - make_tuple(matchers...));
> +template <typename Iter>
> +inline internal::AllOfArrayMatcher<
> + typename ::std::iterator_traits<Iter>::value_type>
> +AllOfArray(Iter first, Iter last) {
> + return internal::AllOfArrayMatcher<
> + typename ::std::iterator_traits<Iter>::value_type>(first, last);
> }
>
> -#endif // GTEST_LANG_CXX11
> +template <typename T>
> +inline internal::AnyOfArrayMatcher<T> AnyOfArray(const T* ptr, size_t
> count) {
> + return AnyOfArray(ptr, ptr + count);
> +}
> +
> +template <typename T>
> +inline internal::AllOfArrayMatcher<T> AllOfArray(const T* ptr, size_t
> count) {
> + return AllOfArray(ptr, ptr + count);
> +}
> +
> +template <typename T, size_t N>
> +inline internal::AnyOfArrayMatcher<T> AnyOfArray(const T (&array)[N]) {
> + return AnyOfArray(array, N);
> +}
> +
> +template <typename T, size_t N>
> +inline internal::AllOfArrayMatcher<T> AllOfArray(const T (&array)[N]) {
> + return AllOfArray(array, N);
> +}
> +
> +template <typename Container>
> +inline internal::AnyOfArrayMatcher<typename Container::value_type>
> AnyOfArray(
> + const Container& container) {
> + return AnyOfArray(container.begin(), container.end());
> +}
> +
> +template <typename Container>
> +inline internal::AllOfArrayMatcher<typename Container::value_type>
> AllOfArray(
> + const Container& container) {
> + return AllOfArray(container.begin(), container.end());
> +}
> +
> +template <typename T>
> +inline internal::AnyOfArrayMatcher<T> AnyOfArray(
> + ::std::initializer_list<T> xs) {
> + return AnyOfArray(xs.begin(), xs.end());
> +}
> +
> +template <typename T>
> +inline internal::AllOfArrayMatcher<T> AllOfArray(
> + ::std::initializer_list<T> xs) {
> + return AllOfArray(xs.begin(), xs.end());
> +}
> +
> +// Args<N1, N2, ..., Nk>(a_matcher) matches a tuple if the selected
> +// fields of it matches a_matcher. C++ doesn't support default
> +// arguments for function templates, so we have to overload it.
> +template <size_t... k, typename InnerMatcher>
> +internal::ArgsMatcher<typename std::decay<InnerMatcher>::type, k...> Args(
> + InnerMatcher&& matcher) {
> + return internal::ArgsMatcher<typename std::decay<InnerMatcher>::type,
> k...>(
> + std::forward<InnerMatcher>(matcher));
> +}
>
> // AllArgs(m) is a synonym of m. This is useful in
> //
> @@ -5288,8 +4574,8 @@
> PolymorphicMatcher<internal::variant_matcher::VariantMatcher<T> >
> VariantWith(
>
> // These macros allow using matchers to check values in Google Test
> // tests. ASSERT_THAT(value, matcher) and EXPECT_THAT(value, matcher)
> -// succeed iff the value matches the matcher. If the assertion fails,
> -// the value and the description of the matcher will be printed.
> +// succeed if and only if the value matches the matcher. If the assertion
> +// fails, the value and the description of the matcher will be printed.
> #define ASSERT_THAT(value, matcher) ASSERT_PRED_FORMAT1(\
> ::testing::internal::MakePredicateFormatterFromMatcher(matcher),
> value)
> #define EXPECT_THAT(value, matcher) EXPECT_PRED_FORMAT1(\
> @@ -5297,14 +4583,14 @@
> PolymorphicMatcher<internal::variant_matcher::VariantMatcher<T> >
> VariantWith(
>
> } // namespace testing
>
> -GTEST_DISABLE_MSC_WARNINGS_POP_() // 4251 5046
> -
> #ifdef __clang__
> #if __has_warning("-Wdeprecated-copy")
> #pragma clang diagnostic pop
> #endif
> #endif
>
> +GTEST_DISABLE_MSC_WARNINGS_POP_() // 4251 5046
> +
> // Include any custom callback matchers added by the local installation.
> // We must include this header at the end to make sure it can use the
> // declarations from this file.
>
> diff --git
> a/llvm/utils/unittest/googlemock/include/gmock/gmock-more-actions.h
> b/llvm/utils/unittest/googlemock/include/gmock/gmock-more-actions.h
> index 632a54cb8ab1b..56de2d10681a0 100644
> --- a/llvm/utils/unittest/googlemock/include/gmock/gmock-more-actions.h
> +++ b/llvm/utils/unittest/googlemock/include/gmock/gmock-more-actions.h
> @@ -40,59 +40,13 @@
> #define GMOCK_INCLUDE_GMOCK_GMOCK_MORE_ACTIONS_H_
>
> #include <algorithm>
> +#include <type_traits>
>
> #include "gmock/gmock-generated-actions.h"
>
> namespace testing {
> namespace internal {
>
> -// Implements the Invoke(f) action. The template argument
> -// FunctionImpl is the implementation type of f, which can be either a
> -// function pointer or a functor. Invoke(f) can be used as an
> -// Action<F> as long as f's type is compatible with F (i.e. f can be
> -// assigned to a tr1::function<F>).
> -template <typename FunctionImpl>
> -class InvokeAction {
> - public:
> - // The c'tor makes a copy of function_impl (either a function
> - // pointer or a functor).
> - explicit InvokeAction(FunctionImpl function_impl)
> - : function_impl_(function_impl) {}
> -
> - template <typename Result, typename ArgumentTuple>
> - Result Perform(const ArgumentTuple& args) {
> - return InvokeHelper<Result, ArgumentTuple>::Invoke(function_impl_,
> args);
> - }
> -
> - private:
> - FunctionImpl function_impl_;
> -
> - GTEST_DISALLOW_ASSIGN_(InvokeAction);
> -};
> -
> -// Implements the Invoke(object_ptr, &Class::Method) action.
> -template <class Class, typename MethodPtr>
> -class InvokeMethodAction {
> - public:
> - InvokeMethodAction(Class* obj_ptr, MethodPtr method_ptr)
> - : method_ptr_(method_ptr), obj_ptr_(obj_ptr) {}
> -
> - template <typename Result, typename ArgumentTuple>
> - Result Perform(const ArgumentTuple& args) const {
> - return InvokeHelper<Result, ArgumentTuple>::InvokeMethod(
> - obj_ptr_, method_ptr_, args);
> - }
> -
> - private:
> - // The order of these members matters. Reversing the order can trigger
> - // warning C4121 in MSVC (see
> - // http://computer-programming-forum.com/7-vc.net/6fbc30265f860ad1.htm
> ).
> - const MethodPtr method_ptr_;
> - Class* const obj_ptr_;
> -
> - GTEST_DISALLOW_ASSIGN_(InvokeMethodAction);
> -};
> -
> // An internal replacement for std::copy which mimics its behavior. This
> is
> // necessary because Visual Studio deprecates ::std::copy, issuing
> warning 4996.
> // However Visual Studio 2010 and later do not honor #pragmas which
> disable that
> @@ -111,45 +65,6 @@ inline OutputIterator CopyElements(InputIterator first,
>
> // Various overloads for Invoke().
>
> -// Creates an action that invokes 'function_impl' with the mock
> -// function's arguments.
> -template <typename FunctionImpl>
> -PolymorphicAction<internal::InvokeAction<FunctionImpl> > Invoke(
> - FunctionImpl function_impl) {
> - return MakePolymorphicAction(
> - internal::InvokeAction<FunctionImpl>(function_impl));
> -}
> -
> -// Creates an action that invokes the given method on the given object
> -// with the mock function's arguments.
> -template <class Class, typename MethodPtr>
> -PolymorphicAction<internal::InvokeMethodAction<Class, MethodPtr> > Invoke(
> - Class* obj_ptr, MethodPtr method_ptr) {
> - return MakePolymorphicAction(
> - internal::InvokeMethodAction<Class, MethodPtr>(obj_ptr,
> method_ptr));
> -}
> -
> -// WithoutArgs(inner_action) can be used in a mock function with a
> -// non-empty argument list to perform inner_action, which takes no
> -// argument. In other words, it adapts an action accepting no
> -// argument to one that accepts (and ignores) arguments.
> -template <typename InnerAction>
> -inline internal::WithArgsAction<InnerAction>
> -WithoutArgs(const InnerAction& action) {
> - return internal::WithArgsAction<InnerAction>(action);
> -}
> -
> -// WithArg<k>(an_action) creates an action that passes the k-th
> -// (0-based) argument of the mock function to an_action and performs
> -// it. It adapts an action accepting one argument to one that accepts
> -// multiple arguments. For convenience, we also provide
> -// WithArgs<k>(an_action) (defined below) as a synonym.
> -template <int k, typename InnerAction>
> -inline internal::WithArgsAction<InnerAction, k>
> -WithArg(const InnerAction& action) {
> - return internal::WithArgsAction<InnerAction, k>(action);
> -}
> -
> // The ACTION*() macros trigger warning C4100 (unreferenced formal
> // parameter) in MSVC with -W4. Unfortunately they cannot be fixed in
> // the macro definition, as the warnings are generated when the macro
> @@ -164,7 +79,7 @@ WithArg(const InnerAction& action) {
> ACTION_TEMPLATE(ReturnArg,
> HAS_1_TEMPLATE_PARAMS(int, k),
> AND_0_VALUE_PARAMS()) {
> - return ::testing::get<k>(args);
> + return ::std::get<k>(args);
> }
>
> // Action SaveArg<k>(pointer) saves the k-th (0-based) argument of the
> @@ -172,7 +87,7 @@ ACTION_TEMPLATE(ReturnArg,
> ACTION_TEMPLATE(SaveArg,
> HAS_1_TEMPLATE_PARAMS(int, k),
> AND_1_VALUE_PARAMS(pointer)) {
> - *pointer = ::testing::get<k>(args);
> + *pointer = ::std::get<k>(args);
> }
>
> // Action SaveArgPointee<k>(pointer) saves the value pointed to
> @@ -180,7 +95,7 @@ ACTION_TEMPLATE(SaveArg,
> ACTION_TEMPLATE(SaveArgPointee,
> HAS_1_TEMPLATE_PARAMS(int, k),
> AND_1_VALUE_PARAMS(pointer)) {
> - *pointer = *::testing::get<k>(args);
> + *pointer = *::std::get<k>(args);
> }
>
> // Action SetArgReferee<k>(value) assigns 'value' to the variable
> @@ -188,13 +103,13 @@ ACTION_TEMPLATE(SaveArgPointee,
> ACTION_TEMPLATE(SetArgReferee,
> HAS_1_TEMPLATE_PARAMS(int, k),
> AND_1_VALUE_PARAMS(value)) {
> - typedef typename ::testing::tuple_element<k, args_type>::type argk_type;
> + typedef typename ::std::tuple_element<k, args_type>::type argk_type;
> // Ensures that argument #k is a reference. If you get a compiler
> // error on the next line, you are using SetArgReferee<k>(value) in
> // a mock function whose k-th (0-based) argument is not a reference.
> - GTEST_COMPILE_ASSERT_(internal::is_reference<argk_type>::value,
> + GTEST_COMPILE_ASSERT_(std::is_reference<argk_type>::value,
>
> SetArgReferee_must_be_used_with_a_reference_argument);
> - ::testing::get<k>(args) = value;
> + ::std::get<k>(args) = value;
> }
>
> // Action SetArrayArgument<k>(first, last) copies the elements in
> @@ -207,9 +122,9 @@ ACTION_TEMPLATE(SetArrayArgument,
> AND_2_VALUE_PARAMS(first, last)) {
> // Visual Studio deprecates ::std::copy, so we use our own copy in that
> case.
> #ifdef _MSC_VER
> - internal::CopyElements(first, last, ::testing::get<k>(args));
> + internal::CopyElements(first, last, ::std::get<k>(args));
> #else
> - ::std::copy(first, last, ::testing::get<k>(args));
> + ::std::copy(first, last, ::std::get<k>(args));
> #endif
> }
>
> @@ -218,7 +133,7 @@ ACTION_TEMPLATE(SetArrayArgument,
> ACTION_TEMPLATE(DeleteArg,
> HAS_1_TEMPLATE_PARAMS(int, k),
> AND_0_VALUE_PARAMS()) {
> - delete ::testing::get<k>(args);
> + delete ::std::get<k>(args);
> }
>
> // This action returns the value pointed to by 'pointer'.
>
> diff --git
> a/llvm/utils/unittest/googlemock/include/gmock/gmock-nice-strict.h
> b/llvm/utils/unittest/googlemock/include/gmock/gmock-nice-strict.h
> new file mode 100644
> index 0000000000000..5495a9805b5fa
> --- /dev/null
> +++ b/llvm/utils/unittest/googlemock/include/gmock/gmock-nice-strict.h
> @@ -0,0 +1,215 @@
> +// Copyright 2008, Google Inc.
> +// All rights reserved.
> +//
> +// Redistribution and use in source and binary forms, with or without
> +// modification, are permitted provided that the following conditions are
> +// met:
> +//
> +// * Redistributions of source code must retain the above copyright
> +// notice, this list of conditions and the following disclaimer.
> +// * Redistributions in binary form must reproduce the above
> +// copyright notice, this list of conditions and the following disclaimer
> +// in the documentation and/or other materials provided with the
> +// distribution.
> +// * Neither the name of Google Inc. nor the names of its
> +// contributors may be used to endorse or promote products derived from
> +// this software without specific prior written permission.
> +//
> +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
> +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
> +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
> +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
> +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
> +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
> +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
> +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
> +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
> +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
> +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
> +
> +
> +// Implements class templates NiceMock, NaggyMock, and StrictMock.
> +//
> +// Given a mock class MockFoo that is created using Google Mock,
> +// NiceMock<MockFoo> is a subclass of MockFoo that allows
> +// uninteresting calls (i.e. calls to mock methods that have no
> +// EXPECT_CALL specs), NaggyMock<MockFoo> is a subclass of MockFoo
> +// that prints a warning when an uninteresting call occurs, and
> +// StrictMock<MockFoo> is a subclass of MockFoo that treats all
> +// uninteresting calls as errors.
> +//
> +// Currently a mock is naggy by default, so MockFoo and
> +// NaggyMock<MockFoo> behave like the same. However, we will soon
> +// switch the default behavior of mocks to be nice, as that in general
> +// leads to more maintainable tests. When that happens, MockFoo will
> +// stop behaving like NaggyMock<MockFoo> and start behaving like
> +// NiceMock<MockFoo>.
> +//
> +// NiceMock, NaggyMock, and StrictMock "inherit" the constructors of
> +// their respective base class. Therefore you can write
> +// NiceMock<MockFoo>(5, "a") to construct a nice mock where MockFoo
> +// has a constructor that accepts (int, const char*), for example.
> +//
> +// A known limitation is that NiceMock<MockFoo>, NaggyMock<MockFoo>,
> +// and StrictMock<MockFoo> only works for mock methods defined using
> +// the MOCK_METHOD* family of macros DIRECTLY in the MockFoo class.
> +// If a mock method is defined in a base class of MockFoo, the "nice"
> +// or "strict" modifier may not affect it, depending on the compiler.
> +// In particular, nesting NiceMock, NaggyMock, and StrictMock is NOT
> +// supported.
> +
> +// GOOGLETEST_CM0002 DO NOT DELETE
> +
> +#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_NICE_STRICT_H_
> +#define GMOCK_INCLUDE_GMOCK_GMOCK_NICE_STRICT_H_
> +
> +#include "gmock/gmock-spec-builders.h"
> +#include "gmock/internal/gmock-port.h"
> +
> +namespace testing {
> +
> +template <class MockClass>
> +class NiceMock : public MockClass {
> + public:
> + NiceMock() : MockClass() {
> + ::testing::Mock::AllowUninterestingCalls(
> + internal::ImplicitCast_<MockClass*>(this));
> + }
> +
> + // Ideally, we would inherit base class's constructors through a using
> + // declaration, which would preserve their visibility. However, many
> existing
> + // tests rely on the fact that current implementation reexports
> protected
> + // constructors as public. These tests would need to be cleaned up
> first.
> +
> + // Single argument constructor is special-cased so that it can be
> + // made explicit.
> + template <typename A>
> + explicit NiceMock(A&& arg) : MockClass(std::forward<A>(arg)) {
> + ::testing::Mock::AllowUninterestingCalls(
> + internal::ImplicitCast_<MockClass*>(this));
> + }
> +
> + template <typename A1, typename A2, typename... An>
> + NiceMock(A1&& arg1, A2&& arg2, An&&... args)
> + : MockClass(std::forward<A1>(arg1), std::forward<A2>(arg2),
> + std::forward<An>(args)...) {
> + ::testing::Mock::AllowUninterestingCalls(
> + internal::ImplicitCast_<MockClass*>(this));
> + }
> +
> + ~NiceMock() { // NOLINT
> + ::testing::Mock::UnregisterCallReaction(
> + internal::ImplicitCast_<MockClass*>(this));
> + }
> +
> + private:
> + GTEST_DISALLOW_COPY_AND_ASSIGN_(NiceMock);
> +};
> +
> +template <class MockClass>
> +class NaggyMock : public MockClass {
> + public:
> + NaggyMock() : MockClass() {
> + ::testing::Mock::WarnUninterestingCalls(
> + internal::ImplicitCast_<MockClass*>(this));
> + }
> +
> + // Ideally, we would inherit base class's constructors through a using
> + // declaration, which would preserve their visibility. However, many
> existing
> + // tests rely on the fact that current implementation reexports
> protected
> + // constructors as public. These tests would need to be cleaned up
> first.
> +
> + // Single argument constructor is special-cased so that it can be
> + // made explicit.
> + template <typename A>
> + explicit NaggyMock(A&& arg) : MockClass(std::forward<A>(arg)) {
> + ::testing::Mock::WarnUninterestingCalls(
> + internal::ImplicitCast_<MockClass*>(this));
> + }
> +
> + template <typename A1, typename A2, typename... An>
> + NaggyMock(A1&& arg1, A2&& arg2, An&&... args)
> + : MockClass(std::forward<A1>(arg1), std::forward<A2>(arg2),
> + std::forward<An>(args)...) {
> + ::testing::Mock::WarnUninterestingCalls(
> + internal::ImplicitCast_<MockClass*>(this));
> + }
> +
> + ~NaggyMock() { // NOLINT
> + ::testing::Mock::UnregisterCallReaction(
> + internal::ImplicitCast_<MockClass*>(this));
> + }
> +
> + private:
> + GTEST_DISALLOW_COPY_AND_ASSIGN_(NaggyMock);
> +};
> +
> +template <class MockClass>
> +class StrictMock : public MockClass {
> + public:
> + StrictMock() : MockClass() {
> + ::testing::Mock::FailUninterestingCalls(
> + internal::ImplicitCast_<MockClass*>(this));
> + }
> +
> + // Ideally, we would inherit base class's constructors through a using
> + // declaration, which would preserve their visibility. However, many
> existing
> + // tests rely on the fact that current implementation reexports
> protected
> + // constructors as public. These tests would need to be cleaned up
> first.
> +
> + // Single argument constructor is special-cased so that it can be
> + // made explicit.
> + template <typename A>
> + explicit StrictMock(A&& arg) : MockClass(std::forward<A>(arg)) {
> + ::testing::Mock::FailUninterestingCalls(
> + internal::ImplicitCast_<MockClass*>(this));
> + }
> +
> + template <typename A1, typename A2, typename... An>
> + StrictMock(A1&& arg1, A2&& arg2, An&&... args)
> + : MockClass(std::forward<A1>(arg1), std::forward<A2>(arg2),
> + std::forward<An>(args)...) {
> + ::testing::Mock::FailUninterestingCalls(
> + internal::ImplicitCast_<MockClass*>(this));
> + }
> +
> + ~StrictMock() { // NOLINT
> + ::testing::Mock::UnregisterCallReaction(
> + internal::ImplicitCast_<MockClass*>(this));
> + }
> +
> + private:
> + GTEST_DISALLOW_COPY_AND_ASSIGN_(StrictMock);
> +};
> +
> +// The following specializations catch some (relatively more common)
> +// user errors of nesting nice and strict mocks. They do NOT catch
> +// all possible errors.
> +
> +// These specializations are declared but not defined, as NiceMock,
> +// NaggyMock, and StrictMock cannot be nested.
> +
> +template <typename MockClass>
> +class NiceMock<NiceMock<MockClass> >;
> +template <typename MockClass>
> +class NiceMock<NaggyMock<MockClass> >;
> +template <typename MockClass>
> +class NiceMock<StrictMock<MockClass> >;
> +
> +template <typename MockClass>
> +class NaggyMock<NiceMock<MockClass> >;
> +template <typename MockClass>
> +class NaggyMock<NaggyMock<MockClass> >;
> +template <typename MockClass>
> +class NaggyMock<StrictMock<MockClass> >;
> +
> +template <typename MockClass>
> +class StrictMock<NiceMock<MockClass> >;
> +template <typename MockClass>
> +class StrictMock<NaggyMock<MockClass> >;
> +template <typename MockClass>
> +class StrictMock<StrictMock<MockClass> >;
> +
> +} // namespace testing
> +
> +#endif // GMOCK_INCLUDE_GMOCK_GMOCK_NICE_STRICT_H_
>
> diff --git
> a/llvm/utils/unittest/googlemock/include/gmock/gmock-spec-builders.h
> b/llvm/utils/unittest/googlemock/include/gmock/gmock-spec-builders.h
> index 61e7134230aa3..7df6c87a4c307 100644
> --- a/llvm/utils/unittest/googlemock/include/gmock/gmock-spec-builders.h
> +++ b/llvm/utils/unittest/googlemock/include/gmock/gmock-spec-builders.h
> @@ -63,10 +63,14 @@
> #ifndef GMOCK_INCLUDE_GMOCK_GMOCK_SPEC_BUILDERS_H_
> #define GMOCK_INCLUDE_GMOCK_GMOCK_SPEC_BUILDERS_H_
>
> +#include <functional>
> #include <map>
> +#include <memory>
> #include <set>
> #include <sstream>
> #include <string>
> +#include <type_traits>
> +#include <utility>
> #include <vector>
> #include "gmock/gmock-actions.h"
> #include "gmock/gmock-cardinalities.h"
> @@ -106,9 +110,6 @@ template <typename F> class TypedExpectation;
> // Helper class for testing the Expectation class template.
> class ExpectationTester;
>
> -// Base class for function mockers.
> -template <typename F> class FunctionMockerBase;
> -
> // Protects the mock object registry (in class Mock), all function
> // mockers, and all expectations.
> //
> @@ -125,9 +126,9 @@ GTEST_API_ GTEST_DECLARE_STATIC_MUTEX_(g_gmock_mutex);
> // Untyped base class for ActionResultHolder<R>.
> class UntypedActionResultHolderBase;
>
> -// Abstract base class of FunctionMockerBase. This is the
> +// Abstract base class of FunctionMocker. This is the
> // type-agnostic part of the function mocker interface. Its pure
> -// virtual methods are implemented by FunctionMockerBase.
> +// virtual methods are implemented by FunctionMocker.
> class GTEST_API_ UntypedFunctionMockerBase {
> public:
> UntypedFunctionMockerBase();
> @@ -189,7 +190,6 @@ class GTEST_API_ UntypedFunctionMockerBase {
> // this information in the global mock registry. Will be called
> // whenever an EXPECT_CALL() or ON_CALL() is executed on this mock
> // method.
> - // FIXME: rename to SetAndRegisterOwner().
> void RegisterOwner(const void* mock_obj)
> GTEST_LOCK_EXCLUDED_(g_gmock_mutex);
>
> @@ -220,8 +220,7 @@ class GTEST_API_ UntypedFunctionMockerBase {
> protected:
> typedef std::vector<const void*> UntypedOnCallSpecs;
>
> - typedef std::vector<internal::linked_ptr<ExpectationBase> >
> - UntypedExpectations;
> + using UntypedExpectations =
> std::vector<std::shared_ptr<ExpectationBase>>;
>
> // Returns an Expectation object that references and co-owns exp,
> // which must be an expectation on this mock function.
> @@ -306,11 +305,9 @@ class OnCallSpec : public UntypedOnCallSpecBase {
> : UntypedOnCallSpecBase(a_file, a_line),
> matchers_(matchers),
> // By default, extra_matcher_ should match anything. However,
> - // we cannot initialize it with _ as that triggers a compiler
> - // bug in Symbian's C++ compiler (cannot decide between two
> - // overloaded constructors of Matcher<const ArgumentTuple&>).
> - extra_matcher_(A<const ArgumentTuple&>()) {
> - }
> + // we cannot initialize it with _ as that causes ambiguity between
> + // Matcher's copy and move constructor for some argument types.
> + extra_matcher_(A<const ArgumentTuple&>()) {}
>
> // Implements the .With() clause.
> OnCallSpec& With(const Matcher<const ArgumentTuple&>& m) {
> @@ -337,7 +334,7 @@ class OnCallSpec : public UntypedOnCallSpecBase {
> return *this;
> }
>
> - // Returns true iff the given arguments match the matchers.
> + // Returns true if and only if the given arguments match the matchers.
> bool Matches(const ArgumentTuple& args) const {
> return TupleMatches(matchers_, args) && extra_matcher_.Matches(args);
> }
> @@ -395,18 +392,28 @@ class GTEST_API_ Mock {
> GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
>
> // Verifies all expectations on the given mock object and clears its
> - // default actions and expectations. Returns true iff the
> + // default actions and expectations. Returns true if and only if the
> // verification was successful.
> static bool VerifyAndClear(void* mock_obj)
> GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
>
> + // Returns whether the mock was created as a naggy mock (default)
> + static bool IsNaggy(void* mock_obj)
> + GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
> + // Returns whether the mock was created as a nice mock
> + static bool IsNice(void* mock_obj)
> + GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
> + // Returns whether the mock was created as a strict mock
> + static bool IsStrict(void* mock_obj)
> + GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
> +
> private:
> friend class internal::UntypedFunctionMockerBase;
>
> // Needed for a function mocker to register itself (so that we know
> // how to clear a mock object).
> template <typename F>
> - friend class internal::FunctionMockerBase;
> + friend class internal::FunctionMocker;
>
> template <typename M>
> friend class NiceMock;
> @@ -469,7 +476,7 @@ class GTEST_API_ Mock {
> // Unregisters a mock method; removes the owning mock object from
> // the registry when the last mock method associated with it has
> // been unregistered. This is called only in the destructor of
> - // FunctionMockerBase.
> + // FunctionMocker.
> static void UnregisterLocked(internal::UntypedFunctionMockerBase*
> mocker)
> GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex);
> }; // class Mock
> @@ -489,12 +496,7 @@ class GTEST_API_ Mock {
> // - Constness is shallow: a const Expectation object itself cannot
> // be modified, but the mutable methods of the ExpectationBase
> // object it references can be called via expectation_base().
> -// - The constructors and destructor are defined out-of-line because
> -// the Symbian WINSCW compiler wants to otherwise instantiate them
> -// when it sees this class definition, at which point it doesn't have
> -// ExpectationBase available yet, leading to incorrect destruction
> -// in the linked_ptr (or compilation errors if using a checking
> -// linked_ptr).
> +
> class GTEST_API_ Expectation {
> public:
> // Constructs a null object that doesn't reference any expectation.
> @@ -516,7 +518,8 @@ class GTEST_API_ Expectation {
> // The compiler-generated copy ctor and operator= work exactly as
> // intended, so we don't need to define our own.
>
> - // Returns true iff rhs references the same expectation as this object
> does.
> + // Returns true if and only if rhs references the same expectation as
> this
> + // object does.
> bool operator==(const Expectation& rhs) const {
> return expectation_base_ == rhs.expectation_base_;
> }
> @@ -530,7 +533,7 @@ class GTEST_API_ Expectation {
> friend class ::testing::internal::UntypedFunctionMockerBase;
>
> template <typename F>
> - friend class ::testing::internal::FunctionMockerBase;
> + friend class ::testing::internal::FunctionMocker;
>
> template <typename F>
> friend class ::testing::internal::TypedExpectation;
> @@ -546,16 +549,15 @@ class GTEST_API_ Expectation {
> typedef ::std::set<Expectation, Less> Set;
>
> Expectation(
> - const internal::linked_ptr<internal::ExpectationBase>&
> expectation_base);
> + const std::shared_ptr<internal::ExpectationBase>& expectation_base);
>
> // Returns the expectation this object references.
> - const internal::linked_ptr<internal::ExpectationBase>&
> - expectation_base() const {
> + const std::shared_ptr<internal::ExpectationBase>& expectation_base()
> const {
> return expectation_base_;
> }
>
> - // A linked_ptr that co-owns the expectation this handle references.
> - internal::linked_ptr<internal::ExpectationBase> expectation_base_;
> + // A shared_ptr that co-owns the expectation this handle references.
> + std::shared_ptr<internal::ExpectationBase> expectation_base_;
> };
>
> // A set of expectation handles. Useful in the .After() clause of
> @@ -599,8 +601,8 @@ class ExpectationSet {
> // The compiler-generator ctor and operator= works exactly as
> // intended, so we don't need to define our own.
>
> - // Returns true iff rhs contains the same set of Expectation objects
> - // as this does.
> + // Returns true if and only if rhs contains the same set of Expectation
> + // objects as this does.
> bool operator==(const ExpectationSet& rhs) const {
> return expectations_ == rhs.expectations_;
> }
> @@ -637,11 +639,8 @@ class GTEST_API_ Sequence {
> void AddExpectation(const Expectation& expectation) const;
>
> private:
> - // The last expectation in this sequence. We use a linked_ptr here
> - // because Sequence objects are copyable and we want the copies to
> - // be aliases. The linked_ptr allows the copies to co-own and share
> - // the same Expectation object.
> - internal::linked_ptr<Expectation> last_expectation_;
> + // The last expectation in this sequence.
> + std::shared_ptr<Expectation> last_expectation_;
> }; // class Sequence
>
> // An object of this type causes all EXPECT_CALL() statements
> @@ -764,8 +763,8 @@ class GTEST_API_ ExpectationBase {
> // by the subclasses to implement the .Times() clause.
> void SpecifyCardinality(const Cardinality& cardinality);
>
> - // Returns true iff the user specified the cardinality explicitly
> - // using a .Times().
> + // Returns true if and only if the user specified the cardinality
> + // explicitly using a .Times().
> bool cardinality_specified() const { return cardinality_specified_; }
>
> // Sets the cardinality of this expectation spec.
> @@ -781,7 +780,7 @@ class GTEST_API_ ExpectationBase {
> void RetireAllPreRequisites()
> GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex);
>
> - // Returns true iff this expectation is retired.
> + // Returns true if and only if this expectation is retired.
> bool is_retired() const
> GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
> g_gmock_mutex.AssertHeld();
> @@ -795,28 +794,29 @@ class GTEST_API_ ExpectationBase {
> retired_ = true;
> }
>
> - // Returns true iff this expectation is satisfied.
> + // Returns true if and only if this expectation is satisfied.
> bool IsSatisfied() const
> GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
> g_gmock_mutex.AssertHeld();
> return cardinality().IsSatisfiedByCallCount(call_count_);
> }
>
> - // Returns true iff this expectation is saturated.
> + // Returns true if and only if this expectation is saturated.
> bool IsSaturated() const
> GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
> g_gmock_mutex.AssertHeld();
> return cardinality().IsSaturatedByCallCount(call_count_);
> }
>
> - // Returns true iff this expectation is over-saturated.
> + // Returns true if and only if this expectation is over-saturated.
> bool IsOverSaturated() const
> GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
> g_gmock_mutex.AssertHeld();
> return cardinality().IsOverSaturatedByCallCount(call_count_);
> }
>
> - // Returns true iff all pre-requisites of this expectation are
> satisfied.
> + // Returns true if and only if all pre-requisites of this expectation
> are
> + // satisfied.
> bool AllPrerequisitesAreSatisfied() const
> GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex);
>
> @@ -859,12 +859,12 @@ class GTEST_API_ ExpectationBase {
> const char* file_; // The file that contains the expectation.
> int line_; // The line number of the expectation.
> const std::string source_text_; // The EXPECT_CALL(...) source text.
> - // True iff the cardinality is specified explicitly.
> + // True if and only if the cardinality is specified explicitly.
> bool cardinality_specified_;
> Cardinality cardinality_; // The cardinality of the
> expectation.
> // The immediate pre-requisites (i.e. expectations that must be
> // satisfied before this expectation can be matched) of this
> - // expectation. We use linked_ptr in the set because we want an
> + // expectation. We use std::shared_ptr in the set because we want an
> // Expectation object to be co-owned by its FunctionMocker and its
> // successors. This allows multiple mock objects to be deleted at
> //
> diff erent times.
> @@ -873,7 +873,7 @@ class GTEST_API_ ExpectationBase {
> // This group of fields are the current state of the expectation,
> // and can change as the mock function is called.
> int call_count_; // How many times this expectation has been invoked.
> - bool retired_; // True iff this expectation has retired.
> + bool retired_; // True if and only if this expectation has retired.
> UntypedActions untyped_actions_;
> bool extra_matcher_specified_;
> bool repeated_action_specified_; // True if a WillRepeatedly() was
> specified.
> @@ -893,20 +893,19 @@ class TypedExpectation : public ExpectationBase {
> typedef typename Function<F>::ArgumentMatcherTuple ArgumentMatcherTuple;
> typedef typename Function<F>::Result Result;
>
> - TypedExpectation(FunctionMockerBase<F>* owner, const char* a_file, int
> a_line,
> + TypedExpectation(FunctionMocker<F>* owner, const char* a_file, int
> a_line,
> const std::string& a_source_text,
> const ArgumentMatcherTuple& m)
> : ExpectationBase(a_file, a_line, a_source_text),
> owner_(owner),
> matchers_(m),
> // By default, extra_matcher_ should match anything. However,
> - // we cannot initialize it with _ as that triggers a compiler
> - // bug in Symbian's C++ compiler (cannot decide between two
> - // overloaded constructors of Matcher<const ArgumentTuple&>).
> + // we cannot initialize it with _ as that causes ambiguity between
> + // Matcher's copy and move constructor for some argument types.
> extra_matcher_(A<const ArgumentTuple&>()),
> repeated_action_(DoDefault()) {}
>
> - virtual ~TypedExpectation() {
> + ~TypedExpectation() override {
> // Check the validity of the action count if it hasn't been done
> // yet (for example, if the expectation was never used).
> CheckActionCountIfNotDone();
> @@ -1072,7 +1071,7 @@ class TypedExpectation : public ExpectationBase {
>
> // If this mock method has an extra matcher (i.e. .With(matcher)),
> // describes it to the ostream.
> - virtual void MaybeDescribeExtraMatcherTo(::std::ostream* os) {
> + void MaybeDescribeExtraMatcherTo(::std::ostream* os) override {
> if (extra_matcher_specified_) {
> *os << " Expected args: ";
> extra_matcher_.DescribeTo(os);
> @@ -1082,26 +1081,25 @@ class TypedExpectation : public ExpectationBase {
>
> private:
> template <typename Function>
> - friend class FunctionMockerBase;
> + friend class FunctionMocker;
>
> // Returns an Expectation object that references and co-owns this
> // expectation.
> - virtual Expectation GetHandle() {
> - return owner_->GetHandleOf(this);
> - }
> + Expectation GetHandle() override { return owner_->GetHandleOf(this); }
>
> // The following methods will be called only after the EXPECT_CALL()
> // statement finishes and when the current thread holds
> // g_gmock_mutex.
>
> - // Returns true iff this expectation matches the given arguments.
> + // Returns true if and only if this expectation matches the given
> arguments.
> bool Matches(const ArgumentTuple& args) const
> GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
> g_gmock_mutex.AssertHeld();
> return TupleMatches(matchers_, args) && extra_matcher_.Matches(args);
> }
>
> - // Returns true iff this expectation should handle the given arguments.
> + // Returns true if and only if this expectation should handle the given
> + // arguments.
> bool ShouldHandleArguments(const ArgumentTuple& args) const
> GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
> g_gmock_mutex.AssertHeld();
> @@ -1161,10 +1159,9 @@ class TypedExpectation : public ExpectationBase {
> }
>
> // Returns the action that should be taken for the current invocation.
> - const Action<F>& GetCurrentAction(
> - const FunctionMockerBase<F>* mocker,
> - const ArgumentTuple& args) const
> - GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
> + const Action<F>& GetCurrentAction(const FunctionMocker<F>* mocker,
> + const ArgumentTuple& args) const
> + GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
> g_gmock_mutex.AssertHeld();
> const int count = call_count();
> Assert(count >= 1, __FILE__, __LINE__,
> @@ -1186,9 +1183,10 @@ class TypedExpectation : public ExpectationBase {
> Log(kWarning, ss.str(), 1);
> }
>
> - return count <= action_count ?
> - *static_cast<const Action<F>*>(untyped_actions_[count - 1]) :
> - repeated_action();
> + return count <= action_count
> + ? *static_cast<const Action<F>*>(
> + untyped_actions_[static_cast<size_t>(count - 1)])
> + : repeated_action();
> }
>
> // Given the arguments of a mock function call, if the call will
> @@ -1198,12 +1196,11 @@ class TypedExpectation : public ExpectationBase {
> // Mock does it to 'why'. This method is not const as it calls
> // IncrementCallCount(). A return value of NULL means the default
> // action.
> - const Action<F>* GetActionForArguments(
> - const FunctionMockerBase<F>* mocker,
> - const ArgumentTuple& args,
> - ::std::ostream* what,
> - ::std::ostream* why)
> - GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
> + const Action<F>* GetActionForArguments(const FunctionMocker<F>* mocker,
> + const ArgumentTuple& args,
> + ::std::ostream* what,
> + ::std::ostream* why)
> + GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
> g_gmock_mutex.AssertHeld();
> if (IsSaturated()) {
> // We have an excessive call.
> @@ -1212,10 +1209,7 @@ class TypedExpectation : public ExpectationBase {
> mocker->DescribeDefaultActionTo(args, what);
> DescribeCallCountTo(why);
>
> - // FIXME: allow the user to control whether
> - // unexpected calls should fail immediately or continue using a
> - // flag --gmock_unexpected_calls_are_fatal.
> - return NULL;
> + return nullptr;
> }
>
> IncrementCallCount();
> @@ -1232,7 +1226,7 @@ class TypedExpectation : public ExpectationBase {
>
> // All the fields below won't change once the EXPECT_CALL()
> // statement finishes.
> - FunctionMockerBase<F>* const owner_;
> + FunctionMocker<F>* const owner_;
> ArgumentMatcherTuple matchers_;
> Matcher<const ArgumentTuple&> extra_matcher_;
> Action<F> repeated_action_;
> @@ -1264,7 +1258,7 @@ class MockSpec {
>
> // Constructs a MockSpec object, given the function mocker object
> // that the spec is associated with.
> - MockSpec(internal::FunctionMockerBase<F>* function_mocker,
> + MockSpec(internal::FunctionMocker<F>* function_mocker,
> const ArgumentMatcherTuple& matchers)
> : function_mocker_(function_mocker), matchers_(matchers) {}
>
> @@ -1300,7 +1294,7 @@ class MockSpec {
> friend class internal::FunctionMocker;
>
> // The function mocker that owns this spec.
> - internal::FunctionMockerBase<F>* const function_mocker_;
> + internal::FunctionMocker<F>* const function_mocker_;
> // The argument matchers specified in the spec.
> ArgumentMatcherTuple matchers_;
>
> @@ -1321,18 +1315,18 @@ class ReferenceOrValueWrapper {
> public:
> // Constructs a wrapper from the given value/reference.
> explicit ReferenceOrValueWrapper(T value)
> - : value_(::testing::internal::move(value)) {
> + : value_(std::move(value)) {
> }
>
> // Unwraps and returns the underlying value/reference, exactly as
> // originally passed. The behavior of calling this more than once on
> // the same object is unspecified.
> - T Unwrap() { return ::testing::internal::move(value_); }
> + T Unwrap() { return std::move(value_); }
>
> // Provides nondestructive access to the underlying value/reference.
> // Always returns a const reference (more precisely,
> - // const RemoveReference<T>&). The behavior of calling this after
> - // calling Unwrap on the same object is unspecified.
> + // const std::add_lvalue_reference<T>::type). The behavior of calling
> this
> + // after calling Unwrap on the same object is unspecified.
> const T& Peek() const {
> return value_;
> }
> @@ -1391,7 +1385,7 @@ class ActionResultHolder : public
> UntypedActionResultHolderBase {
> }
>
> // Prints the held value as an action's result to os.
> - virtual void PrintAsActionResult(::std::ostream* os) const {
> + void PrintAsActionResult(::std::ostream* os) const override {
> *os << "\n Returns: ";
> // T may be a reference type, so we don't use UniversalPrint().
> UniversalPrinter<T>::Print(result_.Peek(), os);
> @@ -1401,28 +1395,27 @@ class ActionResultHolder : public
> UntypedActionResultHolderBase {
> // result in a new-ed ActionResultHolder.
> template <typename F>
> static ActionResultHolder* PerformDefaultAction(
> - const FunctionMockerBase<F>* func_mocker,
> - typename RvalueRef<typename Function<F>::ArgumentTuple>::type args,
> + const FunctionMocker<F>* func_mocker,
> + typename Function<F>::ArgumentTuple&& args,
> const std::string& call_description) {
> return new
> ActionResultHolder(Wrapper(func_mocker->PerformDefaultAction(
> - internal::move(args), call_description)));
> + std::move(args), call_description)));
> }
>
> // Performs the given action and returns the result in a new-ed
> // ActionResultHolder.
> template <typename F>
> static ActionResultHolder* PerformAction(
> - const Action<F>& action,
> - typename RvalueRef<typename Function<F>::ArgumentTuple>::type args)
> {
> + const Action<F>& action, typename Function<F>::ArgumentTuple&&
> args) {
> return new ActionResultHolder(
> - Wrapper(action.Perform(internal::move(args))));
> + Wrapper(action.Perform(std::move(args))));
> }
>
> private:
> typedef ReferenceOrValueWrapper<T> Wrapper;
>
> explicit ActionResultHolder(Wrapper result)
> - : result_(::testing::internal::move(result)) {
> + : result_(std::move(result)) {
> }
>
> Wrapper result_;
> @@ -1436,16 +1429,16 @@ class ActionResultHolder<void> : public
> UntypedActionResultHolderBase {
> public:
> void Unwrap() { }
>
> - virtual void PrintAsActionResult(::std::ostream* /* os */) const {}
> + void PrintAsActionResult(::std::ostream* /* os */) const override {}
>
> // Performs the given mock function's default action and returns
> ownership
> // of an empty ActionResultHolder*.
> template <typename F>
> static ActionResultHolder* PerformDefaultAction(
> - const FunctionMockerBase<F>* func_mocker,
> - typename RvalueRef<typename Function<F>::ArgumentTuple>::type args,
> + const FunctionMocker<F>* func_mocker,
> + typename Function<F>::ArgumentTuple&& args,
> const std::string& call_description) {
> - func_mocker->PerformDefaultAction(internal::move(args),
> call_description);
> + func_mocker->PerformDefaultAction(std::move(args), call_description);
> return new ActionResultHolder;
> }
>
> @@ -1453,9 +1446,8 @@ class ActionResultHolder<void> : public
> UntypedActionResultHolderBase {
> // ActionResultHolder*.
> template <typename F>
> static ActionResultHolder* PerformAction(
> - const Action<F>& action,
> - typename RvalueRef<typename Function<F>::ArgumentTuple>::type args)
> {
> - action.Perform(internal::move(args));
> + const Action<F>& action, typename Function<F>::ArgumentTuple&&
> args) {
> + action.Perform(std::move(args));
> return new ActionResultHolder;
> }
>
> @@ -1464,23 +1456,39 @@ class ActionResultHolder<void> : public
> UntypedActionResultHolderBase {
> GTEST_DISALLOW_COPY_AND_ASSIGN_(ActionResultHolder);
> };
>
> -// The base of the function mocker class for the given function type.
> -// We put the methods in this class instead of its child to avoid code
> -// bloat.
> template <typename F>
> -class FunctionMockerBase : public UntypedFunctionMockerBase {
> +class FunctionMocker;
> +
> +template <typename R, typename... Args>
> +class FunctionMocker<R(Args...)> final : public UntypedFunctionMockerBase
> {
> + using F = R(Args...);
> +
> public:
> - typedef typename Function<F>::Result Result;
> - typedef typename Function<F>::ArgumentTuple ArgumentTuple;
> - typedef typename Function<F>::ArgumentMatcherTuple ArgumentMatcherTuple;
> + using Result = R;
> + using ArgumentTuple = std::tuple<Args...>;
> + using ArgumentMatcherTuple = std::tuple<Matcher<Args>...>;
> +
> + FunctionMocker() {}
>
> - FunctionMockerBase() {}
> + // There is no generally useful and implementable semantics of
> + // copying a mock object, so copying a mock is usually a user error.
> + // Thus we disallow copying function mockers. If the user really
> + // wants to copy a mock object, they should implement their own copy
> + // operation, for example:
> + //
> + // class MockFoo : public Foo {
> + // public:
> + // // Defines a copy constructor explicitly.
> + // MockFoo(const MockFoo& src) {}
> + // ...
> + // };
> + FunctionMocker(const FunctionMocker&) = delete;
> + FunctionMocker& operator=(const FunctionMocker&) = delete;
>
> // The destructor verifies that all expectations on this mock
> // function have been satisfied. If not, it will report Google Test
> // non-fatal failures for the violations.
> - virtual ~FunctionMockerBase()
> - GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
> + ~FunctionMocker() override GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
> MutexLock l(&g_gmock_mutex);
> VerifyAndClearExpectationsLocked();
> Mock::UnregisterLocked(this);
> @@ -1500,7 +1508,7 @@ class FunctionMockerBase : public
> UntypedFunctionMockerBase {
> return spec;
> }
>
> - return NULL;
> + return nullptr;
> }
>
> // Performs the default action of this mock function on the given
> @@ -1510,13 +1518,12 @@ class FunctionMockerBase : public
> UntypedFunctionMockerBase {
> // mutable state of this object, and thus can be called concurrently
> // without locking.
> // L = *
> - Result PerformDefaultAction(
> - typename RvalueRef<typename Function<F>::ArgumentTuple>::type args,
> - const std::string& call_description) const {
> + Result PerformDefaultAction(ArgumentTuple&& args,
> + const std::string& call_description) const {
> const OnCallSpec<F>* const spec =
> this->FindOnCallSpec(args);
> - if (spec != NULL) {
> - return spec->GetAction().Perform(internal::move(args));
> + if (spec != nullptr) {
> + return spec->GetAction().Perform(std::move(args));
> }
> const std::string message =
> call_description +
> @@ -1537,11 +1544,11 @@ class FunctionMockerBase : public
> UntypedFunctionMockerBase {
> // the error message to describe the call in the case the default
> // action fails. The caller is responsible for deleting the result.
> // L = *
> - virtual UntypedActionResultHolderBase* UntypedPerformDefaultAction(
> + UntypedActionResultHolderBase* UntypedPerformDefaultAction(
> void* untyped_args, // must point to an ArgumentTuple
> - const std::string& call_description) const {
> + const std::string& call_description) const override {
> ArgumentTuple* args = static_cast<ArgumentTuple*>(untyped_args);
> - return ResultHolder::PerformDefaultAction(this, internal::move(*args),
> + return ResultHolder::PerformDefaultAction(this, std::move(*args),
> call_description);
> }
>
> @@ -1549,18 +1556,18 @@ class FunctionMockerBase : public
> UntypedFunctionMockerBase {
> // the action's result. The caller is responsible for deleting the
> // result.
> // L = *
> - virtual UntypedActionResultHolderBase* UntypedPerformAction(
> - const void* untyped_action, void* untyped_args) const {
> + UntypedActionResultHolderBase* UntypedPerformAction(
> + const void* untyped_action, void* untyped_args) const override {
> // Make a copy of the action before performing it, in case the
> // action deletes the mock object (and thus deletes itself).
> const Action<F> action = *static_cast<const
> Action<F>*>(untyped_action);
> ArgumentTuple* args = static_cast<ArgumentTuple*>(untyped_args);
> - return ResultHolder::PerformAction(action, internal::move(*args));
> + return ResultHolder::PerformAction(action, std::move(*args));
> }
>
> // Implements UntypedFunctionMockerBase::ClearDefaultActionsLocked():
> // clears the ON_CALL()s set on this mock function.
> - virtual void ClearDefaultActionsLocked()
> + void ClearDefaultActionsLocked() override
> GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
> g_gmock_mutex.AssertHeld();
>
> @@ -1586,26 +1593,26 @@ class FunctionMockerBase : public
> UntypedFunctionMockerBase {
> g_gmock_mutex.Lock();
> }
>
> - protected:
> - template <typename Function>
> - friend class MockSpec;
> -
> - typedef ActionResultHolder<Result> ResultHolder;
> -
> // Returns the result of invoking this mock function with the given
> // arguments. This function can be safely called from multiple
> // threads concurrently.
> - Result InvokeWith(
> - typename RvalueRef<typename Function<F>::ArgumentTuple>::type args)
> - GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
> - // const_cast is required since in C++98 we still pass ArgumentTuple
> around
> - // by const& instead of rvalue reference.
> - void* untyped_args = const_cast<void*>(static_cast<const
> void*>(&args));
> - scoped_ptr<ResultHolder> holder(
> - DownCast_<ResultHolder*>(this->UntypedInvokeWith(untyped_args)));
> + Result Invoke(Args... args) GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
> + ArgumentTuple tuple(std::forward<Args>(args)...);
> + std::unique_ptr<ResultHolder> holder(DownCast_<ResultHolder*>(
> + this->UntypedInvokeWith(static_cast<void*>(&tuple))));
> return holder->Unwrap();
> }
>
> + MockSpec<F> With(Matcher<Args>... m) {
> + return MockSpec<F>(this, ::std::make_tuple(std::move(m)...));
> + }
> +
> + protected:
> + template <typename Function>
> + friend class MockSpec;
> +
> + typedef ActionResultHolder<Result> ResultHolder;
> +
> // Adds and returns a default action spec for this mock function.
> OnCallSpec<F>& AddNewOnCallSpec(
> const char* file, int line,
> @@ -1625,14 +1632,14 @@ class FunctionMockerBase : public
> UntypedFunctionMockerBase {
> Mock::RegisterUseByOnCallOrExpectCall(MockObject(), file, line);
> TypedExpectation<F>* const expectation =
> new TypedExpectation<F>(this, file, line, source_text, m);
> - const linked_ptr<ExpectationBase> untyped_expectation(expectation);
> + const std::shared_ptr<ExpectationBase>
> untyped_expectation(expectation);
> // See the definition of untyped_expectations_ for why access to
> // it is unprotected here.
> untyped_expectations_.push_back(untyped_expectation);
>
> // Adds this expectation into the implicit sequence if there is one.
> Sequence* const implicit_sequence = g_gmock_implicit_sequence.get();
> - if (implicit_sequence != NULL) {
> + if (implicit_sequence != nullptr) {
> implicit_sequence->AddExpectation(Expectation(untyped_expectation));
> }
>
> @@ -1651,10 +1658,9 @@ class FunctionMockerBase : public
> UntypedFunctionMockerBase {
> ::std::ostream* os) const {
> const OnCallSpec<F>* const spec = FindOnCallSpec(args);
>
> - if (spec == NULL) {
> - *os << (internal::type_equals<Result, void>::value ?
> - "returning directly.\n" :
> - "returning default value.\n");
> + if (spec == nullptr) {
> + *os << (std::is_void<Result>::value ? "returning directly.\n"
> + : "returning default value.\n");
> } else {
> *os << "taking default action specified at:\n"
> << FormatFileLocation(spec->file(), spec->line()) << "\n";
> @@ -1664,10 +1670,9 @@ class FunctionMockerBase : public
> UntypedFunctionMockerBase {
> // Writes a message that the call is uninteresting (i.e. neither
> // explicitly expected nor explicitly unexpected) to the given
> // ostream.
> - virtual void UntypedDescribeUninterestingCall(
> - const void* untyped_args,
> - ::std::ostream* os) const
> - GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
> + void UntypedDescribeUninterestingCall(const void* untyped_args,
> + ::std::ostream* os) const override
> + GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
> const ArgumentTuple& args =
> *static_cast<const ArgumentTuple*>(untyped_args);
> *os << "Uninteresting mock function call - ";
> @@ -1692,18 +1697,17 @@ class FunctionMockerBase : public
> UntypedFunctionMockerBase {
> // section. The reason is that we have no control on what the
> // action does (it can invoke an arbitrary user function or even a
> // mock function) and excessive locking could cause a dead lock.
> - virtual const ExpectationBase* UntypedFindMatchingExpectation(
> - const void* untyped_args,
> - const void** untyped_action, bool* is_excessive,
> - ::std::ostream* what, ::std::ostream* why)
> - GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
> + const ExpectationBase* UntypedFindMatchingExpectation(
> + const void* untyped_args, const void** untyped_action, bool*
> is_excessive,
> + ::std::ostream* what, ::std::ostream* why) override
> + GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
> const ArgumentTuple& args =
> *static_cast<const ArgumentTuple*>(untyped_args);
> MutexLock l(&g_gmock_mutex);
> TypedExpectation<F>* exp = this->FindMatchingExpectationLocked(args);
> - if (exp == NULL) { // A match wasn't found.
> + if (exp == nullptr) { // A match wasn't found.
> this->FormatUnexpectedCallMessageLocked(args, what, why);
> - return NULL;
> + return nullptr;
> }
>
> // This line must be done before calling GetActionForArguments(),
> @@ -1711,15 +1715,15 @@ class FunctionMockerBase : public
> UntypedFunctionMockerBase {
> // its saturation status.
> *is_excessive = exp->IsSaturated();
> const Action<F>* action = exp->GetActionForArguments(this, args,
> what, why);
> - if (action != NULL && action->IsDoDefault())
> - action = NULL; // Normalize "do default" to NULL.
> + if (action != nullptr && action->IsDoDefault())
> + action = nullptr; // Normalize "do default" to NULL.
> *untyped_action = action;
> return exp;
> }
>
> // Prints the given function arguments to the ostream.
> - virtual void UntypedPrintArgs(const void* untyped_args,
> - ::std::ostream* os) const {
> + void UntypedPrintArgs(const void* untyped_args,
> + ::std::ostream* os) const override {
> const ArgumentTuple& args =
> *static_cast<const ArgumentTuple*>(untyped_args);
> UniversalPrint(args, os);
> @@ -1742,7 +1746,7 @@ class FunctionMockerBase : public
> UntypedFunctionMockerBase {
> return exp;
> }
> }
> - return NULL;
> + return nullptr;
> }
>
> // Returns a message that the arguments don't match any expectation.
> @@ -1764,12 +1768,12 @@ class FunctionMockerBase : public
> UntypedFunctionMockerBase {
> ::std::ostream* why) const
> GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
> g_gmock_mutex.AssertHeld();
> - const int count = static_cast<int>(untyped_expectations_.size());
> + const size_t count = untyped_expectations_.size();
> *why << "Google Mock tried the following " << count << " "
> << (count == 1 ? "expectation, but it didn't match" :
> "expectations, but none matched")
> << ":\n";
> - for (int i = 0; i < count; i++) {
> + for (size_t i = 0; i < count; i++) {
> TypedExpectation<F>* const expectation =
>
> static_cast<TypedExpectation<F>*>(untyped_expectations_[i].get());
> *why << "\n";
> @@ -1782,36 +1786,98 @@ class FunctionMockerBase : public
> UntypedFunctionMockerBase {
> expectation->DescribeCallCountTo(why);
> }
> }
> -
> - // There is no generally useful and implementable semantics of
> - // copying a mock object, so copying a mock is usually a user error.
> - // Thus we disallow copying function mockers. If the user really
> - // wants to copy a mock object, they should implement their own copy
> - // operation, for example:
> - //
> - // class MockFoo : public Foo {
> - // public:
> - // // Defines a copy constructor explicitly.
> - // MockFoo(const MockFoo& src) {}
> - // ...
> - // };
> - GTEST_DISALLOW_COPY_AND_ASSIGN_(FunctionMockerBase);
> -}; // class FunctionMockerBase
> +}; // class FunctionMocker
>
> GTEST_DISABLE_MSC_WARNINGS_POP_() // 4355
>
> -// Implements methods of FunctionMockerBase.
> -
> -// Verifies that all expectations on this mock function have been
> -// satisfied. Reports one or more Google Test non-fatal failures and
> -// returns false if not.
> -
> // Reports an uninteresting call (whose description is in msg) in the
> // manner specified by 'reaction'.
> void ReportUninterestingCall(CallReaction reaction, const std::string&
> msg);
>
> } // namespace internal
>
> +// A MockFunction<F> class has one mock method whose type is F. It is
> +// useful when you just want your test code to emit some messages and
> +// have Google Mock verify the right messages are sent (and perhaps at
> +// the right times). For example, if you are exercising code:
> +//
> +// Foo(1);
> +// Foo(2);
> +// Foo(3);
> +//
> +// and want to verify that Foo(1) and Foo(3) both invoke
> +// mock.Bar("a"), but Foo(2) doesn't invoke anything, you can write:
> +//
> +// TEST(FooTest, InvokesBarCorrectly) {
> +// MyMock mock;
> +// MockFunction<void(string check_point_name)> check;
> +// {
> +// InSequence s;
> +//
> +// EXPECT_CALL(mock, Bar("a"));
> +// EXPECT_CALL(check, Call("1"));
> +// EXPECT_CALL(check, Call("2"));
> +// EXPECT_CALL(mock, Bar("a"));
> +// }
> +// Foo(1);
> +// check.Call("1");
> +// Foo(2);
> +// check.Call("2");
> +// Foo(3);
> +// }
> +//
> +// The expectation spec says that the first Bar("a") must happen
> +// before check point "1", the second Bar("a") must happen after check
> +// point "2", and nothing should happen between the two check
> +// points. The explicit check points make it easy to tell which
> +// Bar("a") is called by which call to Foo().
> +//
> +// MockFunction<F> can also be used to exercise code that accepts
> +// std::function<F> callbacks. To do so, use AsStdFunction() method
> +// to create std::function proxy forwarding to original object's Call.
> +// Example:
> +//
> +// TEST(FooTest, RunsCallbackWithBarArgument) {
> +// MockFunction<int(string)> callback;
> +// EXPECT_CALL(callback, Call("bar")).WillOnce(Return(1));
> +// Foo(callback.AsStdFunction());
> +// }
> +template <typename F>
> +class MockFunction;
> +
> +template <typename R, typename... Args>
> +class MockFunction<R(Args...)> {
> + public:
> + MockFunction() {}
> + MockFunction(const MockFunction&) = delete;
> + MockFunction& operator=(const MockFunction&) = delete;
> +
> + std::function<R(Args...)> AsStdFunction() {
> + return [this](Args... args) -> R {
> + return this->Call(std::forward<Args>(args)...);
> + };
> + }
> +
> + // Implementation detail: the expansion of the MOCK_METHOD macro.
> + R Call(Args... args) {
> + mock_.SetOwnerAndName(this, "Call");
> + return mock_.Invoke(std::forward<Args>(args)...);
> + }
> +
> + internal::MockSpec<R(Args...)> gmock_Call(Matcher<Args>... m) {
> + mock_.RegisterOwner(this);
> + return mock_.With(std::move(m)...);
> + }
> +
> + internal::MockSpec<R(Args...)> gmock_Call(const
> internal::WithoutMatchers&,
> + R (*)(Args...)) {
> + return this->gmock_Call(::testing::A<Args>()...);
> + }
> +
> + private:
> + internal::FunctionMocker<R(Args...)> mock_;
> +};
> +
> // The style guide prohibits "using" statements in a namespace scope
> // inside a header file. However, the MockSpec class template is
> // meant to be defined in the ::testing namespace. The following line
> @@ -1907,8 +1973,9 @@ GTEST_DISABLE_MSC_WARNINGS_POP_() // 4251
> // second argument is an internal type derived from the method signature.
> The
> // failure to disambiguate two overloads of this method in the ON_CALL
> statement
> // is how we block callers from setting expectations on overloaded
> methods.
> -#define GMOCK_ON_CALL_IMPL_(mock_expr, Setter, call)
> \
> - ((mock_expr).gmock_##call)(::testing::internal::GetWithoutMatchers(),
> NULL) \
> +#define GMOCK_ON_CALL_IMPL_(mock_expr, Setter, call) \
> + ((mock_expr).gmock_##call)(::testing::internal::GetWithoutMatchers(), \
> + nullptr) \
> .Setter(__FILE__, __LINE__, #mock_expr, #call)
>
> #define ON_CALL(obj, call) \
>
> diff --git a/llvm/utils/unittest/googlemock/include/gmock/gmock.h
> b/llvm/utils/unittest/googlemock/include/gmock/gmock.h
> index 436aabf7d9afe..45645ff637779 100644
> --- a/llvm/utils/unittest/googlemock/include/gmock/gmock.h
> +++ b/llvm/utils/unittest/googlemock/include/gmock/gmock.h
> @@ -39,14 +39,14 @@
>
> // This file implements the following syntax:
> //
> -// ON_CALL(mock_object.Method(...))
> +// ON_CALL(mock_object, Method(...))
> // .With(...) ?
> // .WillByDefault(...);
> //
> // where With() is optional and WillByDefault() must appear exactly
> // once.
> //
> -// EXPECT_CALL(mock_object.Method(...))
> +// EXPECT_CALL(mock_object, Method(...))
> // .With(...) ?
> // .Times(...) ?
> // .InSequence(...) *
> @@ -56,24 +56,25 @@
> //
> // where all clauses are optional and WillOnce() can be repeated.
>
> -#ifdef __clang__
> -#if __has_warning("-Wdeprecated-copy")
> -#pragma clang diagnostic push
> -#pragma clang diagnostic ignored "-Wdeprecated-copy"
> -#endif
> -#endif
> -
> #include "gmock/gmock-actions.h"
> #include "gmock/gmock-cardinalities.h"
> +#include "gmock/gmock-function-mocker.h"
> #include "gmock/gmock-generated-actions.h"
> #include "gmock/gmock-generated-function-mockers.h"
> #include "gmock/gmock-generated-matchers.h"
> -#include "gmock/gmock-generated-nice-strict.h"
> #include "gmock/gmock-matchers.h"
> #include "gmock/gmock-more-actions.h"
> #include "gmock/gmock-more-matchers.h"
> +#include "gmock/gmock-nice-strict.h"
> #include "gmock/internal/gmock-internal-utils.h"
>
> +#ifdef __clang__
> +#if __has_warning("-Wdeprecated-copy")
> +#pragma clang diagnostic push
> +#pragma clang diagnostic ignored "-Wdeprecated-copy"
> +#endif
> +#endif
> +
> namespace testing {
>
> // Declares Google Mock flags that we want a user to use programmatically.
> @@ -98,6 +99,10 @@ GTEST_API_ void InitGoogleMock(int* argc, char** argv);
> // UNICODE mode.
> GTEST_API_ void InitGoogleMock(int* argc, wchar_t** argv);
>
> +// This overloaded version can be used on Arduino/embedded platforms where
> +// there is no argc/argv.
> +GTEST_API_ void InitGoogleMock();
> +
> } // namespace testing
>
> #ifdef __clang__
> @@ -105,4 +110,5 @@ GTEST_API_ void InitGoogleMock(int* argc, wchar_t**
> argv);
> #pragma clang diagnostic pop
> #endif
> #endif
> +
> #endif // GMOCK_INCLUDE_GMOCK_GMOCK_H_
>
> diff --git
> a/llvm/utils/unittest/googlemock/include/gmock/internal/gmock-generated-internal-utils.h
> b/llvm/utils/unittest/googlemock/include/gmock/internal/gmock-generated-internal-utils.h
> deleted file mode 100644
> index 8ccd06fb721b8..0000000000000
> ---
> a/llvm/utils/unittest/googlemock/include/gmock/internal/gmock-generated-internal-utils.h
> +++ /dev/null
> @@ -1,289 +0,0 @@
> -// This file was GENERATED by command:
> -// pump.py gmock-generated-internal-utils.h.pump
> -// DO NOT EDIT BY HAND!!!
> -
> -// Copyright 2007, Google Inc.
> -// All rights reserved.
> -//
> -// Redistribution and use in source and binary forms, with or without
> -// modification, are permitted provided that the following conditions are
> -// met:
> -//
> -// * Redistributions of source code must retain the above copyright
> -// notice, this list of conditions and the following disclaimer.
> -// * Redistributions in binary form must reproduce the above
> -// copyright notice, this list of conditions and the following disclaimer
> -// in the documentation and/or other materials provided with the
> -// distribution.
> -// * Neither the name of Google Inc. nor the names of its
> -// contributors may be used to endorse or promote products derived from
> -// this software without specific prior written permission.
> -//
> -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
> -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
> -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
> -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
> -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
> -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
> -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
> -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
> -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
> -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
> -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
> -
> -
> -// Google Mock - a framework for writing C++ mock classes.
> -//
> -// This file contains template meta-programming utility classes needed
> -// for implementing Google Mock.
> -
> -// GOOGLETEST_CM0002 DO NOT DELETE
> -
> -// IWYU pragma: private, include "gmock/gmock.h
> -
> -#ifndef GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_GENERATED_INTERNAL_UTILS_H_
> -#define GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_GENERATED_INTERNAL_UTILS_H_
> -
> -#include "gmock/internal/gmock-port.h"
> -
> -namespace testing {
> -
> -template <typename T>
> -class Matcher;
> -
> -namespace internal {
> -
> -// An IgnoredValue object can be implicitly constructed from ANY value.
> -// This is used in implementing the IgnoreResult(a) action.
> -class IgnoredValue {
> - public:
> - // This constructor template allows any value to be implicitly
> - // converted to IgnoredValue. The object has no data member and
> - // doesn't try to remember anything about the argument. We
> - // deliberately omit the 'explicit' keyword in order to allow the
> - // conversion to be implicit.
> - template <typename T>
> - IgnoredValue(const T& /* ignored */) {} // NOLINT(runtime/explicit)
> -};
> -
> -// MatcherTuple<T>::type is a tuple type where each field is a Matcher
> -// for the corresponding field in tuple type T.
> -template <typename Tuple>
> -struct MatcherTuple;
> -
> -template <>
> -struct MatcherTuple< ::testing::tuple<> > {
> - typedef ::testing::tuple< > type;
> -};
> -
> -template <typename A1>
> -struct MatcherTuple< ::testing::tuple<A1> > {
> - typedef ::testing::tuple<Matcher<A1> > type;
> -};
> -
> -template <typename A1, typename A2>
> -struct MatcherTuple< ::testing::tuple<A1, A2> > {
> - typedef ::testing::tuple<Matcher<A1>, Matcher<A2> > type;
> -};
> -
> -template <typename A1, typename A2, typename A3>
> -struct MatcherTuple< ::testing::tuple<A1, A2, A3> > {
> - typedef ::testing::tuple<Matcher<A1>, Matcher<A2>, Matcher<A3> > type;
> -};
> -
> -template <typename A1, typename A2, typename A3, typename A4>
> -struct MatcherTuple< ::testing::tuple<A1, A2, A3, A4> > {
> - typedef ::testing::tuple<Matcher<A1>, Matcher<A2>, Matcher<A3>,
> Matcher<A4> >
> - type;
> -};
> -
> -template <typename A1, typename A2, typename A3, typename A4, typename A5>
> -struct MatcherTuple< ::testing::tuple<A1, A2, A3, A4, A5> > {
> - typedef ::testing::tuple<Matcher<A1>, Matcher<A2>, Matcher<A3>,
> Matcher<A4>,
> - Matcher<A5> >
> - type;
> -};
> -
> -template <typename A1, typename A2, typename A3, typename A4, typename A5,
> - typename A6>
> -struct MatcherTuple< ::testing::tuple<A1, A2, A3, A4, A5, A6> > {
> - typedef ::testing::tuple<Matcher<A1>, Matcher<A2>, Matcher<A3>,
> Matcher<A4>,
> - Matcher<A5>, Matcher<A6> >
> - type;
> -};
> -
> -template <typename A1, typename A2, typename A3, typename A4, typename A5,
> - typename A6, typename A7>
> -struct MatcherTuple< ::testing::tuple<A1, A2, A3, A4, A5, A6, A7> > {
> - typedef ::testing::tuple<Matcher<A1>, Matcher<A2>, Matcher<A3>,
> Matcher<A4>,
> - Matcher<A5>, Matcher<A6>, Matcher<A7> >
> - type;
> -};
> -
> -template <typename A1, typename A2, typename A3, typename A4, typename A5,
> - typename A6, typename A7, typename A8>
> -struct MatcherTuple< ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, A8> > {
> - typedef ::testing::tuple<Matcher<A1>, Matcher<A2>, Matcher<A3>,
> Matcher<A4>,
> - Matcher<A5>, Matcher<A6>, Matcher<A7>,
> Matcher<A8> >
> - type;
> -};
> -
> -template <typename A1, typename A2, typename A3, typename A4, typename A5,
> - typename A6, typename A7, typename A8, typename A9>
> -struct MatcherTuple< ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, A8, A9>
> > {
> - typedef ::testing::tuple<Matcher<A1>, Matcher<A2>, Matcher<A3>,
> Matcher<A4>,
> - Matcher<A5>, Matcher<A6>, Matcher<A7>,
> Matcher<A8>,
> - Matcher<A9> >
> - type;
> -};
> -
> -template <typename A1, typename A2, typename A3, typename A4, typename A5,
> - typename A6, typename A7, typename A8, typename A9, typename A10>
> -struct MatcherTuple< ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, A8, A9,
> - A10> > {
> - typedef ::testing::tuple<Matcher<A1>, Matcher<A2>, Matcher<A3>,
> Matcher<A4>,
> - Matcher<A5>, Matcher<A6>, Matcher<A7>,
> Matcher<A8>,
> - Matcher<A9>, Matcher<A10> >
> - type;
> -};
> -
> -// Template struct Function<F>, where F must be a function type, contains
> -// the following typedefs:
> -//
> -// Result: the function's return type.
> -// ArgumentN: the type of the N-th argument, where N starts
> with 1.
> -// ArgumentTuple: the tuple type consisting of all parameters of
> F.
> -// ArgumentMatcherTuple: the tuple type consisting of Matchers for all
> -// parameters of F.
> -// MakeResultVoid: the function type obtained by substituting void
> -// for the return type of F.
> -// MakeResultIgnoredValue:
> -// the function type obtained by substituting
> Something
> -// for the return type of F.
> -template <typename F>
> -struct Function;
> -
> -template <typename R>
> -struct Function<R()> {
> - typedef R Result;
> - typedef ::testing::tuple<> ArgumentTuple;
> - typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
> - typedef void MakeResultVoid();
> - typedef IgnoredValue MakeResultIgnoredValue();
> -};
> -
> -template <typename R, typename A1>
> -struct Function<R(A1)>
> - : Function<R()> {
> - typedef A1 Argument1;
> - typedef ::testing::tuple<A1> ArgumentTuple;
> - typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
> - typedef void MakeResultVoid(A1);
> - typedef IgnoredValue MakeResultIgnoredValue(A1);
> -};
> -
> -template <typename R, typename A1, typename A2>
> -struct Function<R(A1, A2)>
> - : Function<R(A1)> {
> - typedef A2 Argument2;
> - typedef ::testing::tuple<A1, A2> ArgumentTuple;
> - typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
> - typedef void MakeResultVoid(A1, A2);
> - typedef IgnoredValue MakeResultIgnoredValue(A1, A2);
> -};
> -
> -template <typename R, typename A1, typename A2, typename A3>
> -struct Function<R(A1, A2, A3)>
> - : Function<R(A1, A2)> {
> - typedef A3 Argument3;
> - typedef ::testing::tuple<A1, A2, A3> ArgumentTuple;
> - typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
> - typedef void MakeResultVoid(A1, A2, A3);
> - typedef IgnoredValue MakeResultIgnoredValue(A1, A2, A3);
> -};
> -
> -template <typename R, typename A1, typename A2, typename A3, typename A4>
> -struct Function<R(A1, A2, A3, A4)>
> - : Function<R(A1, A2, A3)> {
> - typedef A4 Argument4;
> - typedef ::testing::tuple<A1, A2, A3, A4> ArgumentTuple;
> - typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
> - typedef void MakeResultVoid(A1, A2, A3, A4);
> - typedef IgnoredValue MakeResultIgnoredValue(A1, A2, A3, A4);
> -};
> -
> -template <typename R, typename A1, typename A2, typename A3, typename A4,
> - typename A5>
> -struct Function<R(A1, A2, A3, A4, A5)>
> - : Function<R(A1, A2, A3, A4)> {
> - typedef A5 Argument5;
> - typedef ::testing::tuple<A1, A2, A3, A4, A5> ArgumentTuple;
> - typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
> - typedef void MakeResultVoid(A1, A2, A3, A4, A5);
> - typedef IgnoredValue MakeResultIgnoredValue(A1, A2, A3, A4, A5);
> -};
> -
> -template <typename R, typename A1, typename A2, typename A3, typename A4,
> - typename A5, typename A6>
> -struct Function<R(A1, A2, A3, A4, A5, A6)>
> - : Function<R(A1, A2, A3, A4, A5)> {
> - typedef A6 Argument6;
> - typedef ::testing::tuple<A1, A2, A3, A4, A5, A6> ArgumentTuple;
> - typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
> - typedef void MakeResultVoid(A1, A2, A3, A4, A5, A6);
> - typedef IgnoredValue MakeResultIgnoredValue(A1, A2, A3, A4, A5, A6);
> -};
> -
> -template <typename R, typename A1, typename A2, typename A3, typename A4,
> - typename A5, typename A6, typename A7>
> -struct Function<R(A1, A2, A3, A4, A5, A6, A7)>
> - : Function<R(A1, A2, A3, A4, A5, A6)> {
> - typedef A7 Argument7;
> - typedef ::testing::tuple<A1, A2, A3, A4, A5, A6, A7> ArgumentTuple;
> - typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
> - typedef void MakeResultVoid(A1, A2, A3, A4, A5, A6, A7);
> - typedef IgnoredValue MakeResultIgnoredValue(A1, A2, A3, A4, A5, A6, A7);
> -};
> -
> -template <typename R, typename A1, typename A2, typename A3, typename A4,
> - typename A5, typename A6, typename A7, typename A8>
> -struct Function<R(A1, A2, A3, A4, A5, A6, A7, A8)>
> - : Function<R(A1, A2, A3, A4, A5, A6, A7)> {
> - typedef A8 Argument8;
> - typedef ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, A8> ArgumentTuple;
> - typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
> - typedef void MakeResultVoid(A1, A2, A3, A4, A5, A6, A7, A8);
> - typedef IgnoredValue MakeResultIgnoredValue(A1, A2, A3, A4, A5, A6, A7,
> A8);
> -};
> -
> -template <typename R, typename A1, typename A2, typename A3, typename A4,
> - typename A5, typename A6, typename A7, typename A8, typename A9>
> -struct Function<R(A1, A2, A3, A4, A5, A6, A7, A8, A9)>
> - : Function<R(A1, A2, A3, A4, A5, A6, A7, A8)> {
> - typedef A9 Argument9;
> - typedef ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, A8, A9>
> ArgumentTuple;
> - typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
> - typedef void MakeResultVoid(A1, A2, A3, A4, A5, A6, A7, A8, A9);
> - typedef IgnoredValue MakeResultIgnoredValue(A1, A2, A3, A4, A5, A6, A7,
> A8,
> - A9);
> -};
> -
> -template <typename R, typename A1, typename A2, typename A3, typename A4,
> - typename A5, typename A6, typename A7, typename A8, typename A9,
> - typename A10>
> -struct Function<R(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)>
> - : Function<R(A1, A2, A3, A4, A5, A6, A7, A8, A9)> {
> - typedef A10 Argument10;
> - typedef ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, A8, A9,
> - A10> ArgumentTuple;
> - typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
> - typedef void MakeResultVoid(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10);
> - typedef IgnoredValue MakeResultIgnoredValue(A1, A2, A3, A4, A5, A6, A7,
> A8,
> - A9, A10);
> -};
> -
> -} // namespace internal
> -
> -} // namespace testing
> -
> -#endif // GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_GENERATED_INTERNAL_UTILS_H_
>
> diff --git
> a/llvm/utils/unittest/googlemock/include/gmock/internal/gmock-internal-utils.h
> b/llvm/utils/unittest/googlemock/include/gmock/internal/gmock-internal-utils.h
> index ceda2e8044d31..b9533508ef757 100644
> ---
> a/llvm/utils/unittest/googlemock/include/gmock/internal/gmock-internal-utils.h
> +++
> b/llvm/utils/unittest/googlemock/include/gmock/internal/gmock-internal-utils.h
> @@ -44,11 +44,15 @@
> #include <stdio.h>
> #include <ostream> // NOLINT
> #include <string>
> -#include "gmock/internal/gmock-generated-internal-utils.h"
> +#include <type_traits>
> #include "gmock/internal/gmock-port.h"
> #include "gtest/gtest.h"
>
> namespace testing {
> +
> +template <typename>
> +class Matcher;
> +
> namespace internal {
>
> // Silence MSVC C4100 (unreferenced formal parameter) and
> @@ -94,46 +98,16 @@ inline const typename Pointer::element_type*
> GetRawPointer(const Pointer& p) {
> template <typename Element>
> inline Element* GetRawPointer(Element* p) { return p; }
>
> -// This comparator allows linked_ptr to be stored in sets.
> -template <typename T>
> -struct LinkedPtrLessThan {
> - bool operator()(const ::testing::internal::linked_ptr<T>& lhs,
> - const ::testing::internal::linked_ptr<T>& rhs) const {
> - return lhs.get() < rhs.get();
> - }
> -};
> -
> -// Symbian compilation can be done with wchar_t being either a native
> -// type or a typedef. Using Google Mock with OpenC without wchar_t
> -// should require the definition of _STLP_NO_WCHAR_T.
> -//
> // MSVC treats wchar_t as a native type usually, but treats it as the
> // same as unsigned short when the compiler option /Zc:wchar_t- is
> // specified. It defines _NATIVE_WCHAR_T_DEFINED symbol when wchar_t
> // is a native type.
> -#if (GTEST_OS_SYMBIAN && defined(_STLP_NO_WCHAR_T)) || \
> - (defined(_MSC_VER) && !defined(_NATIVE_WCHAR_T_DEFINED))
> +#if defined(_MSC_VER) && !defined(_NATIVE_WCHAR_T_DEFINED)
> // wchar_t is a typedef.
> #else
> # define GMOCK_WCHAR_T_IS_NATIVE_ 1
> #endif
>
> -// signed wchar_t and unsigned wchar_t are NOT in the C++ standard.
> -// Using them is a bad practice and not portable. So DON'T use them.
> -//
> -// Still, Google Mock is designed to work even if the user uses signed
> -// wchar_t or unsigned wchar_t (obviously, assuming the compiler
> -// supports them).
> -//
> -// To gcc,
> -// wchar_t == signed wchar_t != unsigned wchar_t == unsigned int
> -#ifdef __GNUC__
> -#if !defined(__WCHAR_UNSIGNED__)
> -// signed/unsigned wchar_t are valid types.
> -# define GMOCK_HAS_SIGNED_WCHAR_T_ 1
> -#endif
> -#endif
> -
> // In what follows, we use the term "kind" to indicate whether a type
> // is bool, an integer type (excluding bool), a floating-point type,
> // or none of them. This categorization is useful for determining
> @@ -185,11 +159,11 @@ GMOCK_DECLARE_KIND_(long double, kFloatingPoint);
> static_cast< ::testing::internal::TypeKind>( \
> ::testing::internal::KindOf<type>::value)
>
> -// Evaluates to true iff integer type T is signed.
> +// Evaluates to true if and only if integer type T is signed.
> #define GMOCK_IS_SIGNED_(T) (static_cast<T>(-1) < 0)
>
> // LosslessArithmeticConvertibleImpl<kFromKind, From, kToKind, To>::value
> -// is true iff arithmetic type From can be losslessly converted to
> +// is true if and only if arithmetic type From can be losslessly
> converted to
> // arithmetic type To.
> //
> // It's the user's responsibility to ensure that both From and To are
> @@ -198,30 +172,30 @@ GMOCK_DECLARE_KIND_(long double, kFloatingPoint);
> // From, and kToKind is the kind of To; the value is
> // implementation-defined when the above pre-condition is violated.
> template <TypeKind kFromKind, typename From, TypeKind kToKind, typename
> To>
> -struct LosslessArithmeticConvertibleImpl : public false_type {};
> +struct LosslessArithmeticConvertibleImpl : public std::false_type {};
>
> // Converting bool to bool is lossless.
> template <>
> struct LosslessArithmeticConvertibleImpl<kBool, bool, kBool, bool>
> - : public true_type {}; // NOLINT
> + : public std::true_type {};
>
> // Converting bool to any integer type is lossless.
> template <typename To>
> struct LosslessArithmeticConvertibleImpl<kBool, bool, kInteger, To>
> - : public true_type {}; // NOLINT
> + : public std::true_type {};
>
> // Converting bool to any floating-point type is lossless.
> template <typename To>
> struct LosslessArithmeticConvertibleImpl<kBool, bool, kFloatingPoint, To>
> - : public true_type {}; // NOLINT
> + : public std::true_type {};
>
> // Converting an integer to bool is lossy.
> template <typename From>
> struct LosslessArithmeticConvertibleImpl<kInteger, From, kBool, bool>
> - : public false_type {}; // NOLINT
> + : public std::false_type {};
>
> -// Converting an integer to another non-bool integer is lossless iff
> -// the target type's range encloses the source type's range.
> +// Converting an integer to another non-bool integer is lossless
> +// if and only if the target type's range encloses the source type's
> range.
> template <typename From, typename To>
> struct LosslessArithmeticConvertibleImpl<kInteger, From, kInteger, To>
> : public bool_constant<
> @@ -239,27 +213,27 @@ struct LosslessArithmeticConvertibleImpl<kInteger,
> From, kInteger, To>
> // the format of a floating-point number is implementation-defined.
> template <typename From, typename To>
> struct LosslessArithmeticConvertibleImpl<kInteger, From, kFloatingPoint,
> To>
> - : public false_type {}; // NOLINT
> + : public std::false_type {};
>
> // Converting a floating-point to bool is lossy.
> template <typename From>
> struct LosslessArithmeticConvertibleImpl<kFloatingPoint, From, kBool,
> bool>
> - : public false_type {}; // NOLINT
> + : public std::false_type {};
>
> // Converting a floating-point to an integer is lossy.
> template <typename From, typename To>
> struct LosslessArithmeticConvertibleImpl<kFloatingPoint, From, kInteger,
> To>
> - : public false_type {}; // NOLINT
> + : public std::false_type {};
>
> // Converting a floating-point to another floating-point is lossless
> -// iff the target type is at least as big as the source type.
> +// if and only if the target type is at least as big as the source type.
> template <typename From, typename To>
> struct LosslessArithmeticConvertibleImpl<
> kFloatingPoint, From, kFloatingPoint, To>
> : public bool_constant<sizeof(From) <= sizeof(To)> {}; // NOLINT
>
> -// LosslessArithmeticConvertible<From, To>::value is true iff arithmetic
> -// type From can be losslessly converted to arithmetic type To.
> +// LosslessArithmeticConvertible<From, To>::value is true if and only if
> +// arithmetic type From can be losslessly converted to arithmetic type To.
> //
> // It's the user's responsibility to ensure that both From and To are
> // raw (i.e. has no CV modifier, is not a pointer, and is not a
> @@ -333,11 +307,11 @@ const char kWarningVerbosity[] = "warning";
> // No logs are printed.
> const char kErrorVerbosity[] = "error";
>
> -// Returns true iff a log with the given severity is visible according
> -// to the --gmock_verbose flag.
> +// Returns true if and only if a log with the given severity is visible
> +// according to the --gmock_verbose flag.
> GTEST_API_ bool LogIsVisible(LogSeverity severity);
>
> -// Prints the given message to stdout iff 'severity' >= the level
> +// Prints the given message to stdout if and only if 'severity' >= the
> level
> // specified by the --gmock_verbose flag. If stack_frames_to_skip >=
> // 0, also prints the stack trace excluding the top
> // stack_frames_to_skip frames. In opt mode, any positive
> @@ -362,35 +336,8 @@ class WithoutMatchers {
> // Internal use only: access the singleton instance of WithoutMatchers.
> GTEST_API_ WithoutMatchers GetWithoutMatchers();
>
> -// FIXME: group all type utilities together.
> -
> // Type traits.
>
> -// is_reference<T>::value is non-zero iff T is a reference type.
> -template <typename T> struct is_reference : public false_type {};
> -template <typename T> struct is_reference<T&> : public true_type {};
> -
> -// type_equals<T1, T2>::value is non-zero iff T1 and T2 are the same type.
> -template <typename T1, typename T2> struct type_equals : public
> false_type {};
> -template <typename T> struct type_equals<T, T> : public true_type {};
> -
> -// remove_reference<T>::type removes the reference from type T, if any.
> -template <typename T> struct remove_reference { typedef T type; }; //
> NOLINT
> -template <typename T> struct remove_reference<T&> { typedef T type; }; //
> NOLINT
> -
> -// DecayArray<T>::type turns an array type U[N] to const U* and preserves
> -// other types. Useful for saving a copy of a function argument.
> -template <typename T> struct DecayArray { typedef T type; }; // NOLINT
> -template <typename T, size_t N> struct DecayArray<T[N]> {
> - typedef const T* type;
> -};
> -// Sometimes people use arrays whose size is not available at the use site
> -// (e.g. extern const char kNamePrefix[]). This specialization covers
> that
> -// case.
> -template <typename T> struct DecayArray<T[]> {
> - typedef const T* type;
> -};
> -
> // Disable MSVC warnings for infinite recursion, since in this case the
> // the recursion is unreachable.
> #ifdef _MSC_VER
> @@ -439,9 +386,8 @@ class StlContainerView {
> typedef const type& const_reference;
>
> static const_reference ConstReference(const RawContainer& container) {
> - // Ensures that RawContainer is not a const type.
> - testing::StaticAssertTypeEq<RawContainer,
> - GTEST_REMOVE_CONST_(RawContainer)>();
> + static_assert(!std::is_const<RawContainer>::value,
> + "RawContainer type must not be const");
> return container;
> }
> static type Copy(const RawContainer& container) { return container; }
> @@ -451,7 +397,7 @@ class StlContainerView {
> template <typename Element, size_t N>
> class StlContainerView<Element[N]> {
> public:
> - typedef GTEST_REMOVE_CONST_(Element) RawElement;
> + typedef typename std::remove_const<Element>::type RawElement;
> typedef internal::NativeArray<RawElement> type;
> // NativeArray<T> can represent a native array either by value or by
> // reference (selected by a constructor argument), so 'const type'
> @@ -461,53 +407,32 @@ class StlContainerView<Element[N]> {
> typedef const type const_reference;
>
> static const_reference ConstReference(const Element (&array)[N]) {
> - // Ensures that Element is not a const type.
> - testing::StaticAssertTypeEq<Element, RawElement>();
> -#if GTEST_OS_SYMBIAN
> - // The Nokia Symbian compiler confuses itself in template
> instantiation
> - // for this call without the cast to Element*:
> - // function call '[testing::internal::NativeArray<char
> *>].NativeArray(
> - // {lval} const char *[4], long,
> testing::internal::RelationToSource)'
> - // does not match
> - // 'testing::internal::NativeArray<char *>::NativeArray(
> - // char *const *, unsigned int,
> testing::internal::RelationToSource)'
> - // (instantiating: 'testing::internal::ContainsMatcherImpl
> - // <const char * (&)[4]>::Matches(const char * (&)[4]) const')
> - // (instantiating: 'testing::internal::StlContainerView<char *[4]>::
> - // ConstReference(const char * (&)[4])')
> - // (and though the N parameter type is mismatched in the above
> explicit
> - // conversion of it doesn't help - only the conversion of the array).
> - return type(const_cast<Element*>(&array[0]), N,
> - RelationToSourceReference());
> -#else
> + static_assert(std::is_same<Element, RawElement>::value,
> + "Element type must not be const");
> return type(array, N, RelationToSourceReference());
> -#endif // GTEST_OS_SYMBIAN
> }
> static type Copy(const Element (&array)[N]) {
> -#if GTEST_OS_SYMBIAN
> - return type(const_cast<Element*>(&array[0]), N,
> RelationToSourceCopy());
> -#else
> return type(array, N, RelationToSourceCopy());
> -#endif // GTEST_OS_SYMBIAN
> }
> };
>
> // This specialization is used when RawContainer is a native array
> // represented as a (pointer, size) tuple.
> template <typename ElementPointer, typename Size>
> -class StlContainerView< ::testing::tuple<ElementPointer, Size> > {
> +class StlContainerView< ::std::tuple<ElementPointer, Size> > {
> public:
> - typedef GTEST_REMOVE_CONST_(
> - typename internal::PointeeOf<ElementPointer>::type) RawElement;
> + typedef typename std::remove_const<
> + typename internal::PointeeOf<ElementPointer>::type>::type
> RawElement;
> typedef internal::NativeArray<RawElement> type;
> typedef const type const_reference;
>
> static const_reference ConstReference(
> - const ::testing::tuple<ElementPointer, Size>& array) {
> - return type(get<0>(array), get<1>(array),
> RelationToSourceReference());
> + const ::std::tuple<ElementPointer, Size>& array) {
> + return type(std::get<0>(array), std::get<1>(array),
> + RelationToSourceReference());
> }
> - static type Copy(const ::testing::tuple<ElementPointer, Size>& array) {
> - return type(get<0>(array), get<1>(array), RelationToSourceCopy());
> + static type Copy(const ::std::tuple<ElementPointer, Size>& array) {
> + return type(std::get<0>(array), std::get<1>(array),
> RelationToSourceCopy());
> }
> };
>
> @@ -529,29 +454,12 @@ struct RemoveConstFromKey<std::pair<const K, V> > {
> typedef std::pair<K, V> type;
> };
>
> -// Mapping from booleans to types. Similar to boost::bool_<kValue> and
> -// std::integral_constant<bool, kValue>.
> -template <bool kValue>
> -struct BooleanConstant {};
> -
> // Emit an assertion failure due to incorrect DoDefault() usage.
> Out-of-lined to
> // reduce code size.
> GTEST_API_ void IllegalDoDefault(const char* file, int line);
>
> -#if GTEST_LANG_CXX11
> -// Helper types for Apply() below.
> -template <size_t... Is> struct int_pack { typedef int_pack type; };
> -
> -template <class Pack, size_t I> struct append;
> -template <size_t... Is, size_t I>
> -struct append<int_pack<Is...>, I> : int_pack<Is..., I> {};
> -
> -template <size_t C>
> -struct make_int_pack : append<typename make_int_pack<C - 1>::type, C - 1>
> {};
> -template <> struct make_int_pack<0> : int_pack<> {};
> -
> template <typename F, typename Tuple, size_t... Idx>
> -auto ApplyImpl(F&& f, Tuple&& args, int_pack<Idx...>) -> decltype(
> +auto ApplyImpl(F&& f, Tuple&& args, IndexSequence<Idx...>) -> decltype(
> std::forward<F>(f)(std::get<Idx>(std::forward<Tuple>(args))...)) {
> return std::forward<F>(f)(std::get<Idx>(std::forward<Tuple>(args))...);
> }
> @@ -560,12 +468,42 @@ auto ApplyImpl(F&& f, Tuple&& args,
> int_pack<Idx...>) -> decltype(
> template <typename F, typename Tuple>
> auto Apply(F&& f, Tuple&& args)
> -> decltype(ApplyImpl(std::forward<F>(f), std::forward<Tuple>(args),
> -
> make_int_pack<std::tuple_size<Tuple>::value>())) {
> +
> MakeIndexSequence<std::tuple_size<Tuple>::value>())) {
> return ApplyImpl(std::forward<F>(f), std::forward<Tuple>(args),
> - make_int_pack<std::tuple_size<Tuple>::value>());
> + MakeIndexSequence<std::tuple_size<Tuple>::value>());
> }
> -#endif
>
> +// Template struct Function<F>, where F must be a function type, contains
> +// the following typedefs:
> +//
> +// Result: the function's return type.
> +// Arg<N>: the type of the N-th argument, where N starts
> with 0.
> +// ArgumentTuple: the tuple type consisting of all parameters of
> F.
> +// ArgumentMatcherTuple: the tuple type consisting of Matchers for all
> +// parameters of F.
> +// MakeResultVoid: the function type obtained by substituting void
> +// for the return type of F.
> +// MakeResultIgnoredValue:
> +// the function type obtained by substituting
> Something
> +// for the return type of F.
> +template <typename T>
> +struct Function;
> +
> +template <typename R, typename... Args>
> +struct Function<R(Args...)> {
> + using Result = R;
> + static constexpr size_t ArgumentCount = sizeof...(Args);
> + template <size_t I>
> + using Arg = ElemFromList<I, typename
> MakeIndexSequence<sizeof...(Args)>::type,
> + Args...>;
> + using ArgumentTuple = std::tuple<Args...>;
> + using ArgumentMatcherTuple = std::tuple<Matcher<Args>...>;
> + using MakeResultVoid = void(Args...);
> + using MakeResultIgnoredValue = IgnoredValue(Args...);
> +};
> +
> +template <typename R, typename... Args>
> +constexpr size_t Function<R(Args...)>::ArgumentCount;
>
> #ifdef _MSC_VER
> # pragma warning(pop)
>
> diff --git
> a/llvm/utils/unittest/googlemock/include/gmock/internal/gmock-port.h
> b/llvm/utils/unittest/googlemock/include/gmock/internal/gmock-port.h
> index 0ee6abc80fcd4..27e4c0caf2bcc 100644
> --- a/llvm/utils/unittest/googlemock/include/gmock/internal/gmock-port.h
> +++ b/llvm/utils/unittest/googlemock/include/gmock/internal/gmock-port.h
> @@ -54,14 +54,13 @@
> // here, as Google Mock depends on Google Test. Only add a utility
> // here if it's truly specific to Google Mock.
>
> -#include "gtest/internal/gtest-linked_ptr.h"
> #include "gtest/internal/gtest-port.h"
> #include "gmock/internal/custom/gmock-port.h"
>
> -// For MS Visual C++, check the compiler version. At least VS 2003 is
> +// For MS Visual C++, check the compiler version. At least VS 2015 is
> // required to compile Google Mock.
> -#if defined(_MSC_VER) && _MSC_VER < 1310
> -# error "At least Visual C++ 2003 (7.1) is required to compile Google
> Mock."
> +#if defined(_MSC_VER) && _MSC_VER < 1900
> +# error "At least Visual C++ 2015 (14.0) is required to compile Google
> Mock."
> #endif
>
> // Macro for referencing flags. This is public as we want the user to
>
> diff --git
> a/llvm/utils/unittest/googlemock/include/gmock/internal/gmock-pp.h
> b/llvm/utils/unittest/googlemock/include/gmock/internal/gmock-pp.h
> new file mode 100644
> index 0000000000000..1ab80e1cdbee6
> --- /dev/null
> +++ b/llvm/utils/unittest/googlemock/include/gmock/internal/gmock-pp.h
> @@ -0,0 +1,317 @@
> +#ifndef THIRD_PARTY_GOOGLETEST_GOOGLEMOCK_INCLUDE_GMOCK_PP_H_
> +#define THIRD_PARTY_GOOGLETEST_GOOGLEMOCK_INCLUDE_GMOCK_PP_H_
> +
> +#undef GMOCK_PP_INTERNAL_USE_MSVC
> +#if defined(__clang__)
> +#define GMOCK_PP_INTERNAL_USE_MSVC 0
> +#elif defined(_MSC_VER)
> +// TODO(iserna): Also verify tradional versus comformant preprocessor.
> +static_assert(
> + _MSC_VER >= 1900,
> + "MSVC version not supported. There is support for MSVC 14.0 and
> above.");
> +#define GMOCK_PP_INTERNAL_USE_MSVC 1
> +#else
> +#define GMOCK_PP_INTERNAL_USE_MSVC 0
> +#endif
> +
> +// Expands and concatenates the arguments. Constructed macros reevaluate.
> +#define GMOCK_PP_CAT(_1, _2) GMOCK_PP_INTERNAL_CAT(_1, _2)
> +
> +// Expands and stringifies the only argument.
> +#define GMOCK_PP_STRINGIZE(...) GMOCK_PP_INTERNAL_STRINGIZE(__VA_ARGS__)
> +
> +// Returns empty. Given a variadic number of arguments.
> +#define GMOCK_PP_EMPTY(...)
> +
> +// Returns a comma. Given a variadic number of arguments.
> +#define GMOCK_PP_COMMA(...) ,
> +
> +// Returns the only argument.
> +#define GMOCK_PP_IDENTITY(_1) _1
> +
> +// MSVC preprocessor collapses __VA_ARGS__ in a single argument, we use a
> +// CAT-like directive to force correct evaluation. Each macro has its own.
> +#if GMOCK_PP_INTERNAL_USE_MSVC
> +
> +// Evaluates to the number of arguments after expansion.
> +//
> +// #define PAIR x, y
> +//
> +// GMOCK_PP_NARG() => 1
> +// GMOCK_PP_NARG(x) => 1
> +// GMOCK_PP_NARG(x, y) => 2
> +// GMOCK_PP_NARG(PAIR) => 2
> +//
> +// Requires: the number of arguments after expansion is at most 15.
> +#define GMOCK_PP_NARG(...)
> \
> + GMOCK_PP_INTERNAL_NARG_CAT(
> \
> + GMOCK_PP_INTERNAL_INTERNAL_16TH(__VA_ARGS__, 15, 14, 13, 12, 11,
> 10, 9, \
> + 8, 7, 6, 5, 4, 3, 2, 1), )
> +
> +// Returns 1 if the expansion of arguments has an unprotected comma.
> Otherwise
> +// returns 0. Requires no more than 15 unprotected commas.
> +#define GMOCK_PP_HAS_COMMA(...)
> \
> + GMOCK_PP_INTERNAL_HAS_COMMA_CAT(
> \
> + GMOCK_PP_INTERNAL_INTERNAL_16TH(__VA_ARGS__, 1, 1, 1, 1, 1, 1, 1,
> 1, 1, \
> + 1, 1, 1, 1, 1, 0), )
> +// Returns the first argument.
> +#define GMOCK_PP_HEAD(...) \
> + GMOCK_PP_INTERNAL_HEAD_CAT(GMOCK_PP_INTERNAL_HEAD(__VA_ARGS__), )
> +
> +// Returns the tail. A variadic list of all arguments minus the first.
> Requires
> +// at least one argument.
> +#define GMOCK_PP_TAIL(...) \
> + GMOCK_PP_INTERNAL_TAIL_CAT(GMOCK_PP_INTERNAL_TAIL(__VA_ARGS__), )
> +
> +// Calls CAT(_Macro, NARG(__VA_ARGS__))(__VA_ARGS__)
> +#define GMOCK_PP_VARIADIC_CALL(_Macro, ...) \
> + GMOCK_PP_INTERNAL_VARIADIC_CALL_CAT( \
> + GMOCK_PP_CAT(_Macro, GMOCK_PP_NARG(__VA_ARGS__))(__VA_ARGS__), )
> +
> +#else // GMOCK_PP_INTERNAL_USE_MSVC
> +
> +#define GMOCK_PP_NARG(...)
> \
> + GMOCK_PP_INTERNAL_INTERNAL_16TH(__VA_ARGS__, 15, 14, 13, 12, 11, 10, 9,
> 8, \
> + 7, 6, 5, 4, 3, 2, 1)
> +#define GMOCK_PP_HAS_COMMA(...)
> \
> + GMOCK_PP_INTERNAL_INTERNAL_16TH(__VA_ARGS__, 1, 1, 1, 1, 1, 1, 1, 1, 1,
> 1, \
> + 1, 1, 1, 1, 0)
> +#define GMOCK_PP_HEAD(...) GMOCK_PP_INTERNAL_HEAD(__VA_ARGS__)
> +#define GMOCK_PP_TAIL(...) GMOCK_PP_INTERNAL_TAIL(__VA_ARGS__)
> +#define GMOCK_PP_VARIADIC_CALL(_Macro, ...) \
> + GMOCK_PP_CAT(_Macro, GMOCK_PP_NARG(__VA_ARGS__))(__VA_ARGS__)
> +
> +#endif // GMOCK_PP_INTERNAL_USE_MSVC
> +
> +// If the arguments after expansion have no tokens, evaluates to `1`.
> Otherwise
> +// evaluates to `0`.
> +//
> +// Requires: * the number of arguments after expansion is at most 15.
> +// * If the argument is a macro, it must be able to be called
> with one
> +// argument.
> +//
> +// Implementation details:
> +//
> +// There is one case when it generates a compile error: if the argument
> is macro
> +// that cannot be called with one argument.
> +//
> +// #define M(a, b) // it doesn't matter what it expands to
> +//
> +// // Expected: expands to `0`.
> +// // Actual: compile error.
> +// GMOCK_PP_IS_EMPTY(M)
> +//
> +// There are 4 cases tested:
> +//
> +// * __VA_ARGS__ possible expansion has no unparen'd commas. Expected 0.
> +// * __VA_ARGS__ possible expansion is not enclosed in parenthesis.
> Expected 0.
> +// * __VA_ARGS__ possible expansion is not a macro that ()-evaluates to a
> comma.
> +// Expected 0
> +// * __VA_ARGS__ is empty, or has unparen'd commas, or is enclosed in
> +// parenthesis, or is a macro that ()-evaluates to comma. Expected 1.
> +//
> +// We trigger detection on '0001', i.e. on empty.
> +#define GMOCK_PP_IS_EMPTY(...)
> \
> + GMOCK_PP_INTERNAL_IS_EMPTY(GMOCK_PP_HAS_COMMA(__VA_ARGS__),
> \
> + GMOCK_PP_HAS_COMMA(GMOCK_PP_COMMA
> __VA_ARGS__), \
> + GMOCK_PP_HAS_COMMA(__VA_ARGS__()),
> \
> + GMOCK_PP_HAS_COMMA(GMOCK_PP_COMMA
> __VA_ARGS__()))
> +
> +// Evaluates to _Then if _Cond is 1 and _Else if _Cond is 0.
> +#define GMOCK_PP_IF(_Cond, _Then, _Else) \
> + GMOCK_PP_CAT(GMOCK_PP_INTERNAL_IF_, _Cond)(_Then, _Else)
> +
> +// Evaluates to the number of arguments after expansion. Identifies
> 'empty' as
> +// 0.
> +//
> +// #define PAIR x, y
> +//
> +// GMOCK_PP_NARG0() => 0
> +// GMOCK_PP_NARG0(x) => 1
> +// GMOCK_PP_NARG0(x, y) => 2
> +// GMOCK_PP_NARG0(PAIR) => 2
> +//
> +// Requires: * the number of arguments after expansion is at most 15.
> +// * If the argument is a macro, it must be able to be called
> with one
> +// argument.
> +#define GMOCK_PP_NARG0(...) \
> + GMOCK_PP_IF(GMOCK_PP_IS_EMPTY(__VA_ARGS__), 0,
> GMOCK_PP_NARG(__VA_ARGS__))
> +
> +// Expands to 1 if the first argument starts with something in
> parentheses,
> +// otherwise to 0.
> +#define GMOCK_PP_IS_BEGIN_PARENS(...) \
> + GMOCK_PP_INTERNAL_ALTERNATE_HEAD( \
> + GMOCK_PP_CAT(GMOCK_PP_INTERNAL_IBP_IS_VARIADIC_R_, \
> + GMOCK_PP_INTERNAL_IBP_IS_VARIADIC_C __VA_ARGS__))
> +
> +// Expands to 1 is there is only one argument and it is enclosed in
> parentheses.
> +#define GMOCK_PP_IS_ENCLOSED_PARENS(...) \
> + GMOCK_PP_IF(GMOCK_PP_IS_BEGIN_PARENS(__VA_ARGS__), \
> + GMOCK_PP_IS_EMPTY(GMOCK_PP_EMPTY __VA_ARGS__), 0)
> +
> +// Remove the parens, requires GMOCK_PP_IS_ENCLOSED_PARENS(args) => 1.
> +#define GMOCK_PP_REMOVE_PARENS(...) GMOCK_PP_INTERNAL_REMOVE_PARENS
> __VA_ARGS__
> +
> +// Expands to _Macro(0, _Data, e1) _Macro(1, _Data, e2) ... _Macro(K -1,
> _Data,
> +// eK) as many of GMOCK_INTERNAL_NARG0 _Tuple.
> +// Requires: * |_Macro| can be called with 3 arguments.
> +// * |_Tuple| expansion has no more than 15 elements.
> +#define GMOCK_PP_FOR_EACH(_Macro, _Data, _Tuple) \
> + GMOCK_PP_CAT(GMOCK_PP_INTERNAL_FOR_EACH_IMPL_, GMOCK_PP_NARG0 _Tuple) \
> + (0, _Macro, _Data, _Tuple)
> +
> +// Expands to _Macro(0, _Data, ) _Macro(1, _Data, ) ... _Macro(K - 1,
> _Data, )
> +// Empty if _K = 0.
> +// Requires: * |_Macro| can be called with 3 arguments.
> +// * |_K| literal between 0 and 15
> +#define GMOCK_PP_REPEAT(_Macro, _Data, _N) \
> + GMOCK_PP_CAT(GMOCK_PP_INTERNAL_FOR_EACH_IMPL_, _N) \
> + (0, _Macro, _Data, GMOCK_PP_INTENRAL_EMPTY_TUPLE)
> +
> +// Increments the argument, requires the argument to be between 0 and 15.
> +#define GMOCK_PP_INC(_i) GMOCK_PP_CAT(GMOCK_PP_INTERNAL_INC_, _i)
> +
> +// Returns comma if _i != 0. Requires _i to be between 0 and 15.
> +#define GMOCK_PP_COMMA_IF(_i) GMOCK_PP_CAT(GMOCK_PP_INTERNAL_COMMA_IF_,
> _i)
> +
> +// Internal details follow. Do not use any of these symbols outside of
> this
> +// file or we will break your code.
> +#define GMOCK_PP_INTENRAL_EMPTY_TUPLE (, , , , , , , , , , , , , , , )
> +#define GMOCK_PP_INTERNAL_CAT(_1, _2) _1##_2
> +#define GMOCK_PP_INTERNAL_STRINGIZE(...) #__VA_ARGS__
> +#define GMOCK_PP_INTERNAL_INTERNAL_16TH(_1, _2, _3, _4, _5, _6, _7, _8,
> _9, \
> + _10, _11, _12, _13, _14, _15,
> _16, \
> + ...)
> \
> + _16
> +#define GMOCK_PP_INTERNAL_CAT_5(_1, _2, _3, _4, _5) _1##_2##_3##_4##_5
> +#define GMOCK_PP_INTERNAL_IS_EMPTY(_1, _2, _3, _4)
> \
> +
> GMOCK_PP_HAS_COMMA(GMOCK_PP_INTERNAL_CAT_5(GMOCK_PP_INTERNAL_IS_EMPTY_CASE_,
> \
> + _1, _2, _3, _4))
> +#define GMOCK_PP_INTERNAL_IS_EMPTY_CASE_0001 ,
> +#define GMOCK_PP_INTERNAL_IF_1(_Then, _Else) _Then
> +#define GMOCK_PP_INTERNAL_IF_0(_Then, _Else) _Else
> +#define GMOCK_PP_INTERNAL_HEAD(_1, ...) _1
> +#define GMOCK_PP_INTERNAL_TAIL(_1, ...) __VA_ARGS__
> +
> +#if GMOCK_PP_INTERNAL_USE_MSVC
> +#define GMOCK_PP_INTERNAL_NARG_CAT(_1, _2)
> GMOCK_PP_INTERNAL_NARG_CAT_I(_1, _2)
> +#define GMOCK_PP_INTERNAL_HEAD_CAT(_1, _2)
> GMOCK_PP_INTERNAL_HEAD_CAT_I(_1, _2)
> +#define GMOCK_PP_INTERNAL_HAS_COMMA_CAT(_1, _2) \
> + GMOCK_PP_INTERNAL_HAS_COMMA_CAT_I(_1, _2)
> +#define GMOCK_PP_INTERNAL_TAIL_CAT(_1, _2)
> GMOCK_PP_INTERNAL_TAIL_CAT_I(_1, _2)
> +#define GMOCK_PP_INTERNAL_VARIADIC_CALL_CAT(_1, _2) \
> + GMOCK_PP_INTERNAL_VARIADIC_CALL_CAT_I(_1, _2)
> +#define GMOCK_PP_INTERNAL_NARG_CAT_I(_1, _2) _1##_2
> +#define GMOCK_PP_INTERNAL_HEAD_CAT_I(_1, _2) _1##_2
> +#define GMOCK_PP_INTERNAL_HAS_COMMA_CAT_I(_1, _2) _1##_2
> +#define GMOCK_PP_INTERNAL_TAIL_CAT_I(_1, _2) _1##_2
> +#define GMOCK_PP_INTERNAL_VARIADIC_CALL_CAT_I(_1, _2) _1##_2
> +#define GMOCK_PP_INTERNAL_ALTERNATE_HEAD(...) \
> + GMOCK_PP_INTERNAL_ALTERNATE_HEAD_CAT(GMOCK_PP_HEAD(__VA_ARGS__), )
> +#define GMOCK_PP_INTERNAL_ALTERNATE_HEAD_CAT(_1, _2) \
> + GMOCK_PP_INTERNAL_ALTERNATE_HEAD_CAT_I(_1, _2)
> +#define GMOCK_PP_INTERNAL_ALTERNATE_HEAD_CAT_I(_1, _2) _1##_2
> +#else // GMOCK_PP_INTERNAL_USE_MSVC
> +#define GMOCK_PP_INTERNAL_ALTERNATE_HEAD(...) GMOCK_PP_HEAD(__VA_ARGS__)
> +#endif // GMOCK_PP_INTERNAL_USE_MSVC
> +
> +#define GMOCK_PP_INTERNAL_IBP_IS_VARIADIC_C(...) 1 _
> +#define GMOCK_PP_INTERNAL_IBP_IS_VARIADIC_R_1 1,
> +#define
> GMOCK_PP_INTERNAL_IBP_IS_VARIADIC_R_GMOCK_PP_INTERNAL_IBP_IS_VARIADIC_C \
> + 0,
> +#define GMOCK_PP_INTERNAL_REMOVE_PARENS(...) __VA_ARGS__
> +#define GMOCK_PP_INTERNAL_INC_0 1
> +#define GMOCK_PP_INTERNAL_INC_1 2
> +#define GMOCK_PP_INTERNAL_INC_2 3
> +#define GMOCK_PP_INTERNAL_INC_3 4
> +#define GMOCK_PP_INTERNAL_INC_4 5
> +#define GMOCK_PP_INTERNAL_INC_5 6
> +#define GMOCK_PP_INTERNAL_INC_6 7
> +#define GMOCK_PP_INTERNAL_INC_7 8
> +#define GMOCK_PP_INTERNAL_INC_8 9
> +#define GMOCK_PP_INTERNAL_INC_9 10
> +#define GMOCK_PP_INTERNAL_INC_10 11
> +#define GMOCK_PP_INTERNAL_INC_11 12
> +#define GMOCK_PP_INTERNAL_INC_12 13
> +#define GMOCK_PP_INTERNAL_INC_13 14
> +#define GMOCK_PP_INTERNAL_INC_14 15
> +#define GMOCK_PP_INTERNAL_INC_15 16
> +#define GMOCK_PP_INTERNAL_COMMA_IF_0
> +#define GMOCK_PP_INTERNAL_COMMA_IF_1 ,
> +#define GMOCK_PP_INTERNAL_COMMA_IF_2 ,
> +#define GMOCK_PP_INTERNAL_COMMA_IF_3 ,
> +#define GMOCK_PP_INTERNAL_COMMA_IF_4 ,
> +#define GMOCK_PP_INTERNAL_COMMA_IF_5 ,
> +#define GMOCK_PP_INTERNAL_COMMA_IF_6 ,
> +#define GMOCK_PP_INTERNAL_COMMA_IF_7 ,
> +#define GMOCK_PP_INTERNAL_COMMA_IF_8 ,
> +#define GMOCK_PP_INTERNAL_COMMA_IF_9 ,
> +#define GMOCK_PP_INTERNAL_COMMA_IF_10 ,
> +#define GMOCK_PP_INTERNAL_COMMA_IF_11 ,
> +#define GMOCK_PP_INTERNAL_COMMA_IF_12 ,
> +#define GMOCK_PP_INTERNAL_COMMA_IF_13 ,
> +#define GMOCK_PP_INTERNAL_COMMA_IF_14 ,
> +#define GMOCK_PP_INTERNAL_COMMA_IF_15 ,
> +#define GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, _element) \
> + _Macro(_i, _Data, _element)
> +#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_0(_i, _Macro, _Data, _Tuple)
> +#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_1(_i, _Macro, _Data, _Tuple) \
> + GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple)
> +#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_2(_i, _Macro, _Data, _Tuple) \
> + GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
> + GMOCK_PP_INTERNAL_FOR_EACH_IMPL_1(GMOCK_PP_INC(_i), _Macro, _Data, \
> + (GMOCK_PP_TAIL _Tuple))
> +#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_3(_i, _Macro, _Data, _Tuple) \
> + GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
> + GMOCK_PP_INTERNAL_FOR_EACH_IMPL_2(GMOCK_PP_INC(_i), _Macro, _Data, \
> + (GMOCK_PP_TAIL _Tuple))
> +#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_4(_i, _Macro, _Data, _Tuple) \
> + GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
> + GMOCK_PP_INTERNAL_FOR_EACH_IMPL_3(GMOCK_PP_INC(_i), _Macro, _Data, \
> + (GMOCK_PP_TAIL _Tuple))
> +#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_5(_i, _Macro, _Data, _Tuple) \
> + GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
> + GMOCK_PP_INTERNAL_FOR_EACH_IMPL_4(GMOCK_PP_INC(_i), _Macro, _Data, \
> + (GMOCK_PP_TAIL _Tuple))
> +#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_6(_i, _Macro, _Data, _Tuple) \
> + GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
> + GMOCK_PP_INTERNAL_FOR_EACH_IMPL_5(GMOCK_PP_INC(_i), _Macro, _Data, \
> + (GMOCK_PP_TAIL _Tuple))
> +#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_7(_i, _Macro, _Data, _Tuple) \
> + GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
> + GMOCK_PP_INTERNAL_FOR_EACH_IMPL_6(GMOCK_PP_INC(_i), _Macro, _Data, \
> + (GMOCK_PP_TAIL _Tuple))
> +#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_8(_i, _Macro, _Data, _Tuple) \
> + GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
> + GMOCK_PP_INTERNAL_FOR_EACH_IMPL_7(GMOCK_PP_INC(_i), _Macro, _Data, \
> + (GMOCK_PP_TAIL _Tuple))
> +#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_9(_i, _Macro, _Data, _Tuple) \
> + GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
> + GMOCK_PP_INTERNAL_FOR_EACH_IMPL_8(GMOCK_PP_INC(_i), _Macro, _Data, \
> + (GMOCK_PP_TAIL _Tuple))
> +#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_10(_i, _Macro, _Data, _Tuple) \
> + GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
> + GMOCK_PP_INTERNAL_FOR_EACH_IMPL_9(GMOCK_PP_INC(_i), _Macro, _Data, \
> + (GMOCK_PP_TAIL _Tuple))
> +#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_11(_i, _Macro, _Data, _Tuple) \
> + GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
> + GMOCK_PP_INTERNAL_FOR_EACH_IMPL_10(GMOCK_PP_INC(_i), _Macro, _Data, \
> + (GMOCK_PP_TAIL _Tuple))
> +#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_12(_i, _Macro, _Data, _Tuple) \
> + GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
> + GMOCK_PP_INTERNAL_FOR_EACH_IMPL_11(GMOCK_PP_INC(_i), _Macro, _Data, \
> + (GMOCK_PP_TAIL _Tuple))
> +#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_13(_i, _Macro, _Data, _Tuple) \
> + GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
> + GMOCK_PP_INTERNAL_FOR_EACH_IMPL_12(GMOCK_PP_INC(_i), _Macro, _Data, \
> + (GMOCK_PP_TAIL _Tuple))
> +#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_14(_i, _Macro, _Data, _Tuple) \
> + GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
> + GMOCK_PP_INTERNAL_FOR_EACH_IMPL_13(GMOCK_PP_INC(_i), _Macro, _Data, \
> + (GMOCK_PP_TAIL _Tuple))
> +#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_15(_i, _Macro, _Data, _Tuple) \
> + GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
> + GMOCK_PP_INTERNAL_FOR_EACH_IMPL_14(GMOCK_PP_INC(_i), _Macro, _Data, \
> + (GMOCK_PP_TAIL _Tuple))
> +
> +#endif //
> THIRD_PARTY_GOOGLETEST_GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PP_H_
>
> diff --git a/llvm/utils/unittest/googlemock/src/gmock-cardinalities.cc
> b/llvm/utils/unittest/googlemock/src/gmock-cardinalities.cc
> index 0549f7276d78c..7463f4383233c 100644
> --- a/llvm/utils/unittest/googlemock/src/gmock-cardinalities.cc
> +++ b/llvm/utils/unittest/googlemock/src/gmock-cardinalities.cc
> @@ -70,18 +70,18 @@ class BetweenCardinalityImpl : public
> CardinalityInterface {
>
> // Conservative estimate on the lower/upper bound of the number of
> // calls allowed.
> - virtual int ConservativeLowerBound() const { return min_; }
> - virtual int ConservativeUpperBound() const { return max_; }
> + int ConservativeLowerBound() const override { return min_; }
> + int ConservativeUpperBound() const override { return max_; }
>
> - virtual bool IsSatisfiedByCallCount(int call_count) const {
> + bool IsSatisfiedByCallCount(int call_count) const override {
> return min_ <= call_count && call_count <= max_;
> }
>
> - virtual bool IsSaturatedByCallCount(int call_count) const {
> + bool IsSaturatedByCallCount(int call_count) const override {
> return call_count >= max_;
> }
>
> - virtual void DescribeTo(::std::ostream* os) const;
> + void DescribeTo(::std::ostream* os) const override;
>
> private:
> const int min_;
>
> diff --git a/llvm/utils/unittest/googlemock/src/gmock-internal-utils.cc
> b/llvm/utils/unittest/googlemock/src/gmock-internal-utils.cc
> index e3a674859a85d..e5b547981d14d 100644
> --- a/llvm/utils/unittest/googlemock/src/gmock-internal-utils.cc
> +++ b/llvm/utils/unittest/googlemock/src/gmock-internal-utils.cc
> @@ -93,8 +93,8 @@ GTEST_API_ std::string
> ConvertIdentifierNameToWords(const char* id_name) {
> // use Google Mock with a testing framework other than Google Test.
> class GoogleTestFailureReporter : public FailureReporterInterface {
> public:
> - virtual void ReportFailure(FailureType type, const char* file, int line,
> - const std::string& message) {
> + void ReportFailure(FailureType type, const char* file, int line,
> + const std::string& message) override {
> AssertHelper(type == kFatal ?
> TestPartResult::kFatalFailure :
> TestPartResult::kNonFatalFailure,
> @@ -123,8 +123,8 @@ GTEST_API_ FailureReporterInterface*
> GetFailureReporter() {
> // Protects global resources (stdout in particular) used by Log().
> static GTEST_DEFINE_STATIC_MUTEX_(g_log_mutex);
>
> -// Returns true iff a log with the given severity is visible according
> -// to the --gmock_verbose flag.
> +// Returns true if and only if a log with the given severity is visible
> +// according to the --gmock_verbose flag.
> GTEST_API_ bool LogIsVisible(LogSeverity severity) {
> if (GMOCK_FLAG(verbose) == kInfoVerbosity) {
> // Always show the log if --gmock_verbose=info.
> @@ -139,7 +139,7 @@ GTEST_API_ bool LogIsVisible(LogSeverity severity) {
> }
> }
>
> -// Prints the given message to stdout iff 'severity' >= the level
> +// Prints the given message to stdout if and only if 'severity' >= the
> level
> // specified by the --gmock_verbose flag. If stack_frames_to_skip >=
> // 0, also prints the stack trace excluding the top
> // stack_frames_to_skip frames. In opt mode, any positive
> @@ -154,9 +154,6 @@ GTEST_API_ void Log(LogSeverity severity, const
> std::string& message,
> // Ensures that logs from
> diff erent threads don't interleave.
> MutexLock l(&g_log_mutex);
>
> - // "using ::std::cout;" doesn't work with Symbian's STLport, where cout
> is a
> - // macro.
> -
> if (severity == kWarning) {
> // Prints a GMOCK WARNING marker to make the warnings easily
> searchable.
> std::cout << "\nGMOCK WARNING:";
>
> diff --git a/llvm/utils/unittest/googlemock/src/gmock-matchers.cc
> b/llvm/utils/unittest/googlemock/src/gmock-matchers.cc
> index f8ddff15b5c05..4a3f7af2351de 100644
> --- a/llvm/utils/unittest/googlemock/src/gmock-matchers.cc
> +++ b/llvm/utils/unittest/googlemock/src/gmock-matchers.cc
> @@ -42,116 +42,6 @@
> #include <string>
>
> namespace testing {
> -
> -// Constructs a matcher that matches a const std::string& whose value is
> -// equal to s.
> -Matcher<const std::string&>::Matcher(const std::string& s) { *this =
> Eq(s); }
> -
> -#if GTEST_HAS_GLOBAL_STRING
> -// Constructs a matcher that matches a const std::string& whose value is
> -// equal to s.
> -Matcher<const std::string&>::Matcher(const ::string& s) {
> - *this = Eq(static_cast<std::string>(s));
> -}
> -#endif // GTEST_HAS_GLOBAL_STRING
> -
> -// Constructs a matcher that matches a const std::string& whose value is
> -// equal to s.
> -Matcher<const std::string&>::Matcher(const char* s) {
> - *this = Eq(std::string(s));
> -}
> -
> -// Constructs a matcher that matches a std::string whose value is equal to
> -// s.
> -Matcher<std::string>::Matcher(const std::string& s) { *this = Eq(s); }
> -
> -#if GTEST_HAS_GLOBAL_STRING
> -// Constructs a matcher that matches a std::string whose value is equal to
> -// s.
> -Matcher<std::string>::Matcher(const ::string& s) {
> - *this = Eq(static_cast<std::string>(s));
> -}
> -#endif // GTEST_HAS_GLOBAL_STRING
> -
> -// Constructs a matcher that matches a std::string whose value is equal to
> -// s.
> -Matcher<std::string>::Matcher(const char* s) { *this =
> Eq(std::string(s)); }
> -
> -#if GTEST_HAS_GLOBAL_STRING
> -// Constructs a matcher that matches a const ::string& whose value is
> -// equal to s.
> -Matcher<const ::string&>::Matcher(const std::string& s) {
> - *this = Eq(static_cast<::string>(s));
> -}
> -
> -// Constructs a matcher that matches a const ::string& whose value is
> -// equal to s.
> -Matcher<const ::string&>::Matcher(const ::string& s) { *this = Eq(s); }
> -
> -// Constructs a matcher that matches a const ::string& whose value is
> -// equal to s.
> -Matcher<const ::string&>::Matcher(const char* s) { *this =
> Eq(::string(s)); }
> -
> -// Constructs a matcher that matches a ::string whose value is equal to s.
> -Matcher<::string>::Matcher(const std::string& s) {
> - *this = Eq(static_cast<::string>(s));
> -}
> -
> -// Constructs a matcher that matches a ::string whose value is equal to s.
> -Matcher<::string>::Matcher(const ::string& s) { *this = Eq(s); }
> -
> -// Constructs a matcher that matches a string whose value is equal to s.
> -Matcher<::string>::Matcher(const char* s) { *this = Eq(::string(s)); }
> -#endif // GTEST_HAS_GLOBAL_STRING
> -
> -#if GTEST_HAS_ABSL
> -// Constructs a matcher that matches a const absl::string_view& whose
> value is
> -// equal to s.
> -Matcher<const absl::string_view&>::Matcher(const std::string& s) {
> - *this = Eq(s);
> -}
> -
> -#if GTEST_HAS_GLOBAL_STRING
> -// Constructs a matcher that matches a const absl::string_view& whose
> value is
> -// equal to s.
> -Matcher<const absl::string_view&>::Matcher(const ::string& s) { *this =
> Eq(s); }
> -#endif // GTEST_HAS_GLOBAL_STRING
> -
> -// Constructs a matcher that matches a const absl::string_view& whose
> value is
> -// equal to s.
> -Matcher<const absl::string_view&>::Matcher(const char* s) {
> - *this = Eq(std::string(s));
> -}
> -
> -// Constructs a matcher that matches a const absl::string_view& whose
> value is
> -// equal to s.
> -Matcher<const absl::string_view&>::Matcher(absl::string_view s) {
> - *this = Eq(std::string(s));
> -}
> -
> -// Constructs a matcher that matches a absl::string_view whose value is
> equal to
> -// s.
> -Matcher<absl::string_view>::Matcher(const std::string& s) { *this =
> Eq(s); }
> -
> -#if GTEST_HAS_GLOBAL_STRING
> -// Constructs a matcher that matches a absl::string_view whose value is
> equal to
> -// s.
> -Matcher<absl::string_view>::Matcher(const ::string& s) { *this = Eq(s); }
> -#endif // GTEST_HAS_GLOBAL_STRING
> -
> -// Constructs a matcher that matches a absl::string_view whose value is
> equal to
> -// s.
> -Matcher<absl::string_view>::Matcher(const char* s) {
> - *this = Eq(std::string(s));
> -}
> -
> -// Constructs a matcher that matches a absl::string_view whose value is
> equal to
> -// s.
> -Matcher<absl::string_view>::Matcher(absl::string_view s) {
> - *this = Eq(std::string(s));
> -}
> -#endif // GTEST_HAS_ABSL
> -
> namespace internal {
>
> // Returns the description for a matcher defined using the MATCHER*()
>
> diff --git a/llvm/utils/unittest/googlemock/src/gmock-spec-builders.cc
> b/llvm/utils/unittest/googlemock/src/gmock-spec-builders.cc
> index b93f4e0ef6b50..f9d3434560b40 100644
> --- a/llvm/utils/unittest/googlemock/src/gmock-spec-builders.cc
> +++ b/llvm/utils/unittest/googlemock/src/gmock-spec-builders.cc
> @@ -38,6 +38,7 @@
> #include <stdlib.h>
> #include <iostream> // NOLINT
> #include <map>
> +#include <memory>
> #include <set>
> #include <string>
> #include <vector>
> @@ -49,9 +50,9 @@
> #endif
>
> // Silence C4800 (C4800: 'int *const ': forcing value
> -// to bool 'true' or 'false') for MSVC 14,15
> +// to bool 'true' or 'false') for MSVC 15
> #ifdef _MSC_VER
> -#if _MSC_VER <= 1900
> +#if _MSC_VER == 1900
> # pragma warning(push)
> # pragma warning(disable:4800)
> #endif
> @@ -125,8 +126,8 @@ void ExpectationBase::RetireAllPreRequisites()
> }
> }
>
> -// Returns true iff all pre-requisites of this expectation have been
> -// satisfied.
> +// Returns true if and only if all pre-requisites of this expectation
> +// have been satisfied.
> bool ExpectationBase::AllPrerequisitesAreSatisfied() const
> GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
> g_gmock_mutex.AssertHeld();
> @@ -291,17 +292,17 @@ void ReportUninterestingCall(CallReaction reaction,
> const std::string& msg) {
> "an EXPECT_CALL() if you don't mean to enforce the call. "
> "See "
> "
> https://github.com/google/googletest/blob/master/googlemock/"
> - "docs/CookBook.md#"
> + "docs/cook_book.md#"
> "knowing-when-to-expect for details.\n",
> stack_frames_to_skip);
> break;
> default: // FAIL
> - Expect(false, NULL, -1, msg);
> + Expect(false, nullptr, -1, msg);
> }
> }
>
> UntypedFunctionMockerBase::UntypedFunctionMockerBase()
> - : mock_obj_(NULL), name_("") {}
> + : mock_obj_(nullptr), name_("") {}
>
> UntypedFunctionMockerBase::~UntypedFunctionMockerBase() {}
>
> @@ -340,7 +341,7 @@ const void* UntypedFunctionMockerBase::MockObject()
> const
> // We protect mock_obj_ under g_gmock_mutex in case this mock
> // function is called from two threads concurrently.
> MutexLock l(&g_gmock_mutex);
> - Assert(mock_obj_ != NULL, __FILE__, __LINE__,
> + Assert(mock_obj_ != nullptr, __FILE__, __LINE__,
> "MockObject() must not be called before RegisterOwner() or "
> "SetOwnerAndName() has been called.");
> mock_obj = mock_obj_;
> @@ -357,7 +358,7 @@ const char* UntypedFunctionMockerBase::Name() const
> // We protect name_ under g_gmock_mutex in case this mock
> // function is called from two threads concurrently.
> MutexLock l(&g_gmock_mutex);
> - Assert(name_ != NULL, __FILE__, __LINE__,
> + Assert(name_ != nullptr, __FILE__, __LINE__,
> "Name() must not be called before SetOwnerAndName() has "
> "been called.");
> name = name_;
> @@ -383,7 +384,7 @@ UntypedActionResultHolderBase*
> UntypedFunctionMockerBase::UntypedInvokeWith(
> const CallReaction reaction =
> Mock::GetReactionOnUninterestingCalls(MockObject());
>
> - // True iff we need to print this call's arguments and return
> + // True if and only if we need to print this call's arguments and
> return
> // value. This definition must be kept in sync with
> // the behavior of ReportUninterestingCall().
> const bool need_to_report_uninteresting_call =
> @@ -414,8 +415,7 @@ UntypedActionResultHolderBase*
> UntypedFunctionMockerBase::UntypedInvokeWith(
> this->UntypedPerformDefaultAction(untyped_args, ss.str());
>
> // Prints the function result.
> - if (result != NULL)
> - result->PrintAsActionResult(&ss);
> + if (result != nullptr) result->PrintAsActionResult(&ss);
>
> ReportUninterestingCall(reaction, ss.str());
> return result;
> @@ -425,7 +425,7 @@ UntypedActionResultHolderBase*
> UntypedFunctionMockerBase::UntypedInvokeWith(
> ::std::stringstream ss;
> ::std::stringstream why;
> ::std::stringstream loc;
> - const void* untyped_action = NULL;
> + const void* untyped_action = nullptr;
>
> // The UntypedFindMatchingExpectation() function acquires and
> // releases g_gmock_mutex.
> @@ -433,19 +433,19 @@ UntypedActionResultHolderBase*
> UntypedFunctionMockerBase::UntypedInvokeWith(
> this->UntypedFindMatchingExpectation(
> untyped_args, &untyped_action, &is_excessive,
> &ss, &why);
> - const bool found = untyped_expectation != NULL;
> + const bool found = untyped_expectation != nullptr;
>
> - // True iff we need to print the call's arguments and return value.
> + // True if and only if we need to print the call's arguments
> + // and return value.
> // This definition must be kept in sync with the uses of Expect()
> // and Log() in this function.
> const bool need_to_report_call =
> !found || is_excessive || LogIsVisible(kInfo);
> if (!need_to_report_call) {
> // Perform the action without printing the call information.
> - return
> - untyped_action == NULL ?
> - this->UntypedPerformDefaultAction(untyped_args, "") :
> - this->UntypedPerformAction(untyped_action, untyped_args);
> + return untyped_action == nullptr
> + ? this->UntypedPerformDefaultAction(untyped_args, "")
> + : this->UntypedPerformAction(untyped_action, untyped_args);
> }
>
> ss << " Function call: " << Name();
> @@ -458,16 +458,15 @@ UntypedActionResultHolderBase*
> UntypedFunctionMockerBase::UntypedInvokeWith(
> }
>
> UntypedActionResultHolderBase* const result =
> - untyped_action == NULL ?
> - this->UntypedPerformDefaultAction(untyped_args, ss.str()) :
> - this->UntypedPerformAction(untyped_action, untyped_args);
> - if (result != NULL)
> - result->PrintAsActionResult(&ss);
> + untyped_action == nullptr
> + ? this->UntypedPerformDefaultAction(untyped_args, ss.str())
> + : this->UntypedPerformAction(untyped_action, untyped_args);
> + if (result != nullptr) result->PrintAsActionResult(&ss);
> ss << "\n" << why.str();
>
> if (!found) {
> // No expectation matches this call - reports a failure.
> - Expect(false, NULL, -1, ss.str());
> + Expect(false, nullptr, -1, ss.str());
> } else if (is_excessive) {
> // We had an upper-bound violation and the failure message is in ss.
> Expect(false, untyped_expectation->file(),
> @@ -568,15 +567,15 @@ typedef
> std::set<internal::UntypedFunctionMockerBase*> FunctionMockers;
> // expectations.
> struct MockObjectState {
> MockObjectState()
> - : first_used_file(NULL), first_used_line(-1), leakable(false) {}
> + : first_used_file(nullptr), first_used_line(-1), leakable(false) {}
>
> // Where in the source file an ON_CALL or EXPECT_CALL is first
> // invoked on this mock object.
> const char* first_used_file;
> int first_used_line;
> - ::std::string first_used_test_case;
> + ::std::string first_used_test_suite;
> ::std::string first_used_test;
> - bool leakable; // true iff it's OK to leak the object.
> + bool leakable; // true if and only if it's OK to leak the object.
> FunctionMockers function_mockers; // All registered methods of the
> object.
> };
>
> @@ -594,9 +593,6 @@ class MockObjectRegistry {
> // object alive. Therefore we report any living object as test
> // failure, unless the user explicitly asked us to ignore it.
> ~MockObjectRegistry() {
> - // "using ::std::cout;" doesn't work with Symbian's STLport, where
> cout is
> - // a macro.
> -
> if (!GMOCK_FLAG(catch_leaked_mocks))
> return;
>
> @@ -614,8 +610,8 @@ class MockObjectRegistry {
> state.first_used_line);
> std::cout << " ERROR: this mock object";
> if (state.first_used_test != "") {
> - std::cout << " (used in test " << state.first_used_test_case <<
> "."
> - << state.first_used_test << ")";
> + std::cout << " (used in test " << state.first_used_test_suite <<
> "."
> + << state.first_used_test << ")";
> }
> std::cout << " should be deleted but never is. Its address is @"
> << it->first << ".";
> @@ -723,7 +719,7 @@ bool Mock::VerifyAndClearExpectations(void* mock_obj)
> }
>
> // Verifies all expectations on the given mock object and clears its
> -// default actions and expectations. Returns true iff the
> +// default actions and expectations. Returns true if and only if the
> // verification was successful.
> bool Mock::VerifyAndClear(void* mock_obj)
> GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
> @@ -760,6 +756,19 @@ bool Mock::VerifyAndClearExpectationsLocked(void*
> mock_obj)
> return expectations_met;
> }
>
> +bool Mock::IsNaggy(void* mock_obj)
> + GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
> + return Mock::GetReactionOnUninterestingCalls(mock_obj) ==
> internal::kWarn;
> +}
> +bool Mock::IsNice(void* mock_obj)
> + GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
> + return Mock::GetReactionOnUninterestingCalls(mock_obj) ==
> internal::kAllow;
> +}
> +bool Mock::IsStrict(void* mock_obj)
> + GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
> + return Mock::GetReactionOnUninterestingCalls(mock_obj) ==
> internal::kFail;
> +}
> +
> // Registers a mock object and a mock method it owns.
> void Mock::Register(const void* mock_obj,
> internal::UntypedFunctionMockerBase* mocker)
> @@ -776,16 +785,13 @@ void Mock::RegisterUseByOnCallOrExpectCall(const
> void* mock_obj,
> GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
> internal::MutexLock l(&internal::g_gmock_mutex);
> MockObjectState& state = g_mock_object_registry.states()[mock_obj];
> - if (state.first_used_file == NULL) {
> + if (state.first_used_file == nullptr) {
> state.first_used_file = file;
> state.first_used_line = line;
> const TestInfo* const test_info =
> UnitTest::GetInstance()->current_test_info();
> - if (test_info != NULL) {
> - // FIXME: record the test case name when the
> - // ON_CALL or EXPECT_CALL is invoked from SetUpTestCase() or
> - // TearDownTestCase().
> - state.first_used_test_case = test_info->test_case_name();
> + if (test_info != nullptr) {
> + state.first_used_test_suite = test_info->test_suite_name();
> state.first_used_test = test_info->name();
> }
> }
> @@ -838,7 +844,7 @@ void Mock::ClearDefaultActionsLocked(void* mock_obj)
> Expectation::Expectation() {}
>
> Expectation::Expectation(
> - const internal::linked_ptr<internal::ExpectationBase>&
> an_expectation_base)
> + const std::shared_ptr<internal::ExpectationBase>& an_expectation_base)
> : expectation_base_(an_expectation_base) {}
>
> Expectation::~Expectation() {}
> @@ -846,7 +852,7 @@ Expectation::~Expectation() {}
> // Adds an expectation to a sequence.
> void Sequence::AddExpectation(const Expectation& expectation) const {
> if (*last_expectation_ != expectation) {
> - if (last_expectation_->expectation_base() != NULL) {
> + if (last_expectation_->expectation_base() != nullptr) {
> expectation.expectation_base()->immediate_prerequisites_
> += *last_expectation_;
> }
> @@ -856,7 +862,7 @@ void Sequence::AddExpectation(const Expectation&
> expectation) const {
>
> // Creates the implicit sequence if there isn't one.
> InSequence::InSequence() {
> - if (internal::g_gmock_implicit_sequence.get() == NULL) {
> + if (internal::g_gmock_implicit_sequence.get() == nullptr) {
> internal::g_gmock_implicit_sequence.set(new Sequence);
> sequence_created_ = true;
> } else {
> @@ -869,14 +875,14 @@ InSequence::InSequence() {
> InSequence::~InSequence() {
> if (sequence_created_) {
> delete internal::g_gmock_implicit_sequence.get();
> - internal::g_gmock_implicit_sequence.set(NULL);
> + internal::g_gmock_implicit_sequence.set(nullptr);
> }
> }
>
> } // namespace testing
>
> #ifdef _MSC_VER
> -#if _MSC_VER <= 1900
> +#if _MSC_VER == 1900
> # pragma warning(pop)
> #endif
> #endif
>
> diff --git a/llvm/utils/unittest/googlemock/src/gmock.cc
> b/llvm/utils/unittest/googlemock/src/gmock.cc
> index 36356c9334ee2..32b2a7394fd08 100644
> --- a/llvm/utils/unittest/googlemock/src/gmock.cc
> +++ b/llvm/utils/unittest/googlemock/src/gmock.cc
> @@ -33,12 +33,9 @@
>
> namespace testing {
>
> -// FIXME: support using environment variables to
> -// control the flag values, like what Google Test does.
> -
> GMOCK_DEFINE_bool_(catch_leaked_mocks, true,
> - "true iff Google Mock should report leaked mock
> objects "
> - "as failures.");
> + "true if and only if Google Mock should report leaked "
> + "mock objects as failures.");
>
> GMOCK_DEFINE_string_(verbose, internal::kWarningVerbosity,
> "Controls how verbose Google Mock's output is."
> @@ -65,12 +62,12 @@ static const char* ParseGoogleMockFlagValue(const
> char* str,
> const char* flag,
> bool def_optional) {
> // str and flag must not be NULL.
> - if (str == NULL || flag == NULL) return NULL;
> + if (str == nullptr || flag == nullptr) return nullptr;
>
> // The flag must start with "--gmock_".
> const std::string flag_str = std::string("--gmock_") + flag;
> const size_t flag_len = flag_str.length();
> - if (strncmp(str, flag_str.c_str(), flag_len) != 0) return NULL;
> + if (strncmp(str, flag_str.c_str(), flag_len) != 0) return nullptr;
>
> // Skips the flag name.
> const char* flag_end = str + flag_len;
> @@ -83,7 +80,7 @@ static const char* ParseGoogleMockFlagValue(const char*
> str,
> // If def_optional is true and there are more characters after the
> // flag name, or if def_optional is false, there must be a '=' after
> // the flag name.
> - if (flag_end[0] != '=') return NULL;
> + if (flag_end[0] != '=') return nullptr;
>
> // Returns the string after "=".
> return flag_end + 1;
> @@ -100,7 +97,7 @@ static bool ParseGoogleMockBoolFlag(const char* str,
> const char* flag,
> const char* const value_str = ParseGoogleMockFlagValue(str, flag, true);
>
> // Aborts if the parsing failed.
> - if (value_str == NULL) return false;
> + if (value_str == nullptr) return false;
>
> // Converts the string value to a bool.
> *value = !(*value_str == '0' || *value_str == 'f' || *value_str == 'F');
> @@ -119,7 +116,7 @@ static bool ParseGoogleMockStringFlag(const char* str,
> const char* flag,
> const char* const value_str = ParseGoogleMockFlagValue(str, flag,
> false);
>
> // Aborts if the parsing failed.
> - if (value_str == NULL) return false;
> + if (value_str == nullptr) return false;
>
> // Sets *value to the value of the flag.
> *value = value_str;
> @@ -132,7 +129,7 @@ static bool ParseGoogleMockIntFlag(const char* str,
> const char* flag,
> const char* const value_str = ParseGoogleMockFlagValue(str, flag, true);
>
> // Aborts if the parsing failed.
> - if (value_str == NULL) return false;
> + if (value_str == nullptr) return false;
>
> // Sets *value to the value of the flag.
> return ParseInt32(Message() << "The value of flag --" << flag,
> @@ -201,4 +198,16 @@ GTEST_API_ void InitGoogleMock(int* argc, wchar_t**
> argv) {
> internal::InitGoogleMockImpl(argc, argv);
> }
>
> +// This overloaded version can be used on Arduino/embedded platforms where
> +// there is no argc/argv.
> +GTEST_API_ void InitGoogleMock() {
> + // Since Arduino doesn't have a command line, fake out the argc/argv
> arguments
> + int argc = 1;
> + const auto arg0 = "dummy";
> + char* argv0 = const_cast<char*>(arg0);
> + char** argv = &argv0;
> +
> + internal::InitGoogleMockImpl(&argc, argv);
> +}
> +
> } // namespace testing
>
> diff --git
> a/llvm/utils/unittest/googletest/include/gtest/gtest-death-test.h
> b/llvm/utils/unittest/googletest/include/gtest/gtest-death-test.h
> index 20c54d869519f..dc878ffbb3ae5 100644
> --- a/llvm/utils/unittest/googletest/include/gtest/gtest-death-test.h
> +++ b/llvm/utils/unittest/googletest/include/gtest/gtest-death-test.h
> @@ -161,7 +161,6 @@ GTEST_API_ bool InDeathTestChild();
> // is rarely a problem as people usually don't put the test binary
> // directory in PATH.
> //
> -// FIXME: make thread-safe death tests search the PATH.
>
> // Asserts that a given statement causes the program to exit, with an
> // integer exit status that satisfies predicate, and emitting error output
> @@ -170,7 +169,7 @@ GTEST_API_ bool InDeathTestChild();
> GTEST_DEATH_TEST_(statement, predicate, regex, GTEST_FATAL_FAILURE_)
>
> // Like ASSERT_EXIT, but continues on to successive tests in the
> -// test case, if any:
> +// test suite, if any:
> # define EXPECT_EXIT(statement, predicate, regex) \
> GTEST_DEATH_TEST_(statement, predicate, regex,
> GTEST_NONFATAL_FAILURE_)
>
> @@ -181,7 +180,7 @@ GTEST_API_ bool InDeathTestChild();
> ASSERT_EXIT(statement, ::testing::internal::ExitedUnsuccessfully,
> regex)
>
> // Like ASSERT_DEATH, but continues on to successive tests in the
> -// test case, if any:
> +// test suite, if any:
> # define EXPECT_DEATH(statement, regex) \
> EXPECT_EXIT(statement, ::testing::internal::ExitedUnsuccessfully,
> regex)
>
> @@ -228,7 +227,7 @@ class GTEST_API_ KilledBySignal {
> // return 12;
> // }
> //
> -// TEST(TestCase, TestDieOr12WorksInDgbAndOpt) {
> +// TEST(TestSuite, TestDieOr12WorksInDgbAndOpt) {
> // int sideeffect = 0;
> // // Only asserts in dbg.
> // EXPECT_DEBUG_DEATH(DieInDebugOr12(&sideeffect), "death");
> @@ -277,20 +276,20 @@ class GTEST_API_ KilledBySignal {
> // This macro is used for implementing macros such as
> // EXPECT_DEATH_IF_SUPPORTED and ASSERT_DEATH_IF_SUPPORTED on systems
> where
> // death tests are not supported. Those macros must compile on such
> systems
> -// iff EXPECT_DEATH and ASSERT_DEATH compile with the same parameters on
> -// systems that support death tests. This allows one to write such a macro
> -// on a system that does not support death tests and be sure that it will
> -// compile on a death-test supporting system. It is exposed publicly so
> that
> -// systems that have death-tests with stricter requirements than
> -// GTEST_HAS_DEATH_TEST can write their own equivalent of
> -// EXPECT_DEATH_IF_SUPPORTED and ASSERT_DEATH_IF_SUPPORTED.
> +// if and only if EXPECT_DEATH and ASSERT_DEATH compile with the same
> parameters
> +// on systems that support death tests. This allows one to write such a
> macro on
> +// a system that does not support death tests and be sure that it will
> compile
> +// on a death-test supporting system. It is exposed publicly so that
> systems
> +// that have death-tests with stricter requirements than
> GTEST_HAS_DEATH_TEST
> +// can write their own equivalent of EXPECT_DEATH_IF_SUPPORTED and
> +// ASSERT_DEATH_IF_SUPPORTED.
> //
> // Parameters:
> // statement - A statement that a macro such as EXPECT_DEATH would test
> // for program termination. This macro has to make sure
> this
> // statement is compiled but not executed, to ensure that
> // EXPECT_DEATH_IF_SUPPORTED compiles with a certain
> -// parameter iff EXPECT_DEATH compiles with it.
> +// parameter if and only if EXPECT_DEATH compiles with it.
> // regex - A regex that a macro such as EXPECT_DEATH would use to
> test
> // the output of statement. This parameter has to be
> // compiled but not evaluated by this macro, to ensure that
>
> diff --git
> a/llvm/utils/unittest/googletest/include/gtest/gtest-matchers.h
> b/llvm/utils/unittest/googletest/include/gtest/gtest-matchers.h
> new file mode 100644
> index 0000000000000..9de6c2e10a20d
> --- /dev/null
> +++ b/llvm/utils/unittest/googletest/include/gtest/gtest-matchers.h
> @@ -0,0 +1,750 @@
> +// Copyright 2007, Google Inc.
> +// All rights reserved.
> +//
> +// Redistribution and use in source and binary forms, with or without
> +// modification, are permitted provided that the following conditions are
> +// met:
> +//
> +// * Redistributions of source code must retain the above copyright
> +// notice, this list of conditions and the following disclaimer.
> +// * Redistributions in binary form must reproduce the above
> +// copyright notice, this list of conditions and the following disclaimer
> +// in the documentation and/or other materials provided with the
> +// distribution.
> +// * Neither the name of Google Inc. nor the names of its
> +// contributors may be used to endorse or promote products derived from
> +// this software without specific prior written permission.
> +//
> +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
> +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
> +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
> +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
> +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
> +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
> +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
> +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
> +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
> +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
> +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
> +
> +// The Google C++ Testing and Mocking Framework (Google Test)
> +//
> +// This file implements just enough of the matcher interface to allow
> +// EXPECT_DEATH and friends to accept a matcher argument.
> +
> +// IWYU pragma: private, include "testing/base/public/gunit.h"
> +// IWYU pragma: friend third_party/googletest/googlemock/.*
> +// IWYU pragma: friend third_party/googletest/googletest/.*
> +
> +#ifndef GTEST_INCLUDE_GTEST_GTEST_MATCHERS_H_
> +#define GTEST_INCLUDE_GTEST_GTEST_MATCHERS_H_
> +
> +#include <memory>
> +#include <ostream>
> +#include <string>
> +#include <type_traits>
> +
> +#include "gtest/gtest-printers.h"
> +#include "gtest/internal/gtest-internal.h"
> +#include "gtest/internal/gtest-port.h"
> +
> +// MSVC warning C5046 is new as of VS2017 version 15.8.
> +#if defined(_MSC_VER) && _MSC_VER >= 1915
> +#define GTEST_MAYBE_5046_ 5046
> +#else
> +#define GTEST_MAYBE_5046_
> +#endif
> +
> +GTEST_DISABLE_MSC_WARNINGS_PUSH_(
> + 4251 GTEST_MAYBE_5046_ /* class A needs to have dll-interface to be
> used by
> + clients of class B */
> + /* Symbol involving type with internal linkage not defined */)
> +
> +namespace testing {
> +
> +// To implement a matcher Foo for type T, define:
> +// 1. a class FooMatcherImpl that implements the
> +// MatcherInterface<T> interface, and
> +// 2. a factory function that creates a Matcher<T> object from a
> +// FooMatcherImpl*.
> +//
> +// The two-level delegation design makes it possible to allow a user
> +// to write "v" instead of "Eq(v)" where a Matcher is expected, which
> +// is impossible if we pass matchers by pointers. It also eases
> +// ownership management as Matcher objects can now be copied like
> +// plain values.
> +
> +// MatchResultListener is an abstract class. Its << operator can be
> +// used by a matcher to explain why a value matches or doesn't match.
> +//
> +class MatchResultListener {
> + public:
> + // Creates a listener object with the given underlying ostream. The
> + // listener does not own the ostream, and does not dereference it
> + // in the constructor or destructor.
> + explicit MatchResultListener(::std::ostream* os) : stream_(os) {}
> + virtual ~MatchResultListener() = 0; // Makes this class abstract.
> +
> + // Streams x to the underlying ostream; does nothing if the ostream
> + // is NULL.
> + template <typename T>
> + MatchResultListener& operator<<(const T& x) {
> + if (stream_ != nullptr) *stream_ << x;
> + return *this;
> + }
> +
> + // Returns the underlying ostream.
> + ::std::ostream* stream() { return stream_; }
> +
> + // Returns true if and only if the listener is interested in an
> explanation
> + // of the match result. A matcher's MatchAndExplain() method can use
> + // this information to avoid generating the explanation when no one
> + // intends to hear it.
> + bool IsInterested() const { return stream_ != nullptr; }
> +
> + private:
> + ::std::ostream* const stream_;
> +
> + GTEST_DISALLOW_COPY_AND_ASSIGN_(MatchResultListener);
> +};
> +
> +inline MatchResultListener::~MatchResultListener() {
> +}
> +
> +// An instance of a subclass of this knows how to describe itself as a
> +// matcher.
> +class MatcherDescriberInterface {
> + public:
> + virtual ~MatcherDescriberInterface() {}
> +
> + // Describes this matcher to an ostream. The function should print
> + // a verb phrase that describes the property a value matching this
> + // matcher should have. The subject of the verb phrase is the value
> + // being matched. For example, the DescribeTo() method of the Gt(7)
> + // matcher prints "is greater than 7".
> + virtual void DescribeTo(::std::ostream* os) const = 0;
> +
> + // Describes the negation of this matcher to an ostream. For
> + // example, if the description of this matcher is "is greater than
> + // 7", the negated description could be "is not greater than 7".
> + // You are not required to override this when implementing
> + // MatcherInterface, but it is highly advised so that your matcher
> + // can produce good error messages.
> + virtual void DescribeNegationTo(::std::ostream* os) const {
> + *os << "not (";
> + DescribeTo(os);
> + *os << ")";
> + }
> +};
> +
> +// The implementation of a matcher.
> +template <typename T>
> +class MatcherInterface : public MatcherDescriberInterface {
> + public:
> + // Returns true if and only if the matcher matches x; also explains the
> + // match result to 'listener' if necessary (see the next paragraph), in
> + // the form of a non-restrictive relative clause ("which ...",
> + // "whose ...", etc) that describes x. For example, the
> + // MatchAndExplain() method of the Pointee(...) matcher should
> + // generate an explanation like "which points to ...".
> + //
> + // Implementations of MatchAndExplain() should add an explanation of
> + // the match result *if and only if* they can provide additional
> + // information that's not already present (or not obvious) in the
> + // print-out of x and the matcher's description. Whether the match
> + // succeeds is not a factor in deciding whether an explanation is
> + // needed, as sometimes the caller needs to print a failure message
> + // when the match succeeds (e.g. when the matcher is used inside
> + // Not()).
> + //
> + // For example, a "has at least 10 elements" matcher should explain
> + // what the actual element count is, regardless of the match result,
> + // as it is useful information to the reader; on the other hand, an
> + // "is empty" matcher probably only needs to explain what the actual
> + // size is when the match fails, as it's redundant to say that the
> + // size is 0 when the value is already known to be empty.
> + //
> + // You should override this method when defining a new matcher.
> + //
> + // It's the responsibility of the caller (Google Test) to guarantee
> + // that 'listener' is not NULL. This helps to simplify a matcher's
> + // implementation when it doesn't care about the performance, as it
> + // can talk to 'listener' without checking its validity first.
> + // However, in order to implement dummy listeners efficiently,
> + // listener->stream() may be NULL.
> + virtual bool MatchAndExplain(T x, MatchResultListener* listener) const
> = 0;
> +
> + // Inherits these methods from MatcherDescriberInterface:
> + // virtual void DescribeTo(::std::ostream* os) const = 0;
> + // virtual void DescribeNegationTo(::std::ostream* os) const;
> +};
> +
> +namespace internal {
> +
> +// Converts a MatcherInterface<T> to a MatcherInterface<const T&>.
> +template <typename T>
> +class MatcherInterfaceAdapter : public MatcherInterface<const T&> {
> + public:
> + explicit MatcherInterfaceAdapter(const MatcherInterface<T>* impl)
> + : impl_(impl) {}
> + ~MatcherInterfaceAdapter() override { delete impl_; }
> +
> + void DescribeTo(::std::ostream* os) const override {
> impl_->DescribeTo(os); }
> +
> + void DescribeNegationTo(::std::ostream* os) const override {
> + impl_->DescribeNegationTo(os);
> + }
> +
> + bool MatchAndExplain(const T& x,
> + MatchResultListener* listener) const override {
> + return impl_->MatchAndExplain(x, listener);
> + }
> +
> + private:
> + const MatcherInterface<T>* const impl_;
> +
> + GTEST_DISALLOW_COPY_AND_ASSIGN_(MatcherInterfaceAdapter);
> +};
> +
> +struct AnyEq {
> + template <typename A, typename B>
> + bool operator()(const A& a, const B& b) const { return a == b; }
> +};
> +struct AnyNe {
> + template <typename A, typename B>
> + bool operator()(const A& a, const B& b) const { return a != b; }
> +};
> +struct AnyLt {
> + template <typename A, typename B>
> + bool operator()(const A& a, const B& b) const { return a < b; }
> +};
> +struct AnyGt {
> + template <typename A, typename B>
> + bool operator()(const A& a, const B& b) const { return a > b; }
> +};
> +struct AnyLe {
> + template <typename A, typename B>
> + bool operator()(const A& a, const B& b) const { return a <= b; }
> +};
> +struct AnyGe {
> + template <typename A, typename B>
> + bool operator()(const A& a, const B& b) const { return a >= b; }
> +};
> +
> +// A match result listener that ignores the explanation.
> +class DummyMatchResultListener : public MatchResultListener {
> + public:
> + DummyMatchResultListener() : MatchResultListener(nullptr) {}
> +
> + private:
> + GTEST_DISALLOW_COPY_AND_ASSIGN_(DummyMatchResultListener);
> +};
> +
> +// A match result listener that forwards the explanation to a given
> +// ostream. The
> diff erence between this and MatchResultListener is
> +// that the former is concrete.
> +class StreamMatchResultListener : public MatchResultListener {
> + public:
> + explicit StreamMatchResultListener(::std::ostream* os)
> + : MatchResultListener(os) {}
> +
> + private:
> + GTEST_DISALLOW_COPY_AND_ASSIGN_(StreamMatchResultListener);
> +};
> +
> +// An internal class for implementing Matcher<T>, which will derive
> +// from it. We put functionalities common to all Matcher<T>
> +// specializations here to avoid code duplication.
> +template <typename T>
> +class MatcherBase {
> + public:
> + // Returns true if and only if the matcher matches x; also explains the
> + // match result to 'listener'.
> + bool MatchAndExplain(const T& x, MatchResultListener* listener) const {
> + return impl_->MatchAndExplain(x, listener);
> + }
> +
> + // Returns true if and only if this matcher matches x.
> + bool Matches(const T& x) const {
> + DummyMatchResultListener dummy;
> + return MatchAndExplain(x, &dummy);
> + }
> +
> + // Describes this matcher to an ostream.
> + void DescribeTo(::std::ostream* os) const { impl_->DescribeTo(os); }
> +
> + // Describes the negation of this matcher to an ostream.
> + void DescribeNegationTo(::std::ostream* os) const {
> + impl_->DescribeNegationTo(os);
> + }
> +
> + // Explains why x matches, or doesn't match, the matcher.
> + void ExplainMatchResultTo(const T& x, ::std::ostream* os) const {
> + StreamMatchResultListener listener(os);
> + MatchAndExplain(x, &listener);
> + }
> +
> + // Returns the describer for this matcher object; retains ownership
> + // of the describer, which is only guaranteed to be alive when
> + // this matcher object is alive.
> + const MatcherDescriberInterface* GetDescriber() const {
> + return impl_.get();
> + }
> +
> + protected:
> + MatcherBase() {}
> +
> + // Constructs a matcher from its implementation.
> + explicit MatcherBase(const MatcherInterface<const T&>* impl) :
> impl_(impl) {}
> +
> + template <typename U>
> + explicit MatcherBase(
> + const MatcherInterface<U>* impl,
> + typename std::enable_if<!std::is_same<U, const U&>::value>::type* =
> + nullptr)
> + : impl_(new internal::MatcherInterfaceAdapter<U>(impl)) {}
> +
> + MatcherBase(const MatcherBase&) = default;
> + MatcherBase& operator=(const MatcherBase&) = default;
> + MatcherBase(MatcherBase&&) = default;
> + MatcherBase& operator=(MatcherBase&&) = default;
> +
> + virtual ~MatcherBase() {}
> +
> + private:
> + std::shared_ptr<const MatcherInterface<const T&>> impl_;
> +};
> +
> +} // namespace internal
> +
> +// A Matcher<T> is a copyable and IMMUTABLE (except by assignment)
> +// object that can check whether a value of type T matches. The
> +// implementation of Matcher<T> is just a std::shared_ptr to const
> +// MatcherInterface<T>. Don't inherit from Matcher!
> +template <typename T>
> +class Matcher : public internal::MatcherBase<T> {
> + public:
> + // Constructs a null matcher. Needed for storing Matcher objects in STL
> + // containers. A default-constructed matcher is not yet initialized.
> You
> + // cannot use it until a valid value has been assigned to it.
> + explicit Matcher() {} // NOLINT
> +
> + // Constructs a matcher from its implementation.
> + explicit Matcher(const MatcherInterface<const T&>* impl)
> + : internal::MatcherBase<T>(impl) {}
> +
> + template <typename U>
> + explicit Matcher(
> + const MatcherInterface<U>* impl,
> + typename std::enable_if<!std::is_same<U, const U&>::value>::type* =
> + nullptr)
> + : internal::MatcherBase<T>(impl) {}
> +
> + // Implicit constructor here allows people to write
> + // EXPECT_CALL(foo, Bar(5)) instead of EXPECT_CALL(foo, Bar(Eq(5)))
> sometimes
> + Matcher(T value); // NOLINT
> +};
> +
> +// The following two specializations allow the user to write str
> +// instead of Eq(str) and "foo" instead of Eq("foo") when a std::string
> +// matcher is expected.
> +template <>
> +class GTEST_API_ Matcher<const std::string&>
> + : public internal::MatcherBase<const std::string&> {
> + public:
> + Matcher() {}
> +
> + explicit Matcher(const MatcherInterface<const std::string&>* impl)
> + : internal::MatcherBase<const std::string&>(impl) {}
> +
> + // Allows the user to write str instead of Eq(str) sometimes, where
> + // str is a std::string object.
> + Matcher(const std::string& s); // NOLINT
> +
> + // Allows the user to write "foo" instead of Eq("foo") sometimes.
> + Matcher(const char* s); // NOLINT
> +};
> +
> +template <>
> +class GTEST_API_ Matcher<std::string>
> + : public internal::MatcherBase<std::string> {
> + public:
> + Matcher() {}
> +
> + explicit Matcher(const MatcherInterface<const std::string&>* impl)
> + : internal::MatcherBase<std::string>(impl) {}
> + explicit Matcher(const MatcherInterface<std::string>* impl)
> + : internal::MatcherBase<std::string>(impl) {}
> +
> + // Allows the user to write str instead of Eq(str) sometimes, where
> + // str is a string object.
> + Matcher(const std::string& s); // NOLINT
> +
> + // Allows the user to write "foo" instead of Eq("foo") sometimes.
> + Matcher(const char* s); // NOLINT
> +};
> +
> +#if GTEST_HAS_ABSL
> +// The following two specializations allow the user to write str
> +// instead of Eq(str) and "foo" instead of Eq("foo") when a
> absl::string_view
> +// matcher is expected.
> +template <>
> +class GTEST_API_ Matcher<const absl::string_view&>
> + : public internal::MatcherBase<const absl::string_view&> {
> + public:
> + Matcher() {}
> +
> + explicit Matcher(const MatcherInterface<const absl::string_view&>* impl)
> + : internal::MatcherBase<const absl::string_view&>(impl) {}
> +
> + // Allows the user to write str instead of Eq(str) sometimes, where
> + // str is a std::string object.
> + Matcher(const std::string& s); // NOLINT
> +
> + // Allows the user to write "foo" instead of Eq("foo") sometimes.
> + Matcher(const char* s); // NOLINT
> +
> + // Allows the user to pass absl::string_views directly.
> + Matcher(absl::string_view s); // NOLINT
> +};
> +
> +template <>
> +class GTEST_API_ Matcher<absl::string_view>
> + : public internal::MatcherBase<absl::string_view> {
> + public:
> + Matcher() {}
> +
> + explicit Matcher(const MatcherInterface<const absl::string_view&>* impl)
> + : internal::MatcherBase<absl::string_view>(impl) {}
> + explicit Matcher(const MatcherInterface<absl::string_view>* impl)
> + : internal::MatcherBase<absl::string_view>(impl) {}
> +
> + // Allows the user to write str instead of Eq(str) sometimes, where
> + // str is a std::string object.
> + Matcher(const std::string& s); // NOLINT
> +
> + // Allows the user to write "foo" instead of Eq("foo") sometimes.
> + Matcher(const char* s); // NOLINT
> +
> + // Allows the user to pass absl::string_views directly.
> + Matcher(absl::string_view s); // NOLINT
> +};
> +#endif // GTEST_HAS_ABSL
> +
> +// Prints a matcher in a human-readable format.
> +template <typename T>
> +std::ostream& operator<<(std::ostream& os, const Matcher<T>& matcher) {
> + matcher.DescribeTo(&os);
> + return os;
> +}
> +
> +// The PolymorphicMatcher class template makes it easy to implement a
> +// polymorphic matcher (i.e. a matcher that can match values of more
> +// than one type, e.g. Eq(n) and NotNull()).
> +//
> +// To define a polymorphic matcher, a user should provide an Impl
> +// class that has a DescribeTo() method and a DescribeNegationTo()
> +// method, and define a member function (or member function template)
> +//
> +// bool MatchAndExplain(const Value& value,
> +// MatchResultListener* listener) const;
> +//
> +// See the definition of NotNull() for a complete example.
> +template <class Impl>
> +class PolymorphicMatcher {
> + public:
> + explicit PolymorphicMatcher(const Impl& an_impl) : impl_(an_impl) {}
> +
> + // Returns a mutable reference to the underlying matcher
> + // implementation object.
> + Impl& mutable_impl() { return impl_; }
> +
> + // Returns an immutable reference to the underlying matcher
> + // implementation object.
> + const Impl& impl() const { return impl_; }
> +
> + template <typename T>
> + operator Matcher<T>() const {
> + return Matcher<T>(new MonomorphicImpl<const T&>(impl_));
> + }
> +
> + private:
> + template <typename T>
> + class MonomorphicImpl : public MatcherInterface<T> {
> + public:
> + explicit MonomorphicImpl(const Impl& impl) : impl_(impl) {}
> +
> + virtual void DescribeTo(::std::ostream* os) const {
> impl_.DescribeTo(os); }
> +
> + virtual void DescribeNegationTo(::std::ostream* os) const {
> + impl_.DescribeNegationTo(os);
> + }
> +
> + virtual bool MatchAndExplain(T x, MatchResultListener* listener)
> const {
> + return impl_.MatchAndExplain(x, listener);
> + }
> +
> + private:
> + const Impl impl_;
> + };
> +
> + Impl impl_;
> +};
> +
> +// Creates a matcher from its implementation.
> +// DEPRECATED: Especially in the generic code, prefer:
> +// Matcher<T>(new MyMatcherImpl<const T&>(...));
> +//
> +// MakeMatcher may create a Matcher that accepts its argument by value,
> which
> +// leads to unnecessary copies & lack of support for non-copyable types.
> +template <typename T>
> +inline Matcher<T> MakeMatcher(const MatcherInterface<T>* impl) {
> + return Matcher<T>(impl);
> +}
> +
> +// Creates a polymorphic matcher from its implementation. This is
> +// easier to use than the PolymorphicMatcher<Impl> constructor as it
> +// doesn't require you to explicitly write the template argument, e.g.
> +//
> +// MakePolymorphicMatcher(foo);
> +// vs
> +// PolymorphicMatcher<TypeOfFoo>(foo);
> +template <class Impl>
> +inline PolymorphicMatcher<Impl> MakePolymorphicMatcher(const Impl& impl) {
> + return PolymorphicMatcher<Impl>(impl);
> +}
> +
> +namespace internal {
> +// Implements a matcher that compares a given value with a
> +// pre-supplied value using one of the ==, <=, <, etc, operators. The
> +// two values being compared don't have to have the same type.
> +//
> +// The matcher defined here is polymorphic (for example, Eq(5) can be
> +// used to match an int, a short, a double, etc). Therefore we use
> +// a template type conversion operator in the implementation.
> +//
> +// The following template definition assumes that the Rhs parameter is
> +// a "bare" type (i.e. neither 'const T' nor 'T&').
> +template <typename D, typename Rhs, typename Op>
> +class ComparisonBase {
> + public:
> + explicit ComparisonBase(const Rhs& rhs) : rhs_(rhs) {}
> + template <typename Lhs>
> + operator Matcher<Lhs>() const {
> + return Matcher<Lhs>(new Impl<const Lhs&>(rhs_));
> + }
> +
> + private:
> + template <typename T>
> + static const T& Unwrap(const T& v) { return v; }
> + template <typename T>
> + static const T& Unwrap(std::reference_wrapper<T> v) { return v; }
> +
> + template <typename Lhs, typename = Rhs>
> + class Impl : public MatcherInterface<Lhs> {
> + public:
> + explicit Impl(const Rhs& rhs) : rhs_(rhs) {}
> + bool MatchAndExplain(Lhs lhs,
> + MatchResultListener* /* listener */) const
> override {
> + return Op()(lhs, Unwrap(rhs_));
> + }
> + void DescribeTo(::std::ostream* os) const override {
> + *os << D::Desc() << " ";
> + UniversalPrint(Unwrap(rhs_), os);
> + }
> + void DescribeNegationTo(::std::ostream* os) const override {
> + *os << D::NegatedDesc() << " ";
> + UniversalPrint(Unwrap(rhs_), os);
> + }
> +
> + private:
> + Rhs rhs_;
> + };
> + Rhs rhs_;
> +};
> +
> +template <typename Rhs>
> +class EqMatcher : public ComparisonBase<EqMatcher<Rhs>, Rhs, AnyEq> {
> + public:
> + explicit EqMatcher(const Rhs& rhs)
> + : ComparisonBase<EqMatcher<Rhs>, Rhs, AnyEq>(rhs) { }
> + static const char* Desc() { return "is equal to"; }
> + static const char* NegatedDesc() { return "isn't equal to"; }
> +};
> +template <typename Rhs>
> +class NeMatcher : public ComparisonBase<NeMatcher<Rhs>, Rhs, AnyNe> {
> + public:
> + explicit NeMatcher(const Rhs& rhs)
> + : ComparisonBase<NeMatcher<Rhs>, Rhs, AnyNe>(rhs) { }
> + static const char* Desc() { return "isn't equal to"; }
> + static const char* NegatedDesc() { return "is equal to"; }
> +};
> +template <typename Rhs>
> +class LtMatcher : public ComparisonBase<LtMatcher<Rhs>, Rhs, AnyLt> {
> + public:
> + explicit LtMatcher(const Rhs& rhs)
> + : ComparisonBase<LtMatcher<Rhs>, Rhs, AnyLt>(rhs) { }
> + static const char* Desc() { return "is <"; }
> + static const char* NegatedDesc() { return "isn't <"; }
> +};
> +template <typename Rhs>
> +class GtMatcher : public ComparisonBase<GtMatcher<Rhs>, Rhs, AnyGt> {
> + public:
> + explicit GtMatcher(const Rhs& rhs)
> + : ComparisonBase<GtMatcher<Rhs>, Rhs, AnyGt>(rhs) { }
> + static const char* Desc() { return "is >"; }
> + static const char* NegatedDesc() { return "isn't >"; }
> +};
> +template <typename Rhs>
> +class LeMatcher : public ComparisonBase<LeMatcher<Rhs>, Rhs, AnyLe> {
> + public:
> + explicit LeMatcher(const Rhs& rhs)
> + : ComparisonBase<LeMatcher<Rhs>, Rhs, AnyLe>(rhs) { }
> + static const char* Desc() { return "is <="; }
> + static const char* NegatedDesc() { return "isn't <="; }
> +};
> +template <typename Rhs>
> +class GeMatcher : public ComparisonBase<GeMatcher<Rhs>, Rhs, AnyGe> {
> + public:
> + explicit GeMatcher(const Rhs& rhs)
> + : ComparisonBase<GeMatcher<Rhs>, Rhs, AnyGe>(rhs) { }
> + static const char* Desc() { return "is >="; }
> + static const char* NegatedDesc() { return "isn't >="; }
> +};
> +
> +// Implements polymorphic matchers MatchesRegex(regex) and
> +// ContainsRegex(regex), which can be used as a Matcher<T> as long as
> +// T can be converted to a string.
> +class MatchesRegexMatcher {
> + public:
> + MatchesRegexMatcher(const RE* regex, bool full_match)
> + : regex_(regex), full_match_(full_match) {}
> +
> +#if GTEST_HAS_ABSL
> + bool MatchAndExplain(const absl::string_view& s,
> + MatchResultListener* listener) const {
> + return MatchAndExplain(std::string(s), listener);
> + }
> +#endif // GTEST_HAS_ABSL
> +
> + // Accepts pointer types, particularly:
> + // const char*
> + // char*
> + // const wchar_t*
> + // wchar_t*
> + template <typename CharType>
> + bool MatchAndExplain(CharType* s, MatchResultListener* listener) const {
> + return s != nullptr && MatchAndExplain(std::string(s), listener);
> + }
> +
> + // Matches anything that can convert to std::string.
> + //
> + // This is a template, not just a plain function with const
> std::string&,
> + // because absl::string_view has some interfering non-explicit
> constructors.
> + template <class MatcheeStringType>
> + bool MatchAndExplain(const MatcheeStringType& s,
> + MatchResultListener* /* listener */) const {
> + const std::string& s2(s);
> + return full_match_ ? RE::FullMatch(s2, *regex_)
> + : RE::PartialMatch(s2, *regex_);
> + }
> +
> + void DescribeTo(::std::ostream* os) const {
> + *os << (full_match_ ? "matches" : "contains") << " regular expression
> ";
> + UniversalPrinter<std::string>::Print(regex_->pattern(), os);
> + }
> +
> + void DescribeNegationTo(::std::ostream* os) const {
> + *os << "doesn't " << (full_match_ ? "match" : "contain")
> + << " regular expression ";
> + UniversalPrinter<std::string>::Print(regex_->pattern(), os);
> + }
> +
> + private:
> + const std::shared_ptr<const RE> regex_;
> + const bool full_match_;
> +};
> +} // namespace internal
> +
> +// Matches a string that fully matches regular expression 'regex'.
> +// The matcher takes ownership of 'regex'.
> +inline PolymorphicMatcher<internal::MatchesRegexMatcher> MatchesRegex(
> + const internal::RE* regex) {
> + return MakePolymorphicMatcher(internal::MatchesRegexMatcher(regex,
> true));
> +}
> +inline PolymorphicMatcher<internal::MatchesRegexMatcher> MatchesRegex(
> + const std::string& regex) {
> + return MatchesRegex(new internal::RE(regex));
> +}
> +
> +// Matches a string that contains regular expression 'regex'.
> +// The matcher takes ownership of 'regex'.
> +inline PolymorphicMatcher<internal::MatchesRegexMatcher> ContainsRegex(
> + const internal::RE* regex) {
> + return MakePolymorphicMatcher(internal::MatchesRegexMatcher(regex,
> false));
> +}
> +inline PolymorphicMatcher<internal::MatchesRegexMatcher> ContainsRegex(
> + const std::string& regex) {
> + return ContainsRegex(new internal::RE(regex));
> +}
> +
> +// Creates a polymorphic matcher that matches anything equal to x.
> +// Note: if the parameter of Eq() were declared as const T&, Eq("foo")
> +// wouldn't compile.
> +template <typename T>
> +inline internal::EqMatcher<T> Eq(T x) { return internal::EqMatcher<T>(x);
> }
> +
> +// Constructs a Matcher<T> from a 'value' of type T. The constructed
> +// matcher matches any value that's equal to 'value'.
> +template <typename T>
> +Matcher<T>::Matcher(T value) { *this = Eq(value); }
> +
> +// Creates a monomorphic matcher that matches anything with type Lhs
> +// and equal to rhs. A user may need to use this instead of Eq(...)
> +// in order to resolve an overloading ambiguity.
> +//
> +// TypedEq<T>(x) is just a convenient short-hand for Matcher<T>(Eq(x))
> +// or Matcher<T>(x), but more readable than the latter.
> +//
> +// We could define similar monomorphic matchers for other comparison
> +// operations (e.g. TypedLt, TypedGe, and etc), but decided not to do
> +// it yet as those are used much less than Eq() in practice. A user
> +// can always write Matcher<T>(Lt(5)) to be explicit about the type,
> +// for example.
> +template <typename Lhs, typename Rhs>
> +inline Matcher<Lhs> TypedEq(const Rhs& rhs) { return Eq(rhs); }
> +
> +// Creates a polymorphic matcher that matches anything >= x.
> +template <typename Rhs>
> +inline internal::GeMatcher<Rhs> Ge(Rhs x) {
> + return internal::GeMatcher<Rhs>(x);
> +}
> +
> +// Creates a polymorphic matcher that matches anything > x.
> +template <typename Rhs>
> +inline internal::GtMatcher<Rhs> Gt(Rhs x) {
> + return internal::GtMatcher<Rhs>(x);
> +}
> +
> +// Creates a polymorphic matcher that matches anything <= x.
> +template <typename Rhs>
> +inline internal::LeMatcher<Rhs> Le(Rhs x) {
> + return internal::LeMatcher<Rhs>(x);
> +}
> +
> +// Creates a polymorphic matcher that matches anything < x.
> +template <typename Rhs>
> +inline internal::LtMatcher<Rhs> Lt(Rhs x) {
> + return internal::LtMatcher<Rhs>(x);
> +}
> +
> +// Creates a polymorphic matcher that matches anything != x.
> +template <typename Rhs>
> +inline internal::NeMatcher<Rhs> Ne(Rhs x) {
> + return internal::NeMatcher<Rhs>(x);
> +}
> +} // namespace testing
> +
> +GTEST_DISABLE_MSC_WARNINGS_POP_() // 4251 5046
> +
> +#endif // GTEST_INCLUDE_GTEST_GTEST_MATCHERS_H_
>
> diff --git a/llvm/utils/unittest/googletest/include/gtest/gtest-message.h
> b/llvm/utils/unittest/googletest/include/gtest/gtest-message.h
> index 892e086466ad5..cbabe5defd77d 100644
> --- a/llvm/utils/unittest/googletest/include/gtest/gtest-message.h
> +++ b/llvm/utils/unittest/googletest/include/gtest/gtest-message.h
> @@ -48,6 +48,7 @@
> #define GTEST_INCLUDE_GTEST_GTEST_MESSAGE_H_
>
> #include <limits>
> +#include <memory>
>
> #include "gtest/internal/gtest-port.h"
> #include "gtest/internal/custom/raw-ostream.h"
> @@ -107,14 +108,6 @@ class GTEST_API_ Message {
> *ss_ << str;
> }
>
> -#if GTEST_OS_SYMBIAN
> - // Streams a value (either a pointer or not) to this object.
> - template <typename T>
> - inline Message& operator <<(const T& value) {
> - StreamHelper(typename internal::is_pointer<T>::type(), value);
> - return *this;
> - }
> -#else
> // Streams a non-pointer value to this object.
> template <typename T>
> inline Message& operator <<(const T& val) {
> @@ -152,14 +145,13 @@ class GTEST_API_ Message {
> // as "(null)".
> template <typename T>
> inline Message& operator <<(T* const& pointer) { // NOLINT
> - if (pointer == NULL) {
> + if (pointer == nullptr) {
> *ss_ << "(null)";
> } else {
> *ss_ << llvm_gtest::printable(pointer);
> }
> return *this;
> }
> -#endif // GTEST_OS_SYMBIAN
>
> // Since the basic IO manipulators are overloaded for both narrow
> // and wide streams, we have to provide this specialized definition
> @@ -188,12 +180,6 @@ class GTEST_API_ Message {
> Message& operator <<(const ::std::wstring& wstr);
> #endif // GTEST_HAS_STD_WSTRING
>
> -#if GTEST_HAS_GLOBAL_WSTRING
> - // Converts the given wide string to a narrow string using the UTF-8
> - // encoding, and streams the result to this Message object.
> - Message& operator <<(const ::wstring& wstr);
> -#endif // GTEST_HAS_GLOBAL_WSTRING
> -
> // Gets the text streamed to this object so far as an std::string.
> // Each '\0' character in the buffer is replaced with "\\0".
> //
> @@ -201,31 +187,8 @@ class GTEST_API_ Message {
> std::string GetString() const;
>
> private:
> -#if GTEST_OS_SYMBIAN
> - // These are needed as the Nokia Symbian Compiler cannot decide between
> - // const T& and const T* in a function template. The Nokia compiler
> _can_
> - // decide between class template specializations for T and T*, so a
> - // tr1::type_traits-like is_pointer works, and we can overload on that.
> - template <typename T>
> - inline void StreamHelper(internal::true_type /*is_pointer*/, T*
> pointer) {
> - if (pointer == NULL) {
> - *ss_ << "(null)";
> - } else {
> - *ss_ << pointer;
> - }
> - }
> - template <typename T>
> - inline void StreamHelper(internal::false_type /*is_pointer*/,
> - const T& value) {
> - // See the comments in Message& operator <<(const T&) above for why
> - // we need this using statement.
> - using ::operator <<;
> - *ss_ << value;
> - }
> -#endif // GTEST_OS_SYMBIAN
> -
> // We'll hold the text streamed to this object here.
> - const internal::scoped_ptr< ::std::stringstream> ss_;
> + const std::unique_ptr< ::std::stringstream> ss_;
>
> // We declare (but don't implement) this to prevent the compiler
> // from implementing the assignment operator.
>
> diff --git
> a/llvm/utils/unittest/googletest/include/gtest/gtest-param-test.h
> b/llvm/utils/unittest/googletest/include/gtest/gtest-param-test.h
> index 3e95e4390e00e..c2e6eae3d8326 100644
> --- a/llvm/utils/unittest/googletest/include/gtest/gtest-param-test.h
> +++ b/llvm/utils/unittest/googletest/include/gtest/gtest-param-test.h
> @@ -1,7 +1,3 @@
> -// This file was GENERATED by command:
> -// pump.py gtest-param-test.h.pump
> -// DO NOT EDIT BY HAND!!!
> -
> // Copyright 2008, Google Inc.
> // All rights reserved.
> //
> @@ -75,7 +71,7 @@ TEST_P(FooTest, HasBlahBlah) {
> ...
> }
>
> -// Finally, you can use INSTANTIATE_TEST_CASE_P to instantiate the test
> +// Finally, you can use INSTANTIATE_TEST_SUITE_P to instantiate the test
> // case with any set of parameters you want. Google Test defines a number
> // of functions for generating test parameters. They return what we call
> // (surprise!) parameter generators. Here is a summary of them, which
> @@ -96,17 +92,17 @@ TEST_P(FooTest, HasBlahBlah) {
> // For more details, see comments at the definitions of these functions
> below
> // in this file.
> //
> -// The following statement will instantiate tests from the FooTest test
> case
> +// The following statement will instantiate tests from the FooTest test
> suite
> // each with parameter values "meeny", "miny", and "moe".
>
> -INSTANTIATE_TEST_CASE_P(InstantiationName,
> - FooTest,
> - Values("meeny", "miny", "moe"));
> +INSTANTIATE_TEST_SUITE_P(InstantiationName,
> + FooTest,
> + Values("meeny", "miny", "moe"));
>
> // To distinguish
> diff erent instances of the pattern, (yes, you
> -// can instantiate it more then once) the first argument to the
> -// INSTANTIATE_TEST_CASE_P macro is a prefix that will be added to the
> -// actual test case name. Remember to pick unique prefixes for
> diff erent
> +// can instantiate it more than once) the first argument to the
> +// INSTANTIATE_TEST_SUITE_P macro is a prefix that will be added to the
> +// actual test suite name. Remember to pick unique prefixes for
> diff erent
> // instantiations. The tests from the instantiation above will have
> // these names:
> //
> @@ -123,7 +119,7 @@ INSTANTIATE_TEST_CASE_P(InstantiationName,
> // with parameter values "cat" and "dog":
>
> const char* pets[] = {"cat", "dog"};
> -INSTANTIATE_TEST_CASE_P(AnotherInstantiationName, FooTest,
> ValuesIn(pets));
> +INSTANTIATE_TEST_SUITE_P(AnotherInstantiationName, FooTest,
> ValuesIn(pets));
>
> // The tests from the instantiation above will have these names:
> //
> @@ -132,9 +128,9 @@ INSTANTIATE_TEST_CASE_P(AnotherInstantiationName,
> FooTest, ValuesIn(pets));
> // * AnotherInstantiationName/FooTest.HasBlahBlah/0 for "cat"
> // * AnotherInstantiationName/FooTest.HasBlahBlah/1 for "dog"
> //
> -// Please note that INSTANTIATE_TEST_CASE_P will instantiate all tests
> -// in the given test case, whether their definitions come before or
> -// AFTER the INSTANTIATE_TEST_CASE_P statement.
> +// Please note that INSTANTIATE_TEST_SUITE_P will instantiate all tests
> +// in the given test suite, whether their definitions come before or
> +// AFTER the INSTANTIATE_TEST_SUITE_P statement.
> //
> // Please also note that generator expressions (including parameters to
> the
> // generators) are evaluated in InitGoogleTest(), after main() has
> started.
> @@ -178,26 +174,23 @@ TEST_P(DerivedTest, DoesBlah) {
>
> #endif // 0
>
> -#include "gtest/internal/gtest-port.h"
> -
> -#if !GTEST_OS_SYMBIAN
> -# include <utility>
> -#endif
> +#include <iterator>
> +#include <utility>
>
> #include "gtest/internal/gtest-internal.h"
> #include "gtest/internal/gtest-param-util.h"
> -#include "gtest/internal/gtest-param-util-generated.h"
> +#include "gtest/internal/gtest-port.h"
>
> namespace testing {
>
> // Functions producing parameter generators.
> //
> // Google Test uses these generators to produce parameters for value-
> -// parameterized tests. When a parameterized test case is instantiated
> +// parameterized tests. When a parameterized test suite is instantiated
> // with a particular generator, Google Test creates and runs tests
> // for each element in the sequence produced by the generator.
> //
> -// In the following sample, tests from test case FooTest are instantiated
> +// In the following sample, tests from test suite FooTest are instantiated
> // each three times with parameter values 3, 5, and 8:
> //
> // class FooTest : public TestWithParam<int> { ... };
> @@ -206,7 +199,7 @@ namespace testing {
> // }
> // TEST_P(FooTest, TestThat) {
> // }
> -// INSTANTIATE_TEST_CASE_P(TestSequence, FooTest, Values(3, 5, 8));
> +// INSTANTIATE_TEST_SUITE_P(TestSequence, FooTest, Values(3, 5, 8));
> //
>
> // Range() returns generators providing sequences of values in a range.
> @@ -263,13 +256,13 @@ internal::ParamGenerator<T> Range(T start, T end) {
> //
> // Examples:
> //
> -// This instantiates tests from test case StringTest
> +// This instantiates tests from test suite StringTest
> // each with C-string values of "foo", "bar", and "baz":
> //
> // const char* strings[] = {"foo", "bar", "baz"};
> -// INSTANTIATE_TEST_CASE_P(StringSequence, StringTest, ValuesIn(strings));
> +// INSTANTIATE_TEST_SUITE_P(StringSequence, StringTest,
> ValuesIn(strings));
> //
> -// This instantiates tests from test case StlStringTest
> +// This instantiates tests from test suite StlStringTest
> // each with STL strings with values "a" and "b":
> //
> // ::std::vector< ::std::string> GetParameterStrings() {
> @@ -279,9 +272,9 @@ internal::ParamGenerator<T> Range(T start, T end) {
> // return v;
> // }
> //
> -// INSTANTIATE_TEST_CASE_P(CharSequence,
> -// StlStringTest,
> -// ValuesIn(GetParameterStrings()));
> +// INSTANTIATE_TEST_SUITE_P(CharSequence,
> +// StlStringTest,
> +// ValuesIn(GetParameterStrings()));
> //
> //
> // This will also instantiate tests from CharTest
> @@ -294,16 +287,15 @@ internal::ParamGenerator<T> Range(T start, T end) {
> // return list;
> // }
> // ::std::list<char> l = GetParameterChars();
> -// INSTANTIATE_TEST_CASE_P(CharSequence2,
> -// CharTest,
> -// ValuesIn(l.begin(), l.end()));
> +// INSTANTIATE_TEST_SUITE_P(CharSequence2,
> +// CharTest,
> +// ValuesIn(l.begin(), l.end()));
> //
> template <typename ForwardIterator>
> internal::ParamGenerator<
> - typename
> ::testing::internal::IteratorTraits<ForwardIterator>::value_type>
> + typename std::iterator_traits<ForwardIterator>::value_type>
> ValuesIn(ForwardIterator begin, ForwardIterator end) {
> - typedef typename ::testing::internal::IteratorTraits<ForwardIterator>
> - ::value_type ParamType;
> + typedef typename std::iterator_traits<ForwardIterator>::value_type
> ParamType;
> return internal::ParamGenerator<ParamType>(
> new internal::ValuesInIteratorRangeGenerator<ParamType>(begin,
> end));
> }
> @@ -326,869 +318,22 @@ internal::ParamGenerator<typename
> Container::value_type> ValuesIn(
> // Values(T v1, T v2, ..., T vN)
> // - returns a generator producing sequences with elements v1, v2, ...,
> vN.
> //
> -// For example, this instantiates tests from test case BarTest each
> +// For example, this instantiates tests from test suite BarTest each
> // with values "one", "two", and "three":
> //
> -// INSTANTIATE_TEST_CASE_P(NumSequence, BarTest, Values("one", "two",
> "three"));
> +// INSTANTIATE_TEST_SUITE_P(NumSequence,
> +// BarTest,
> +// Values("one", "two", "three"));
> //
> -// This instantiates tests from test case BazTest each with values 1, 2,
> 3.5.
> +// This instantiates tests from test suite BazTest each with values 1, 2,
> 3.5.
> // The exact type of values will depend on the type of parameter in
> BazTest.
> //
> -// INSTANTIATE_TEST_CASE_P(FloatingNumbers, BazTest, Values(1, 2, 3.5));
> +// INSTANTIATE_TEST_SUITE_P(FloatingNumbers, BazTest, Values(1, 2, 3.5));
> //
> -// Currently, Values() supports from 1 to 50 parameters.
> //
> -template <typename T1>
> -internal::ValueArray1<T1> Values(T1 v1) {
> - return internal::ValueArray1<T1>(v1);
> -}
> -
> -template <typename T1, typename T2>
> -internal::ValueArray2<T1, T2> Values(T1 v1, T2 v2) {
> - return internal::ValueArray2<T1, T2>(v1, v2);
> -}
> -
> -template <typename T1, typename T2, typename T3>
> -internal::ValueArray3<T1, T2, T3> Values(T1 v1, T2 v2, T3 v3) {
> - return internal::ValueArray3<T1, T2, T3>(v1, v2, v3);
> -}
> -
> -template <typename T1, typename T2, typename T3, typename T4>
> -internal::ValueArray4<T1, T2, T3, T4> Values(T1 v1, T2 v2, T3 v3, T4 v4) {
> - return internal::ValueArray4<T1, T2, T3, T4>(v1, v2, v3, v4);
> -}
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5>
> -internal::ValueArray5<T1, T2, T3, T4, T5> Values(T1 v1, T2 v2, T3 v3, T4
> v4,
> - T5 v5) {
> - return internal::ValueArray5<T1, T2, T3, T4, T5>(v1, v2, v3, v4, v5);
> -}
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6>
> -internal::ValueArray6<T1, T2, T3, T4, T5, T6> Values(T1 v1, T2 v2, T3 v3,
> - T4 v4, T5 v5, T6 v6) {
> - return internal::ValueArray6<T1, T2, T3, T4, T5, T6>(v1, v2, v3, v4,
> v5, v6);
> -}
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7>
> -internal::ValueArray7<T1, T2, T3, T4, T5, T6, T7> Values(T1 v1, T2 v2, T3
> v3,
> - T4 v4, T5 v5, T6 v6, T7 v7) {
> - return internal::ValueArray7<T1, T2, T3, T4, T5, T6, T7>(v1, v2, v3,
> v4, v5,
> - v6, v7);
> -}
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8>
> -internal::ValueArray8<T1, T2, T3, T4, T5, T6, T7, T8> Values(T1 v1, T2 v2,
> - T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8) {
> - return internal::ValueArray8<T1, T2, T3, T4, T5, T6, T7, T8>(v1, v2,
> v3, v4,
> - v5, v6, v7, v8);
> -}
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9>
> -internal::ValueArray9<T1, T2, T3, T4, T5, T6, T7, T8, T9> Values(T1 v1,
> T2 v2,
> - T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9) {
> - return internal::ValueArray9<T1, T2, T3, T4, T5, T6, T7, T8, T9>(v1,
> v2, v3,
> - v4, v5, v6, v7, v8, v9);
> -}
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10>
> -internal::ValueArray10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Values(T1
> v1,
> - T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10) {
> - return internal::ValueArray10<T1, T2, T3, T4, T5, T6, T7, T8, T9,
> T10>(v1,
> - v2, v3, v4, v5, v6, v7, v8, v9, v10);
> -}
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11>
> -internal::ValueArray11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,
> - T11> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8,
> T9 v9,
> - T10 v10, T11 v11) {
> - return internal::ValueArray11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,
> - T11>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11);
> -}
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11, typename T12>
> -internal::ValueArray12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
> - T12> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8,
> T9 v9,
> - T10 v10, T11 v11, T12 v12) {
> - return internal::ValueArray12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,
> T11,
> - T12>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12);
> -}
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11, typename T12, typename T13>
> -internal::ValueArray13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
> - T13> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8,
> T9 v9,
> - T10 v10, T11 v11, T12 v12, T13 v13) {
> - return internal::ValueArray13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,
> T11,
> - T12, T13>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13);
> -}
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11, typename T12, typename T13, typename T14>
> -internal::ValueArray14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
> T13,
> - T14> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8,
> T9 v9,
> - T10 v10, T11 v11, T12 v12, T13 v13, T14 v14) {
> - return internal::ValueArray14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,
> T11,
> - T12, T13, T14>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12,
> v13,
> - v14);
> -}
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11, typename T12, typename T13, typename T14, typename T15>
> -internal::ValueArray15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
> T13,
> - T14, T15> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8
> v8,
> - T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15) {
> - return internal::ValueArray15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,
> T11,
> - T12, T13, T14, T15>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11,
> v12,
> - v13, v14, v15);
> -}
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11, typename T12, typename T13, typename T14, typename T15,
> - typename T16>
> -internal::ValueArray16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
> T13,
> - T14, T15, T16> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7,
> - T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15,
> - T16 v16) {
> - return internal::ValueArray16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,
> T11,
> - T12, T13, T14, T15, T16>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10,
> v11,
> - v12, v13, v14, v15, v16);
> -}
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11, typename T12, typename T13, typename T14, typename T15,
> - typename T16, typename T17>
> -internal::ValueArray17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
> T13,
> - T14, T15, T16, T17> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6,
> T7 v7,
> - T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15,
> - T16 v16, T17 v17) {
> - return internal::ValueArray17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,
> T11,
> - T12, T13, T14, T15, T16, T17>(v1, v2, v3, v4, v5, v6, v7, v8, v9,
> v10,
> - v11, v12, v13, v14, v15, v16, v17);
> -}
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11, typename T12, typename T13, typename T14, typename T15,
> - typename T16, typename T17, typename T18>
> -internal::ValueArray18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
> T13,
> - T14, T15, T16, T17, T18> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6
> v6,
> - T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15
> v15,
> - T16 v16, T17 v17, T18 v18) {
> - return internal::ValueArray18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,
> T11,
> - T12, T13, T14, T15, T16, T17, T18>(v1, v2, v3, v4, v5, v6, v7, v8,
> v9,
> - v10, v11, v12, v13, v14, v15, v16, v17, v18);
> -}
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11, typename T12, typename T13, typename T14, typename T15,
> - typename T16, typename T17, typename T18, typename T19>
> -internal::ValueArray19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
> T13,
> - T14, T15, T16, T17, T18, T19> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5
> v5,
> - T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14
> v14,
> - T15 v15, T16 v16, T17 v17, T18 v18, T19 v19) {
> - return internal::ValueArray19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,
> T11,
> - T12, T13, T14, T15, T16, T17, T18, T19>(v1, v2, v3, v4, v5, v6, v7,
> v8,
> - v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19);
> -}
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11, typename T12, typename T13, typename T14, typename T15,
> - typename T16, typename T17, typename T18, typename T19, typename T20>
> -internal::ValueArray20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
> T13,
> - T14, T15, T16, T17, T18, T19, T20> Values(T1 v1, T2 v2, T3 v3, T4 v4,
> - T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13,
> - T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20) {
> - return internal::ValueArray20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,
> T11,
> - T12, T13, T14, T15, T16, T17, T18, T19, T20>(v1, v2, v3, v4, v5,
> v6, v7,
> - v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20);
> -}
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11, typename T12, typename T13, typename T14, typename T15,
> - typename T16, typename T17, typename T18, typename T19, typename T20,
> - typename T21>
> -internal::ValueArray21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
> T13,
> - T14, T15, T16, T17, T18, T19, T20, T21> Values(T1 v1, T2 v2, T3 v3,
> T4 v4,
> - T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13,
> - T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21
> v21) {
> - return internal::ValueArray21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,
> T11,
> - T12, T13, T14, T15, T16, T17, T18, T19, T20, T21>(v1, v2, v3, v4,
> v5, v6,
> - v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20,
> v21);
> -}
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11, typename T12, typename T13, typename T14, typename T15,
> - typename T16, typename T17, typename T18, typename T19, typename T20,
> - typename T21, typename T22>
> -internal::ValueArray22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
> T13,
> - T14, T15, T16, T17, T18, T19, T20, T21, T22> Values(T1 v1, T2 v2, T3
> v3,
> - T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12,
> - T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20
> v20,
> - T21 v21, T22 v22) {
> - return internal::ValueArray22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,
> T11,
> - T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22>(v1, v2, v3,
> v4,
> - v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18,
> v19,
> - v20, v21, v22);
> -}
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11, typename T12, typename T13, typename T14, typename T15,
> - typename T16, typename T17, typename T18, typename T19, typename T20,
> - typename T21, typename T22, typename T23>
> -internal::ValueArray23<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
> T13,
> - T14, T15, T16, T17, T18, T19, T20, T21, T22, T23> Values(T1 v1, T2 v2,
> - T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11,
> T12 v12,
> - T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20
> v20,
> - T21 v21, T22 v22, T23 v23) {
> - return internal::ValueArray23<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,
> T11,
> - T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23>(v1, v2,
> v3,
> - v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17,
> v18, v19,
> - v20, v21, v22, v23);
> -}
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11, typename T12, typename T13, typename T14, typename T15,
> - typename T16, typename T17, typename T18, typename T19, typename T20,
> - typename T21, typename T22, typename T23, typename T24>
> -internal::ValueArray24<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
> T13,
> - T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24> Values(T1 v1,
> T2 v2,
> - T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11,
> T12 v12,
> - T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20
> v20,
> - T21 v21, T22 v22, T23 v23, T24 v24) {
> - return internal::ValueArray24<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,
> T11,
> - T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23,
> T24>(v1, v2,
> - v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17,
> v18,
> - v19, v20, v21, v22, v23, v24);
> -}
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11, typename T12, typename T13, typename T14, typename T15,
> - typename T16, typename T17, typename T18, typename T19, typename T20,
> - typename T21, typename T22, typename T23, typename T24, typename T25>
> -internal::ValueArray25<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
> T13,
> - T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25> Values(T1
> v1,
> - T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11
> v11,
> - T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19
> v19,
> - T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25) {
> - return internal::ValueArray25<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,
> T11,
> - T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24,
> T25>(v1,
> - v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16,
> v17,
> - v18, v19, v20, v21, v22, v23, v24, v25);
> -}
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11, typename T12, typename T13, typename T14, typename T15,
> - typename T16, typename T17, typename T18, typename T19, typename T20,
> - typename T21, typename T22, typename T23, typename T24, typename T25,
> - typename T26>
> -internal::ValueArray26<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
> T13,
> - T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
> - T26> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8,
> T9 v9,
> - T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17
> v17,
> - T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25
> v25,
> - T26 v26) {
> - return internal::ValueArray26<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,
> T11,
> - T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24,
> T25,
> - T26>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14,
> v15,
> - v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26);
> -}
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11, typename T12, typename T13, typename T14, typename T15,
> - typename T16, typename T17, typename T18, typename T19, typename T20,
> - typename T21, typename T22, typename T23, typename T24, typename T25,
> - typename T26, typename T27>
> -internal::ValueArray27<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
> T13,
> - T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
> - T27> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8,
> T9 v9,
> - T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17
> v17,
> - T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25
> v25,
> - T26 v26, T27 v27) {
> - return internal::ValueArray27<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,
> T11,
> - T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24,
> T25,
> - T26, T27>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13,
> v14,
> - v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27);
> -}
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11, typename T12, typename T13, typename T14, typename T15,
> - typename T16, typename T17, typename T18, typename T19, typename T20,
> - typename T21, typename T22, typename T23, typename T24, typename T25,
> - typename T26, typename T27, typename T28>
> -internal::ValueArray28<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
> T13,
> - T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
> - T28> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8,
> T9 v9,
> - T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17
> v17,
> - T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25
> v25,
> - T26 v26, T27 v27, T28 v28) {
> - return internal::ValueArray28<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,
> T11,
> - T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24,
> T25,
> - T26, T27, T28>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12,
> v13,
> - v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26,
> v27,
> - v28);
> -}
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11, typename T12, typename T13, typename T14, typename T15,
> - typename T16, typename T17, typename T18, typename T19, typename T20,
> - typename T21, typename T22, typename T23, typename T24, typename T25,
> - typename T26, typename T27, typename T28, typename T29>
> -internal::ValueArray29<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
> T13,
> - T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
> T28,
> - T29> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8,
> T9 v9,
> - T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17
> v17,
> - T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25
> v25,
> - T26 v26, T27 v27, T28 v28, T29 v29) {
> - return internal::ValueArray29<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,
> T11,
> - T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24,
> T25,
> - T26, T27, T28, T29>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11,
> v12,
> - v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25,
> v26,
> - v27, v28, v29);
> -}
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11, typename T12, typename T13, typename T14, typename T15,
> - typename T16, typename T17, typename T18, typename T19, typename T20,
> - typename T21, typename T22, typename T23, typename T24, typename T25,
> - typename T26, typename T27, typename T28, typename T29, typename T30>
> -internal::ValueArray30<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
> T13,
> - T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
> T28,
> - T29, T30> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8
> v8,
> - T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16,
> - T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24
> v24,
> - T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30) {
> - return internal::ValueArray30<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,
> T11,
> - T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24,
> T25,
> - T26, T27, T28, T29, T30>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10,
> v11,
> - v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24,
> v25,
> - v26, v27, v28, v29, v30);
> -}
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11, typename T12, typename T13, typename T14, typename T15,
> - typename T16, typename T17, typename T18, typename T19, typename T20,
> - typename T21, typename T22, typename T23, typename T24, typename T25,
> - typename T26, typename T27, typename T28, typename T29, typename T30,
> - typename T31>
> -internal::ValueArray31<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
> T13,
> - T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
> T28,
> - T29, T30, T31> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7,
> - T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15,
> - T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23
> v23,
> - T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31
> v31) {
> - return internal::ValueArray31<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,
> T11,
> - T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24,
> T25,
> - T26, T27, T28, T29, T30, T31>(v1, v2, v3, v4, v5, v6, v7, v8, v9,
> v10,
> - v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23,
> v24,
> - v25, v26, v27, v28, v29, v30, v31);
> -}
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11, typename T12, typename T13, typename T14, typename T15,
> - typename T16, typename T17, typename T18, typename T19, typename T20,
> - typename T21, typename T22, typename T23, typename T24, typename T25,
> - typename T26, typename T27, typename T28, typename T29, typename T30,
> - typename T31, typename T32>
> -internal::ValueArray32<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
> T13,
> - T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
> T28,
> - T29, T30, T31, T32> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6,
> T7 v7,
> - T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15,
> - T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23
> v23,
> - T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31
> v31,
> - T32 v32) {
> - return internal::ValueArray32<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,
> T11,
> - T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24,
> T25,
> - T26, T27, T28, T29, T30, T31, T32>(v1, v2, v3, v4, v5, v6, v7, v8,
> v9,
> - v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22,
> v23,
> - v24, v25, v26, v27, v28, v29, v30, v31, v32);
> -}
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11, typename T12, typename T13, typename T14, typename T15,
> - typename T16, typename T17, typename T18, typename T19, typename T20,
> - typename T21, typename T22, typename T23, typename T24, typename T25,
> - typename T26, typename T27, typename T28, typename T29, typename T30,
> - typename T31, typename T32, typename T33>
> -internal::ValueArray33<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
> T13,
> - T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
> T28,
> - T29, T30, T31, T32, T33> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6
> v6,
> - T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15
> v15,
> - T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23
> v23,
> - T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31
> v31,
> - T32 v32, T33 v33) {
> - return internal::ValueArray33<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,
> T11,
> - T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24,
> T25,
> - T26, T27, T28, T29, T30, T31, T32, T33>(v1, v2, v3, v4, v5, v6, v7,
> v8,
> - v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21,
> v22, v23,
> - v24, v25, v26, v27, v28, v29, v30, v31, v32, v33);
> -}
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11, typename T12, typename T13, typename T14, typename T15,
> - typename T16, typename T17, typename T18, typename T19, typename T20,
> - typename T21, typename T22, typename T23, typename T24, typename T25,
> - typename T26, typename T27, typename T28, typename T29, typename T30,
> - typename T31, typename T32, typename T33, typename T34>
> -internal::ValueArray34<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
> T13,
> - T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
> T28,
> - T29, T30, T31, T32, T33, T34> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5
> v5,
> - T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14
> v14,
> - T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22
> v22,
> - T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30
> v30,
> - T31 v31, T32 v32, T33 v33, T34 v34) {
> - return internal::ValueArray34<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,
> T11,
> - T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24,
> T25,
> - T26, T27, T28, T29, T30, T31, T32, T33, T34>(v1, v2, v3, v4, v5,
> v6, v7,
> - v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21,
> v22,
> - v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34);
> -}
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11, typename T12, typename T13, typename T14, typename T15,
> - typename T16, typename T17, typename T18, typename T19, typename T20,
> - typename T21, typename T22, typename T23, typename T24, typename T25,
> - typename T26, typename T27, typename T28, typename T29, typename T30,
> - typename T31, typename T32, typename T33, typename T34, typename T35>
> -internal::ValueArray35<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
> T13,
> - T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
> T28,
> - T29, T30, T31, T32, T33, T34, T35> Values(T1 v1, T2 v2, T3 v3, T4 v4,
> - T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13,
> - T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21
> v21,
> - T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29
> v29,
> - T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35) {
> - return internal::ValueArray35<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,
> T11,
> - T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24,
> T25,
> - T26, T27, T28, T29, T30, T31, T32, T33, T34, T35>(v1, v2, v3, v4,
> v5, v6,
> - v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20,
> v21,
> - v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34,
> v35);
> -}
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11, typename T12, typename T13, typename T14, typename T15,
> - typename T16, typename T17, typename T18, typename T19, typename T20,
> - typename T21, typename T22, typename T23, typename T24, typename T25,
> - typename T26, typename T27, typename T28, typename T29, typename T30,
> - typename T31, typename T32, typename T33, typename T34, typename T35,
> - typename T36>
> -internal::ValueArray36<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
> T13,
> - T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
> T28,
> - T29, T30, T31, T32, T33, T34, T35, T36> Values(T1 v1, T2 v2, T3 v3,
> T4 v4,
> - T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13,
> - T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21
> v21,
> - T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29
> v29,
> - T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36) {
> - return internal::ValueArray36<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,
> T11,
> - T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24,
> T25,
> - T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36>(v1, v2, v3,
> v4,
> - v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18,
> v19,
> - v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32,
> v33,
> - v34, v35, v36);
> -}
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11, typename T12, typename T13, typename T14, typename T15,
> - typename T16, typename T17, typename T18, typename T19, typename T20,
> - typename T21, typename T22, typename T23, typename T24, typename T25,
> - typename T26, typename T27, typename T28, typename T29, typename T30,
> - typename T31, typename T32, typename T33, typename T34, typename T35,
> - typename T36, typename T37>
> -internal::ValueArray37<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
> T13,
> - T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
> T28,
> - T29, T30, T31, T32, T33, T34, T35, T36, T37> Values(T1 v1, T2 v2, T3
> v3,
> - T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12,
> - T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20
> v20,
> - T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28
> v28,
> - T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36
> v36,
> - T37 v37) {
> - return internal::ValueArray37<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,
> T11,
> - T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24,
> T25,
> - T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37>(v1, v2,
> v3,
> - v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17,
> v18, v19,
> - v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32,
> v33,
> - v34, v35, v36, v37);
> -}
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11, typename T12, typename T13, typename T14, typename T15,
> - typename T16, typename T17, typename T18, typename T19, typename T20,
> - typename T21, typename T22, typename T23, typename T24, typename T25,
> - typename T26, typename T27, typename T28, typename T29, typename T30,
> - typename T31, typename T32, typename T33, typename T34, typename T35,
> - typename T36, typename T37, typename T38>
> -internal::ValueArray38<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
> T13,
> - T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
> T28,
> - T29, T30, T31, T32, T33, T34, T35, T36, T37, T38> Values(T1 v1, T2 v2,
> - T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11,
> T12 v12,
> - T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20
> v20,
> - T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28
> v28,
> - T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36
> v36,
> - T37 v37, T38 v38) {
> - return internal::ValueArray38<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,
> T11,
> - T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24,
> T25,
> - T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37,
> T38>(v1, v2,
> - v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17,
> v18,
> - v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31,
> v32,
> - v33, v34, v35, v36, v37, v38);
> -}
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11, typename T12, typename T13, typename T14, typename T15,
> - typename T16, typename T17, typename T18, typename T19, typename T20,
> - typename T21, typename T22, typename T23, typename T24, typename T25,
> - typename T26, typename T27, typename T28, typename T29, typename T30,
> - typename T31, typename T32, typename T33, typename T34, typename T35,
> - typename T36, typename T37, typename T38, typename T39>
> -internal::ValueArray39<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
> T13,
> - T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
> T28,
> - T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39> Values(T1 v1,
> T2 v2,
> - T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11,
> T12 v12,
> - T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20
> v20,
> - T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28
> v28,
> - T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36
> v36,
> - T37 v37, T38 v38, T39 v39) {
> - return internal::ValueArray39<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,
> T11,
> - T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24,
> T25,
> - T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38,
> T39>(v1,
> - v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16,
> v17,
> - v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30,
> v31,
> - v32, v33, v34, v35, v36, v37, v38, v39);
> -}
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11, typename T12, typename T13, typename T14, typename T15,
> - typename T16, typename T17, typename T18, typename T19, typename T20,
> - typename T21, typename T22, typename T23, typename T24, typename T25,
> - typename T26, typename T27, typename T28, typename T29, typename T30,
> - typename T31, typename T32, typename T33, typename T34, typename T35,
> - typename T36, typename T37, typename T38, typename T39, typename T40>
> -internal::ValueArray40<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
> T13,
> - T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
> T28,
> - T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40> Values(T1
> v1,
> - T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11
> v11,
> - T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19
> v19,
> - T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27
> v27,
> - T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35
> v35,
> - T36 v36, T37 v37, T38 v38, T39 v39, T40 v40) {
> - return internal::ValueArray40<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,
> T11,
> - T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24,
> T25,
> - T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38,
> T39,
> - T40>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14,
> v15,
> - v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28,
> v29,
> - v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40);
> -}
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11, typename T12, typename T13, typename T14, typename T15,
> - typename T16, typename T17, typename T18, typename T19, typename T20,
> - typename T21, typename T22, typename T23, typename T24, typename T25,
> - typename T26, typename T27, typename T28, typename T29, typename T30,
> - typename T31, typename T32, typename T33, typename T34, typename T35,
> - typename T36, typename T37, typename T38, typename T39, typename T40,
> - typename T41>
> -internal::ValueArray41<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
> T13,
> - T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
> T28,
> - T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
> - T41> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8,
> T9 v9,
> - T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17
> v17,
> - T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25
> v25,
> - T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33
> v33,
> - T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41
> v41) {
> - return internal::ValueArray41<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,
> T11,
> - T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24,
> T25,
> - T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38,
> T39,
> - T40, T41>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13,
> v14,
> - v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27,
> v28,
> - v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41);
> -}
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11, typename T12, typename T13, typename T14, typename T15,
> - typename T16, typename T17, typename T18, typename T19, typename T20,
> - typename T21, typename T22, typename T23, typename T24, typename T25,
> - typename T26, typename T27, typename T28, typename T29, typename T30,
> - typename T31, typename T32, typename T33, typename T34, typename T35,
> - typename T36, typename T37, typename T38, typename T39, typename T40,
> - typename T41, typename T42>
> -internal::ValueArray42<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
> T13,
> - T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
> T28,
> - T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41,
> - T42> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8,
> T9 v9,
> - T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17
> v17,
> - T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25
> v25,
> - T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33
> v33,
> - T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41
> v41,
> - T42 v42) {
> - return internal::ValueArray42<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,
> T11,
> - T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24,
> T25,
> - T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38,
> T39,
> - T40, T41, T42>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12,
> v13,
> - v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26,
> v27,
> - v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40,
> v41,
> - v42);
> -}
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11, typename T12, typename T13, typename T14, typename T15,
> - typename T16, typename T17, typename T18, typename T19, typename T20,
> - typename T21, typename T22, typename T23, typename T24, typename T25,
> - typename T26, typename T27, typename T28, typename T29, typename T30,
> - typename T31, typename T32, typename T33, typename T34, typename T35,
> - typename T36, typename T37, typename T38, typename T39, typename T40,
> - typename T41, typename T42, typename T43>
> -internal::ValueArray43<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
> T13,
> - T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
> T28,
> - T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42,
> - T43> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8,
> T9 v9,
> - T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17
> v17,
> - T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25
> v25,
> - T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33
> v33,
> - T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41
> v41,
> - T42 v42, T43 v43) {
> - return internal::ValueArray43<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,
> T11,
> - T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24,
> T25,
> - T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38,
> T39,
> - T40, T41, T42, T43>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11,
> v12,
> - v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25,
> v26,
> - v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39,
> v40,
> - v41, v42, v43);
> -}
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11, typename T12, typename T13, typename T14, typename T15,
> - typename T16, typename T17, typename T18, typename T19, typename T20,
> - typename T21, typename T22, typename T23, typename T24, typename T25,
> - typename T26, typename T27, typename T28, typename T29, typename T30,
> - typename T31, typename T32, typename T33, typename T34, typename T35,
> - typename T36, typename T37, typename T38, typename T39, typename T40,
> - typename T41, typename T42, typename T43, typename T44>
> -internal::ValueArray44<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
> T13,
> - T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
> T28,
> - T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42,
> T43,
> - T44> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8,
> T9 v9,
> - T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17
> v17,
> - T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25
> v25,
> - T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33
> v33,
> - T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41
> v41,
> - T42 v42, T43 v43, T44 v44) {
> - return internal::ValueArray44<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,
> T11,
> - T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24,
> T25,
> - T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38,
> T39,
> - T40, T41, T42, T43, T44>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10,
> v11,
> - v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24,
> v25,
> - v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38,
> v39,
> - v40, v41, v42, v43, v44);
> -}
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11, typename T12, typename T13, typename T14, typename T15,
> - typename T16, typename T17, typename T18, typename T19, typename T20,
> - typename T21, typename T22, typename T23, typename T24, typename T25,
> - typename T26, typename T27, typename T28, typename T29, typename T30,
> - typename T31, typename T32, typename T33, typename T34, typename T35,
> - typename T36, typename T37, typename T38, typename T39, typename T40,
> - typename T41, typename T42, typename T43, typename T44, typename T45>
> -internal::ValueArray45<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
> T13,
> - T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
> T28,
> - T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42,
> T43,
> - T44, T45> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8
> v8,
> - T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16,
> - T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24
> v24,
> - T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32
> v32,
> - T33 v33, T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40
> v40,
> - T41 v41, T42 v42, T43 v43, T44 v44, T45 v45) {
> - return internal::ValueArray45<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,
> T11,
> - T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24,
> T25,
> - T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38,
> T39,
> - T40, T41, T42, T43, T44, T45>(v1, v2, v3, v4, v5, v6, v7, v8, v9,
> v10,
> - v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23,
> v24,
> - v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37,
> v38,
> - v39, v40, v41, v42, v43, v44, v45);
> -}
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11, typename T12, typename T13, typename T14, typename T15,
> - typename T16, typename T17, typename T18, typename T19, typename T20,
> - typename T21, typename T22, typename T23, typename T24, typename T25,
> - typename T26, typename T27, typename T28, typename T29, typename T30,
> - typename T31, typename T32, typename T33, typename T34, typename T35,
> - typename T36, typename T37, typename T38, typename T39, typename T40,
> - typename T41, typename T42, typename T43, typename T44, typename T45,
> - typename T46>
> -internal::ValueArray46<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
> T13,
> - T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
> T28,
> - T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42,
> T43,
> - T44, T45, T46> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7,
> - T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15,
> - T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23
> v23,
> - T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31
> v31,
> - T32 v32, T33 v33, T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39
> v39,
> - T40 v40, T41 v41, T42 v42, T43 v43, T44 v44, T45 v45, T46 v46) {
> - return internal::ValueArray46<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,
> T11,
> - T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24,
> T25,
> - T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38,
> T39,
> - T40, T41, T42, T43, T44, T45, T46>(v1, v2, v3, v4, v5, v6, v7, v8,
> v9,
> - v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22,
> v23,
> - v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36,
> v37,
> - v38, v39, v40, v41, v42, v43, v44, v45, v46);
> -}
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11, typename T12, typename T13, typename T14, typename T15,
> - typename T16, typename T17, typename T18, typename T19, typename T20,
> - typename T21, typename T22, typename T23, typename T24, typename T25,
> - typename T26, typename T27, typename T28, typename T29, typename T30,
> - typename T31, typename T32, typename T33, typename T34, typename T35,
> - typename T36, typename T37, typename T38, typename T39, typename T40,
> - typename T41, typename T42, typename T43, typename T44, typename T45,
> - typename T46, typename T47>
> -internal::ValueArray47<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
> T13,
> - T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
> T28,
> - T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42,
> T43,
> - T44, T45, T46, T47> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6,
> T7 v7,
> - T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15,
> - T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23
> v23,
> - T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31
> v31,
> - T32 v32, T33 v33, T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39
> v39,
> - T40 v40, T41 v41, T42 v42, T43 v43, T44 v44, T45 v45, T46 v46, T47
> v47) {
> - return internal::ValueArray47<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,
> T11,
> - T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24,
> T25,
> - T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38,
> T39,
> - T40, T41, T42, T43, T44, T45, T46, T47>(v1, v2, v3, v4, v5, v6, v7,
> v8,
> - v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21,
> v22, v23,
> - v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36,
> v37,
> - v38, v39, v40, v41, v42, v43, v44, v45, v46, v47);
> -}
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11, typename T12, typename T13, typename T14, typename T15,
> - typename T16, typename T17, typename T18, typename T19, typename T20,
> - typename T21, typename T22, typename T23, typename T24, typename T25,
> - typename T26, typename T27, typename T28, typename T29, typename T30,
> - typename T31, typename T32, typename T33, typename T34, typename T35,
> - typename T36, typename T37, typename T38, typename T39, typename T40,
> - typename T41, typename T42, typename T43, typename T44, typename T45,
> - typename T46, typename T47, typename T48>
> -internal::ValueArray48<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
> T13,
> - T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
> T28,
> - T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42,
> T43,
> - T44, T45, T46, T47, T48> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6
> v6,
> - T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15
> v15,
> - T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23
> v23,
> - T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31
> v31,
> - T32 v32, T33 v33, T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39
> v39,
> - T40 v40, T41 v41, T42 v42, T43 v43, T44 v44, T45 v45, T46 v46, T47
> v47,
> - T48 v48) {
> - return internal::ValueArray48<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,
> T11,
> - T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24,
> T25,
> - T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38,
> T39,
> - T40, T41, T42, T43, T44, T45, T46, T47, T48>(v1, v2, v3, v4, v5,
> v6, v7,
> - v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21,
> v22,
> - v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35,
> v36,
> - v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48);
> -}
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11, typename T12, typename T13, typename T14, typename T15,
> - typename T16, typename T17, typename T18, typename T19, typename T20,
> - typename T21, typename T22, typename T23, typename T24, typename T25,
> - typename T26, typename T27, typename T28, typename T29, typename T30,
> - typename T31, typename T32, typename T33, typename T34, typename T35,
> - typename T36, typename T37, typename T38, typename T39, typename T40,
> - typename T41, typename T42, typename T43, typename T44, typename T45,
> - typename T46, typename T47, typename T48, typename T49>
> -internal::ValueArray49<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
> T13,
> - T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
> T28,
> - T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42,
> T43,
> - T44, T45, T46, T47, T48, T49> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5
> v5,
> - T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14
> v14,
> - T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22
> v22,
> - T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30
> v30,
> - T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36, T37 v37, T38
> v38,
> - T39 v39, T40 v40, T41 v41, T42 v42, T43 v43, T44 v44, T45 v45, T46
> v46,
> - T47 v47, T48 v48, T49 v49) {
> - return internal::ValueArray49<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,
> T11,
> - T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24,
> T25,
> - T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38,
> T39,
> - T40, T41, T42, T43, T44, T45, T46, T47, T48, T49>(v1, v2, v3, v4,
> v5, v6,
> - v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20,
> v21,
> - v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34,
> v35,
> - v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48,
> v49);
> -}
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11, typename T12, typename T13, typename T14, typename T15,
> - typename T16, typename T17, typename T18, typename T19, typename T20,
> - typename T21, typename T22, typename T23, typename T24, typename T25,
> - typename T26, typename T27, typename T28, typename T29, typename T30,
> - typename T31, typename T32, typename T33, typename T34, typename T35,
> - typename T36, typename T37, typename T38, typename T39, typename T40,
> - typename T41, typename T42, typename T43, typename T44, typename T45,
> - typename T46, typename T47, typename T48, typename T49, typename T50>
> -internal::ValueArray50<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
> T13,
> - T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
> T28,
> - T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42,
> T43,
> - T44, T45, T46, T47, T48, T49, T50> Values(T1 v1, T2 v2, T3 v3, T4 v4,
> - T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13,
> - T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21
> v21,
> - T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29
> v29,
> - T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36, T37
> v37,
> - T38 v38, T39 v39, T40 v40, T41 v41, T42 v42, T43 v43, T44 v44, T45
> v45,
> - T46 v46, T47 v47, T48 v48, T49 v49, T50 v50) {
> - return internal::ValueArray50<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,
> T11,
> - T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24,
> T25,
> - T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38,
> T39,
> - T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50>(v1, v2, v3,
> v4,
> - v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18,
> v19,
> - v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32,
> v33,
> - v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46,
> v47,
> - v48, v49, v50);
> +template <typename... T>
> +internal::ValueArray<T...> Values(T... v) {
> + return internal::ValueArray<T...>(std::move(v)...);
> }
>
> // Bool() allows generating tests with parameters in a set of (false,
> true).
> @@ -1201,7 +346,7 @@ internal::ValueArray50<T1, T2, T3, T4, T5, T6, T7,
> T8, T9, T10, T11, T12, T13,
> // of multiple flags can be tested when several Bool()'s are combined
> using
> // Combine() function.
> //
> -// In the following example all tests in the test case FlagDependentTest
> +// In the following example all tests in the test suite FlagDependentTest
> // will be instantiated twice with parameters false and true.
> //
> // class FlagDependentTest : public testing::TestWithParam<bool> {
> @@ -1209,13 +354,12 @@ internal::ValueArray50<T1, T2, T3, T4, T5, T6, T7,
> T8, T9, T10, T11, T12, T13,
> // external_flag = GetParam();
> // }
> // }
> -// INSTANTIATE_TEST_CASE_P(BoolSequence, FlagDependentTest, Bool());
> +// INSTANTIATE_TEST_SUITE_P(BoolSequence, FlagDependentTest, Bool());
> //
> inline internal::ParamGenerator<bool> Bool() {
> return Values(false, true);
> }
>
> -# if GTEST_HAS_COMBINE
> // Combine() allows the user to combine two or more sequences to produce
> // values of a Cartesian product of those sequences' elements.
> //
> @@ -1224,184 +368,83 @@ inline internal::ParamGenerator<bool> Bool() {
> // - returns a generator producing sequences with elements coming from
> // the Cartesian product of elements from the sequences generated by
> // gen1, gen2, ..., genN. The sequence elements will have a type of
> -// tuple<T1, T2, ..., TN> where T1, T2, ..., TN are the types
> +// std::tuple<T1, T2, ..., TN> where T1, T2, ..., TN are the types
> // of elements from sequences produces by gen1, gen2, ..., genN.
> //
> -// Combine can have up to 10 arguments. This number is currently limited
> -// by the maximum number of elements in the tuple implementation used by
> Google
> -// Test.
> +// Combine can have up to 10 arguments.
> //
> // Example:
> //
> -// This will instantiate tests in test case AnimalTest each one with
> +// This will instantiate tests in test suite AnimalTest each one with
> // the parameter values tuple("cat", BLACK), tuple("cat", WHITE),
> // tuple("dog", BLACK), and tuple("dog", WHITE):
> //
> // enum Color { BLACK, GRAY, WHITE };
> // class AnimalTest
> -// : public testing::TestWithParam<tuple<const char*, Color> > {...};
> +// : public testing::TestWithParam<std::tuple<const char*, Color> >
> {...};
> //
> // TEST_P(AnimalTest, AnimalLooksNice) {...}
> //
> -// INSTANTIATE_TEST_CASE_P(AnimalVariations, AnimalTest,
> -// Combine(Values("cat", "dog"),
> -// Values(BLACK, WHITE)));
> +// INSTANTIATE_TEST_SUITE_P(AnimalVariations, AnimalTest,
> +// Combine(Values("cat", "dog"),
> +// Values(BLACK, WHITE)));
> //
> // This will instantiate tests in FlagDependentTest with all variations
> of two
> // Boolean flags:
> //
> // class FlagDependentTest
> -// : public testing::TestWithParam<tuple<bool, bool> > {
> +// : public testing::TestWithParam<std::tuple<bool, bool> > {
> // virtual void SetUp() {
> // // Assigns external_flag_1 and external_flag_2 values from the
> tuple.
> -// tie(external_flag_1, external_flag_2) = GetParam();
> +// std::tie(external_flag_1, external_flag_2) = GetParam();
> // }
> // };
> //
> // TEST_P(FlagDependentTest, TestFeature1) {
> // // Test your code using external_flag_1 and external_flag_2 here.
> // }
> -// INSTANTIATE_TEST_CASE_P(TwoBoolSequence, FlagDependentTest,
> -// Combine(Bool(), Bool()));
> -//
> -template <typename Generator1, typename Generator2>
> -internal::CartesianProductHolder2<Generator1, Generator2> Combine(
> - const Generator1& g1, const Generator2& g2) {
> - return internal::CartesianProductHolder2<Generator1, Generator2>(
> - g1, g2);
> -}
> -
> -template <typename Generator1, typename Generator2, typename Generator3>
> -internal::CartesianProductHolder3<Generator1, Generator2, Generator3>
> Combine(
> - const Generator1& g1, const Generator2& g2, const Generator3& g3) {
> - return internal::CartesianProductHolder3<Generator1, Generator2,
> Generator3>(
> - g1, g2, g3);
> -}
> -
> -template <typename Generator1, typename Generator2, typename Generator3,
> - typename Generator4>
> -internal::CartesianProductHolder4<Generator1, Generator2, Generator3,
> - Generator4> Combine(
> - const Generator1& g1, const Generator2& g2, const Generator3& g3,
> - const Generator4& g4) {
> - return internal::CartesianProductHolder4<Generator1, Generator2,
> Generator3,
> - Generator4>(
> - g1, g2, g3, g4);
> -}
> -
> -template <typename Generator1, typename Generator2, typename Generator3,
> - typename Generator4, typename Generator5>
> -internal::CartesianProductHolder5<Generator1, Generator2, Generator3,
> - Generator4, Generator5> Combine(
> - const Generator1& g1, const Generator2& g2, const Generator3& g3,
> - const Generator4& g4, const Generator5& g5) {
> - return internal::CartesianProductHolder5<Generator1, Generator2,
> Generator3,
> - Generator4, Generator5>(
> - g1, g2, g3, g4, g5);
> -}
> -
> -template <typename Generator1, typename Generator2, typename Generator3,
> - typename Generator4, typename Generator5, typename Generator6>
> -internal::CartesianProductHolder6<Generator1, Generator2, Generator3,
> - Generator4, Generator5, Generator6> Combine(
> - const Generator1& g1, const Generator2& g2, const Generator3& g3,
> - const Generator4& g4, const Generator5& g5, const Generator6& g6)
> {
> - return internal::CartesianProductHolder6<Generator1, Generator2,
> Generator3,
> - Generator4, Generator5, Generator6>(
> - g1, g2, g3, g4, g5, g6);
> -}
> -
> -template <typename Generator1, typename Generator2, typename Generator3,
> - typename Generator4, typename Generator5, typename Generator6,
> - typename Generator7>
> -internal::CartesianProductHolder7<Generator1, Generator2, Generator3,
> - Generator4, Generator5, Generator6, Generator7> Combine(
> - const Generator1& g1, const Generator2& g2, const Generator3& g3,
> - const Generator4& g4, const Generator5& g5, const Generator6& g6,
> - const Generator7& g7) {
> - return internal::CartesianProductHolder7<Generator1, Generator2,
> Generator3,
> - Generator4, Generator5, Generator6, Generator7>(
> - g1, g2, g3, g4, g5, g6, g7);
> -}
> -
> -template <typename Generator1, typename Generator2, typename Generator3,
> - typename Generator4, typename Generator5, typename Generator6,
> - typename Generator7, typename Generator8>
> -internal::CartesianProductHolder8<Generator1, Generator2, Generator3,
> - Generator4, Generator5, Generator6, Generator7, Generator8> Combine(
> - const Generator1& g1, const Generator2& g2, const Generator3& g3,
> - const Generator4& g4, const Generator5& g5, const Generator6& g6,
> - const Generator7& g7, const Generator8& g8) {
> - return internal::CartesianProductHolder8<Generator1, Generator2,
> Generator3,
> - Generator4, Generator5, Generator6, Generator7, Generator8>(
> - g1, g2, g3, g4, g5, g6, g7, g8);
> -}
> -
> -template <typename Generator1, typename Generator2, typename Generator3,
> - typename Generator4, typename Generator5, typename Generator6,
> - typename Generator7, typename Generator8, typename Generator9>
> -internal::CartesianProductHolder9<Generator1, Generator2, Generator3,
> - Generator4, Generator5, Generator6, Generator7, Generator8,
> - Generator9> Combine(
> - const Generator1& g1, const Generator2& g2, const Generator3& g3,
> - const Generator4& g4, const Generator5& g5, const Generator6& g6,
> - const Generator7& g7, const Generator8& g8, const Generator9& g9)
> {
> - return internal::CartesianProductHolder9<Generator1, Generator2,
> Generator3,
> - Generator4, Generator5, Generator6, Generator7, Generator8,
> Generator9>(
> - g1, g2, g3, g4, g5, g6, g7, g8, g9);
> -}
> -
> -template <typename Generator1, typename Generator2, typename Generator3,
> - typename Generator4, typename Generator5, typename Generator6,
> - typename Generator7, typename Generator8, typename Generator9,
> - typename Generator10>
> -internal::CartesianProductHolder10<Generator1, Generator2, Generator3,
> - Generator4, Generator5, Generator6, Generator7, Generator8,
> Generator9,
> - Generator10> Combine(
> - const Generator1& g1, const Generator2& g2, const Generator3& g3,
> - const Generator4& g4, const Generator5& g5, const Generator6& g6,
> - const Generator7& g7, const Generator8& g8, const Generator9& g9,
> - const Generator10& g10) {
> - return internal::CartesianProductHolder10<Generator1, Generator2,
> Generator3,
> - Generator4, Generator5, Generator6, Generator7, Generator8,
> Generator9,
> - Generator10>(
> - g1, g2, g3, g4, g5, g6, g7, g8, g9, g10);
> -}
> -# endif // GTEST_HAS_COMBINE
> -
> -# define TEST_P(test_case_name, test_name) \
> - class GTEST_TEST_CLASS_NAME_(test_case_name, test_name) \
> - : public test_case_name { \
> - public: \
> - GTEST_TEST_CLASS_NAME_(test_case_name, test_name)() {} \
> - virtual void TestBody(); \
> - private: \
> - static int AddToRegistry() { \
> - ::testing::UnitTest::GetInstance()->parameterized_test_registry(). \
> - GetTestCasePatternHolder<test_case_name>(\
> - #test_case_name, \
> - ::testing::internal::CodeLocation(\
> - __FILE__, __LINE__))->AddTestPattern(\
> - GTEST_STRINGIFY_(test_case_name), \
> - GTEST_STRINGIFY_(test_name), \
> - new ::testing::internal::TestMetaFactory< \
> - GTEST_TEST_CLASS_NAME_(\
> - test_case_name, test_name)>()); \
> - return 0; \
> - } \
> - static int gtest_registering_dummy_ GTEST_ATTRIBUTE_UNUSED_; \
> - GTEST_DISALLOW_COPY_AND_ASSIGN_(\
> - GTEST_TEST_CLASS_NAME_(test_case_name, test_name)); \
> - }; \
> - int GTEST_TEST_CLASS_NAME_(test_case_name, \
> - test_name)::gtest_registering_dummy_ = \
> - GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::AddToRegistry();
> \
> - void GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::TestBody()
> -
> -// The optional last argument to INSTANTIATE_TEST_CASE_P allows the user
> -// to specify a function or functor that generates custom test name
> suffixes
> -// based on the test parameters. The function should accept one argument
> of
> -// type testing::TestParamInfo<class ParamType>, and return std::string.
> +// INSTANTIATE_TEST_SUITE_P(TwoBoolSequence, FlagDependentTest,
> +// Combine(Bool(), Bool()));
> +//
> +template <typename... Generator>
> +internal::CartesianProductHolder<Generator...> Combine(const
> Generator&... g) {
> + return internal::CartesianProductHolder<Generator...>(g...);
> +}
> +
> +#define TEST_P(test_suite_name, test_name)
> \
> + class GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)
> \
> + : public test_suite_name {
> \
> + public:
> \
> + GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)() {}
> \
> + virtual void TestBody();
> \
> +
> \
> + private:
> \
> + static int AddToRegistry() {
> \
> + ::testing::UnitTest::GetInstance()
> \
> + ->parameterized_test_registry()
> \
> + .GetTestSuitePatternHolder<test_suite_name>(
> \
> + #test_suite_name,
> \
> + ::testing::internal::CodeLocation(__FILE__, __LINE__))
> \
> + ->AddTestPattern(
> \
> + GTEST_STRINGIFY_(test_suite_name),
> GTEST_STRINGIFY_(test_name), \
> + new
> ::testing::internal::TestMetaFactory<GTEST_TEST_CLASS_NAME_( \
> + test_suite_name, test_name)>());
> \
> + return 0;
> \
> + }
> \
> + static int gtest_registering_dummy_ GTEST_ATTRIBUTE_UNUSED_;
> \
> +
> GTEST_DISALLOW_COPY_AND_ASSIGN_(GTEST_TEST_CLASS_NAME_(test_suite_name, \
> + test_name));
> \
> + };
> \
> + int GTEST_TEST_CLASS_NAME_(test_suite_name,
> \
> + test_name)::gtest_registering_dummy_ =
> \
> + GTEST_TEST_CLASS_NAME_(test_suite_name,
> test_name)::AddToRegistry(); \
> + void GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)::TestBody()
> +
> +// The last argument to INSTANTIATE_TEST_SUITE_P allows the user to
> specify
> +// generator and an optional function or functor that generates custom
> test name
> +// suffixes based on the test parameters. Such a function or functor
> should
> +// accept one argument of type testing::TestParamInfo<class ParamType>,
> and
> +// return std::string.
> //
> // testing::PrintToStringParamName is a builtin test suffix generator that
> // returns the value of testing::PrintToString(GetParam()).
> @@ -1410,24 +453,50 @@ internal::CartesianProductHolder10<Generator1,
> Generator2, Generator3,
> // alphanumeric characters or underscore. Because PrintToString adds
> quotes
> // to std::string and C strings, it won't work for these types.
>
> -# define INSTANTIATE_TEST_CASE_P(prefix, test_case_name, generator, ...) \
> - static ::testing::internal::ParamGenerator<test_case_name::ParamType> \
> - gtest_##prefix##test_case_name##_EvalGenerator_() { return
> generator; } \
> - static ::std::string
> gtest_##prefix##test_case_name##_EvalGenerateName_( \
> - const ::testing::TestParamInfo<test_case_name::ParamType>& info) { \
> - return
> ::testing::internal::GetParamNameGen<test_case_name::ParamType> \
> - (__VA_ARGS__)(info); \
> - } \
> - static int gtest_##prefix##test_case_name##_dummy_
> GTEST_ATTRIBUTE_UNUSED_ = \
> - ::testing::UnitTest::GetInstance()->parameterized_test_registry(). \
> - GetTestCasePatternHolder<test_case_name>(\
> - #test_case_name, \
> - ::testing::internal::CodeLocation(\
> - __FILE__, __LINE__))->AddTestCaseInstantiation(\
> - #prefix, \
> - >est_##prefix##test_case_name##_EvalGenerator_, \
> -
> >est_##prefix##test_case_name##_EvalGenerateName_, \
> - __FILE__, __LINE__)
> +#define GTEST_EXPAND_(arg) arg
> +#define GTEST_GET_FIRST_(first, ...) first
> +#define GTEST_GET_SECOND_(first, second, ...) second
> +
> +#define INSTANTIATE_TEST_SUITE_P(prefix, test_suite_name, ...)
> \
> + static ::testing::internal::ParamGenerator<test_suite_name::ParamType>
> \
> + gtest_##prefix##test_suite_name##_EvalGenerator_() {
> \
> + return GTEST_EXPAND_(GTEST_GET_FIRST_(__VA_ARGS__, DUMMY_PARAM_));
> \
> + }
> \
> + static ::std::string
> gtest_##prefix##test_suite_name##_EvalGenerateName_( \
> + const ::testing::TestParamInfo<test_suite_name::ParamType>& info)
> { \
> + if (::testing::internal::AlwaysFalse()) {
> \
> + ::testing::internal::TestNotEmpty(GTEST_EXPAND_(GTEST_GET_SECOND_(
> \
> + __VA_ARGS__,
> \
> +
> ::testing::internal::DefaultParamName<test_suite_name::ParamType>, \
> + DUMMY_PARAM_)));
> \
> + auto t = std::make_tuple(__VA_ARGS__);
> \
> + static_assert(std::tuple_size<decltype(t)>::value <= 2,
> \
> + "Too Many Args!");
> \
> + }
> \
> + return ((GTEST_EXPAND_(GTEST_GET_SECOND_(
> \
> + __VA_ARGS__,
> \
> +
> ::testing::internal::DefaultParamName<test_suite_name::ParamType>, \
> + DUMMY_PARAM_))))(info);
> \
> + }
> \
> + static int gtest_##prefix##test_suite_name##_dummy_
> \
> + GTEST_ATTRIBUTE_UNUSED_ =
> \
> + ::testing::UnitTest::GetInstance()
> \
> + ->parameterized_test_registry()
> \
> + .GetTestSuitePatternHolder<test_suite_name>(
> \
> + #test_suite_name,
> \
> + ::testing::internal::CodeLocation(__FILE__, __LINE__))
> \
> + ->AddTestSuiteInstantiation(
> \
> + #prefix,
> >est_##prefix##test_suite_name##_EvalGenerator_, \
> + >est_##prefix##test_suite_name##_EvalGenerateName_,
> \
> + __FILE__, __LINE__)
> +
> +// Legacy API is deprecated but still available
> +#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
> +#define INSTANTIATE_TEST_CASE_P
> \
> +
> static_assert(::testing::internal::InstantiateTestCase_P_IsDeprecated(), \
> + "");
> \
> + INSTANTIATE_TEST_SUITE_P
> +#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
>
> } // namespace testing
>
>
> diff --git
> a/llvm/utils/unittest/googletest/include/gtest/gtest-printers.h
> b/llvm/utils/unittest/googletest/include/gtest/gtest-printers.h
> index c4b3de950c2b6..956f07910484a 100644
> --- a/llvm/utils/unittest/googletest/include/gtest/gtest-printers.h
> +++ b/llvm/utils/unittest/googletest/include/gtest/gtest-printers.h
> @@ -100,19 +100,18 @@
> #ifndef GTEST_INCLUDE_GTEST_GTEST_PRINTERS_H_
> #define GTEST_INCLUDE_GTEST_GTEST_PRINTERS_H_
>
> +#include <functional>
> #include <ostream> // NOLINT
> #include <sstream>
> #include <string>
> +#include <tuple>
> +#include <type_traits>
> #include <utility>
> #include <vector>
> -#include "gtest/internal/gtest-port.h"
> #include "gtest/internal/gtest-internal.h"
> +#include "gtest/internal/gtest-port.h"
> #include "gtest/internal/custom/raw-ostream.h"
>
> -#if GTEST_HAS_STD_TUPLE_
> -# include <tuple>
> -#endif
> -
> #if GTEST_HAS_ABSL
> #include "absl/strings/string_view.h"
> #include "absl/types/optional.h"
> @@ -153,9 +152,10 @@ class TypeWithoutFormatter {
> public:
> // This default version is called when kTypeKind is kOtherType.
> static void PrintValue(const T& value, ::std::ostream* os) {
> - PrintBytesInObjectTo(static_cast<const unsigned char*>(
> - reinterpret_cast<const void*>(&value)),
> - sizeof(value), os);
> + PrintBytesInObjectTo(
> + static_cast<const unsigned char*>(
> + reinterpret_cast<const void*>(std::addressof(value))),
> + sizeof(value), os);
> }
> };
>
> @@ -234,12 +234,12 @@ ::std::basic_ostream<Char, CharTraits>& operator<<(
> ::std::basic_ostream<Char, CharTraits>& os, const T& x) {
> TypeWithoutFormatter<T, (internal::IsAProtocolMessage<T>::value
> ? kProtobuf
> - : internal::ImplicitlyConvertible<
> + : std::is_convertible<
> const T&,
> internal::BiggestInt>::value
> ? kConvertibleToInteger
> :
> #if GTEST_HAS_ABSL
> - internal::ImplicitlyConvertible<
> + std::is_convertible<
> const T&,
> absl::string_view>::value
> ? kConvertibleToStringView
> :
> @@ -359,16 +359,6 @@ GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(const wchar_t);
> GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(char, ::std::string);
> GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const char, ::std::string);
>
> -#if GTEST_HAS_GLOBAL_STRING
> -GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(char, ::string);
> -GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const char, ::string);
> -#endif
> -
> -#if GTEST_HAS_GLOBAL_WSTRING
> -GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(wchar_t, ::wstring);
> -GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const wchar_t, ::wstring);
> -#endif
> -
> #if GTEST_HAS_STD_WSTRING
> GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(wchar_t, ::std::wstring);
> GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const wchar_t, ::std::wstring);
> @@ -449,7 +439,7 @@ void DefaultPrintTo(WrapPrinterType<kPrintContainer>
> /* dummy */,
> template <typename T>
> void DefaultPrintTo(WrapPrinterType<kPrintPointer> /* dummy */,
> T* p, ::std::ostream* os) {
> - if (p == NULL) {
> + if (p == nullptr) {
> *os << "NULL";
> } else {
> // T is not a function type. We just call << to print p,
> @@ -461,7 +451,7 @@ void DefaultPrintTo(WrapPrinterType<kPrintPointer> /*
> dummy */,
> template <typename T>
> void DefaultPrintTo(WrapPrinterType<kPrintFunctionPointer> /* dummy */,
> T* p, ::std::ostream* os) {
> - if (p == NULL) {
> + if (p == nullptr) {
> *os << "NULL";
> } else {
> // T is a function type, so '*os << p' doesn't do what we want
> @@ -516,13 +506,9 @@ void PrintTo(const T& value, ::std::ostream* os) {
> (sizeof(IsContainerTest<T>(0)) == sizeof(IsContainer))
> &&
> !IsRecursiveContainer<T>::value
> ? kPrintContainer
> - : !is_pointer<T>::value
> + : !std::is_pointer<T>::value
> ? kPrintOther
> -#if GTEST_LANG_CXX11
> : std::is_function<typename
> std::remove_pointer<T>::type>::value
> -#else
> - : !internal::ImplicitlyConvertible<T, const void*>::value
> -#endif
> ? kPrintFunctionPointer
> : kPrintPointer > (),
> value, os);
> @@ -604,27 +590,13 @@ void PrintRawArrayTo(const T a[], size_t count,
> ::std::ostream* os) {
> }
> }
>
> -// Overloads for ::string and ::std::string.
> -#if GTEST_HAS_GLOBAL_STRING
> -GTEST_API_ void PrintStringTo(const ::string&s, ::std::ostream* os);
> -inline void PrintTo(const ::string& s, ::std::ostream* os) {
> - PrintStringTo(s, os);
> -}
> -#endif // GTEST_HAS_GLOBAL_STRING
> -
> +// Overloads for ::std::string.
> GTEST_API_ void PrintStringTo(const ::std::string&s, ::std::ostream* os);
> inline void PrintTo(const ::std::string& s, ::std::ostream* os) {
> PrintStringTo(s, os);
> }
>
> -// Overloads for ::wstring and ::std::wstring.
> -#if GTEST_HAS_GLOBAL_WSTRING
> -GTEST_API_ void PrintWideStringTo(const ::wstring&s, ::std::ostream* os);
> -inline void PrintTo(const ::wstring& s, ::std::ostream* os) {
> - PrintWideStringTo(s, os);
> -}
> -#endif // GTEST_HAS_GLOBAL_WSTRING
> -
> +// Overloads for ::std::wstring.
> #if GTEST_HAS_STD_WSTRING
> GTEST_API_ void PrintWideStringTo(const ::std::wstring&s, ::std::ostream*
> os);
> inline void PrintTo(const ::std::wstring& s, ::std::ostream* os) {
> @@ -639,99 +611,38 @@ inline void PrintTo(absl::string_view sp,
> ::std::ostream* os) {
> }
> #endif // GTEST_HAS_ABSL
>
> -#if GTEST_LANG_CXX11
> inline void PrintTo(std::nullptr_t, ::std::ostream* os) { *os <<
> "(nullptr)"; }
> -#endif // GTEST_LANG_CXX11
>
> -#if GTEST_HAS_TR1_TUPLE || GTEST_HAS_STD_TUPLE_
> -// Helper function for printing a tuple. T must be instantiated with
> -// a tuple type.
> template <typename T>
> -void PrintTupleTo(const T& t, ::std::ostream* os);
> -#endif // GTEST_HAS_TR1_TUPLE || GTEST_HAS_STD_TUPLE_
> -
> -#if GTEST_HAS_TR1_TUPLE
> -// Overload for ::std::tr1::tuple. Needed for printing function
> arguments,
> -// which are packed as tuples.
> -
> -// Overloaded PrintTo() for tuples of various arities. We support
> -// tuples of up-to 10 fields. The following implementation works
> -// regardless of whether tr1::tuple is implemented using the
> -// non-standard variadic template feature or not.
> -
> -inline void PrintTo(const ::std::tr1::tuple<>& t, ::std::ostream* os) {
> - PrintTupleTo(t, os);
> -}
> -
> -template <typename T1>
> -void PrintTo(const ::std::tr1::tuple<T1>& t, ::std::ostream* os) {
> - PrintTupleTo(t, os);
> -}
> -
> -template <typename T1, typename T2>
> -void PrintTo(const ::std::tr1::tuple<T1, T2>& t, ::std::ostream* os) {
> - PrintTupleTo(t, os);
> -}
> -
> -template <typename T1, typename T2, typename T3>
> -void PrintTo(const ::std::tr1::tuple<T1, T2, T3>& t, ::std::ostream* os) {
> - PrintTupleTo(t, os);
> -}
> -
> -template <typename T1, typename T2, typename T3, typename T4>
> -void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4>& t, ::std::ostream*
> os) {
> - PrintTupleTo(t, os);
> -}
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5>
> -void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5>& t,
> - ::std::ostream* os) {
> - PrintTupleTo(t, os);
> -}
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6>
> -void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6>& t,
> - ::std::ostream* os) {
> - PrintTupleTo(t, os);
> -}
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7>
> -void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7>& t,
> - ::std::ostream* os) {
> - PrintTupleTo(t, os);
> -}
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8>
> -void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8>& t,
> - ::std::ostream* os) {
> - PrintTupleTo(t, os);
> +void PrintTo(std::reference_wrapper<T> ref, ::std::ostream* os) {
> + UniversalPrinter<T&>::Print(ref.get(), os);
> }
>
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9>
> -void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9>&
> t,
> - ::std::ostream* os) {
> - PrintTupleTo(t, os);
> -}
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename
> T10>
> -void PrintTo(
> - const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>& t,
> - ::std::ostream* os) {
> - PrintTupleTo(t, os);
> +// Helper function for printing a tuple. T must be instantiated with
> +// a tuple type.
> +template <typename T>
> +void PrintTupleTo(const T&, std::integral_constant<size_t, 0>,
> + ::std::ostream*) {}
> +
> +template <typename T, size_t I>
> +void PrintTupleTo(const T& t, std::integral_constant<size_t, I>,
> + ::std::ostream* os) {
> + PrintTupleTo(t, std::integral_constant<size_t, I - 1>(), os);
> + GTEST_INTENTIONAL_CONST_COND_PUSH_()
> + if (I > 1) {
> + GTEST_INTENTIONAL_CONST_COND_POP_()
> + *os << ", ";
> + }
> + UniversalPrinter<typename std::tuple_element<I - 1, T>::type>::Print(
> + std::get<I - 1>(t), os);
> }
> -#endif // GTEST_HAS_TR1_TUPLE
>
> -#if GTEST_HAS_STD_TUPLE_
> template <typename... Types>
> void PrintTo(const ::std::tuple<Types...>& t, ::std::ostream* os) {
> - PrintTupleTo(t, os);
> + *os << "(";
> + PrintTupleTo(t, std::integral_constant<size_t, sizeof...(Types)>(), os);
> + *os << ")";
> }
> -#endif // GTEST_HAS_STD_TUPLE_
>
> // Overload for std::pair.
> template <typename T1, typename T2>
> @@ -827,7 +738,6 @@ void UniversalPrintArray(const T* begin, size_t len,
> ::std::ostream* os) {
> // If the array has more than kThreshold elements, we'll have to
> // omit some details by printing only the first and the last
> // kChunkSize elements.
> - // FIXME: let the user control the threshold using a flag.
> if (len <= kThreshold) {
> PrintRawArrayTo(begin, len, os);
> } else {
> @@ -906,7 +816,7 @@ template <>
> class UniversalTersePrinter<const char*> {
> public:
> static void Print(const char* str, ::std::ostream* os) {
> - if (str == NULL) {
> + if (str == nullptr) {
> *os << "NULL";
> } else {
> UniversalPrint(std::string(str), os);
> @@ -926,7 +836,7 @@ template <>
> class UniversalTersePrinter<const wchar_t*> {
> public:
> static void Print(const wchar_t* str, ::std::ostream* os) {
> - if (str == NULL) {
> + if (str == nullptr) {
> *os << "NULL";
> } else {
> UniversalPrint(::std::wstring(str), os);
> @@ -962,109 +872,20 @@ void UniversalPrint(const T& value, ::std::ostream*
> os) {
>
> typedef ::std::vector< ::std::string> Strings;
>
> -// TuplePolicy<TupleT> must provide:
> -// - tuple_size
> -// size of tuple TupleT.
> -// - get<size_t I>(const TupleT& t)
> -// static function extracting element I of tuple TupleT.
> -// - tuple_element<size_t I>::type
> -// type of element I of tuple TupleT.
> -template <typename TupleT>
> -struct TuplePolicy;
> -
> -#if GTEST_HAS_TR1_TUPLE
> -template <typename TupleT>
> -struct TuplePolicy {
> - typedef TupleT Tuple;
> - static const size_t tuple_size = ::std::tr1::tuple_size<Tuple>::value;
> -
> - template <size_t I>
> - struct tuple_element : ::std::tr1::tuple_element<static_cast<int>(I),
> Tuple> {
> - };
> -
> - template <size_t I>
> - static typename AddReference<const typename ::std::tr1::tuple_element<
> - static_cast<int>(I), Tuple>::type>::type
> - get(const Tuple& tuple) {
> - return ::std::tr1::get<I>(tuple);
> - }
> -};
> -template <typename TupleT>
> -const size_t TuplePolicy<TupleT>::tuple_size;
> -#endif // GTEST_HAS_TR1_TUPLE
> -
> -#if GTEST_HAS_STD_TUPLE_
> -template <typename... Types>
> -struct TuplePolicy< ::std::tuple<Types...> > {
> - typedef ::std::tuple<Types...> Tuple;
> - static const size_t tuple_size = ::std::tuple_size<Tuple>::value;
> -
> - template <size_t I>
> - struct tuple_element : ::std::tuple_element<I, Tuple> {};
> -
> - template <size_t I>
> - static const typename ::std::tuple_element<I, Tuple>::type& get(
> - const Tuple& tuple) {
> - return ::std::get<I>(tuple);
> - }
> -};
> -template <typename... Types>
> -const size_t TuplePolicy< ::std::tuple<Types...> >::tuple_size;
> -#endif // GTEST_HAS_STD_TUPLE_
> -
> -#if GTEST_HAS_TR1_TUPLE || GTEST_HAS_STD_TUPLE_
> -// This helper template allows PrintTo() for tuples and
> -// UniversalTersePrintTupleFieldsToStrings() to be defined by
> -// induction on the number of tuple fields. The idea is that
> -// TuplePrefixPrinter<N>::PrintPrefixTo(t, os) prints the first N
> -// fields in tuple t, and can be defined in terms of
> -// TuplePrefixPrinter<N - 1>.
> -//
> -// The inductive case.
> -template <size_t N>
> -struct TuplePrefixPrinter {
> - // Prints the first N fields of a tuple.
> - template <typename Tuple>
> - static void PrintPrefixTo(const Tuple& t, ::std::ostream* os) {
> - TuplePrefixPrinter<N - 1>::PrintPrefixTo(t, os);
> - GTEST_INTENTIONAL_CONST_COND_PUSH_()
> - if (N > 1) {
> - GTEST_INTENTIONAL_CONST_COND_POP_()
> - *os << ", ";
> - }
> - UniversalPrinter<
> - typename TuplePolicy<Tuple>::template tuple_element<N - 1>::type>
> - ::Print(TuplePolicy<Tuple>::template get<N - 1>(t), os);
> - }
> -
> // Tersely prints the first N fields of a tuple to a string vector,
> // one element for each field.
> - template <typename Tuple>
> - static void TersePrintPrefixToStrings(const Tuple& t, Strings* strings)
> {
> - TuplePrefixPrinter<N - 1>::TersePrintPrefixToStrings(t, strings);
> - ::std::stringstream ss;
> - UniversalTersePrint(TuplePolicy<Tuple>::template get<N - 1>(t), &ss);
> - strings->push_back(ss.str());
> - }
> -};
> -
> -// Base case.
> -template <>
> -struct TuplePrefixPrinter<0> {
> - template <typename Tuple>
> - static void PrintPrefixTo(const Tuple&, ::std::ostream*) {}
> -
> - template <typename Tuple>
> - static void TersePrintPrefixToStrings(const Tuple&, Strings*) {}
> -};
> -
> -// Helper function for printing a tuple.
> -// Tuple must be either std::tr1::tuple or std::tuple type.
> template <typename Tuple>
> -void PrintTupleTo(const Tuple& t, ::std::ostream* os) {
> - *os << "(";
> - TuplePrefixPrinter<TuplePolicy<Tuple>::tuple_size>::PrintPrefixTo(t,
> os);
> - *os << ")";
> +void TersePrintPrefixToStrings(const Tuple&,
> std::integral_constant<size_t, 0>,
> + Strings*) {}
> +template <typename Tuple, size_t I>
> +void TersePrintPrefixToStrings(const Tuple& t,
> + std::integral_constant<size_t, I>,
> + Strings* strings) {
> + TersePrintPrefixToStrings(t, std::integral_constant<size_t, I - 1>(),
> + strings);
> + ::std::stringstream ss;
> + UniversalTersePrint(std::get<I - 1>(t), &ss);
> + strings->push_back(ss.str());
> }
>
> // Prints the fields of a tuple tersely to a string vector, one
> @@ -1073,11 +894,11 @@ void PrintTupleTo(const Tuple& t, ::std::ostream*
> os) {
> template <typename Tuple>
> Strings UniversalTersePrintTupleFieldsToStrings(const Tuple& value) {
> Strings result;
> - TuplePrefixPrinter<TuplePolicy<Tuple>::tuple_size>::
> - TersePrintPrefixToStrings(value, &result);
> + TersePrintPrefixToStrings(
> + value, std::integral_constant<size_t,
> std::tuple_size<Tuple>::value>(),
> + &result);
> return result;
> }
> -#endif // GTEST_HAS_TR1_TUPLE || GTEST_HAS_STD_TUPLE_
>
> } // namespace internal
>
>
> diff --git a/llvm/utils/unittest/googletest/include/gtest/gtest-spi.h
> b/llvm/utils/unittest/googletest/include/gtest/gtest-spi.h
> index 1e8983938ea27..aa38870e8e1c9 100644
> --- a/llvm/utils/unittest/googletest/include/gtest/gtest-spi.h
> +++ b/llvm/utils/unittest/googletest/include/gtest/gtest-spi.h
> @@ -72,14 +72,15 @@ class GTEST_API_ ScopedFakeTestPartResultReporter
> TestPartResultArray* result);
>
> // The d'tor restores the previous test part result reporter.
> - virtual ~ScopedFakeTestPartResultReporter();
> + ~ScopedFakeTestPartResultReporter() override;
>
> // Appends the TestPartResult object to the TestPartResultArray
> // received in the constructor.
> //
> // This method is from the TestPartResultReporterInterface
> // interface.
> - virtual void ReportTestPartResult(const TestPartResult& result);
> + void ReportTestPartResult(const TestPartResult& result) override;
> +
> private:
> void Init();
>
>
> diff --git
> a/llvm/utils/unittest/googletest/include/gtest/gtest-test-part.h
> b/llvm/utils/unittest/googletest/include/gtest/gtest-test-part.h
> index 1c7b89e08796d..05a79853586a9 100644
> --- a/llvm/utils/unittest/googletest/include/gtest/gtest-test-part.h
> +++ b/llvm/utils/unittest/googletest/include/gtest/gtest-test-part.h
> @@ -53,22 +53,20 @@ class GTEST_API_ TestPartResult {
> enum Type {
> kSuccess, // Succeeded.
> kNonFatalFailure, // Failed but the test can continue.
> - kFatalFailure // Failed and the test should be terminated.
> + kFatalFailure, // Failed and the test should be terminated.
> + kSkip // Skipped.
> };
>
> // C'tor. TestPartResult does NOT have a default constructor.
> // Always use this constructor (with parameters) to create a
> // TestPartResult object.
> - TestPartResult(Type a_type,
> - const char* a_file_name,
> - int a_line_number,
> + TestPartResult(Type a_type, const char* a_file_name, int a_line_number,
> const char* a_message)
> : type_(a_type),
> - file_name_(a_file_name == NULL ? "" : a_file_name),
> + file_name_(a_file_name == nullptr ? "" : a_file_name),
> line_number_(a_line_number),
> summary_(ExtractSummary(a_message)),
> - message_(a_message) {
> - }
> + message_(a_message) {}
>
> // Gets the outcome of the test part.
> Type type() const { return type_; }
> @@ -76,7 +74,7 @@ class GTEST_API_ TestPartResult {
> // Gets the name of the source file where the test part took place, or
> // NULL if it's unknown.
> const char* file_name() const {
> - return file_name_.empty() ? NULL : file_name_.c_str();
> + return file_name_.empty() ? nullptr : file_name_.c_str();
> }
>
> // Gets the line in the source file where the test part took place,
> @@ -89,18 +87,21 @@ class GTEST_API_ TestPartResult {
> // Gets the message associated with the test part.
> const char* message() const { return message_.c_str(); }
>
> - // Returns true iff the test part passed.
> - bool passed() const { return type_ == kSuccess; }
> + // Returns true if and only if the test part was skipped.
> + bool skipped() const { return type_ == kSkip; }
>
> - // Returns true iff the test part failed.
> - bool failed() const { return type_ != kSuccess; }
> + // Returns true if and only if the test part passed.
> + bool passed() const { return type_ == kSuccess; }
>
> - // Returns true iff the test part non-fatally failed.
> + // Returns true if and only if the test part non-fatally failed.
> bool nonfatally_failed() const { return type_ == kNonFatalFailure; }
>
> - // Returns true iff the test part fatally failed.
> + // Returns true if and only if the test part fatally failed.
> bool fatally_failed() const { return type_ == kFatalFailure; }
>
> + // Returns true if and only if the test part failed.
> + bool failed() const { return fatally_failed() || nonfatally_failed(); }
> +
> private:
> Type type_;
>
> @@ -164,8 +165,8 @@ class GTEST_API_ HasNewFatalFailureHelper
> : public TestPartResultReporterInterface {
> public:
> HasNewFatalFailureHelper();
> - virtual ~HasNewFatalFailureHelper();
> - virtual void ReportTestPartResult(const TestPartResult& result);
> + ~HasNewFatalFailureHelper() override;
> + void ReportTestPartResult(const TestPartResult& result) override;
> bool has_new_fatal_failure() const { return has_new_fatal_failure_; }
> private:
> bool has_new_fatal_failure_;
>
> diff --git
> a/llvm/utils/unittest/googletest/include/gtest/gtest-typed-test.h
> b/llvm/utils/unittest/googletest/include/gtest/gtest-typed-test.h
> index 74bce46bdc50f..095ce058022f8 100644
> --- a/llvm/utils/unittest/googletest/include/gtest/gtest-typed-test.h
> +++ b/llvm/utils/unittest/googletest/include/gtest/gtest-typed-test.h
> @@ -52,22 +52,22 @@ class FooTest : public testing::Test {
> T value_;
> };
>
> -// Next, associate a list of types with the test case, which will be
> +// Next, associate a list of types with the test suite, which will be
> // repeated for each type in the list. The typedef is necessary for
> // the macro to parse correctly.
> typedef testing::Types<char, int, unsigned int> MyTypes;
> -TYPED_TEST_CASE(FooTest, MyTypes);
> +TYPED_TEST_SUITE(FooTest, MyTypes);
>
> // If the type list contains only one type, you can write that type
> // directly without Types<...>:
> -// TYPED_TEST_CASE(FooTest, int);
> +// TYPED_TEST_SUITE(FooTest, int);
>
> // Then, use TYPED_TEST() instead of TEST_F() to define as many typed
> -// tests for this test case as you want.
> +// tests for this test suite as you want.
> TYPED_TEST(FooTest, DoesBlah) {
> - // Inside a test, refer to TypeParam to get the type parameter.
> - // Since we are inside a derived class template, C++ requires use to
> - // visit the members of FooTest via 'this'.
> + // Inside a test, refer to the special name TypeParam to get the type
> + // parameter. Since we are inside a derived class template, C++
> requires
> + // us to visit the members of FooTest via 'this'.
> TypeParam n = this->value_;
>
> // To visit static members of the fixture, add the TestFixture::
> @@ -83,7 +83,7 @@ TYPED_TEST(FooTest, DoesBlah) {
>
> TYPED_TEST(FooTest, HasPropertyA) { ... }
>
> -// TYPED_TEST_CASE takes an optional third argument which allows to
> specify a
> +// TYPED_TEST_SUITE takes an optional third argument which allows to
> specify a
> // class that generates custom test name suffixes based on the type. This
> should
> // be a class which has a static template function GetName(int index)
> returning
> // a string for each type. The provided integer index equals the index of
> the
> @@ -99,7 +99,7 @@ TYPED_TEST(FooTest, HasPropertyA) { ... }
> // if (std::is_same<T, unsigned int>()) return "unsignedInt";
> // }
> // };
> -// TYPED_TEST_CASE(FooTest, MyTypes, MyTypeNames);
> +// TYPED_TEST_SUITE(FooTest, MyTypes, MyTypeNames);
>
> #endif // 0
>
> @@ -126,13 +126,13 @@ class FooTest : public testing::Test {
> ...
> };
>
> -// Next, declare that you will define a type-parameterized test case
> +// Next, declare that you will define a type-parameterized test suite
> // (the _P suffix is for "parameterized" or "pattern", whichever you
> // prefer):
> -TYPED_TEST_CASE_P(FooTest);
> +TYPED_TEST_SUITE_P(FooTest);
>
> // Then, use TYPED_TEST_P() to define as many type-parameterized tests
> -// for this type-parameterized test case as you want.
> +// for this type-parameterized test suite as you want.
> TYPED_TEST_P(FooTest, DoesBlah) {
> // Inside a test, refer to TypeParam to get the type parameter.
> TypeParam n = 0;
> @@ -143,10 +143,10 @@ TYPED_TEST_P(FooTest, HasPropertyA) { ... }
>
> // Now the tricky part: you need to register all test patterns before
> // you can instantiate them. The first argument of the macro is the
> -// test case name; the rest are the names of the tests in this test
> +// test suite name; the rest are the names of the tests in this test
> // case.
> -REGISTER_TYPED_TEST_CASE_P(FooTest,
> - DoesBlah, HasPropertyA);
> +REGISTER_TYPED_TEST_SUITE_P(FooTest,
> + DoesBlah, HasPropertyA);
>
> // Finally, you are free to instantiate the pattern with the types you
> // want. If you put the above code in a header file, you can #include
> @@ -154,19 +154,19 @@ REGISTER_TYPED_TEST_CASE_P(FooTest,
> //
> // To distinguish
> diff erent instances of the pattern, the first
> // argument to the INSTANTIATE_* macro is a prefix that will be added
> -// to the actual test case name. Remember to pick unique prefixes for
> +// to the actual test suite name. Remember to pick unique prefixes for
> //
> diff erent instances.
> typedef testing::Types<char, int, unsigned int> MyTypes;
> -INSTANTIATE_TYPED_TEST_CASE_P(My, FooTest, MyTypes);
> +INSTANTIATE_TYPED_TEST_SUITE_P(My, FooTest, MyTypes);
>
> // If the type list contains only one type, you can write that type
> // directly without Types<...>:
> -// INSTANTIATE_TYPED_TEST_CASE_P(My, FooTest, int);
> +// INSTANTIATE_TYPED_TEST_SUITE_P(My, FooTest, int);
> //
> -// Similar to the optional argument of TYPED_TEST_CASE above,
> -// INSTANTIATE_TEST_CASE_P takes an optional fourth argument which allows
> to
> +// Similar to the optional argument of TYPED_TEST_SUITE above,
> +// INSTANTIATE_TEST_SUITE_P takes an optional fourth argument which
> allows to
> // generate custom names.
> -// INSTANTIATE_TYPED_TEST_CASE_P(My, FooTest, MyTypes, MyTypeNames);
> +// INSTANTIATE_TYPED_TEST_SUITE_P(My, FooTest, MyTypes, MyTypeNames);
>
> #endif // 0
>
> @@ -180,21 +180,18 @@ INSTANTIATE_TYPED_TEST_CASE_P(My, FooTest, MyTypes);
> // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
> //
> // Expands to the name of the typedef for the type parameters of the
> -// given test case.
> -# define GTEST_TYPE_PARAMS_(TestCaseName)
> gtest_type_params_##TestCaseName##_
> +// given test suite.
> +#define GTEST_TYPE_PARAMS_(TestSuiteName)
> gtest_type_params_##TestSuiteName##_
>
> // Expands to the name of the typedef for the NameGenerator, responsible
> for
> // creating the suffixes of the name.
> -#define GTEST_NAME_GENERATOR_(TestCaseName) \
> - gtest_type_params_##TestCaseName##_NameGenerator
> -
> -// The 'Types' template argument below must have spaces around it
> -// since some compilers may choke on '>>' when passing a template
> -// instance (e.g. Types<int>)
> -# define TYPED_TEST_CASE(CaseName, Types, ...)
> \
> - typedef ::testing::internal::TypeList< Types >::type
> GTEST_TYPE_PARAMS_( \
> - CaseName);
> \
> - typedef ::testing::internal::NameGeneratorSelector<__VA_ARGS__>::type
> \
> +#define GTEST_NAME_GENERATOR_(TestSuiteName) \
> + gtest_type_params_##TestSuiteName##_NameGenerator
> +
> +#define TYPED_TEST_SUITE(CaseName, Types, ...) \
> + typedef ::testing::internal::TypeList<Types>::type GTEST_TYPE_PARAMS_( \
> + CaseName); \
> + typedef ::testing::internal::NameGeneratorSelector<__VA_ARGS__>::type \
> GTEST_NAME_GENERATOR_(CaseName)
>
> # define TYPED_TEST(CaseName, TestName)
> \
> @@ -224,6 +221,13 @@ INSTANTIATE_TYPED_TEST_CASE_P(My, FooTest, MyTypes);
> void GTEST_TEST_CLASS_NAME_(CaseName,
> \
> TestName)<gtest_TypeParam_>::TestBody()
>
> +// Legacy API is deprecated but still available
> +#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
> +#define TYPED_TEST_CASE \
> + static_assert(::testing::internal::TypedTestCaseIsDeprecated(), ""); \
> + TYPED_TEST_SUITE
> +#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
> +
> #endif // GTEST_HAS_TYPED_TEST
>
> // Implements type-parameterized tests.
> @@ -233,73 +237,93 @@ INSTANTIATE_TYPED_TEST_CASE_P(My, FooTest, MyTypes);
> // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
> //
> // Expands to the namespace name that the type-parameterized tests for
> -// the given type-parameterized test case are defined in. The exact
> +// the given type-parameterized test suite are defined in. The exact
> // name of the namespace is subject to change without notice.
> -# define GTEST_CASE_NAMESPACE_(TestCaseName) \
> - gtest_case_##TestCaseName##_
> +#define GTEST_SUITE_NAMESPACE_(TestSuiteName)
> gtest_suite_##TestSuiteName##_
>
> // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
> //
> // Expands to the name of the variable used to remember the names of
> -// the defined tests in the given test case.
> -# define GTEST_TYPED_TEST_CASE_P_STATE_(TestCaseName) \
> - gtest_typed_test_case_p_state_##TestCaseName##_
> +// the defined tests in the given test suite.
> +#define GTEST_TYPED_TEST_SUITE_P_STATE_(TestSuiteName) \
> + gtest_typed_test_suite_p_state_##TestSuiteName##_
>
> // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE DIRECTLY.
> //
> // Expands to the name of the variable used to remember the names of
> -// the registered tests in the given test case.
> -# define GTEST_REGISTERED_TEST_NAMES_(TestCaseName) \
> - gtest_registered_test_names_##TestCaseName##_
> +// the registered tests in the given test suite.
> +#define GTEST_REGISTERED_TEST_NAMES_(TestSuiteName) \
> + gtest_registered_test_names_##TestSuiteName##_
>
> // The variables defined in the type-parameterized test macros are
> // static as typically these macros are used in a .h file that can be
> // #included in multiple translation units linked together.
> -# define TYPED_TEST_CASE_P(CaseName) \
> - static ::testing::internal::TypedTestCasePState \
> - GTEST_TYPED_TEST_CASE_P_STATE_(CaseName)
> -
> -# define TYPED_TEST_P(CaseName, TestName) \
> - namespace GTEST_CASE_NAMESPACE_(CaseName) { \
> - template <typename gtest_TypeParam_> \
> - class TestName : public CaseName<gtest_TypeParam_> { \
> - private: \
> - typedef CaseName<gtest_TypeParam_> TestFixture; \
> - typedef gtest_TypeParam_ TypeParam; \
> - virtual void TestBody(); \
> - }; \
> - static bool gtest_##TestName##_defined_ GTEST_ATTRIBUTE_UNUSED_ = \
> - GTEST_TYPED_TEST_CASE_P_STATE_(CaseName).AddTestName(\
> - __FILE__, __LINE__, #CaseName, #TestName); \
> - } \
> - template <typename gtest_TypeParam_> \
> - void
> GTEST_CASE_NAMESPACE_(CaseName)::TestName<gtest_TypeParam_>::TestBody()
> -
> -# define REGISTER_TYPED_TEST_CASE_P(CaseName, ...) \
> - namespace GTEST_CASE_NAMESPACE_(CaseName) { \
> - typedef ::testing::internal::Templates<__VA_ARGS__>::type
> gtest_AllTests_; \
> - } \
> - static const char* const GTEST_REGISTERED_TEST_NAMES_(CaseName) \
> - GTEST_ATTRIBUTE_UNUSED_ = \
> -
> GTEST_TYPED_TEST_CASE_P_STATE_(CaseName).VerifyRegisteredTestNames( \
> - __FILE__, __LINE__, #__VA_ARGS__)
> -
> -// The 'Types' template argument below must have spaces around it
> -// since some compilers may choke on '>>' when passing a template
> -// instance (e.g. Types<int>)
> -# define INSTANTIATE_TYPED_TEST_CASE_P(Prefix, CaseName, Types, ...)
> \
> - static bool gtest_##Prefix##_##CaseName GTEST_ATTRIBUTE_UNUSED_ =
> \
> - ::testing::internal::TypeParameterizedTestCase<
> \
> - CaseName, GTEST_CASE_NAMESPACE_(CaseName)::gtest_AllTests_,
> \
> - ::testing::internal::TypeList< Types >::type>::
> \
> - Register(#Prefix,
> \
> - ::testing::internal::CodeLocation(__FILE__, __LINE__),
> \
> - >EST_TYPED_TEST_CASE_P_STATE_(CaseName), #CaseName,
> \
> - GTEST_REGISTERED_TEST_NAMES_(CaseName),
> \
> - ::testing::internal::GenerateNames<
> \
> - ::testing::internal::NameGeneratorSelector<
> \
> - __VA_ARGS__>::type,
> \
> - ::testing::internal::TypeList< Types >::type>())
> +#define TYPED_TEST_SUITE_P(SuiteName) \
> + static ::testing::internal::TypedTestSuitePState \
> + GTEST_TYPED_TEST_SUITE_P_STATE_(SuiteName)
> +
> +// Legacy API is deprecated but still available
> +#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
> +#define TYPED_TEST_CASE_P
> \
> + static_assert(::testing::internal::TypedTestCase_P_IsDeprecated(), "");
> \
> + TYPED_TEST_SUITE_P
> +#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
> +
> +#define TYPED_TEST_P(SuiteName, TestName) \
> + namespace GTEST_SUITE_NAMESPACE_(SuiteName) { \
> + template <typename gtest_TypeParam_> \
> + class TestName : public SuiteName<gtest_TypeParam_> { \
> + private: \
> + typedef SuiteName<gtest_TypeParam_> TestFixture; \
> + typedef gtest_TypeParam_ TypeParam; \
> + virtual void TestBody(); \
> + }; \
> + static bool gtest_##TestName##_defined_ GTEST_ATTRIBUTE_UNUSED_ = \
> + GTEST_TYPED_TEST_SUITE_P_STATE_(SuiteName).AddTestName( \
> + __FILE__, __LINE__, #SuiteName, #TestName); \
> + } \
> + template <typename gtest_TypeParam_> \
> + void GTEST_SUITE_NAMESPACE_( \
> + SuiteName)::TestName<gtest_TypeParam_>::TestBody()
> +
> +#define REGISTER_TYPED_TEST_SUITE_P(SuiteName, ...)
> \
> + namespace GTEST_SUITE_NAMESPACE_(SuiteName) {
> \
> + typedef ::testing::internal::Templates<__VA_ARGS__>::type
> gtest_AllTests_; \
> + }
> \
> + static const char* const GTEST_REGISTERED_TEST_NAMES_(
> \
> + SuiteName) GTEST_ATTRIBUTE_UNUSED_ =
> \
> +
> GTEST_TYPED_TEST_SUITE_P_STATE_(SuiteName).VerifyRegisteredTestNames( \
> + __FILE__, __LINE__, #__VA_ARGS__)
> +
> +// Legacy API is deprecated but still available
> +#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
> +#define REGISTER_TYPED_TEST_CASE_P
> \
> +
> static_assert(::testing::internal::RegisterTypedTestCase_P_IsDeprecated(), \
> + "");
> \
> + REGISTER_TYPED_TEST_SUITE_P
> +#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
> +
> +#define INSTANTIATE_TYPED_TEST_SUITE_P(Prefix, SuiteName, Types, ...)
> \
> + static bool gtest_##Prefix##_##SuiteName GTEST_ATTRIBUTE_UNUSED_ =
> \
> + ::testing::internal::TypeParameterizedTestSuite<
> \
> + SuiteName, GTEST_SUITE_NAMESPACE_(SuiteName)::gtest_AllTests_,
> \
> + ::testing::internal::TypeList<Types>::type>::
> \
> + Register(#Prefix,
> \
> + ::testing::internal::CodeLocation(__FILE__,
> __LINE__), \
> + >EST_TYPED_TEST_SUITE_P_STATE_(SuiteName),
> #SuiteName, \
> + GTEST_REGISTERED_TEST_NAMES_(SuiteName),
> \
> + ::testing::internal::GenerateNames<
> \
> + ::testing::internal::NameGeneratorSelector<
> \
> + __VA_ARGS__>::type,
> \
> + ::testing::internal::TypeList<Types>::type>())
> +
> +// Legacy API is deprecated but still available
> +#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
> +#define INSTANTIATE_TYPED_TEST_CASE_P
> \
> + static_assert(
> \
> + ::testing::internal::InstantiateTypedTestCase_P_IsDeprecated(),
> ""); \
> + INSTANTIATE_TYPED_TEST_SUITE_P
> +#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
>
> #endif // GTEST_HAS_TYPED_TEST_P
>
>
> diff --git a/llvm/utils/unittest/googletest/include/gtest/gtest.h
> b/llvm/utils/unittest/googletest/include/gtest/gtest.h
> index 5df4b0a3a7127..dbe5b1c2c3f64 100644
> --- a/llvm/utils/unittest/googletest/include/gtest/gtest.h
> +++ b/llvm/utils/unittest/googletest/include/gtest/gtest.h
> @@ -52,13 +52,17 @@
> #ifndef GTEST_INCLUDE_GTEST_GTEST_H_
> #define GTEST_INCLUDE_GTEST_GTEST_H_
>
> +#include <cstddef>
> #include <limits>
> +#include <memory>
> #include <ostream>
> +#include <type_traits>
> #include <vector>
>
> #include "gtest/internal/gtest-internal.h"
> #include "gtest/internal/gtest-string.h"
> #include "gtest/gtest-death-test.h"
> +#include "gtest/gtest-matchers.h"
> #include "gtest/gtest-message.h"
> #include "gtest/gtest-param-test.h"
> #include "gtest/gtest-printers.h"
> @@ -69,21 +73,6 @@
> GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
> /* class A needs to have dll-interface to be used by clients of class B
> */)
>
> -// Depending on the platform,
> diff erent string classes are available.
> -// On Linux, in addition to ::std::string, Google also makes use of
> -// class ::string, which has the same interface as ::std::string, but
> -// has a
> diff erent implementation.
> -//
> -// You can define GTEST_HAS_GLOBAL_STRING to 1 to indicate that
> -// ::string is available AND is a distinct type to ::std::string, or
> -// define it to 0 to indicate otherwise.
> -//
> -// If ::std::string and ::string are the same class on your platform
> -// due to aliasing, you should define GTEST_HAS_GLOBAL_STRING to 0.
> -//
> -// If you do not define GTEST_HAS_GLOBAL_STRING, it is defined
> -// heuristically.
> -
> namespace testing {
>
> // Silence C4100 (unreferenced formal parameter) and 4805
> @@ -195,7 +184,12 @@ void
> ReportFailureInUnknownLocation(TestPartResult::Type result_type,
> // If we don't forward declare them the compiler might confuse the classes
> // in friendship clauses with same named classes on the scope.
> class Test;
> -class TestCase;
> +class TestSuite;
> +
> +// Old API is still available but deprecated
> +#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
> +using TestCase = TestSuite;
> +#endif
> class TestInfo;
> class UnitTest;
>
> @@ -298,9 +292,10 @@ class GTEST_API_ AssertionResult {
> template <typename T>
> explicit AssertionResult(
> const T& success,
> - typename internal::EnableIf<
> - !internal::ImplicitlyConvertible<T,
> AssertionResult>::value>::type*
> - /*enabler*/ = NULL)
> + typename std::enable_if<
> + !std::is_convertible<T, AssertionResult>::value>::type*
> + /*enabler*/
> + = nullptr)
> : success_(success) {}
>
> #if defined(_MSC_VER) && _MSC_VER < 1910
> @@ -313,7 +308,7 @@ class GTEST_API_ AssertionResult {
> return *this;
> }
>
> - // Returns true iff the assertion succeeded.
> + // Returns true if and only if the assertion succeeded.
> operator bool() const { return success_; } // NOLINT
>
> // Returns the assertion's negation. Used with EXPECT/ASSERT_FALSE.
> @@ -324,9 +319,8 @@ class GTEST_API_ AssertionResult {
> // assertion's expectation). When nothing has been streamed into the
> // object, returns an empty string.
> const char* message() const {
> - return message_.get() != NULL ? message_->c_str() : "";
> + return message_.get() != nullptr ? message_->c_str() : "";
> }
> - // FIXME: Remove this after making sure no clients use it.
> // Deprecated; please use message() instead.
> const char* failure_message() const { return message(); }
>
> @@ -347,8 +341,7 @@ class GTEST_API_ AssertionResult {
> private:
> // Appends the contents of message to message_.
> void AppendMessage(const Message& a_message) {
> - if (message_.get() == NULL)
> - message_.reset(new ::std::string);
> + if (message_.get() == nullptr) message_.reset(new ::std::string);
> message_->append(a_message.GetString().c_str());
> }
>
> @@ -361,7 +354,7 @@ class GTEST_API_ AssertionResult {
> // construct is not satisfied with the predicate's outcome.
> // Referenced via a pointer to avoid taking too much stack frame space
> // with test assertions.
> - internal::scoped_ptr< ::std::string> message_;
> + std::unique_ptr< ::std::string> message_;
> };
>
> // Makes a successful assertion result.
> @@ -385,8 +378,8 @@ namespace testing {
>
> // The abstract class that all tests inherit from.
> //
> -// In Google Test, a unit test program contains one or many TestCases, and
> -// each TestCase contains one or many Tests.
> +// In Google Test, a unit test program contains one or many TestSuites,
> and
> +// each TestSuite contains one or many Tests.
> //
> // When you define a test using the TEST macro, you don't need to
> // explicitly derive from Test - the TEST macro automatically does
> @@ -410,49 +403,57 @@ class GTEST_API_ Test {
> public:
> friend class TestInfo;
>
> - // Defines types for pointers to functions that set up and tear down
> - // a test case.
> - typedef internal::SetUpTestCaseFunc SetUpTestCaseFunc;
> - typedef internal::TearDownTestCaseFunc TearDownTestCaseFunc;
> -
> // The d'tor is virtual as we intend to inherit from Test.
> virtual ~Test();
>
> // Sets up the stuff shared by all tests in this test case.
> //
> - // Google Test will call Foo::SetUpTestCase() before running the first
> + // Google Test will call Foo::SetUpTestSuite() before running the first
> // test in test case Foo. Hence a sub-class can define its own
> - // SetUpTestCase() method to shadow the one defined in the super
> + // SetUpTestSuite() method to shadow the one defined in the super
> // class.
> - static void SetUpTestCase() {}
> + // Failures that happen during SetUpTestSuite are logged but otherwise
> + // ignored.
> + static void SetUpTestSuite() {}
>
> - // Tears down the stuff shared by all tests in this test case.
> + // Tears down the stuff shared by all tests in this test suite.
> //
> - // Google Test will call Foo::TearDownTestCase() after running the last
> + // Google Test will call Foo::TearDownTestSuite() after running the last
> // test in test case Foo. Hence a sub-class can define its own
> - // TearDownTestCase() method to shadow the one defined in the super
> + // TearDownTestSuite() method to shadow the one defined in the super
> // class.
> + // Failures that happen during TearDownTestSuite are logged but
> otherwise
> + // ignored.
> + static void TearDownTestSuite() {}
> +
> + // Legacy API is deprecated but still available
> +#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
> static void TearDownTestCase() {}
> + static void SetUpTestCase() {}
> +#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
>
> - // Returns true iff the current test has a fatal failure.
> + // Returns true if and only if the current test has a fatal failure.
> static bool HasFatalFailure();
>
> - // Returns true iff the current test has a non-fatal failure.
> + // Returns true if and only if the current test has a non-fatal failure.
> static bool HasNonfatalFailure();
>
> - // Returns true iff the current test has a (either fatal or
> + // Returns true if and only if the current test was skipped.
> + static bool IsSkipped();
> +
> + // Returns true if and only if the current test has a (either fatal or
> // non-fatal) failure.
> static bool HasFailure() { return HasFatalFailure() ||
> HasNonfatalFailure(); }
>
> - // Logs a property for the current test, test case, or for the entire
> + // Logs a property for the current test, test suite, or for the entire
> // invocation of the test program when used outside of the context of a
> - // test case. Only the last value for a given key is remembered. These
> + // test suite. Only the last value for a given key is remembered.
> These
> // are public static so they can be called from utility functions that
> are
> // not members of the test fixture. Calls to RecordProperty made during
> // lifespan of the test (from the moment its constructor starts to the
> // moment its destructor finishes) will be output in XML as attributes
> of
> // the <testcase> element. Properties recorded from fixture's
> - // SetUpTestCase or TearDownTestCase are logged as attributes of the
> + // SetUpTestSuite or TearDownTestSuite are logged as attributes of the
> // corresponding <testsuite> element. Calls to RecordProperty made in
> the
> // global context (before or after invocation of RUN_ALL_TESTS and from
> // SetUp/TearDown method of Environment objects registered with Google
> @@ -471,8 +472,8 @@ class GTEST_API_ Test {
> virtual void TearDown();
>
> private:
> - // Returns true iff the current test has the same fixture class as
> - // the first test in the current test case.
> + // Returns true if and only if the current test has the same fixture
> class
> + // as the first test in the current test suite.
> static bool HasSameFixtureClass();
>
> // Runs the test after the test fixture has been set up.
> @@ -490,7 +491,7 @@ class GTEST_API_ Test {
> // internal method to avoid clashing with names used in user TESTs.
> void DeleteSelf_() { delete this; }
>
> - const internal::scoped_ptr< GTEST_FLAG_SAVER_ > gtest_flag_saver_;
> + const std::unique_ptr<GTEST_FLAG_SAVER_> gtest_flag_saver_;
>
> // Often a user misspells SetUp() as Setup() and spends a long time
> // wondering why it is never called by Google Test. The declaration of
> @@ -509,7 +510,7 @@ class GTEST_API_ Test {
> // If you see an error about overriding the following function or
> // about it being private, you have mis-spelled SetUp() as Setup().
> struct Setup_should_be_spelled_SetUp {};
> - virtual Setup_should_be_spelled_SetUp* Setup() { return NULL; }
> + virtual Setup_should_be_spelled_SetUp* Setup() { return nullptr; }
>
> // We disallow copying Tests.
> GTEST_DISALLOW_COPY_AND_ASSIGN_(Test);
> @@ -573,21 +574,28 @@ class GTEST_API_ TestResult {
> // Returns the number of the test properties.
> int test_property_count() const;
>
> - // Returns true iff the test passed (i.e. no test part failed).
> - bool Passed() const { return !Failed(); }
> + // Returns true if and only if the test passed (i.e. no test part
> failed).
> + bool Passed() const { return !Skipped() && !Failed(); }
> +
> + // Returns true if and only if the test was skipped.
> + bool Skipped() const;
>
> - // Returns true iff the test failed.
> + // Returns true if and only if the test failed.
> bool Failed() const;
>
> - // Returns true iff the test fatally failed.
> + // Returns true if and only if the test fatally failed.
> bool HasFatalFailure() const;
>
> - // Returns true iff the test has a non-fatal failure.
> + // Returns true if and only if the test has a non-fatal failure.
> bool HasNonfatalFailure() const;
>
> // Returns the elapsed time, in milliseconds.
> TimeInMillis elapsed_time() const { return elapsed_time_; }
>
> + // Gets the time of the test case start, in ms from the start of the
> + // UNIX epoch.
> + TimeInMillis start_timestamp() const { return start_timestamp_; }
> +
> // Returns the i-th test part result among all the results. i can range
> from 0
> // to total_part_count() - 1. If i is not in that range, aborts the
> program.
> const TestPartResult& GetTestPartResult(int i) const;
> @@ -599,7 +607,7 @@ class GTEST_API_ TestResult {
>
> private:
> friend class TestInfo;
> - friend class TestCase;
> + friend class TestSuite;
> friend class UnitTest;
> friend class internal::DefaultGlobalTestPartResultReporter;
> friend class internal::ExecDeathTest;
> @@ -618,6 +626,9 @@ class GTEST_API_ TestResult {
> return test_properties_;
> }
>
> + // Sets the start time.
> + void set_start_timestamp(TimeInMillis start) { start_timestamp_ =
> start; }
> +
> // Sets the elapsed time.
> void set_elapsed_time(TimeInMillis elapsed) { elapsed_time_ = elapsed; }
>
> @@ -631,7 +642,7 @@ class GTEST_API_ TestResult {
> const TestProperty& test_property);
>
> // Adds a failure if the key is a reserved attribute of Google Test
> - // testcase tags. Returns true if the property is valid.
> + // testsuite tags. Returns true if the property is valid.
> // FIXME: Validate attribute names are legal and human readable.
> static bool ValidateTestProperty(const std::string& xml_element,
> const TestProperty& test_property);
> @@ -661,6 +672,8 @@ class GTEST_API_ TestResult {
> std::vector<TestProperty> test_properties_;
> // Running count of death tests.
> int death_test_count_;
> + // The start time, in milliseconds since UNIX Epoch.
> + TimeInMillis start_timestamp_;
> // The elapsed time, in milliseconds.
> TimeInMillis elapsed_time_;
>
> @@ -670,7 +683,7 @@ class GTEST_API_ TestResult {
>
> // A TestInfo object stores the following information about a test:
> //
> -// Test case name
> +// Test suite name
> // Test name
> // Whether the test should be run
> // A function pointer that creates the test object when invoked
> @@ -685,8 +698,13 @@ class GTEST_API_ TestInfo {
> // don't inherit from TestInfo.
> ~TestInfo();
>
> - // Returns the test case name.
> - const char* test_case_name() const { return test_case_name_.c_str(); }
> + // Returns the test suite name.
> + const char* test_suite_name() const { return test_suite_name_.c_str(); }
> +
> +// Legacy API is deprecated but still available
> +#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
> + const char* test_case_name() const { return test_suite_name(); }
> +#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
>
> // Returns the test name.
> const char* name() const { return name_.c_str(); }
> @@ -694,17 +712,15 @@ class GTEST_API_ TestInfo {
> // Returns the name of the parameter type, or NULL if this is not a
> typed
> // or a type-parameterized test.
> const char* type_param() const {
> - if (type_param_.get() != NULL)
> - return type_param_->c_str();
> - return NULL;
> + if (type_param_.get() != nullptr) return type_param_->c_str();
> + return nullptr;
> }
>
> // Returns the text representation of the value parameter, or NULL if
> this
> // is not a value-parameterized test.
> const char* value_param() const {
> - if (value_param_.get() != NULL)
> - return value_param_->c_str();
> - return NULL;
> + if (value_param_.get() != nullptr) return value_param_->c_str();
> + return nullptr;
> }
>
> // Returns the file name where this test is defined.
> @@ -721,7 +737,7 @@ class GTEST_API_ TestInfo {
> // been specified) and its full name matches the user-specified filter.
> //
> // Google Test allows the user to filter the tests by their full names.
> - // The full name of a test Bar in test case Foo is defined as
> + // The full name of a test Bar in test suite Foo is defined as
> // "Foo.Bar". Only the tests that match the filter will run.
> //
> // A filter is a colon-separated list of glob (not regex) patterns,
> @@ -734,7 +750,7 @@ class GTEST_API_ TestInfo {
> // contains the character 'A' or starts with "Foo.".
> bool should_run() const { return should_run_; }
>
> - // Returns true iff this test will appear in the XML report.
> + // Returns true if and only if this test will appear in the XML report.
> bool is_reportable() const {
> // The XML report includes tests matching the filter, excluding those
> // run in other shards.
> @@ -749,24 +765,19 @@ class GTEST_API_ TestInfo {
> friend class internal::DefaultDeathTestFactory;
> #endif // GTEST_HAS_DEATH_TEST
> friend class Test;
> - friend class TestCase;
> + friend class TestSuite;
> friend class internal::UnitTestImpl;
> friend class internal::StreamingListenerTest;
> friend TestInfo* internal::MakeAndRegisterTestInfo(
> - const char* test_case_name,
> - const char* name,
> - const char* type_param,
> - const char* value_param,
> - internal::CodeLocation code_location,
> - internal::TypeId fixture_class_id,
> - Test::SetUpTestCaseFunc set_up_tc,
> - Test::TearDownTestCaseFunc tear_down_tc,
> + const char* test_suite_name, const char* name, const char*
> type_param,
> + const char* value_param, internal::CodeLocation code_location,
> + internal::TypeId fixture_class_id, internal::SetUpTestSuiteFunc
> set_up_tc,
> + internal::TearDownTestSuiteFunc tear_down_tc,
> internal::TestFactoryBase* factory);
>
> // Constructs a TestInfo object. The newly constructed instance assumes
> // ownership of the factory object.
> - TestInfo(const std::string& test_case_name,
> - const std::string& name,
> + TestInfo(const std::string& test_suite_name, const std::string& name,
> const char* a_type_param, // NULL if not a
> type-parameterized test
> const char* a_value_param, // NULL if not a
> value-parameterized test
> internal::CodeLocation a_code_location,
> @@ -788,21 +799,21 @@ class GTEST_API_ TestInfo {
> }
>
> // These fields are immutable properties of the test.
> - const std::string test_case_name_; // Test case name
> + const std::string test_suite_name_; // test suite name
> const std::string name_; // Test name
> // Name of the parameter type, or NULL if this is not a typed or a
> // type-parameterized test.
> - const internal::scoped_ptr<const ::std::string> type_param_;
> + const std::unique_ptr<const ::std::string> type_param_;
> // Text representation of the value parameter, or NULL if this is not a
> // value-parameterized test.
> - const internal::scoped_ptr<const ::std::string> value_param_;
> + const std::unique_ptr<const ::std::string> value_param_;
> internal::CodeLocation location_;
> - const internal::TypeId fixture_class_id_; // ID of the test fixture
> class
> - bool should_run_; // True iff this test should run
> - bool is_disabled_; // True iff this test is disabled
> - bool matches_filter_; // True if this test matches the
> - // user-specified filter.
> - bool is_in_another_shard_; // Will be run in another shard.
> + const internal::TypeId fixture_class_id_; // ID of the test fixture
> class
> + bool should_run_; // True if and only if this test should run
> + bool is_disabled_; // True if and only if this test is disabled
> + bool matches_filter_; // True if this test matches the
> + // user-specified filter.
> + bool is_in_another_shard_; // Will be run in another shard.
> internal::TestFactoryBase* const factory_; // The factory that creates
> // the test object
>
> @@ -813,90 +824,96 @@ class GTEST_API_ TestInfo {
> GTEST_DISALLOW_COPY_AND_ASSIGN_(TestInfo);
> };
>
> -// A test case, which consists of a vector of TestInfos.
> +// A test suite, which consists of a vector of TestInfos.
> //
> -// TestCase is not copyable.
> -class GTEST_API_ TestCase {
> +// TestSuite is not copyable.
> +class GTEST_API_ TestSuite {
> public:
> - // Creates a TestCase with the given name.
> + // Creates a TestSuite with the given name.
> //
> - // TestCase does NOT have a default constructor. Always use this
> - // constructor to create a TestCase object.
> + // TestSuite does NOT have a default constructor. Always use this
> + // constructor to create a TestSuite object.
> //
> // Arguments:
> //
> - // name: name of the test case
> + // name: name of the test suite
> // a_type_param: the name of the test's type parameter, or NULL if
> // this is not a type-parameterized test.
> - // set_up_tc: pointer to the function that sets up the test case
> - // tear_down_tc: pointer to the function that tears down the test case
> - TestCase(const char* name, const char* a_type_param,
> - Test::SetUpTestCaseFunc set_up_tc,
> - Test::TearDownTestCaseFunc tear_down_tc);
> + // set_up_tc: pointer to the function that sets up the test suite
> + // tear_down_tc: pointer to the function that tears down the test
> suite
> + TestSuite(const char* name, const char* a_type_param,
> + internal::SetUpTestSuiteFunc set_up_tc,
> + internal::TearDownTestSuiteFunc tear_down_tc);
>
> - // Destructor of TestCase.
> - virtual ~TestCase();
> + // Destructor of TestSuite.
> + virtual ~TestSuite();
>
> - // Gets the name of the TestCase.
> + // Gets the name of the TestSuite.
> const char* name() const { return name_.c_str(); }
>
> // Returns the name of the parameter type, or NULL if this is not a
> - // type-parameterized test case.
> + // type-parameterized test suite.
> const char* type_param() const {
> - if (type_param_.get() != NULL)
> - return type_param_->c_str();
> - return NULL;
> + if (type_param_.get() != nullptr) return type_param_->c_str();
> + return nullptr;
> }
>
> - // Returns true if any test in this test case should run.
> + // Returns true if any test in this test suite should run.
> bool should_run() const { return should_run_; }
>
> - // Gets the number of successful tests in this test case.
> + // Gets the number of successful tests in this test suite.
> int successful_test_count() const;
>
> - // Gets the number of failed tests in this test case.
> + // Gets the number of skipped tests in this test suite.
> + int skipped_test_count() const;
> +
> + // Gets the number of failed tests in this test suite.
> int failed_test_count() const;
>
> // Gets the number of disabled tests that will be reported in the XML
> report.
> int reportable_disabled_test_count() const;
>
> - // Gets the number of disabled tests in this test case.
> + // Gets the number of disabled tests in this test suite.
> int disabled_test_count() const;
>
> // Gets the number of tests to be printed in the XML report.
> int reportable_test_count() const;
>
> - // Get the number of tests in this test case that should run.
> + // Get the number of tests in this test suite that should run.
> int test_to_run_count() const;
>
> - // Gets the number of all tests in this test case.
> + // Gets the number of all tests in this test suite.
> int total_test_count() const;
>
> - // Returns true iff the test case passed.
> + // Returns true if and only if the test suite passed.
> bool Passed() const { return !Failed(); }
>
> - // Returns true iff the test case failed.
> + // Returns true if and only if the test suite failed.
> bool Failed() const { return failed_test_count() > 0; }
>
> // Returns the elapsed time, in milliseconds.
> TimeInMillis elapsed_time() const { return elapsed_time_; }
>
> + // Gets the time of the test suite start, in ms from the start of the
> + // UNIX epoch.
> + TimeInMillis start_timestamp() const { return start_timestamp_; }
> +
> // Returns the i-th test among all the tests. i can range from 0 to
> // total_test_count() - 1. If i is not in that range, returns NULL.
> const TestInfo* GetTestInfo(int i) const;
>
> // Returns the TestResult that holds test properties recorded during
> - // execution of SetUpTestCase and TearDownTestCase.
> + // execution of SetUpTestSuite and TearDownTestSuite.
> const TestResult& ad_hoc_test_result() const { return
> ad_hoc_test_result_; }
>
> private:
> friend class Test;
> friend class internal::UnitTestImpl;
>
> - // Gets the (mutable) vector of TestInfos in this TestCase.
> + // Gets the (mutable) vector of TestInfos in this TestSuite.
> std::vector<TestInfo*>& test_info_list() { return test_info_list_; }
>
> - // Gets the (immutable) vector of TestInfos in this TestCase.
> + // Gets the (immutable) vector of TestInfos in this TestSuite.
> const std::vector<TestInfo*>& test_info_list() const {
> return test_info_list_;
> }
> @@ -908,51 +925,64 @@ class GTEST_API_ TestCase {
> // Sets the should_run member.
> void set_should_run(bool should) { should_run_ = should; }
>
> - // Adds a TestInfo to this test case. Will delete the TestInfo upon
> - // destruction of the TestCase object.
> + // Adds a TestInfo to this test suite. Will delete the TestInfo upon
> + // destruction of the TestSuite object.
> void AddTestInfo(TestInfo * test_info);
>
> - // Clears the results of all tests in this test case.
> + // Clears the results of all tests in this test suite.
> void ClearResult();
>
> - // Clears the results of all tests in the given test case.
> - static void ClearTestCaseResult(TestCase* test_case) {
> - test_case->ClearResult();
> + // Clears the results of all tests in the given test suite.
> + static void ClearTestSuiteResult(TestSuite* test_suite) {
> + test_suite->ClearResult();
> }
>
> - // Runs every test in this TestCase.
> + // Runs every test in this TestSuite.
> void Run();
>
> - // Runs SetUpTestCase() for this TestCase. This wrapper is needed
> - // for catching exceptions thrown from SetUpTestCase().
> - void RunSetUpTestCase() { (*set_up_tc_)(); }
> + // Runs SetUpTestSuite() for this TestSuite. This wrapper is needed
> + // for catching exceptions thrown from SetUpTestSuite().
> + void RunSetUpTestSuite() {
> + if (set_up_tc_ != nullptr) {
> + (*set_up_tc_)();
> + }
> + }
>
> - // Runs TearDownTestCase() for this TestCase. This wrapper is
> - // needed for catching exceptions thrown from TearDownTestCase().
> - void RunTearDownTestCase() { (*tear_down_tc_)(); }
> + // Runs TearDownTestSuite() for this TestSuite. This wrapper is
> + // needed for catching exceptions thrown from TearDownTestSuite().
> + void RunTearDownTestSuite() {
> + if (tear_down_tc_ != nullptr) {
> + (*tear_down_tc_)();
> + }
> + }
>
> - // Returns true iff test passed.
> + // Returns true if and only if test passed.
> static bool TestPassed(const TestInfo* test_info) {
> return test_info->should_run() && test_info->result()->Passed();
> }
>
> - // Returns true iff test failed.
> + // Returns true if and only if test skipped.
> + static bool TestSkipped(const TestInfo* test_info) {
> + return test_info->should_run() && test_info->result()->Skipped();
> + }
> +
> + // Returns true if and only if test failed.
> static bool TestFailed(const TestInfo* test_info) {
> return test_info->should_run() && test_info->result()->Failed();
> }
>
> - // Returns true iff the test is disabled and will be reported in the XML
> - // report.
> + // Returns true if and only if the test is disabled and will be
> reported in
> + // the XML report.
> static bool TestReportableDisabled(const TestInfo* test_info) {
> return test_info->is_reportable() && test_info->is_disabled_;
> }
>
> - // Returns true iff test is disabled.
> + // Returns true if and only if test is disabled.
> static bool TestDisabled(const TestInfo* test_info) {
> return test_info->is_disabled_;
> }
>
> - // Returns true iff this test will appear in the XML report.
> + // Returns true if and only if this test will appear in the XML report.
> static bool TestReportable(const TestInfo* test_info) {
> return test_info->is_reportable();
> }
> @@ -962,17 +992,17 @@ class GTEST_API_ TestCase {
> return test_info->should_run();
> }
>
> - // Shuffles the tests in this test case.
> + // Shuffles the tests in this test suite.
> void ShuffleTests(internal::Random* random);
>
> // Restores the test order to before the first shuffle.
> void UnshuffleTests();
>
> - // Name of the test case.
> + // Name of the test suite.
> std::string name_;
> // Name of the parameter type, or NULL if this is not a typed or a
> // type-parameterized test.
> - const internal::scoped_ptr<const ::std::string> type_param_;
> + const std::unique_ptr<const ::std::string> type_param_;
> // The vector of TestInfos in their original order. It owns the
> // elements in the vector.
> std::vector<TestInfo*> test_info_list_;
> @@ -980,20 +1010,22 @@ class GTEST_API_ TestCase {
> // shuffling and restoring the test order. The i-th element in this
> // vector is the index of the i-th test in the shuffled test list.
> std::vector<int> test_indices_;
> - // Pointer to the function that sets up the test case.
> - Test::SetUpTestCaseFunc set_up_tc_;
> - // Pointer to the function that tears down the test case.
> - Test::TearDownTestCaseFunc tear_down_tc_;
> - // True iff any test in this test case should run.
> + // Pointer to the function that sets up the test suite.
> + internal::SetUpTestSuiteFunc set_up_tc_;
> + // Pointer to the function that tears down the test suite.
> + internal::TearDownTestSuiteFunc tear_down_tc_;
> + // True if and only if any test in this test suite should run.
> bool should_run_;
> + // The start time, in milliseconds since UNIX Epoch.
> + TimeInMillis start_timestamp_;
> // Elapsed time, in milliseconds.
> TimeInMillis elapsed_time_;
> - // Holds test properties recorded during execution of SetUpTestCase and
> - // TearDownTestCase.
> + // Holds test properties recorded during execution of SetUpTestSuite and
> + // TearDownTestSuite.
> TestResult ad_hoc_test_result_;
>
> - // We disallow copying TestCases.
> - GTEST_DISALLOW_COPY_AND_ASSIGN_(TestCase);
> + // We disallow copying TestSuites.
> + GTEST_DISALLOW_COPY_AND_ASSIGN_(TestSuite);
> };
>
> // An Environment object is capable of setting up and tearing down an
> @@ -1024,7 +1056,7 @@ class Environment {
> // If you see an error about overriding the following function or
> // about it being private, you have mis-spelled SetUp() as Setup().
> struct Setup_should_be_spelled_SetUp {};
> - virtual Setup_should_be_spelled_SetUp* Setup() { return NULL; }
> + virtual Setup_should_be_spelled_SetUp* Setup() { return nullptr; }
> };
>
> #if GTEST_HAS_EXCEPTIONS
> @@ -1060,8 +1092,13 @@ class TestEventListener {
> // Fired after environment set-up for each iteration of tests ends.
> virtual void OnEnvironmentsSetUpEnd(const UnitTest& unit_test) = 0;
>
> - // Fired before the test case starts.
> - virtual void OnTestCaseStart(const TestCase& test_case) = 0;
> + // Fired before the test suite starts.
> + virtual void OnTestSuiteStart(const TestSuite& /*test_suite*/) {}
> +
> + // Legacy API is deprecated but still available
> +#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
> + virtual void OnTestCaseStart(const TestCase& /*test_case*/) {}
> +#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
>
> // Fired before the test starts.
> virtual void OnTestStart(const TestInfo& test_info) = 0;
> @@ -1074,8 +1111,13 @@ class TestEventListener {
> // Fired after the test ends.
> virtual void OnTestEnd(const TestInfo& test_info) = 0;
>
> - // Fired after the test case ends.
> - virtual void OnTestCaseEnd(const TestCase& test_case) = 0;
> + // Fired after the test suite ends.
> + virtual void OnTestSuiteEnd(const TestSuite& /*test_suite*/) {}
> +
> +// Legacy API is deprecated but still available
> +#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
> + virtual void OnTestCaseEnd(const TestCase& /*test_case*/) {}
> +#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
>
> // Fired before environment tear-down for each iteration of tests
> starts.
> virtual void OnEnvironmentsTearDownStart(const UnitTest& unit_test) = 0;
> @@ -1098,21 +1140,30 @@ class TestEventListener {
> // above.
> class EmptyTestEventListener : public TestEventListener {
> public:
> - virtual void OnTestProgramStart(const UnitTest& /*unit_test*/) {}
> - virtual void OnTestIterationStart(const UnitTest& /*unit_test*/,
> - int /*iteration*/) {}
> - virtual void OnEnvironmentsSetUpStart(const UnitTest& /*unit_test*/) {}
> - virtual void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) {}
> - virtual void OnTestCaseStart(const TestCase& /*test_case*/) {}
> - virtual void OnTestStart(const TestInfo& /*test_info*/) {}
> - virtual void OnTestPartResult(const TestPartResult&
> /*test_part_result*/) {}
> - virtual void OnTestEnd(const TestInfo& /*test_info*/) {}
> - virtual void OnTestCaseEnd(const TestCase& /*test_case*/) {}
> - virtual void OnEnvironmentsTearDownStart(const UnitTest& /*unit_test*/)
> {}
> - virtual void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) {}
> - virtual void OnTestIterationEnd(const UnitTest& /*unit_test*/,
> - int /*iteration*/) {}
> - virtual void OnTestProgramEnd(const UnitTest& /*unit_test*/) {}
> + void OnTestProgramStart(const UnitTest& /*unit_test*/) override {}
> + void OnTestIterationStart(const UnitTest& /*unit_test*/,
> + int /*iteration*/) override {}
> + void OnEnvironmentsSetUpStart(const UnitTest& /*unit_test*/) override {}
> + void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) override {}
> + void OnTestSuiteStart(const TestSuite& /*test_suite*/) override {}
> +// Legacy API is deprecated but still available
> +#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
> + void OnTestCaseStart(const TestCase& /*test_case*/) override {}
> +#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
> +
> + void OnTestStart(const TestInfo& /*test_info*/) override {}
> + void OnTestPartResult(const TestPartResult& /*test_part_result*/)
> override {}
> + void OnTestEnd(const TestInfo& /*test_info*/) override {}
> + void OnTestSuiteEnd(const TestSuite& /*test_suite*/) override {}
> +#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
> + void OnTestCaseEnd(const TestCase& /*test_case*/) override {}
> +#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
> +
> + void OnEnvironmentsTearDownStart(const UnitTest& /*unit_test*/)
> override {}
> + void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) override
> {}
> + void OnTestIterationEnd(const UnitTest& /*unit_test*/,
> + int /*iteration*/) override {}
> + void OnTestProgramEnd(const UnitTest& /*unit_test*/) override {}
> };
>
> // TestEventListeners lets users add listeners to track events in Google
> Test.
> @@ -1152,7 +1203,7 @@ class GTEST_API_ TestEventListeners {
> }
>
> private:
> - friend class TestCase;
> + friend class TestSuite;
> friend class TestInfo;
> friend class internal::DefaultGlobalTestPartResultReporter;
> friend class internal::NoExecDeathTest;
> @@ -1193,7 +1244,7 @@ class GTEST_API_ TestEventListeners {
> GTEST_DISALLOW_COPY_AND_ASSIGN_(TestEventListeners);
> };
>
> -// A UnitTest consists of a vector of TestCases.
> +// A UnitTest consists of a vector of TestSuites.
> //
> // This is a singleton class. The only instance of UnitTest is
> // created when UnitTest::GetInstance() is first called. This
> @@ -1222,10 +1273,14 @@ class GTEST_API_ UnitTest {
> // was executed. The UnitTest object owns the string.
> const char* original_working_dir() const;
>
> - // Returns the TestCase object for the test that's currently running,
> + // Returns the TestSuite object for the test that's currently running,
> // or NULL if no test is running.
> - const TestCase* current_test_case() const
> - GTEST_LOCK_EXCLUDED_(mutex_);
> + const TestSuite* current_test_suite() const
> GTEST_LOCK_EXCLUDED_(mutex_);
> +
> +// Legacy API is still available but deprecated
> +#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
> + const TestCase* current_test_case() const GTEST_LOCK_EXCLUDED_(mutex_);
> +#endif
>
> // Returns the TestInfo object for the test that's currently running,
> // or NULL if no test is running.
> @@ -1235,29 +1290,40 @@ class GTEST_API_ UnitTest {
> // Returns the random seed used at the start of the current test run.
> int random_seed() const;
>
> - // Returns the ParameterizedTestCaseRegistry object used to keep track
> of
> + // Returns the ParameterizedTestSuiteRegistry object used to keep track
> of
> // value-parameterized tests and instantiate and register them.
> //
> // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
> - internal::ParameterizedTestCaseRegistry& parameterized_test_registry()
> + internal::ParameterizedTestSuiteRegistry& parameterized_test_registry()
> GTEST_LOCK_EXCLUDED_(mutex_);
>
> - // Gets the number of successful test cases.
> - int successful_test_case_count() const;
> + // Gets the number of successful test suites.
> + int successful_test_suite_count() const;
>
> - // Gets the number of failed test cases.
> - int failed_test_case_count() const;
> + // Gets the number of failed test suites.
> + int failed_test_suite_count() const;
>
> - // Gets the number of all test cases.
> - int total_test_case_count() const;
> + // Gets the number of all test suites.
> + int total_test_suite_count() const;
>
> - // Gets the number of all test cases that contain at least one test
> + // Gets the number of all test suites that contain at least one test
> // that should run.
> + int test_suite_to_run_count() const;
> +
> + // Legacy API is deprecated but still available
> +#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
> + int successful_test_case_count() const;
> + int failed_test_case_count() const;
> + int total_test_case_count() const;
> int test_case_to_run_count() const;
> +#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
>
> // Gets the number of successful tests.
> int successful_test_count() const;
>
> + // Gets the number of skipped tests.
> + int skipped_test_count() const;
> +
> // Gets the number of failed tests.
> int failed_test_count() const;
>
> @@ -1283,19 +1349,25 @@ class GTEST_API_ UnitTest {
> // Gets the elapsed time, in milliseconds.
> TimeInMillis elapsed_time() const;
>
> - // Returns true iff the unit test passed (i.e. all test cases passed).
> + // Returns true if and only if the unit test passed (i.e. all test
> suites
> + // passed).
> bool Passed() const;
>
> - // Returns true iff the unit test failed (i.e. some test case failed
> - // or something outside of all tests failed).
> + // Returns true if and only if the unit test failed (i.e. some test
> suite
> + // failed or something outside of all tests failed).
> bool Failed() const;
>
> - // Gets the i-th test case among all the test cases. i can range from 0
> to
> - // total_test_case_count() - 1. If i is not in that range, returns NULL.
> + // Gets the i-th test suite among all the test suites. i can range from
> 0 to
> + // total_test_suite_count() - 1. If i is not in that range, returns
> NULL.
> + const TestSuite* GetTestSuite(int i) const;
> +
> +// Legacy API is deprecated but still available
> +#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
> const TestCase* GetTestCase(int i) const;
> +#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
>
> // Returns the TestResult containing information on test failures and
> - // properties logged outside of individual test cases.
> + // properties logged outside of individual test suites.
> const TestResult& ad_hoc_test_result() const;
>
> // Returns the list of event listeners that can be used to track events
> @@ -1326,15 +1398,15 @@ class GTEST_API_ UnitTest {
> GTEST_LOCK_EXCLUDED_(mutex_);
>
> // Adds a TestProperty to the current TestResult object when invoked
> from
> - // inside a test, to current TestCase's ad_hoc_test_result_ when invoked
> - // from SetUpTestCase or TearDownTestCase, or to the global property set
> + // inside a test, to current TestSuite's ad_hoc_test_result_ when
> invoked
> + // from SetUpTestSuite or TearDownTestSuite, or to the global property
> set
> // when invoked elsewhere. If the result already contains a property
> with
> // the same key, the value will be updated.
> void RecordProperty(const std::string& key, const std::string& value);
>
> - // Gets the i-th test case among all the test cases. i can range from 0
> to
> - // total_test_case_count() - 1. If i is not in that range, returns NULL.
> - TestCase* GetMutableTestCase(int i);
> + // Gets the i-th test suite among all the test suites. i can range from
> 0 to
> + // total_test_suite_count() - 1. If i is not in that range, returns
> NULL.
> + TestSuite* GetMutableTestSuite(int i);
>
> // Accessors for the implementation object.
> internal::UnitTestImpl* impl() { return impl_; }
> @@ -1419,6 +1491,10 @@ GTEST_API_ void InitGoogleTest(int* argc, char**
> argv);
> // UNICODE mode.
> GTEST_API_ void InitGoogleTest(int* argc, wchar_t** argv);
>
> +// This overloaded version can be used on Arduino/embedded platforms where
> +// there is no argc/argv.
> +GTEST_API_ void InitGoogleTest();
> +
> namespace internal {
>
> // Separate the error generating code from the code path to reduce the
> stack
> @@ -1435,6 +1511,13 @@ AssertionResult CmpHelperEQFailure(const char*
> lhs_expression,
> false);
> }
>
> +// This block of code defines operator==/!=
> +// to block lexical scope lookup.
> +// It prevents using invalid operator==/!= defined at namespace scope.
> +struct faketype {};
> +inline bool operator==(faketype, faketype) { return true; }
> +inline bool operator!=(faketype, faketype) { return false; }
> +
> // The helper function for {ASSERT|EXPECT}_EQ.
> template <typename T1, typename T2>
> AssertionResult CmpHelperEQ(const char* lhs_expression,
> @@ -1456,18 +1539,17 @@ GTEST_API_ AssertionResult CmpHelperEQ(const char*
> lhs_expression,
> BiggestInt lhs,
> BiggestInt rhs);
>
> -// The helper class for {ASSERT|EXPECT}_EQ. The template argument
> -// lhs_is_null_literal is true iff the first argument to ASSERT_EQ()
> -// is a null pointer literal. The following default implementation is
> -// for lhs_is_null_literal being false.
> -template <bool lhs_is_null_literal>
> class EqHelper {
> public:
> // This templatized version is for the general case.
> - template <typename T1, typename T2>
> + template <
> + typename T1, typename T2,
> + // Disable this overload for cases where one argument is a pointer
> + // and the other is the null pointer constant.
> + typename std::enable_if<!std::is_integral<T1>::value ||
> + !std::is_pointer<T2>::value>::type* =
> nullptr>
> static AssertionResult Compare(const char* lhs_expression,
> - const char* rhs_expression,
> - const T1& lhs,
> + const char* rhs_expression, const T1&
> lhs,
> const T2& rhs) {
> return CmpHelperEQ(lhs_expression, rhs_expression, lhs, rhs);
> }
> @@ -1484,49 +1566,15 @@ class EqHelper {
> BiggestInt rhs) {
> return CmpHelperEQ(lhs_expression, rhs_expression, lhs, rhs);
> }
> -};
>
> -// This specialization is used when the first argument to ASSERT_EQ()
> -// is a null pointer literal, like NULL, false, or 0.
> -template <>
> -class EqHelper<true> {
> - public:
> - // We define two overloaded versions of Compare(). The first
> - // version will be picked when the second argument to ASSERT_EQ() is
> - // NOT a pointer, e.g. ASSERT_EQ(0, AnIntFunction()) or
> - // EXPECT_EQ(false, a_bool).
> - template <typename T1, typename T2>
> - static AssertionResult Compare(
> - const char* lhs_expression,
> - const char* rhs_expression,
> - const T1& lhs,
> - const T2& rhs,
> - // The following line prevents this overload from being considered
> if T2
> - // is not a pointer type. We need this because ASSERT_EQ(NULL,
> my_ptr)
> - // expands to Compare("", "", NULL, my_ptr), which requires a
> conversion
> - // to match the Secret* in the other overload, which would
> otherwise make
> - // this template match better.
> - typename EnableIf<!is_pointer<T2>::value>::type* = 0) {
> - return CmpHelperEQ(lhs_expression, rhs_expression, lhs, rhs);
> - }
> -
> - // This version will be picked when the second argument to ASSERT_EQ()
> is a
> - // pointer, e.g. ASSERT_EQ(NULL, a_pointer).
> template <typename T>
> static AssertionResult Compare(
> - const char* lhs_expression,
> - const char* rhs_expression,
> - // We used to have a second template parameter instead of Secret*.
> That
> - // template parameter would deduce to 'long', making this a better
> match
> - // than the first overload even without the first overload's
> EnableIf.
> - // Unfortunately, gcc with -Wconversion-null warns when "passing
> NULL to
> - // non-pointer argument" (even a deduced integral argument), so the
> old
> - // implementation caused warnings in user code.
> - Secret* /* lhs (NULL) */,
> - T* rhs) {
> + const char* lhs_expression, const char* rhs_expression,
> + // Handle cases where '0' is used as a null pointer literal.
> + std::nullptr_t /* lhs */, T* rhs) {
> // We already know that 'lhs' is a null pointer.
> - return CmpHelperEQ(lhs_expression, rhs_expression,
> - static_cast<T*>(NULL), rhs);
> + return CmpHelperEQ(lhs_expression, rhs_expression,
> static_cast<T*>(nullptr),
> + rhs);
> }
> };
>
> @@ -1755,6 +1803,12 @@ class GTEST_API_ AssertHelper {
> GTEST_DISALLOW_COPY_AND_ASSIGN_(AssertHelper);
> };
>
> +enum GTestColor { COLOR_DEFAULT, COLOR_RED, COLOR_GREEN, COLOR_YELLOW };
> +
> +GTEST_API_ GTEST_ATTRIBUTE_PRINTF_(2, 3) void ColoredPrintf(GTestColor
> color,
> + const char*
> fmt,
> + ...);
> +
> } // namespace internal
>
> // The pure interface class that all value-parameterized tests inherit
> from.
> @@ -1774,13 +1828,13 @@ class GTEST_API_ AssertHelper {
> // FooTest() {
> // // Can use GetParam() here.
> // }
> -// virtual ~FooTest() {
> +// ~FooTest() override {
> // // Can use GetParam() here.
> // }
> -// virtual void SetUp() {
> +// void SetUp() override {
> // // Can use GetParam() here.
> // }
> -// virtual void TearDown {
> +// void TearDown override {
> // // Can use GetParam() here.
> // }
> // };
> @@ -1789,7 +1843,7 @@ class GTEST_API_ AssertHelper {
> // Foo foo;
> // ASSERT_TRUE(foo.DoesBar(GetParam()));
> // }
> -// INSTANTIATE_TEST_CASE_P(OneToTenRange, FooTest, ::testing::Range(1,
> 10));
> +// INSTANTIATE_TEST_SUITE_P(OneToTenRange, FooTest, ::testing::Range(1,
> 10));
>
> template <typename T>
> class WithParamInterface {
> @@ -1798,12 +1852,9 @@ class WithParamInterface {
> virtual ~WithParamInterface() {}
>
> // The current parameter value. Is also available in the test fixture's
> - // constructor. This member function is non-static, even though it only
> - // references static data, to reduce the opportunity for incorrect uses
> - // like writing 'WithParamInterface<bool>::GetParam()' for a test that
> - // uses a fixture whose parameter type is int.
> - const ParamType& GetParam() const {
> - GTEST_CHECK_(parameter_ != NULL)
> + // constructor.
> + static const ParamType& GetParam() {
> + GTEST_CHECK_(parameter_ != nullptr)
> << "GetParam() can only be called inside a value-parameterized
> test "
> << "-- did you intend to write TEST_P instead of TEST_F?";
> return *parameter_;
> @@ -1824,7 +1875,7 @@ class WithParamInterface {
> };
>
> template <typename T>
> -const T* WithParamInterface<T>::parameter_ = NULL;
> +const T* WithParamInterface<T>::parameter_ = nullptr;
>
> // Most value-parameterized classes can ignore the existence of
> // WithParamInterface, and can just inherit from ::testing::TestWithParam.
> @@ -1835,6 +1886,11 @@ class TestWithParam : public Test, public
> WithParamInterface<T> {
>
> // Macros for indicating success/failure in test code.
>
> +// Skips test in runtime.
> +// Skipping test aborts current function.
> +// Skipped tests are neither successful nor failed.
> +#define GTEST_SKIP() GTEST_SKIP_("Skipped")
> +
> // ADD_FAILURE unconditionally adds a failure to the current test.
> // SUCCEED generates a success - it doesn't automatically make the
> // current test successful, as a test is only successful when it has
> @@ -1864,6 +1920,11 @@ class TestWithParam : public Test, public
> WithParamInterface<T> {
> // Generates a fatal failure with a generic message.
> #define GTEST_FAIL() GTEST_FATAL_FAILURE_("Failed")
>
> +// Like GTEST_FAIL(), but at the given source file location.
> +#define GTEST_FAIL_AT(file, line) \
> + GTEST_MESSAGE_AT_(file, line, "Failed", \
> + ::testing::TestPartResult::kFatalFailure)
> +
> // Define this macro to 1 to omit the definition of FAIL(), which is a
> // generic name and clashes with some other libraries.
> #if !GTEST_DONT_DEFINE_FAIL
> @@ -1964,9 +2025,7 @@ class TestWithParam : public Test, public
> WithParamInterface<T> {
> // ASSERT_GT(records.size(), 0) << "There is no record left.";
>
> #define EXPECT_EQ(val1, val2) \
> - EXPECT_PRED_FORMAT2(::testing::internal:: \
> - EqHelper<GTEST_IS_NULL_LITERAL_(val1)>::Compare, \
> - val1, val2)
> + EXPECT_PRED_FORMAT2(::testing::internal::EqHelper::Compare, val1, val2)
> #define EXPECT_NE(val1, val2) \
> EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperNE, val1, val2)
> #define EXPECT_LE(val1, val2) \
> @@ -1979,9 +2038,7 @@ class TestWithParam : public Test, public
> WithParamInterface<T> {
> EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperGT, val1, val2)
>
> #define GTEST_ASSERT_EQ(val1, val2) \
> - ASSERT_PRED_FORMAT2(::testing::internal:: \
> - EqHelper<GTEST_IS_NULL_LITERAL_(val1)>::Compare, \
> - val1, val2)
> + ASSERT_PRED_FORMAT2(::testing::internal::EqHelper::Compare, val1, val2)
> #define GTEST_ASSERT_NE(val1, val2) \
> ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperNE, val1, val2)
> #define GTEST_ASSERT_LE(val1, val2) \
> @@ -2172,12 +2229,6 @@ class GTEST_API_ ScopedTrace {
> PushTrace(file, line, message ? message : "(null)");
> }
>
> -#if GTEST_HAS_GLOBAL_STRING
> - ScopedTrace(const char* file, int line, const ::string& message) {
> - PushTrace(file, line, message);
> - }
> -#endif
> -
> ScopedTrace(const char* file, int line, const std::string& message) {
> PushTrace(file, line, message);
> }
> @@ -2215,10 +2266,9 @@ class GTEST_API_ ScopedTrace {
> ::testing::ScopedTrace GTEST_CONCAT_TOKEN_(gtest_trace_, __LINE__)(\
> __FILE__, __LINE__, (message))
>
> -
> // Compile-time assertion for type equality.
> -// StaticAssertTypeEq<type1, type2>() compiles iff type1 and type2 are
> -// the same type. The value it returns is not interesting.
> +// StaticAssertTypeEq<type1, type2>() compiles if and only if type1 and
> type2
> +// are the same type. The value it returns is not interesting.
> //
> // Instead of making StaticAssertTypeEq a class template, we make it a
> // function template that invokes a helper class template. This
> @@ -2247,18 +2297,19 @@ class GTEST_API_ ScopedTrace {
> //
> // to cause a compiler error.
> template <typename T1, typename T2>
> -bool StaticAssertTypeEq() {
> - (void)internal::StaticAssertTypeEqHelper<T1, T2>();
> +constexpr bool StaticAssertTypeEq() noexcept {
> + static_assert(std::is_same<T1, T2>::value,
> + "type1 and type2 are not the same type");
> return true;
> }
>
> // Defines a test.
> //
> -// The first parameter is the name of the test case, and the second
> -// parameter is the name of the test within the test case.
> +// The first parameter is the name of the test suite, and the second
> +// parameter is the name of the test within the test suite.
> //
> -// The convention is to end the test case name with "Test". For
> -// example, a test case for the Foo class can be named FooTest.
> +// The convention is to end the test suite name with "Test". For
> +// example, a test suite for the Foo class can be named FooTest.
> //
> // Test code should appear between braces after an invocation of
> // this macro. Example:
> @@ -2277,28 +2328,28 @@ bool StaticAssertTypeEq() {
> // code. GetTestTypeId() is guaranteed to always return the same
> // value, as it always calls GetTypeId<>() from the Google Test
> // framework.
> -#define GTEST_TEST(test_case_name, test_name)\
> - GTEST_TEST_(test_case_name, test_name, \
> - ::testing::Test, ::testing::internal::GetTestTypeId())
> +#define GTEST_TEST(test_suite_name, test_name) \
> + GTEST_TEST_(test_suite_name, test_name, ::testing::Test, \
> + ::testing::internal::GetTestTypeId())
>
> // Define this macro to 1 to omit the definition of TEST(), which
> // is a generic name and clashes with some other libraries.
> #if !GTEST_DONT_DEFINE_TEST
> -# define TEST(test_case_name, test_name) GTEST_TEST(test_case_name,
> test_name)
> +#define TEST(test_suite_name, test_name) GTEST_TEST(test_suite_name,
> test_name)
> #endif
>
> // Defines a test that uses a test fixture.
> //
> // The first parameter is the name of the test fixture class, which
> -// also doubles as the test case name. The second parameter is the
> -// name of the test within the test case.
> +// also doubles as the test suite name. The second parameter is the
> +// name of the test within the test suite.
> //
> // A test fixture class must be declared earlier. The user should put
> // the test code between braces after using this macro. Example:
> //
> // class FooTest : public testing::Test {
> // protected:
> -// virtual void SetUp() { b_.AddElement(3); }
> +// void SetUp() override { b_.AddElement(3); }
> //
> // Foo a_;
> // Foo b_;
> @@ -2312,7 +2363,8 @@ bool StaticAssertTypeEq() {
> // EXPECT_EQ(a_.size(), 0);
> // EXPECT_EQ(b_.size(), 1);
> // }
> -
> +//
> +// GOOGLETEST_CM0011 DO NOT DELETE
> #define TEST_F(test_fixture, test_name)\
> GTEST_TEST_(test_fixture, test_name, test_fixture, \
> ::testing::internal::GetTypeId<test_fixture>())
> @@ -2325,6 +2377,86 @@ GTEST_API_ std::string TempDir();
> # pragma warning(pop)
> #endif
>
> +// Dynamically registers a test with the framework.
> +//
> +// This is an advanced API only to be used when the `TEST` macros are
> +// insufficient. The macros should be preferred when possible, as they
> avoid
> +// most of the complexity of calling this function.
> +//
> +// The `factory` argument is a factory callable (move-constructible)
> object or
> +// function pointer that creates a new instance of the Test object. It
> +// handles ownership to the caller. The signature of the callable is
> +// `Fixture*()`, where `Fixture` is the test fixture class for the test.
> All
> +// tests registered with the same `test_suite_name` must return the same
> +// fixture type. This is checked at runtime.
> +//
> +// The framework will infer the fixture class from the factory and will
> call
> +// the `SetUpTestSuite` and `TearDownTestSuite` for it.
> +//
> +// Must be called before `RUN_ALL_TESTS()` is invoked, otherwise behavior
> is
> +// undefined.
> +//
> +// Use case example:
> +//
> +// class MyFixture : public ::testing::Test {
> +// public:
> +// // All of these optional, just like in regular macro usage.
> +// static void SetUpTestSuite() { ... }
> +// static void TearDownTestSuite() { ... }
> +// void SetUp() override { ... }
> +// void TearDown() override { ... }
> +// };
> +//
> +// class MyTest : public MyFixture {
> +// public:
> +// explicit MyTest(int data) : data_(data) {}
> +// void TestBody() override { ... }
> +//
> +// private:
> +// int data_;
> +// };
> +//
> +// void RegisterMyTests(const std::vector<int>& values) {
> +// for (int v : values) {
> +// ::testing::RegisterTest(
> +// "MyFixture", ("Test" + std::to_string(v)).c_str(), nullptr,
> +// std::to_string(v).c_str(),
> +// __FILE__, __LINE__,
> +// // Important to use the fixture type as the return type here.
> +// [=]() -> MyFixture* { return new MyTest(v); });
> +// }
> +// }
> +// ...
> +// int main(int argc, char** argv) {
> +// std::vector<int> values_to_test = LoadValuesFromConfig();
> +// RegisterMyTests(values_to_test);
> +// ...
> +// return RUN_ALL_TESTS();
> +// }
> +//
> +template <int&... ExplicitParameterBarrier, typename Factory>
> +TestInfo* RegisterTest(const char* test_suite_name, const char* test_name,
> + const char* type_param, const char* value_param,
> + const char* file, int line, Factory factory) {
> + using TestT = typename std::remove_pointer<decltype(factory())>::type;
> +
> + class FactoryImpl : public internal::TestFactoryBase {
> + public:
> + explicit FactoryImpl(Factory f) : factory_(std::move(f)) {}
> + Test* CreateTest() override { return factory_(); }
> +
> + private:
> + Factory factory_;
> + };
> +
> + return internal::MakeAndRegisterTestInfo(
> + test_suite_name, test_name, type_param, value_param,
> + internal::CodeLocation(file, line), internal::GetTypeId<TestT>(),
> + internal::SuiteApiResolver<TestT>::GetSetUpCaseOrSuite(file, line),
> + internal::SuiteApiResolver<TestT>::GetTearDownCaseOrSuite(file,
> line),
> + new FactoryImpl{std::move(factory)});
> +}
> +
> } // namespace testing
>
> // Use this function in main() to run all tests. It returns 0 if all
>
> diff --git
> a/llvm/utils/unittest/googletest/include/gtest/gtest_pred_impl.h
> b/llvm/utils/unittest/googletest/include/gtest/gtest_pred_impl.h
> index 0c1105cb8eb2e..d514255c733b7 100644
> --- a/llvm/utils/unittest/googletest/include/gtest/gtest_pred_impl.h
> +++ b/llvm/utils/unittest/googletest/include/gtest/gtest_pred_impl.h
> @@ -27,11 +27,10 @@
> // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
> // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
>
> -// This file is AUTOMATICALLY GENERATED on 01/02/2018 by command
> +// This file is AUTOMATICALLY GENERATED on 01/02/2019 by command
> // 'gen_gtest_pred_impl.py 5'. DO NOT EDIT BY HAND!
> //
> // Implements a family of generic predicate assertion macros.
> -
> // GOOGLETEST_CM0001 DO NOT DELETE
>
> #ifndef GTEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_
> @@ -67,6 +66,8 @@ namespace testing {
> // We also define the EXPECT_* variations.
> //
> // For now we only support predicates whose arity is at most 5.
> +// Please email googletestframework at googlegroups.com if you need
> +// support for higher arities.
>
> // GTEST_ASSERT_ is the basic statement to which all of the assertions
> // in this file reduce. Don't use this in your code.
> @@ -89,9 +90,10 @@ AssertionResult AssertPred1Helper(const char* pred_text,
> const T1& v1) {
> if (pred(v1)) return AssertionSuccess();
>
> - return AssertionFailure() << pred_text << "("
> - << e1 << ") evaluates to false, where"
> - << "\n" << e1 << " evaluates to " << v1;
> + return AssertionFailure()
> + << pred_text << "(" << e1 << ") evaluates to false, where"
> + << "\n"
> + << e1 << " evaluates to " << ::testing::PrintToString(v1);
> }
>
> // Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT1.
> @@ -133,11 +135,12 @@ AssertionResult AssertPred2Helper(const char*
> pred_text,
> const T2& v2) {
> if (pred(v1, v2)) return AssertionSuccess();
>
> - return AssertionFailure() << pred_text << "("
> - << e1 << ", "
> - << e2 << ") evaluates to false, where"
> - << "\n" << e1 << " evaluates to " << v1
> - << "\n" << e2 << " evaluates to " << v2;
> + return AssertionFailure()
> + << pred_text << "(" << e1 << ", " << e2
> + << ") evaluates to false, where"
> + << "\n"
> + << e1 << " evaluates to " << ::testing::PrintToString(v1) << "\n"
> + << e2 << " evaluates to " << ::testing::PrintToString(v2);
> }
>
> // Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT2.
> @@ -184,13 +187,13 @@ AssertionResult AssertPred3Helper(const char*
> pred_text,
> const T3& v3) {
> if (pred(v1, v2, v3)) return AssertionSuccess();
>
> - return AssertionFailure() << pred_text << "("
> - << e1 << ", "
> - << e2 << ", "
> - << e3 << ") evaluates to false, where"
> - << "\n" << e1 << " evaluates to " << v1
> - << "\n" << e2 << " evaluates to " << v2
> - << "\n" << e3 << " evaluates to " << v3;
> + return AssertionFailure()
> + << pred_text << "(" << e1 << ", " << e2 << ", " << e3
> + << ") evaluates to false, where"
> + << "\n"
> + << e1 << " evaluates to " << ::testing::PrintToString(v1) << "\n"
> + << e2 << " evaluates to " << ::testing::PrintToString(v2) << "\n"
> + << e3 << " evaluates to " << ::testing::PrintToString(v3);
> }
>
> // Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT3.
> @@ -242,15 +245,14 @@ AssertionResult AssertPred4Helper(const char*
> pred_text,
> const T4& v4) {
> if (pred(v1, v2, v3, v4)) return AssertionSuccess();
>
> - return AssertionFailure() << pred_text << "("
> - << e1 << ", "
> - << e2 << ", "
> - << e3 << ", "
> - << e4 << ") evaluates to false, where"
> - << "\n" << e1 << " evaluates to " << v1
> - << "\n" << e2 << " evaluates to " << v2
> - << "\n" << e3 << " evaluates to " << v3
> - << "\n" << e4 << " evaluates to " << v4;
> + return AssertionFailure()
> + << pred_text << "(" << e1 << ", " << e2 << ", " << e3 << ", " <<
> e4
> + << ") evaluates to false, where"
> + << "\n"
> + << e1 << " evaluates to " << ::testing::PrintToString(v1) << "\n"
> + << e2 << " evaluates to " << ::testing::PrintToString(v2) << "\n"
> + << e3 << " evaluates to " << ::testing::PrintToString(v3) << "\n"
> + << e4 << " evaluates to " << ::testing::PrintToString(v4);
> }
>
> // Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT4.
> @@ -307,17 +309,15 @@ AssertionResult AssertPred5Helper(const char*
> pred_text,
> const T5& v5) {
> if (pred(v1, v2, v3, v4, v5)) return AssertionSuccess();
>
> - return AssertionFailure() << pred_text << "("
> - << e1 << ", "
> - << e2 << ", "
> - << e3 << ", "
> - << e4 << ", "
> - << e5 << ") evaluates to false, where"
> - << "\n" << e1 << " evaluates to " << v1
> - << "\n" << e2 << " evaluates to " << v2
> - << "\n" << e3 << " evaluates to " << v3
> - << "\n" << e4 << " evaluates to " << v4
> - << "\n" << e5 << " evaluates to " << v5;
> + return AssertionFailure()
> + << pred_text << "(" << e1 << ", " << e2 << ", " << e3 << ", " <<
> e4
> + << ", " << e5 << ") evaluates to false, where"
> + << "\n"
> + << e1 << " evaluates to " << ::testing::PrintToString(v1) << "\n"
> + << e2 << " evaluates to " << ::testing::PrintToString(v2) << "\n"
> + << e3 << " evaluates to " << ::testing::PrintToString(v3) << "\n"
> + << e4 << " evaluates to " << ::testing::PrintToString(v4) << "\n"
> + << e5 << " evaluates to " << ::testing::PrintToString(v5);
> }
>
> // Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT5.
>
> diff --git
> a/llvm/utils/unittest/googletest/include/gtest/internal/gtest-death-test-internal.h
> b/llvm/utils/unittest/googletest/include/gtest/internal/gtest-death-test-internal.h
> index 4db41f8767356..12bb05011f96b 100644
> ---
> a/llvm/utils/unittest/googletest/include/gtest/internal/gtest-death-test-internal.h
> +++
> b/llvm/utils/unittest/googletest/include/gtest/internal/gtest-death-test-internal.h
> @@ -36,9 +36,11 @@
> #ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_DEATH_TEST_INTERNAL_H_
> #define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_DEATH_TEST_INTERNAL_H_
>
> +#include "gtest/gtest-matchers.h"
> #include "gtest/internal/gtest-internal.h"
>
> #include <stdio.h>
> +#include <memory>
>
> namespace testing {
> namespace internal {
> @@ -78,7 +80,7 @@ class GTEST_API_ DeathTest {
> // argument is set. If the death test should be skipped, the pointer
> // is set to NULL; otherwise, it is set to the address of a new concrete
> // DeathTest object that controls the execution of the current test.
> - static bool Create(const char* statement, const RE* regex,
> + static bool Create(const char* statement, Matcher<const std::string&>
> matcher,
> const char* file, int line, DeathTest** test);
> DeathTest();
> virtual ~DeathTest() { }
> @@ -144,21 +146,44 @@ GTEST_DISABLE_MSC_WARNINGS_POP_() // 4251
> class DeathTestFactory {
> public:
> virtual ~DeathTestFactory() { }
> - virtual bool Create(const char* statement, const RE* regex,
> - const char* file, int line, DeathTest** test) = 0;
> + virtual bool Create(const char* statement,
> + Matcher<const std::string&> matcher, const char*
> file,
> + int line, DeathTest** test) = 0;
> };
>
> // A concrete DeathTestFactory implementation for normal use.
> class DefaultDeathTestFactory : public DeathTestFactory {
> public:
> - virtual bool Create(const char* statement, const RE* regex,
> - const char* file, int line, DeathTest** test);
> + bool Create(const char* statement, Matcher<const std::string&> matcher,
> + const char* file, int line, DeathTest** test) override;
> };
>
> // Returns true if exit_status describes a process that was terminated
> // by a signal, or exited normally with a nonzero exit code.
> GTEST_API_ bool ExitedUnsuccessfully(int exit_status);
>
> +// A string passed to EXPECT_DEATH (etc.) is caught by one of these
> overloads
> +// and interpreted as a regex (rather than an Eq matcher) for legacy
> +// compatibility.
> +inline Matcher<const ::std::string&> MakeDeathTestMatcher(
> + ::testing::internal::RE regex) {
> + return ContainsRegex(regex.pattern());
> +}
> +inline Matcher<const ::std::string&> MakeDeathTestMatcher(const char*
> regex) {
> + return ContainsRegex(regex);
> +}
> +inline Matcher<const ::std::string&> MakeDeathTestMatcher(
> + const ::std::string& regex) {
> + return ContainsRegex(regex);
> +}
> +
> +// If a Matcher<const ::std::string&> is passed to EXPECT_DEATH (etc.),
> it's
> +// used directly.
> +inline Matcher<const ::std::string&> MakeDeathTestMatcher(
> + Matcher<const ::std::string&> matcher) {
> + return matcher;
> +}
> +
> // Traps C++ exceptions escaping statement and reports them as test
> // failures. Note that trapping SEH exceptions is not implemented here.
> # if GTEST_HAS_EXCEPTIONS
> @@ -186,36 +211,36 @@ GTEST_API_ bool ExitedUnsuccessfully(int
> exit_status);
>
> // This macro is for implementing ASSERT_DEATH*, EXPECT_DEATH*,
> // ASSERT_EXIT*, and EXPECT_EXIT*.
> -# define GTEST_DEATH_TEST_(statement, predicate, regex, fail) \
> - GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
> - if (::testing::internal::AlwaysTrue()) { \
> - const ::testing::internal::RE& gtest_regex = (regex); \
> - ::testing::internal::DeathTest* gtest_dt; \
> - if (!::testing::internal::DeathTest::Create(#statement, >est_regex,
> \
> - __FILE__, __LINE__, >est_dt)) { \
> - goto GTEST_CONCAT_TOKEN_(gtest_label_, __LINE__); \
> - } \
> - if (gtest_dt != NULL) { \
> - ::testing::internal::scoped_ptr< ::testing::internal::DeathTest> \
> - gtest_dt_ptr(gtest_dt); \
> - switch (gtest_dt->AssumeRole()) { \
> - case ::testing::internal::DeathTest::OVERSEE_TEST: \
> - if (!gtest_dt->Passed(predicate(gtest_dt->Wait()))) { \
> - goto GTEST_CONCAT_TOKEN_(gtest_label_, __LINE__); \
> - } \
> - break; \
> - case ::testing::internal::DeathTest::EXECUTE_TEST: { \
> - ::testing::internal::DeathTest::ReturnSentinel \
> - gtest_sentinel(gtest_dt); \
> - GTEST_EXECUTE_DEATH_TEST_STATEMENT_(statement, gtest_dt); \
> -
> gtest_dt->Abort(::testing::internal::DeathTest::TEST_DID_NOT_DIE); \
> - break; \
> - } \
> - } \
> - } \
> - } else \
> - GTEST_CONCAT_TOKEN_(gtest_label_, __LINE__): \
> - fail(::testing::internal::DeathTest::LastMessage())
> +#define GTEST_DEATH_TEST_(statement, predicate, regex_or_matcher, fail)
> \
> + GTEST_AMBIGUOUS_ELSE_BLOCKER_
> \
> + if (::testing::internal::AlwaysTrue()) {
> \
> + ::testing::internal::DeathTest* gtest_dt;
> \
> + if (!::testing::internal::DeathTest::Create(
> \
> + #statement,
> \
> + ::testing::internal::MakeDeathTestMatcher(regex_or_matcher),
> \
> + __FILE__, __LINE__, >est_dt)) {
> \
> + goto GTEST_CONCAT_TOKEN_(gtest_label_, __LINE__);
> \
> + }
> \
> + if (gtest_dt != nullptr) {
> \
> + std::unique_ptr< ::testing::internal::DeathTest>
> gtest_dt_ptr(gtest_dt); \
> + switch (gtest_dt->AssumeRole()) {
> \
> + case ::testing::internal::DeathTest::OVERSEE_TEST:
> \
> + if (!gtest_dt->Passed(predicate(gtest_dt->Wait()))) {
> \
> + goto GTEST_CONCAT_TOKEN_(gtest_label_, __LINE__);
> \
> + }
> \
> + break;
> \
> + case ::testing::internal::DeathTest::EXECUTE_TEST: {
> \
> + ::testing::internal::DeathTest::ReturnSentinel gtest_sentinel(
> \
> + gtest_dt);
> \
> + GTEST_EXECUTE_DEATH_TEST_STATEMENT_(statement, gtest_dt);
> \
> +
> gtest_dt->Abort(::testing::internal::DeathTest::TEST_DID_NOT_DIE); \
> + break;
> \
> + }
> \
> + }
> \
> + }
> \
> + } else
> \
> + GTEST_CONCAT_TOKEN_(gtest_label_, __LINE__)
> \
> + : fail(::testing::internal::DeathTest::LastMessage())
> // The symbol "fail" here expands to something into which a message
> // can be streamed.
>
> @@ -224,14 +249,13 @@ GTEST_API_ bool ExitedUnsuccessfully(int
> exit_status);
> // must accept a streamed message even though the message is never
> printed.
> // The regex object is not evaluated, but it is used to prevent "unused"
> // warnings and to avoid an expression that doesn't compile in debug mode.
> -#define GTEST_EXECUTE_STATEMENT_(statement, regex) \
> - GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
> - if (::testing::internal::AlwaysTrue()) { \
> - GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
> - } else if (!::testing::internal::AlwaysTrue()) { \
> - const ::testing::internal::RE& gtest_regex = (regex); \
> - static_cast<void>(gtest_regex); \
> - } else \
> +#define GTEST_EXECUTE_STATEMENT_(statement, regex_or_matcher) \
> + GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
> + if (::testing::internal::AlwaysTrue()) { \
> + GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
> + } else if (!::testing::internal::AlwaysTrue()) { \
> + ::testing::internal::MakeDeathTestMatcher(regex_or_matcher); \
> + } else \
> ::testing::Message()
>
> // A class representing the parsed contents of the
>
> diff --git
> a/llvm/utils/unittest/googletest/include/gtest/internal/gtest-filepath.h
> b/llvm/utils/unittest/googletest/include/gtest/internal/gtest-filepath.h
> index ae38d95bf844f..c11b101516e53 100644
> ---
> a/llvm/utils/unittest/googletest/include/gtest/internal/gtest-filepath.h
> +++
> b/llvm/utils/unittest/googletest/include/gtest/internal/gtest-filepath.h
> @@ -110,7 +110,7 @@ class GTEST_API_ FilePath {
> const FilePath& base_name,
> const char* extension);
>
> - // Returns true iff the path is "".
> + // Returns true if and only if the path is "".
> bool IsEmpty() const { return pathname_.empty(); }
>
> // If input name has a trailing separator character, removes it and
> returns
>
> diff --git
> a/llvm/utils/unittest/googletest/include/gtest/internal/gtest-internal.h
> b/llvm/utils/unittest/googletest/include/gtest/internal/gtest-internal.h
> index b762f61fc53c3..94c816a28bdb1 100644
> ---
> a/llvm/utils/unittest/googletest/include/gtest/internal/gtest-internal.h
> +++
> b/llvm/utils/unittest/googletest/include/gtest/internal/gtest-internal.h
> @@ -58,6 +58,7 @@
> #include <map>
> #include <set>
> #include <string>
> +#include <type_traits>
> #include <vector>
>
> #include "gtest/gtest-message.h"
> @@ -79,7 +80,6 @@
> // Stringifies its argument.
> #define GTEST_STRINGIFY_(name) #name
>
> -class ProtocolMessage;
> namespace proto2 { class Message; }
>
> namespace testing {
> @@ -91,7 +91,7 @@ class Message; // Represents a
> failure message.
> class Test; // Represents a test.
> class TestInfo; // Information about a test.
> class TestPartResult; // Result of a test part.
> -class UnitTest; // A collection of test cases.
> +class UnitTest; // A collection of test suites.
>
> template <typename T>
> ::std::string PrintToString(const T& value);
> @@ -106,34 +106,22 @@ class UnitTestImpl; // Opaque
> implementation of UnitTest
> // stack trace.
> GTEST_API_ extern const char kStackTraceMarker[];
>
> -// Two overloaded helpers for checking at compile time whether an
> -// expression is a null pointer literal (i.e. NULL or any 0-valued
> -// compile-time integral constant). Their return values have
> -//
> diff erent sizes, so we can use sizeof() to test which version is
> -// picked by the compiler. These helpers have no implementations, as
> -// we only need their signatures.
> -//
> -// Given IsNullLiteralHelper(x), the compiler will pick the first
> -// version if x can be implicitly converted to Secret*, and pick the
> -// second version otherwise. Since Secret is a secret and incomplete
> -// type, the only expression a user can write that has type Secret* is
> -// a null pointer literal. Therefore, we know that x is a null
> -// pointer literal if and only if the first version is picked by the
> -// compiler.
> -char IsNullLiteralHelper(Secret* p);
> -char (&IsNullLiteralHelper(...))[2]; // NOLINT
> -
> -// A compile-time bool constant that is true if and only if x is a
> -// null pointer literal (i.e. NULL or any 0-valued compile-time
> -// integral constant).
> -#ifdef GTEST_ELLIPSIS_NEEDS_POD_
> -// We lose support for NULL detection where the compiler doesn't like
> -// passing non-POD classes through ellipsis (...).
> -# define GTEST_IS_NULL_LITERAL_(x) false
> -#else
> -# define GTEST_IS_NULL_LITERAL_(x) \
> - (sizeof(::testing::internal::IsNullLiteralHelper(x)) == 1)
> -#endif // GTEST_ELLIPSIS_NEEDS_POD_
> +// An IgnoredValue object can be implicitly constructed from ANY value.
> +class IgnoredValue {
> + struct Sink {};
> + public:
> + // This constructor template allows any value to be implicitly
> + // converted to IgnoredValue. The object has no data member and
> + // doesn't try to remember anything about the argument. We
> + // deliberately omit the 'explicit' keyword in order to allow the
> + // conversion to be implicit.
> + // Disable the conversion if T already has a magical conversion
> operator.
> + // Otherwise we get ambiguity.
> + template <typename T,
> + typename std::enable_if<!std::is_convertible<T, Sink>::value,
> + int>::type = 0>
> + IgnoredValue(const T& /* ignored */) {} // NOLINT(runtime/explicit)
> +};
>
> // Appends the user-supplied message to the Google-Test-generated message.
> GTEST_API_ std::string AppendUserMessage(
> @@ -201,7 +189,7 @@ GTEST_API_ std::string DiffStrings(const std::string&
> left,
> // expected_value: "5"
> // actual_value: "6"
> //
> -// The ignoring_case parameter is true iff the assertion is a
> +// The ignoring_case parameter is true if and only if the assertion is a
> // *_STRCASEEQ*. When it's true, the string " (ignoring case)" will
> // be inserted into the message.
> GTEST_API_ AssertionResult EqFailure(const char* expected_expression,
> @@ -330,15 +318,15 @@ class FloatingPoint {
> // Returns the sign bit of this number.
> Bits sign_bit() const { return kSignBitMask & u_.bits_; }
>
> - // Returns true iff this is NAN (not a number).
> + // Returns true if and only if this is NAN (not a number).
> bool is_nan() const {
> // It's a NAN if the exponent bits are all ones and the fraction
> // bits are not entirely zeros.
> return (exponent_bits() == kExponentBitMask) && (fraction_bits() !=
> 0);
> }
>
> - // Returns true iff this number is at most kMaxUlps ULP's away from
> - // rhs. In particular, this function:
> + // Returns true if and only if this number is at most kMaxUlps ULP's
> away
> + // from rhs. In particular, this function:
> //
> // - returns false if either number is (or both are) NAN.
> // - treats really large numbers as almost equal to infinity.
> @@ -409,7 +397,7 @@ typedef FloatingPoint<float> Float;
> typedef FloatingPoint<double> Double;
>
> // In order to catch the mistake of putting tests that use
> diff erent
> -// test fixture classes in the same test case, we need to assign
> +// test fixture classes in the same test suite, we need to assign
> // unique IDs to fixture classes and compare them. The TypeId type is
> // used to hold such IDs. The user should treat TypeId as an opaque
> // type: the only operation allowed on TypeId values is to compare
> @@ -469,7 +457,7 @@ class TestFactoryBase {
> template <class TestClass>
> class TestFactoryImpl : public TestFactoryBase {
> public:
> - virtual Test* CreateTest() { return new TestClass; }
> + Test* CreateTest() override { return new TestClass; }
> };
>
> #if GTEST_OS_WINDOWS
> @@ -485,9 +473,9 @@ GTEST_API_ AssertionResult IsHRESULTFailure(const
> char* expr,
>
> #endif // GTEST_OS_WINDOWS
>
> -// Types of SetUpTestCase() and TearDownTestCase() functions.
> -typedef void (*SetUpTestCaseFunc)();
> -typedef void (*TearDownTestCaseFunc)();
> +// Types of SetUpTestSuite() and TearDownTestSuite() functions.
> +using SetUpTestSuiteFunc = void (*)();
> +using TearDownTestSuiteFunc = void (*)();
>
> struct CodeLocation {
> CodeLocation(const std::string& a_file, int a_line)
> @@ -497,12 +485,64 @@ struct CodeLocation {
> int line;
> };
>
> +// Helper to identify which setup function for TestCase / TestSuite to
> call.
> +// Only one function is allowed, either TestCase or TestSute but not
> both.
> +
> +// Utility functions to help SuiteApiResolver
> +using SetUpTearDownSuiteFuncType = void (*)();
> +
> +inline SetUpTearDownSuiteFuncType GetNotDefaultOrNull(
> + SetUpTearDownSuiteFuncType a, SetUpTearDownSuiteFuncType def) {
> + return a == def ? nullptr : a;
> +}
> +
> +template <typename T>
> +// Note that SuiteApiResolver inherits from T because
> +// SetUpTestSuite()/TearDownTestSuite() could be protected. Ths way
> +// SuiteApiResolver can access them.
> +struct SuiteApiResolver : T {
> + // testing::Test is only forward declared at this point. So we make it a
> + // dependend class for the compiler to be OK with it.
> + using Test =
> + typename std::conditional<sizeof(T) != 0, ::testing::Test,
> void>::type;
> +
> + static SetUpTearDownSuiteFuncType GetSetUpCaseOrSuite(const char*
> filename,
> + int line_num) {
> + SetUpTearDownSuiteFuncType test_case_fp =
> + GetNotDefaultOrNull(&T::SetUpTestCase, &Test::SetUpTestCase);
> + SetUpTearDownSuiteFuncType test_suite_fp =
> + GetNotDefaultOrNull(&T::SetUpTestSuite, &Test::SetUpTestSuite);
> +
> + GTEST_CHECK_(!test_case_fp || !test_suite_fp)
> + << "Test can not provide both SetUpTestSuite and SetUpTestCase,
> please "
> + "make sure there is only one present at "
> + << filename << ":" << line_num;
> +
> + return test_case_fp != nullptr ? test_case_fp : test_suite_fp;
> + }
> +
> + static SetUpTearDownSuiteFuncType GetTearDownCaseOrSuite(const char*
> filename,
> + int line_num) {
> + SetUpTearDownSuiteFuncType test_case_fp =
> + GetNotDefaultOrNull(&T::TearDownTestCase,
> &Test::TearDownTestCase);
> + SetUpTearDownSuiteFuncType test_suite_fp =
> + GetNotDefaultOrNull(&T::TearDownTestSuite,
> &Test::TearDownTestSuite);
> +
> + GTEST_CHECK_(!test_case_fp || !test_suite_fp)
> + << "Test can not provide both TearDownTestSuite and
> TearDownTestCase,"
> + " please make sure there is only one present at"
> + << filename << ":" << line_num;
> +
> + return test_case_fp != nullptr ? test_case_fp : test_suite_fp;
> + }
> +};
> +
> // Creates a new TestInfo object and registers it with Google Test;
> // returns the created object.
> //
> // Arguments:
> //
> -// test_case_name: name of the test case
> +// test_suite_name: name of the test suite
> // name: name of the test
> // type_param the name of the test's type parameter, or NULL if
> // this is not a typed or a type-parameterized test.
> @@ -510,21 +550,16 @@ struct CodeLocation {
> // or NULL if this is not a type-parameterized test.
> // code_location: code location where the test is defined
> // fixture_class_id: ID of the test fixture class
> -// set_up_tc: pointer to the function that sets up the test case
> -// tear_down_tc: pointer to the function that tears down the test
> case
> +// set_up_tc: pointer to the function that sets up the test suite
> +// tear_down_tc: pointer to the function that tears down the test
> suite
> // factory: pointer to the factory that creates a test object.
> // The newly created TestInfo instance will assume
> // ownership of the factory object.
> GTEST_API_ TestInfo* MakeAndRegisterTestInfo(
> - const char* test_case_name,
> - const char* name,
> - const char* type_param,
> - const char* value_param,
> - CodeLocation code_location,
> - TypeId fixture_class_id,
> - SetUpTestCaseFunc set_up_tc,
> - TearDownTestCaseFunc tear_down_tc,
> - TestFactoryBase* factory);
> + const char* test_suite_name, const char* name, const char* type_param,
> + const char* value_param, CodeLocation code_location,
> + TypeId fixture_class_id, SetUpTestSuiteFunc set_up_tc,
> + TearDownTestSuiteFunc tear_down_tc, TestFactoryBase* factory);
>
> // If *pstr starts with the given prefix, modifies *pstr to be right
> // past the prefix and returns true; otherwise leaves *pstr unchanged
> @@ -536,19 +571,20 @@ GTEST_API_ bool SkipPrefix(const char* prefix, const
> char** pstr);
> GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
> /* class A needs to have dll-interface to be used by clients of class B
> */)
>
> -// State of the definition of a type-parameterized test case.
> -class GTEST_API_ TypedTestCasePState {
> +// State of the definition of a type-parameterized test suite.
> +class GTEST_API_ TypedTestSuitePState {
> public:
> - TypedTestCasePState() : registered_(false) {}
> + TypedTestSuitePState() : registered_(false) {}
>
> // Adds the given test name to defined_test_names_ and return true
> - // if the test case hasn't been registered; otherwise aborts the
> + // if the test suite hasn't been registered; otherwise aborts the
> // program.
> bool AddTestName(const char* file, int line, const char* case_name,
> const char* test_name) {
> if (registered_) {
> - fprintf(stderr, "%s Test %s must be defined before "
> - "REGISTER_TYPED_TEST_CASE_P(%s, ...).\n",
> + fprintf(stderr,
> + "%s Test %s must be defined before "
> + "REGISTER_TYPED_TEST_SUITE_P(%s, ...).\n",
> FormatFileLocation(file, line).c_str(), test_name,
> case_name);
> fflush(stderr);
> posix::Abort();
> @@ -581,14 +617,19 @@ class GTEST_API_ TypedTestCasePState {
> RegisteredTestsMap registered_tests_;
> };
>
> +// Legacy API is deprecated but still available
> +#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
> +using TypedTestCasePState = TypedTestSuitePState;
> +#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
> +
> GTEST_DISABLE_MSC_WARNINGS_POP_() // 4251
>
> // Skips to the first non-space char after the first comma in 'str';
> // returns NULL if no comma is found in 'str'.
> inline const char* SkipComma(const char* str) {
> const char* comma = strchr(str, ',');
> - if (comma == NULL) {
> - return NULL;
> + if (comma == nullptr) {
> + return nullptr;
> }
> while (IsSpace(*(++comma))) {}
> return comma;
> @@ -598,7 +639,7 @@ inline const char* SkipComma(const char* str) {
> // the entire string if it contains no comma.
> inline std::string GetPrefixUntilComma(const char* str) {
> const char* comma = strchr(str, ',');
> - return comma == NULL ? str : std::string(str, comma);
> + return comma == nullptr ? str : std::string(str, comma);
> }
>
> // Splits a given string on a given delimiter, populating a given
> @@ -648,7 +689,7 @@ template <GTEST_TEMPLATE_ Fixture, class TestSel,
> typename Types>
> class TypeParameterizedTest {
> public:
> // 'index' is the index of the test in the type list 'Types'
> - // specified in INSTANTIATE_TYPED_TEST_CASE_P(Prefix, TestCase,
> + // specified in INSTANTIATE_TYPED_TEST_SUITE_P(Prefix, TestSuite,
> // Types). Valid values for 'index' are [0, N - 1] where N is the
> // length of Types.
> static bool Register(const char* prefix, const CodeLocation&
> code_location,
> @@ -663,13 +704,17 @@ class TypeParameterizedTest {
> // list.
> MakeAndRegisterTestInfo(
> (std::string(prefix) + (prefix[0] == '\0' ? "" : "/") + case_name
> +
> - "/" + type_names[index])
> + "/" + type_names[static_cast<size_t>(index)])
> .c_str(),
> StripTrailingSpaces(GetPrefixUntilComma(test_names)).c_str(),
> GetTypeName<Type>().c_str(),
> - NULL, // No value parameter.
> - code_location, GetTypeId<FixtureClass>(),
> TestClass::SetUpTestCase,
> - TestClass::TearDownTestCase, new TestFactoryImpl<TestClass>);
> + nullptr, // No value parameter.
> + code_location, GetTypeId<FixtureClass>(),
> + SuiteApiResolver<TestClass>::GetSetUpCaseOrSuite(
> + code_location.file.c_str(), code_location.line),
> + SuiteApiResolver<TestClass>::GetTearDownCaseOrSuite(
> + code_location.file.c_str(), code_location.line),
> + new TestFactoryImpl<TestClass>);
>
> // Next, recurses (at compile time) with the tail of the type list.
> return TypeParameterizedTest<Fixture, TestSel,
> @@ -695,15 +740,15 @@ class TypeParameterizedTest<Fixture, TestSel,
> Types0> {
> }
> };
>
> -// TypeParameterizedTestCase<Fixture, Tests, Types>::Register()
> +// TypeParameterizedTestSuite<Fixture, Tests, Types>::Register()
> // registers *all combinations* of 'Tests' and 'Types' with Google
> // Test. The return value is insignificant - we just need to return
> // something such that we can call this function in a namespace scope.
> template <GTEST_TEMPLATE_ Fixture, typename Tests, typename Types>
> -class TypeParameterizedTestCase {
> +class TypeParameterizedTestSuite {
> public:
> static bool Register(const char* prefix, CodeLocation code_location,
> - const TypedTestCasePState* state, const char*
> case_name,
> + const TypedTestSuitePState* state, const char*
> case_name,
> const char* test_names,
> const std::vector<std::string>& type_names =
> GenerateNames<DefaultNameGenerator, Types>()) {
> @@ -726,20 +771,20 @@ class TypeParameterizedTestCase {
> prefix, test_location, case_name, test_names, 0, type_names);
>
> // Next, recurses (at compile time) with the tail of the test list.
> - return TypeParameterizedTestCase<Fixture, typename Tests::Tail,
> - Types>::Register(prefix,
> code_location,
> - state, case_name,
> -
> SkipComma(test_names),
> - type_names);
> + return TypeParameterizedTestSuite<Fixture, typename Tests::Tail,
> + Types>::Register(prefix,
> code_location,
> + state, case_name,
> +
> SkipComma(test_names),
> + type_names);
> }
> };
>
> // The base case for the compile time recursion.
> template <GTEST_TEMPLATE_ Fixture, typename Types>
> -class TypeParameterizedTestCase<Fixture, Templates0, Types> {
> +class TypeParameterizedTestSuite<Fixture, Templates0, Types> {
> public:
> static bool Register(const char* /*prefix*/, const CodeLocation&,
> - const TypedTestCasePState* /*state*/,
> + const TypedTestSuitePState* /*state*/,
> const char* /*case_name*/, const char*
> /*test_names*/,
> const std::vector<std::string>& =
> std::vector<std::string>() /*type_names*/) {
> @@ -802,120 +847,16 @@ class GTEST_API_ Random {
> GTEST_DISALLOW_COPY_AND_ASSIGN_(Random);
> };
>
> -// Defining a variable of type CompileAssertTypesEqual<T1, T2> will cause
> a
> -// compiler error iff T1 and T2 are
> diff erent types.
> -template <typename T1, typename T2>
> -struct CompileAssertTypesEqual;
> -
> -template <typename T>
> -struct CompileAssertTypesEqual<T, T> {
> -};
> -
> -// Removes the reference from a type if it is a reference type,
> -// otherwise leaves it unchanged. This is the same as
> -// tr1::remove_reference, which is not widely available yet.
> -template <typename T>
> -struct RemoveReference { typedef T type; }; // NOLINT
> -template <typename T>
> -struct RemoveReference<T&> { typedef T type; }; // NOLINT
> -
> -// A handy wrapper around RemoveReference that works when the argument
> -// T depends on template parameters.
> -#define GTEST_REMOVE_REFERENCE_(T) \
> - typename ::testing::internal::RemoveReference<T>::type
> -
> -// Removes const from a type if it is a const type, otherwise leaves
> -// it unchanged. This is the same as tr1::remove_const, which is not
> -// widely available yet.
> -template <typename T>
> -struct RemoveConst { typedef T type; }; // NOLINT
> -template <typename T>
> -struct RemoveConst<const T> { typedef T type; }; // NOLINT
> -
> -// MSVC 8.0, Sun C++, and IBM XL C++ have a bug which causes the above
> -// definition to fail to remove the const in 'const int[3]' and 'const
> -// char[3][4]'. The following specialization works around the bug.
> -template <typename T, size_t N>
> -struct RemoveConst<const T[N]> {
> - typedef typename RemoveConst<T>::type type[N];
> -};
> -
> -#if defined(_MSC_VER) && _MSC_VER < 1400
> -// This is the only specialization that allows VC++ 7.1 to remove const in
> -// 'const int[3] and 'const int[3][4]'. However, it causes trouble with
> GCC
> -// and thus needs to be conditionally compiled.
> -template <typename T, size_t N>
> -struct RemoveConst<T[N]> {
> - typedef typename RemoveConst<T>::type type[N];
> -};
> -#endif
> -
> -// A handy wrapper around RemoveConst that works when the argument
> -// T depends on template parameters.
> -#define GTEST_REMOVE_CONST_(T) \
> - typename ::testing::internal::RemoveConst<T>::type
> -
> // Turns const U&, U&, const U, and U all into U.
> #define GTEST_REMOVE_REFERENCE_AND_CONST_(T) \
> - GTEST_REMOVE_CONST_(GTEST_REMOVE_REFERENCE_(T))
> -
> -// ImplicitlyConvertible<From, To>::value is a compile-time bool
> -// constant that's true iff type From can be implicitly converted to
> -// type To.
> -template <typename From, typename To>
> -class ImplicitlyConvertible {
> - private:
> - // We need the following helper functions only for their types.
> - // They have no implementations.
> -
> - // MakeFrom() is an expression whose type is From. We cannot simply
> - // use From(), as the type From may not have a public default
> - // constructor.
> - static typename AddReference<From>::type MakeFrom();
> -
> - // These two functions are overloaded. Given an expression
> - // Helper(x), the compiler will pick the first version if x can be
> - // implicitly converted to type To; otherwise it will pick the
> - // second version.
> - //
> - // The first version returns a value of size 1, and the second
> - // version returns a value of size 2. Therefore, by checking the
> - // size of Helper(x), which can be done at compile time, we can tell
> - // which version of Helper() is used, and hence whether x can be
> - // implicitly converted to type To.
> - static char Helper(To);
> - static char (&Helper(...))[2]; // NOLINT
> -
> - // We have to put the 'public' section after the 'private' section,
> - // or MSVC refuses to compile the code.
> - public:
> -#if defined(__BORLANDC__)
> - // C++Builder cannot use member overload resolution during template
> - // instantiation. The simplest workaround is to use its C++0x type
> traits
> - // functions (C++Builder 2009 and above only).
> - static const bool value = __is_convertible(From, To);
> -#else
> - // MSVC warns about implicitly converting from double to int for
> - // possible loss of data, so we need to temporarily disable the
> - // warning.
> - GTEST_DISABLE_MSC_WARNINGS_PUSH_(4244)
> - static const bool value =
> - sizeof(Helper(ImplicitlyConvertible::MakeFrom())) == 1;
> - GTEST_DISABLE_MSC_WARNINGS_POP_()
> -#endif // __BORLANDC__
> -};
> -template <typename From, typename To>
> -const bool ImplicitlyConvertible<From, To>::value;
> + typename std::remove_const<typename
> std::remove_reference<T>::type>::type
>
> // IsAProtocolMessage<T>::value is a compile-time bool constant that's
> -// true iff T is type ProtocolMessage, proto2::Message, or a subclass
> -// of those.
> +// true if and only if T is type proto2::Message or a subclass of it.
> template <typename T>
> struct IsAProtocolMessage
> : public bool_constant<
> - ImplicitlyConvertible<const T*, const ::ProtocolMessage*>::value ||
> - ImplicitlyConvertible<const T*, const ::proto2::Message*>::value> {
> -};
> + std::is_convertible<const T*, const ::proto2::Message*>::value>
> {};
>
> // When the compiler sees expression IsContainerTest<C>(0), if C is an
> // STL-style container class, the first overload of IsContainerTest
> @@ -942,7 +883,6 @@ struct IsAProtocolMessage
> // IsContainerTest(typename C::const_iterator*) and
> // IsContainerTest(...) doesn't work with Visual Age C++ and Sun C++.
> typedef int IsContainer;
> -#if GTEST_LANG_CXX11
> template <class C,
> class Iterator = decltype(::std::declval<const C&>().begin()),
> class = decltype(::std::declval<const C&>().end()),
> @@ -952,14 +892,6 @@ template <class C,
> IsContainer IsContainerTest(int /* dummy */) {
> return 0;
> }
> -#else
> -template <class C>
> -IsContainer IsContainerTest(int /* dummy */,
> - typename C::iterator* /* it */ = NULL,
> - typename C::const_iterator* /* const_it */ =
> NULL) {
> - return 0;
> -}
> -#endif // GTEST_LANG_CXX11
>
> typedef char IsNotContainer;
> template <class C>
> @@ -980,47 +912,30 @@ struct IsHashTable {
> static char test(...);
>
> public:
> - static const bool value = sizeof(test<T>(0, 0)) == sizeof(int);
> + static const bool value = sizeof(test<T>(nullptr, nullptr)) ==
> sizeof(int);
> };
>
> template <typename T>
> const bool IsHashTable<T>::value;
>
> -template<typename T>
> -struct VoidT {
> - typedef void value_type;
> -};
> -
> -template <typename T, typename = void>
> -struct HasValueType : false_type {};
> -template <typename T>
> -struct HasValueType<T, VoidT<typename T::value_type> > : true_type {
> -};
> -
> template <typename C,
> - bool = sizeof(IsContainerTest<C>(0)) == sizeof(IsContainer),
> - bool = HasValueType<C>::value>
> + bool = sizeof(IsContainerTest<C>(0)) == sizeof(IsContainer)>
> struct IsRecursiveContainerImpl;
>
> -template <typename C, bool HV>
> -struct IsRecursiveContainerImpl<C, false, HV> : public false_type {};
> +template <typename C>
> +struct IsRecursiveContainerImpl<C, false> : public std::false_type {};
>
> // Since the IsRecursiveContainerImpl depends on the IsContainerTest we
> need to
> // obey the same inconsistencies as the IsContainerTest, namely check if
> // something is a container is relying on only const_iterator in C++11 and
> // is relying on both const_iterator and iterator otherwise
> template <typename C>
> -struct IsRecursiveContainerImpl<C, true, false> : public false_type {};
> -
> -template <typename C>
> -struct IsRecursiveContainerImpl<C, true, true> {
> - #if GTEST_LANG_CXX11
> - typedef typename IteratorTraits<typename C::const_iterator>::value_type
> - value_type;
> -#else
> - typedef typename IteratorTraits<typename C::iterator>::value_type
> value_type;
> -#endif
> - typedef is_same<value_type, C> type;
> +struct IsRecursiveContainerImpl<C, true> {
> + using value_type = decltype(*std::declval<typename
> C::const_iterator>());
> + using type =
> + std::is_same<typename std::remove_const<
> + typename
> std::remove_reference<value_type>::type>::type,
> + C>;
> };
>
> // IsRecursiveContainer<Type> is a unary compile-time predicate that
> @@ -1032,13 +947,6 @@ struct IsRecursiveContainerImpl<C, true, true> {
> template <typename C>
> struct IsRecursiveContainer : public IsRecursiveContainerImpl<C>::type {};
>
> -// EnableIf<condition>::type is void when 'Cond' is true, and
> -// undefined when 'Cond' is false. To use SFINAE to make a function
> -// overload only apply when a particular expression is true, add
> -// "typename EnableIf<expression>::type* = 0" as the last parameter.
> -template<bool> struct EnableIf;
> -template<> struct EnableIf<true> { typedef void type; }; // NOLINT
> -
> // Utilities for native arrays.
>
> // ArrayEq() compares two k-dimensional native arrays using the
> @@ -1161,10 +1069,9 @@ class NativeArray {
> }
>
> private:
> - enum {
> - kCheckTypeIsNotConstOrAReference = StaticAssertTypeEqHelper<
> - Element, GTEST_REMOVE_REFERENCE_AND_CONST_(Element)>::value
> - };
> + static_assert(!std::is_const<Element>::value, "Type must not be const");
> + static_assert(!std::is_reference<Element>::value,
> + "Type must not be a reference");
>
> // Initializes this object with a copy of the input.
> void InitCopy(const Element* array, size_t a_size) {
> @@ -1189,6 +1096,139 @@ class NativeArray {
> GTEST_DISALLOW_ASSIGN_(NativeArray);
> };
>
> +// Backport of std::index_sequence.
> +template <size_t... Is>
> +struct IndexSequence {
> + using type = IndexSequence;
> +};
> +
> +// Double the IndexSequence, and one if plus_one is true.
> +template <bool plus_one, typename T, size_t sizeofT>
> +struct DoubleSequence;
> +template <size_t... I, size_t sizeofT>
> +struct DoubleSequence<true, IndexSequence<I...>, sizeofT> {
> + using type = IndexSequence<I..., (sizeofT + I)..., 2 * sizeofT>;
> +};
> +template <size_t... I, size_t sizeofT>
> +struct DoubleSequence<false, IndexSequence<I...>, sizeofT> {
> + using type = IndexSequence<I..., (sizeofT + I)...>;
> +};
> +
> +// Backport of std::make_index_sequence.
> +// It uses O(ln(N)) instantiation depth.
> +template <size_t N>
> +struct MakeIndexSequence
> + : DoubleSequence<N % 2 == 1, typename MakeIndexSequence<N / 2>::type,
> + N / 2>::type {};
> +
> +template <>
> +struct MakeIndexSequence<0> : IndexSequence<> {};
> +
> +// FIXME: This implementation of ElemFromList is O(1) in instantiation
> depth,
> +// but it is O(N^2) in total instantiations. Not sure if this is the best
> +// tradeoff, as it will make it somewhat slow to compile.
> +template <typename T, size_t, size_t>
> +struct ElemFromListImpl {};
> +
> +template <typename T, size_t I>
> +struct ElemFromListImpl<T, I, I> {
> + using type = T;
> +};
> +
> +// Get the Nth element from T...
> +// It uses O(1) instantiation depth.
> +template <size_t N, typename I, typename... T>
> +struct ElemFromList;
> +
> +template <size_t N, size_t... I, typename... T>
> +struct ElemFromList<N, IndexSequence<I...>, T...>
> + : ElemFromListImpl<T, N, I>... {};
> +
> +template <typename... T>
> +class FlatTuple;
> +
> +template <typename Derived, size_t I>
> +struct FlatTupleElemBase;
> +
> +template <typename... T, size_t I>
> +struct FlatTupleElemBase<FlatTuple<T...>, I> {
> + using value_type =
> + typename ElemFromList<I, typename
> MakeIndexSequence<sizeof...(T)>::type,
> + T...>::type;
> + FlatTupleElemBase() = default;
> + explicit FlatTupleElemBase(value_type t) : value(std::move(t)) {}
> + value_type value;
> +};
> +
> +template <typename Derived, typename Idx>
> +struct FlatTupleBase;
> +
> +template <size_t... Idx, typename... T>
> +struct FlatTupleBase<FlatTuple<T...>, IndexSequence<Idx...>>
> + : FlatTupleElemBase<FlatTuple<T...>, Idx>... {
> + using Indices = IndexSequence<Idx...>;
> + FlatTupleBase() = default;
> + explicit FlatTupleBase(T... t)
> + : FlatTupleElemBase<FlatTuple<T...>, Idx>(std::move(t))... {}
> +};
> +
> +// Analog to std::tuple but with
> diff erent tradeoffs.
> +// This class minimizes the template instantiation depth, thus allowing
> more
> +// elements that std::tuple would. std::tuple has been seen to require an
> +// instantiation depth of more than 10x the number of elements in some
> +// implementations.
> +// FlatTuple and ElemFromList are not recursive and have a fixed depth
> +// regardless of T...
> +// MakeIndexSequence, on the other hand, it is recursive but with an
> +// instantiation depth of O(ln(N)).
> +template <typename... T>
> +class FlatTuple
> + : private FlatTupleBase<FlatTuple<T...>,
> + typename
> MakeIndexSequence<sizeof...(T)>::type> {
> + using Indices = typename FlatTuple::FlatTupleBase::Indices;
> +
> + public:
> + FlatTuple() = default;
> + explicit FlatTuple(T... t) : FlatTuple::FlatTupleBase(std::move(t)...)
> {}
> +
> + template <size_t I>
> + const typename ElemFromList<I, Indices, T...>::type& Get() const {
> + return static_cast<const FlatTupleElemBase<FlatTuple,
> I>*>(this)->value;
> + }
> +
> + template <size_t I>
> + typename ElemFromList<I, Indices, T...>::type& Get() {
> + return static_cast<FlatTupleElemBase<FlatTuple, I>*>(this)->value;
> + }
> +};
> +
> +// Utility functions to be called with static_assert to induce deprecation
> +// warnings.
> +GTEST_INTERNAL_DEPRECATED(
> + "INSTANTIATE_TEST_CASE_P is deprecated, please use "
> + "INSTANTIATE_TEST_SUITE_P")
> +constexpr bool InstantiateTestCase_P_IsDeprecated() { return true; }
> +
> +GTEST_INTERNAL_DEPRECATED(
> + "TYPED_TEST_CASE_P is deprecated, please use "
> + "TYPED_TEST_SUITE_P")
> +constexpr bool TypedTestCase_P_IsDeprecated() { return true; }
> +
> +GTEST_INTERNAL_DEPRECATED(
> + "TYPED_TEST_CASE is deprecated, please use "
> + "TYPED_TEST_SUITE")
> +constexpr bool TypedTestCaseIsDeprecated() { return true; }
> +
> +GTEST_INTERNAL_DEPRECATED(
> + "REGISTER_TYPED_TEST_CASE_P is deprecated, please use "
> + "REGISTER_TYPED_TEST_SUITE_P")
> +constexpr bool RegisterTypedTestCase_P_IsDeprecated() { return true; }
> +
> +GTEST_INTERNAL_DEPRECATED(
> + "INSTANTIATE_TYPED_TEST_CASE_P is deprecated, please use "
> + "INSTANTIATE_TYPED_TEST_SUITE_P")
> +constexpr bool InstantiateTypedTestCase_P_IsDeprecated() { return true; }
> +
> } // namespace internal
> } // namespace testing
>
> @@ -1208,7 +1248,10 @@ class NativeArray {
> #define GTEST_SUCCESS_(message) \
> GTEST_MESSAGE_(message, ::testing::TestPartResult::kSuccess)
>
> -// Suppress MSVC warning 4702 (unreachable code) for the code following
> +#define GTEST_SKIP_(message) \
> + return GTEST_MESSAGE_(message, ::testing::TestPartResult::kSkip)
> +
> +// Suppress MSVC warning 4072 (unreachable code) for the code following
> // statement if it returns or throws (or doesn't return or throw in some
> // situations).
> #define GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement) \
> @@ -1300,31 +1343,38 @@ class NativeArray {
> " Actual: it does.")
>
> // Expands to the name of the class that implements the given test.
> -#define GTEST_TEST_CLASS_NAME_(test_case_name, test_name) \
> - test_case_name##_##test_name##_Test
> +#define GTEST_TEST_CLASS_NAME_(test_suite_name, test_name) \
> + test_suite_name##_##test_name##_Test
>
> // Helper macro for defining tests.
> -#define GTEST_TEST_(test_case_name, test_name, parent_class, parent_id)\
> -class GTEST_TEST_CLASS_NAME_(test_case_name, test_name) : public
> parent_class {\
> - public:\
> - GTEST_TEST_CLASS_NAME_(test_case_name, test_name)() {}\
> - private:\
> - virtual void TestBody();\
> - static ::testing::TestInfo* const test_info_ GTEST_ATTRIBUTE_UNUSED_;\
> - GTEST_DISALLOW_COPY_AND_ASSIGN_(\
> - GTEST_TEST_CLASS_NAME_(test_case_name, test_name));\
> -};\
> -\
> -::testing::TestInfo* const GTEST_TEST_CLASS_NAME_(test_case_name,
> test_name)\
> - ::test_info_ =\
> - ::testing::internal::MakeAndRegisterTestInfo(\
> - #test_case_name, #test_name, NULL, NULL, \
> - ::testing::internal::CodeLocation(__FILE__, __LINE__), \
> - (parent_id), \
> - parent_class::SetUpTestCase, \
> - parent_class::TearDownTestCase, \
> - new ::testing::internal::TestFactoryImpl<\
> - GTEST_TEST_CLASS_NAME_(test_case_name, test_name)>);\
> -void GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::TestBody()
> +#define GTEST_TEST_(test_suite_name, test_name, parent_class, parent_id)
> \
> + static_assert(sizeof(GTEST_STRINGIFY_(test_suite_name)) > 1,
> \
> + "test_suite_name must not be empty");
> \
> + static_assert(sizeof(GTEST_STRINGIFY_(test_name)) > 1,
> \
> + "test_name must not be empty");
> \
> + class GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)
> \
> + : public parent_class {
> \
> + public:
> \
> + GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)() {}
> \
> +
> \
> + private:
> \
> + virtual void TestBody();
> \
> + static ::testing::TestInfo* const test_info_
> GTEST_ATTRIBUTE_UNUSED_; \
> +
> GTEST_DISALLOW_COPY_AND_ASSIGN_(GTEST_TEST_CLASS_NAME_(test_suite_name, \
> + test_name));
> \
> + };
> \
> +
> \
> + ::testing::TestInfo* const GTEST_TEST_CLASS_NAME_(test_suite_name,
> \
> +
> test_name)::test_info_ = \
> + ::testing::internal::MakeAndRegisterTestInfo(
> \
> + #test_suite_name, #test_name, nullptr, nullptr,
> \
> + ::testing::internal::CodeLocation(__FILE__, __LINE__),
> (parent_id), \
> + ::testing::internal::SuiteApiResolver<
> \
> + parent_class>::GetSetUpCaseOrSuite(__FILE__, __LINE__),
> \
> + ::testing::internal::SuiteApiResolver<
> \
> + parent_class>::GetTearDownCaseOrSuite(__FILE__, __LINE__),
> \
> + new
> ::testing::internal::TestFactoryImpl<GTEST_TEST_CLASS_NAME_( \
> + test_suite_name, test_name)>);
> \
> + void GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)::TestBody()
>
> #endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_
>
> diff --git
> a/llvm/utils/unittest/googletest/include/gtest/internal/gtest-linked_ptr.h
> b/llvm/utils/unittest/googletest/include/gtest/internal/gtest-linked_ptr.h
> deleted file mode 100644
> index 082b87289ae17..0000000000000
> ---
> a/llvm/utils/unittest/googletest/include/gtest/internal/gtest-linked_ptr.h
> +++ /dev/null
> @@ -1,243 +0,0 @@
> -// Copyright 2003 Google Inc.
> -// All rights reserved.
> -//
> -// Redistribution and use in source and binary forms, with or without
> -// modification, are permitted provided that the following conditions are
> -// met:
> -//
> -// * Redistributions of source code must retain the above copyright
> -// notice, this list of conditions and the following disclaimer.
> -// * Redistributions in binary form must reproduce the above
> -// copyright notice, this list of conditions and the following disclaimer
> -// in the documentation and/or other materials provided with the
> -// distribution.
> -// * Neither the name of Google Inc. nor the names of its
> -// contributors may be used to endorse or promote products derived from
> -// this software without specific prior written permission.
> -//
> -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
> -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
> -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
> -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
> -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
> -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
> -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
> -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
> -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
> -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
> -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
> -//
> -// A "smart" pointer type with reference tracking. Every pointer to a
> -// particular object is kept on a circular linked list. When the last
> pointer
> -// to an object is destroyed or reassigned, the object is deleted.
> -//
> -// Used properly, this deletes the object when the last reference goes
> away.
> -// There are several caveats:
> -// - Like all reference counting schemes, cycles lead to leaks.
> -// - Each smart pointer is actually two pointers (8 bytes instead of 4).
> -// - Every time a pointer is assigned, the entire list of pointers to that
> -// object is traversed. This class is therefore NOT SUITABLE when there
> -// will often be more than two or three pointers to a particular object.
> -// - References are only tracked as long as linked_ptr<> objects are
> copied.
> -// If a linked_ptr<> is converted to a raw pointer and back, BAD THINGS
> -// will happen (double deletion).
> -//
> -// A good use of this class is storing object references in STL
> containers.
> -// You can safely put linked_ptr<> in a vector<>.
> -// Other uses may not be as good.
> -//
> -// Note: If you use an incomplete type with linked_ptr<>, the class
> -// *containing* linked_ptr<> must have a constructor and destructor (even
> -// if they do nothing!).
> -//
> -// Bill Gibbons suggested we use something like this.
> -//
> -// Thread Safety:
> -// Unlike other linked_ptr implementations, in this implementation
> -// a linked_ptr object is thread-safe in the sense that:
> -// - it's safe to copy linked_ptr objects concurrently,
> -// - it's safe to copy *from* a linked_ptr and read its underlying
> -// raw pointer (e.g. via get()) concurrently, and
> -// - it's safe to write to two linked_ptrs that point to the same
> -// shared object concurrently.
> -// FIXME: rename this to safe_linked_ptr to avoid
> -// confusion with normal linked_ptr.
> -
> -// GOOGLETEST_CM0001 DO NOT DELETE
> -
> -#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_LINKED_PTR_H_
> -#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_LINKED_PTR_H_
> -
> -#include <stdlib.h>
> -#include <assert.h>
> -
> -#include "gtest/internal/gtest-port.h"
> -
> -namespace testing {
> -namespace internal {
> -
> -// Protects copying of all linked_ptr objects.
> -GTEST_API_ GTEST_DECLARE_STATIC_MUTEX_(g_linked_ptr_mutex);
> -
> -// This is used internally by all instances of linked_ptr<>. It needs to
> be
> -// a non-template class because
> diff erent types of linked_ptr<> can refer to
> -// the same object (linked_ptr<Superclass>(obj) vs
> linked_ptr<Subclass>(obj)).
> -// So, it needs to be possible for
> diff erent types of linked_ptr to participate
> -// in the same circular linked list, so we need a single class type here.
> -//
> -// DO NOT USE THIS CLASS DIRECTLY YOURSELF. Use linked_ptr<T>.
> -class linked_ptr_internal {
> - public:
> - // Create a new circle that includes only this instance.
> - void join_new() {
> - next_ = this;
> - }
> -
> - // Many linked_ptr operations may change p.link_ for some linked_ptr
> - // variable p in the same circle as this object. Therefore we need
> - // to prevent two such operations from occurring concurrently.
> - //
> - // Note that
> diff erent types of linked_ptr objects can coexist in a
> - // circle (e.g. linked_ptr<Base>, linked_ptr<Derived1>, and
> - // linked_ptr<Derived2>). Therefore we must use a single mutex to
> - // protect all linked_ptr objects. This can create serious
> - // contention in production code, but is acceptable in a testing
> - // framework.
> -
> - // Join an existing circle.
> - void join(linked_ptr_internal const* ptr)
> - GTEST_LOCK_EXCLUDED_(g_linked_ptr_mutex) {
> - MutexLock lock(&g_linked_ptr_mutex);
> -
> - linked_ptr_internal const* p = ptr;
> - while (p->next_ != ptr) {
> - assert(p->next_ != this &&
> - "Trying to join() a linked ring we are already in. "
> - "Is GMock thread safety enabled?");
> - p = p->next_;
> - }
> - p->next_ = this;
> - next_ = ptr;
> - }
> -
> - // Leave whatever circle we're part of. Returns true if we were the
> - // last member of the circle. Once this is done, you can join()
> another.
> - bool depart()
> - GTEST_LOCK_EXCLUDED_(g_linked_ptr_mutex) {
> - MutexLock lock(&g_linked_ptr_mutex);
> -
> - if (next_ == this) return true;
> - linked_ptr_internal const* p = next_;
> - while (p->next_ != this) {
> - assert(p->next_ != next_ &&
> - "Trying to depart() a linked ring we are not in. "
> - "Is GMock thread safety enabled?");
> - p = p->next_;
> - }
> - p->next_ = next_;
> - return false;
> - }
> -
> - private:
> - mutable linked_ptr_internal const* next_;
> -};
> -
> -template <typename T>
> -class linked_ptr {
> - public:
> - typedef T element_type;
> -
> - // Take over ownership of a raw pointer. This should happen as soon as
> - // possible after the object is created.
> - explicit linked_ptr(T* ptr = NULL) { capture(ptr); }
> - ~linked_ptr() { depart(); }
> -
> - // Copy an existing linked_ptr<>, adding ourselves to the list of
> references.
> - template <typename U> linked_ptr(linked_ptr<U> const& ptr) {
> copy(&ptr); }
> - linked_ptr(linked_ptr const& ptr) { // NOLINT
> - assert(&ptr != this);
> - copy(&ptr);
> - }
> -
> - // Assignment releases the old value and acquires the new.
> - template <typename U> linked_ptr& operator=(linked_ptr<U> const& ptr) {
> - depart();
> - copy(&ptr);
> - return *this;
> - }
> -
> - linked_ptr& operator=(linked_ptr const& ptr) {
> - if (&ptr != this) {
> - depart();
> - copy(&ptr);
> - }
> - return *this;
> - }
> -
> - // Smart pointer members.
> - void reset(T* ptr = NULL) {
> - depart();
> - capture(ptr);
> - }
> - T* get() const { return value_; }
> - T* operator->() const { return value_; }
> - T& operator*() const { return *value_; }
> -
> - bool operator==(T* p) const { return value_ == p; }
> - bool operator!=(T* p) const { return value_ != p; }
> - template <typename U>
> - bool operator==(linked_ptr<U> const& ptr) const {
> - return value_ == ptr.get();
> - }
> - template <typename U>
> - bool operator!=(linked_ptr<U> const& ptr) const {
> - return value_ != ptr.get();
> - }
> -
> - private:
> - template <typename U>
> - friend class linked_ptr;
> -
> - T* value_;
> - linked_ptr_internal link_;
> -
> - void depart() {
> - if (link_.depart()) delete value_;
> - }
> -
> - void capture(T* ptr) {
> - value_ = ptr;
> - link_.join_new();
> - }
> -
> - template <typename U> void copy(linked_ptr<U> const* ptr) {
> - value_ = ptr->get();
> - if (value_)
> - link_.join(&ptr->link_);
> - else
> - link_.join_new();
> - }
> -};
> -
> -template<typename T> inline
> -bool operator==(T* ptr, const linked_ptr<T>& x) {
> - return ptr == x.get();
> -}
> -
> -template<typename T> inline
> -bool operator!=(T* ptr, const linked_ptr<T>& x) {
> - return ptr != x.get();
> -}
> -
> -// A function to convert T* into linked_ptr<T>
> -// Doing e.g. make_linked_ptr(new FooBarBaz<type>(arg)) is a shorter
> notation
> -// for linked_ptr<FooBarBaz<type> >(new FooBarBaz<type>(arg))
> -template <typename T>
> -linked_ptr<T> make_linked_ptr(T* ptr) {
> - return linked_ptr<T>(ptr);
> -}
> -
> -} // namespace internal
> -} // namespace testing
> -
> -#endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_LINKED_PTR_H_
>
> diff --git
> a/llvm/utils/unittest/googletest/include/gtest/internal/gtest-param-util-generated.h
> b/llvm/utils/unittest/googletest/include/gtest/internal/gtest-param-util-generated.h
> deleted file mode 100644
> index a6f49b256ab52..0000000000000
> ---
> a/llvm/utils/unittest/googletest/include/gtest/internal/gtest-param-util-generated.h
> +++ /dev/null
> @@ -1,5565 +0,0 @@
> -// This file was GENERATED by command:
> -// pump.py gtest-param-util-generated.h.pump
> -// DO NOT EDIT BY HAND!!!
> -
> -// Copyright 2008 Google Inc.
> -// All Rights Reserved.
> -//
> -// Redistribution and use in source and binary forms, with or without
> -// modification, are permitted provided that the following conditions are
> -// met:
> -//
> -// * Redistributions of source code must retain the above copyright
> -// notice, this list of conditions and the following disclaimer.
> -// * Redistributions in binary form must reproduce the above
> -// copyright notice, this list of conditions and the following disclaimer
> -// in the documentation and/or other materials provided with the
> -// distribution.
> -// * Neither the name of Google Inc. nor the names of its
> -// contributors may be used to endorse or promote products derived from
> -// this software without specific prior written permission.
> -//
> -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
> -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
> -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
> -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
> -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
> -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
> -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
> -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
> -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
> -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
> -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
> -
> -
> -// Type and function utilities for implementing parameterized tests.
> -// This file is generated by a SCRIPT. DO NOT EDIT BY HAND!
> -//
> -// Currently Google Test supports at most 50 arguments in Values,
> -// and at most 10 arguments in Combine. Please contact
> -// googletestframework at googlegroups.com if you need more.
> -// Please note that the number of arguments to Combine is limited
> -// by the maximum arity of the implementation of tuple which is
> -// currently set at 10.
> -
> -// GOOGLETEST_CM0001 DO NOT DELETE
> -
> -#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_GENERATED_H_
> -#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_GENERATED_H_
> -
> -#include "gtest/internal/gtest-param-util.h"
> -#include "gtest/internal/gtest-port.h"
> -
> -#ifdef __clang__
> -#if __has_warning("-Wdeprecated-copy")
> -#pragma clang diagnostic push
> -#pragma clang diagnostic ignored "-Wdeprecated-copy"
> -#endif
> -#endif
> -
> -namespace testing {
> -
> -// Forward declarations of ValuesIn(), which is implemented in
> -// include/gtest/gtest-param-test.h.
> -template <typename ForwardIterator>
> -internal::ParamGenerator<
> - typename
> ::testing::internal::IteratorTraits<ForwardIterator>::value_type>
> -ValuesIn(ForwardIterator begin, ForwardIterator end);
> -
> -template <typename T, size_t N>
> -internal::ParamGenerator<T> ValuesIn(const T (&array)[N]);
> -
> -template <class Container>
> -internal::ParamGenerator<typename Container::value_type> ValuesIn(
> - const Container& container);
> -
> -namespace internal {
> -
> -// Used in the Values() function to provide polymorphic capabilities.
> -template <typename T1>
> -class ValueArray1 {
> - public:
> - explicit ValueArray1(T1 v1) : v1_(v1) {}
> -
> - template <typename T>
> - operator ParamGenerator<T>() const {
> - const T array[] = {static_cast<T>(v1_)};
> - return ValuesIn(array);
> - }
> -
> - ValueArray1(const ValueArray1& other) : v1_(other.v1_) {}
> -
> - private:
> - // No implementation - assignment is unsupported.
> - void operator=(const ValueArray1& other);
> -
> - const T1 v1_;
> -};
> -
> -template <typename T1, typename T2>
> -class ValueArray2 {
> - public:
> - ValueArray2(T1 v1, T2 v2) : v1_(v1), v2_(v2) {}
> -
> - template <typename T>
> - operator ParamGenerator<T>() const {
> - const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_)};
> - return ValuesIn(array);
> - }
> -
> - ValueArray2(const ValueArray2& other) : v1_(other.v1_), v2_(other.v2_)
> {}
> -
> - private:
> - // No implementation - assignment is unsupported.
> - void operator=(const ValueArray2& other);
> -
> - const T1 v1_;
> - const T2 v2_;
> -};
> -
> -template <typename T1, typename T2, typename T3>
> -class ValueArray3 {
> - public:
> - ValueArray3(T1 v1, T2 v2, T3 v3) : v1_(v1), v2_(v2), v3_(v3) {}
> -
> - template <typename T>
> - operator ParamGenerator<T>() const {
> - const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> - static_cast<T>(v3_)};
> - return ValuesIn(array);
> - }
> -
> - ValueArray3(const ValueArray3& other) : v1_(other.v1_), v2_(other.v2_),
> - v3_(other.v3_) {}
> -
> - private:
> - // No implementation - assignment is unsupported.
> - void operator=(const ValueArray3& other);
> -
> - const T1 v1_;
> - const T2 v2_;
> - const T3 v3_;
> -};
> -
> -template <typename T1, typename T2, typename T3, typename T4>
> -class ValueArray4 {
> - public:
> - ValueArray4(T1 v1, T2 v2, T3 v3, T4 v4) : v1_(v1), v2_(v2), v3_(v3),
> - v4_(v4) {}
> -
> - template <typename T>
> - operator ParamGenerator<T>() const {
> - const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> - static_cast<T>(v3_), static_cast<T>(v4_)};
> - return ValuesIn(array);
> - }
> -
> - ValueArray4(const ValueArray4& other) : v1_(other.v1_), v2_(other.v2_),
> - v3_(other.v3_), v4_(other.v4_) {}
> -
> - private:
> - // No implementation - assignment is unsupported.
> - void operator=(const ValueArray4& other);
> -
> - const T1 v1_;
> - const T2 v2_;
> - const T3 v3_;
> - const T4 v4_;
> -};
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5>
> -class ValueArray5 {
> - public:
> - ValueArray5(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5) : v1_(v1), v2_(v2),
> v3_(v3),
> - v4_(v4), v5_(v5) {}
> -
> - template <typename T>
> - operator ParamGenerator<T>() const {
> - const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> - static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_)};
> - return ValuesIn(array);
> - }
> -
> - ValueArray5(const ValueArray5& other) : v1_(other.v1_), v2_(other.v2_),
> - v3_(other.v3_), v4_(other.v4_), v5_(other.v5_) {}
> -
> - private:
> - // No implementation - assignment is unsupported.
> - void operator=(const ValueArray5& other);
> -
> - const T1 v1_;
> - const T2 v2_;
> - const T3 v3_;
> - const T4 v4_;
> - const T5 v5_;
> -};
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6>
> -class ValueArray6 {
> - public:
> - ValueArray6(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6) : v1_(v1),
> v2_(v2),
> - v3_(v3), v4_(v4), v5_(v5), v6_(v6) {}
> -
> - template <typename T>
> - operator ParamGenerator<T>() const {
> - const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> - static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> - static_cast<T>(v6_)};
> - return ValuesIn(array);
> - }
> -
> - ValueArray6(const ValueArray6& other) : v1_(other.v1_), v2_(other.v2_),
> - v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_) {}
> -
> - private:
> - // No implementation - assignment is unsupported.
> - void operator=(const ValueArray6& other);
> -
> - const T1 v1_;
> - const T2 v2_;
> - const T3 v3_;
> - const T4 v4_;
> - const T5 v5_;
> - const T6 v6_;
> -};
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7>
> -class ValueArray7 {
> - public:
> - ValueArray7(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7) : v1_(v1),
> - v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7) {}
> -
> - template <typename T>
> - operator ParamGenerator<T>() const {
> - const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> - static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> - static_cast<T>(v6_), static_cast<T>(v7_)};
> - return ValuesIn(array);
> - }
> -
> - ValueArray7(const ValueArray7& other) : v1_(other.v1_), v2_(other.v2_),
> - v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
> - v7_(other.v7_) {}
> -
> - private:
> - // No implementation - assignment is unsupported.
> - void operator=(const ValueArray7& other);
> -
> - const T1 v1_;
> - const T2 v2_;
> - const T3 v3_;
> - const T4 v4_;
> - const T5 v5_;
> - const T6 v6_;
> - const T7 v7_;
> -};
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8>
> -class ValueArray8 {
> - public:
> - ValueArray8(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7,
> - T8 v8) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6),
> v7_(v7),
> - v8_(v8) {}
> -
> - template <typename T>
> - operator ParamGenerator<T>() const {
> - const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> - static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> - static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_)};
> - return ValuesIn(array);
> - }
> -
> - ValueArray8(const ValueArray8& other) : v1_(other.v1_), v2_(other.v2_),
> - v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
> - v7_(other.v7_), v8_(other.v8_) {}
> -
> - private:
> - // No implementation - assignment is unsupported.
> - void operator=(const ValueArray8& other);
> -
> - const T1 v1_;
> - const T2 v2_;
> - const T3 v3_;
> - const T4 v4_;
> - const T5 v5_;
> - const T6 v6_;
> - const T7 v7_;
> - const T8 v8_;
> -};
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9>
> -class ValueArray9 {
> - public:
> - ValueArray9(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8,
> - T9 v9) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6),
> v7_(v7),
> - v8_(v8), v9_(v9) {}
> -
> - template <typename T>
> - operator ParamGenerator<T>() const {
> - const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> - static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> - static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> - static_cast<T>(v9_)};
> - return ValuesIn(array);
> - }
> -
> - ValueArray9(const ValueArray9& other) : v1_(other.v1_), v2_(other.v2_),
> - v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
> - v7_(other.v7_), v8_(other.v8_), v9_(other.v9_) {}
> -
> - private:
> - // No implementation - assignment is unsupported.
> - void operator=(const ValueArray9& other);
> -
> - const T1 v1_;
> - const T2 v2_;
> - const T3 v3_;
> - const T4 v4_;
> - const T5 v5_;
> - const T6 v6_;
> - const T7 v7_;
> - const T8 v8_;
> - const T9 v9_;
> -};
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10>
> -class ValueArray10 {
> - public:
> - ValueArray10(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9
> v9,
> - T10 v10) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6),
> v7_(v7),
> - v8_(v8), v9_(v9), v10_(v10) {}
> -
> - template <typename T>
> - operator ParamGenerator<T>() const {
> - const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> - static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> - static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> - static_cast<T>(v9_), static_cast<T>(v10_)};
> - return ValuesIn(array);
> - }
> -
> - ValueArray10(const ValueArray10& other) : v1_(other.v1_),
> v2_(other.v2_),
> - v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
> - v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_) {}
> -
> - private:
> - // No implementation - assignment is unsupported.
> - void operator=(const ValueArray10& other);
> -
> - const T1 v1_;
> - const T2 v2_;
> - const T3 v3_;
> - const T4 v4_;
> - const T5 v5_;
> - const T6 v6_;
> - const T7 v7_;
> - const T8 v8_;
> - const T9 v9_;
> - const T10 v10_;
> -};
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11>
> -class ValueArray11 {
> - public:
> - ValueArray11(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9
> v9,
> - T10 v10, T11 v11) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5),
> v6_(v6),
> - v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11) {}
> -
> - template <typename T>
> - operator ParamGenerator<T>() const {
> - const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> - static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> - static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> - static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_)};
> - return ValuesIn(array);
> - }
> -
> - ValueArray11(const ValueArray11& other) : v1_(other.v1_),
> v2_(other.v2_),
> - v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
> - v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
> - v11_(other.v11_) {}
> -
> - private:
> - // No implementation - assignment is unsupported.
> - void operator=(const ValueArray11& other);
> -
> - const T1 v1_;
> - const T2 v2_;
> - const T3 v3_;
> - const T4 v4_;
> - const T5 v5_;
> - const T6 v6_;
> - const T7 v7_;
> - const T8 v8_;
> - const T9 v9_;
> - const T10 v10_;
> - const T11 v11_;
> -};
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11, typename T12>
> -class ValueArray12 {
> - public:
> - ValueArray12(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9
> v9,
> - T10 v10, T11 v11, T12 v12) : v1_(v1), v2_(v2), v3_(v3), v4_(v4),
> v5_(v5),
> - v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12)
> {}
> -
> - template <typename T>
> - operator ParamGenerator<T>() const {
> - const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> - static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> - static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> - static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
> - static_cast<T>(v12_)};
> - return ValuesIn(array);
> - }
> -
> - ValueArray12(const ValueArray12& other) : v1_(other.v1_),
> v2_(other.v2_),
> - v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
> - v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
> - v11_(other.v11_), v12_(other.v12_) {}
> -
> - private:
> - // No implementation - assignment is unsupported.
> - void operator=(const ValueArray12& other);
> -
> - const T1 v1_;
> - const T2 v2_;
> - const T3 v3_;
> - const T4 v4_;
> - const T5 v5_;
> - const T6 v6_;
> - const T7 v7_;
> - const T8 v8_;
> - const T9 v9_;
> - const T10 v10_;
> - const T11 v11_;
> - const T12 v12_;
> -};
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11, typename T12, typename T13>
> -class ValueArray13 {
> - public:
> - ValueArray13(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9
> v9,
> - T10 v10, T11 v11, T12 v12, T13 v13) : v1_(v1), v2_(v2), v3_(v3),
> v4_(v4),
> - v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11),
> - v12_(v12), v13_(v13) {}
> -
> - template <typename T>
> - operator ParamGenerator<T>() const {
> - const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> - static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> - static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> - static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
> - static_cast<T>(v12_), static_cast<T>(v13_)};
> - return ValuesIn(array);
> - }
> -
> - ValueArray13(const ValueArray13& other) : v1_(other.v1_),
> v2_(other.v2_),
> - v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
> - v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
> - v11_(other.v11_), v12_(other.v12_), v13_(other.v13_) {}
> -
> - private:
> - // No implementation - assignment is unsupported.
> - void operator=(const ValueArray13& other);
> -
> - const T1 v1_;
> - const T2 v2_;
> - const T3 v3_;
> - const T4 v4_;
> - const T5 v5_;
> - const T6 v6_;
> - const T7 v7_;
> - const T8 v8_;
> - const T9 v9_;
> - const T10 v10_;
> - const T11 v11_;
> - const T12 v12_;
> - const T13 v13_;
> -};
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11, typename T12, typename T13, typename T14>
> -class ValueArray14 {
> - public:
> - ValueArray14(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9
> v9,
> - T10 v10, T11 v11, T12 v12, T13 v13, T14 v14) : v1_(v1), v2_(v2),
> v3_(v3),
> - v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),
> - v11_(v11), v12_(v12), v13_(v13), v14_(v14) {}
> -
> - template <typename T>
> - operator ParamGenerator<T>() const {
> - const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> - static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> - static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> - static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
> - static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_)};
> - return ValuesIn(array);
> - }
> -
> - ValueArray14(const ValueArray14& other) : v1_(other.v1_),
> v2_(other.v2_),
> - v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
> - v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
> - v11_(other.v11_), v12_(other.v12_), v13_(other.v13_),
> v14_(other.v14_) {}
> -
> - private:
> - // No implementation - assignment is unsupported.
> - void operator=(const ValueArray14& other);
> -
> - const T1 v1_;
> - const T2 v2_;
> - const T3 v3_;
> - const T4 v4_;
> - const T5 v5_;
> - const T6 v6_;
> - const T7 v7_;
> - const T8 v8_;
> - const T9 v9_;
> - const T10 v10_;
> - const T11 v11_;
> - const T12 v12_;
> - const T13 v13_;
> - const T14 v14_;
> -};
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11, typename T12, typename T13, typename T14, typename T15>
> -class ValueArray15 {
> - public:
> - ValueArray15(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9
> v9,
> - T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15) : v1_(v1),
> v2_(v2),
> - v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9),
> v10_(v10),
> - v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15) {}
> -
> - template <typename T>
> - operator ParamGenerator<T>() const {
> - const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> - static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> - static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> - static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
> - static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
> - static_cast<T>(v15_)};
> - return ValuesIn(array);
> - }
> -
> - ValueArray15(const ValueArray15& other) : v1_(other.v1_),
> v2_(other.v2_),
> - v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
> - v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
> - v11_(other.v11_), v12_(other.v12_), v13_(other.v13_),
> v14_(other.v14_),
> - v15_(other.v15_) {}
> -
> - private:
> - // No implementation - assignment is unsupported.
> - void operator=(const ValueArray15& other);
> -
> - const T1 v1_;
> - const T2 v2_;
> - const T3 v3_;
> - const T4 v4_;
> - const T5 v5_;
> - const T6 v6_;
> - const T7 v7_;
> - const T8 v8_;
> - const T9 v9_;
> - const T10 v10_;
> - const T11 v11_;
> - const T12 v12_;
> - const T13 v13_;
> - const T14 v14_;
> - const T15 v15_;
> -};
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11, typename T12, typename T13, typename T14, typename T15,
> - typename T16>
> -class ValueArray16 {
> - public:
> - ValueArray16(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9
> v9,
> - T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16) :
> v1_(v1),
> - v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8),
> v9_(v9),
> - v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15),
> - v16_(v16) {}
> -
> - template <typename T>
> - operator ParamGenerator<T>() const {
> - const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> - static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> - static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> - static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
> - static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
> - static_cast<T>(v15_), static_cast<T>(v16_)};
> - return ValuesIn(array);
> - }
> -
> - ValueArray16(const ValueArray16& other) : v1_(other.v1_),
> v2_(other.v2_),
> - v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
> - v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
> - v11_(other.v11_), v12_(other.v12_), v13_(other.v13_),
> v14_(other.v14_),
> - v15_(other.v15_), v16_(other.v16_) {}
> -
> - private:
> - // No implementation - assignment is unsupported.
> - void operator=(const ValueArray16& other);
> -
> - const T1 v1_;
> - const T2 v2_;
> - const T3 v3_;
> - const T4 v4_;
> - const T5 v5_;
> - const T6 v6_;
> - const T7 v7_;
> - const T8 v8_;
> - const T9 v9_;
> - const T10 v10_;
> - const T11 v11_;
> - const T12 v12_;
> - const T13 v13_;
> - const T14 v14_;
> - const T15 v15_;
> - const T16 v16_;
> -};
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11, typename T12, typename T13, typename T14, typename T15,
> - typename T16, typename T17>
> -class ValueArray17 {
> - public:
> - ValueArray17(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9
> v9,
> - T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16,
> - T17 v17) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6),
> v7_(v7),
> - v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13),
> v14_(v14),
> - v15_(v15), v16_(v16), v17_(v17) {}
> -
> - template <typename T>
> - operator ParamGenerator<T>() const {
> - const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> - static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> - static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> - static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
> - static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
> - static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_)};
> - return ValuesIn(array);
> - }
> -
> - ValueArray17(const ValueArray17& other) : v1_(other.v1_),
> v2_(other.v2_),
> - v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
> - v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
> - v11_(other.v11_), v12_(other.v12_), v13_(other.v13_),
> v14_(other.v14_),
> - v15_(other.v15_), v16_(other.v16_), v17_(other.v17_) {}
> -
> - private:
> - // No implementation - assignment is unsupported.
> - void operator=(const ValueArray17& other);
> -
> - const T1 v1_;
> - const T2 v2_;
> - const T3 v3_;
> - const T4 v4_;
> - const T5 v5_;
> - const T6 v6_;
> - const T7 v7_;
> - const T8 v8_;
> - const T9 v9_;
> - const T10 v10_;
> - const T11 v11_;
> - const T12 v12_;
> - const T13 v13_;
> - const T14 v14_;
> - const T15 v15_;
> - const T16 v16_;
> - const T17 v17_;
> -};
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11, typename T12, typename T13, typename T14, typename T15,
> - typename T16, typename T17, typename T18>
> -class ValueArray18 {
> - public:
> - ValueArray18(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9
> v9,
> - T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17
> v17,
> - T18 v18) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6),
> v7_(v7),
> - v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13),
> v14_(v14),
> - v15_(v15), v16_(v16), v17_(v17), v18_(v18) {}
> -
> - template <typename T>
> - operator ParamGenerator<T>() const {
> - const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> - static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> - static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> - static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
> - static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
> - static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
> - static_cast<T>(v18_)};
> - return ValuesIn(array);
> - }
> -
> - ValueArray18(const ValueArray18& other) : v1_(other.v1_),
> v2_(other.v2_),
> - v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
> - v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
> - v11_(other.v11_), v12_(other.v12_), v13_(other.v13_),
> v14_(other.v14_),
> - v15_(other.v15_), v16_(other.v16_), v17_(other.v17_),
> v18_(other.v18_) {}
> -
> - private:
> - // No implementation - assignment is unsupported.
> - void operator=(const ValueArray18& other);
> -
> - const T1 v1_;
> - const T2 v2_;
> - const T3 v3_;
> - const T4 v4_;
> - const T5 v5_;
> - const T6 v6_;
> - const T7 v7_;
> - const T8 v8_;
> - const T9 v9_;
> - const T10 v10_;
> - const T11 v11_;
> - const T12 v12_;
> - const T13 v13_;
> - const T14 v14_;
> - const T15 v15_;
> - const T16 v16_;
> - const T17 v17_;
> - const T18 v18_;
> -};
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11, typename T12, typename T13, typename T14, typename T15,
> - typename T16, typename T17, typename T18, typename T19>
> -class ValueArray19 {
> - public:
> - ValueArray19(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9
> v9,
> - T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17
> v17,
> - T18 v18, T19 v19) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5),
> v6_(v6),
> - v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12),
> v13_(v13),
> - v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19) {}
> -
> - template <typename T>
> - operator ParamGenerator<T>() const {
> - const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> - static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> - static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> - static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
> - static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
> - static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
> - static_cast<T>(v18_), static_cast<T>(v19_)};
> - return ValuesIn(array);
> - }
> -
> - ValueArray19(const ValueArray19& other) : v1_(other.v1_),
> v2_(other.v2_),
> - v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
> - v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
> - v11_(other.v11_), v12_(other.v12_), v13_(other.v13_),
> v14_(other.v14_),
> - v15_(other.v15_), v16_(other.v16_), v17_(other.v17_),
> v18_(other.v18_),
> - v19_(other.v19_) {}
> -
> - private:
> - // No implementation - assignment is unsupported.
> - void operator=(const ValueArray19& other);
> -
> - const T1 v1_;
> - const T2 v2_;
> - const T3 v3_;
> - const T4 v4_;
> - const T5 v5_;
> - const T6 v6_;
> - const T7 v7_;
> - const T8 v8_;
> - const T9 v9_;
> - const T10 v10_;
> - const T11 v11_;
> - const T12 v12_;
> - const T13 v13_;
> - const T14 v14_;
> - const T15 v15_;
> - const T16 v16_;
> - const T17 v17_;
> - const T18 v18_;
> - const T19 v19_;
> -};
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11, typename T12, typename T13, typename T14, typename T15,
> - typename T16, typename T17, typename T18, typename T19, typename T20>
> -class ValueArray20 {
> - public:
> - ValueArray20(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9
> v9,
> - T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17
> v17,
> - T18 v18, T19 v19, T20 v20) : v1_(v1), v2_(v2), v3_(v3), v4_(v4),
> v5_(v5),
> - v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12),
> - v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18),
> - v19_(v19), v20_(v20) {}
> -
> - template <typename T>
> - operator ParamGenerator<T>() const {
> - const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> - static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> - static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> - static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
> - static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
> - static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
> - static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_)};
> - return ValuesIn(array);
> - }
> -
> - ValueArray20(const ValueArray20& other) : v1_(other.v1_),
> v2_(other.v2_),
> - v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
> - v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
> - v11_(other.v11_), v12_(other.v12_), v13_(other.v13_),
> v14_(other.v14_),
> - v15_(other.v15_), v16_(other.v16_), v17_(other.v17_),
> v18_(other.v18_),
> - v19_(other.v19_), v20_(other.v20_) {}
> -
> - private:
> - // No implementation - assignment is unsupported.
> - void operator=(const ValueArray20& other);
> -
> - const T1 v1_;
> - const T2 v2_;
> - const T3 v3_;
> - const T4 v4_;
> - const T5 v5_;
> - const T6 v6_;
> - const T7 v7_;
> - const T8 v8_;
> - const T9 v9_;
> - const T10 v10_;
> - const T11 v11_;
> - const T12 v12_;
> - const T13 v13_;
> - const T14 v14_;
> - const T15 v15_;
> - const T16 v16_;
> - const T17 v17_;
> - const T18 v18_;
> - const T19 v19_;
> - const T20 v20_;
> -};
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11, typename T12, typename T13, typename T14, typename T15,
> - typename T16, typename T17, typename T18, typename T19, typename T20,
> - typename T21>
> -class ValueArray21 {
> - public:
> - ValueArray21(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9
> v9,
> - T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17
> v17,
> - T18 v18, T19 v19, T20 v20, T21 v21) : v1_(v1), v2_(v2), v3_(v3),
> v4_(v4),
> - v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11),
> - v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17),
> - v18_(v18), v19_(v19), v20_(v20), v21_(v21) {}
> -
> - template <typename T>
> - operator ParamGenerator<T>() const {
> - const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> - static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> - static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> - static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
> - static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
> - static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
> - static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
> - static_cast<T>(v21_)};
> - return ValuesIn(array);
> - }
> -
> - ValueArray21(const ValueArray21& other) : v1_(other.v1_),
> v2_(other.v2_),
> - v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
> - v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
> - v11_(other.v11_), v12_(other.v12_), v13_(other.v13_),
> v14_(other.v14_),
> - v15_(other.v15_), v16_(other.v16_), v17_(other.v17_),
> v18_(other.v18_),
> - v19_(other.v19_), v20_(other.v20_), v21_(other.v21_) {}
> -
> - private:
> - // No implementation - assignment is unsupported.
> - void operator=(const ValueArray21& other);
> -
> - const T1 v1_;
> - const T2 v2_;
> - const T3 v3_;
> - const T4 v4_;
> - const T5 v5_;
> - const T6 v6_;
> - const T7 v7_;
> - const T8 v8_;
> - const T9 v9_;
> - const T10 v10_;
> - const T11 v11_;
> - const T12 v12_;
> - const T13 v13_;
> - const T14 v14_;
> - const T15 v15_;
> - const T16 v16_;
> - const T17 v17_;
> - const T18 v18_;
> - const T19 v19_;
> - const T20 v20_;
> - const T21 v21_;
> -};
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11, typename T12, typename T13, typename T14, typename T15,
> - typename T16, typename T17, typename T18, typename T19, typename T20,
> - typename T21, typename T22>
> -class ValueArray22 {
> - public:
> - ValueArray22(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9
> v9,
> - T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17
> v17,
> - T18 v18, T19 v19, T20 v20, T21 v21, T22 v22) : v1_(v1), v2_(v2),
> v3_(v3),
> - v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),
> - v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16),
> - v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22) {}
> -
> - template <typename T>
> - operator ParamGenerator<T>() const {
> - const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> - static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> - static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> - static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
> - static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
> - static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
> - static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
> - static_cast<T>(v21_), static_cast<T>(v22_)};
> - return ValuesIn(array);
> - }
> -
> - ValueArray22(const ValueArray22& other) : v1_(other.v1_),
> v2_(other.v2_),
> - v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
> - v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
> - v11_(other.v11_), v12_(other.v12_), v13_(other.v13_),
> v14_(other.v14_),
> - v15_(other.v15_), v16_(other.v16_), v17_(other.v17_),
> v18_(other.v18_),
> - v19_(other.v19_), v20_(other.v20_), v21_(other.v21_),
> v22_(other.v22_) {}
> -
> - private:
> - // No implementation - assignment is unsupported.
> - void operator=(const ValueArray22& other);
> -
> - const T1 v1_;
> - const T2 v2_;
> - const T3 v3_;
> - const T4 v4_;
> - const T5 v5_;
> - const T6 v6_;
> - const T7 v7_;
> - const T8 v8_;
> - const T9 v9_;
> - const T10 v10_;
> - const T11 v11_;
> - const T12 v12_;
> - const T13 v13_;
> - const T14 v14_;
> - const T15 v15_;
> - const T16 v16_;
> - const T17 v17_;
> - const T18 v18_;
> - const T19 v19_;
> - const T20 v20_;
> - const T21 v21_;
> - const T22 v22_;
> -};
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11, typename T12, typename T13, typename T14, typename T15,
> - typename T16, typename T17, typename T18, typename T19, typename T20,
> - typename T21, typename T22, typename T23>
> -class ValueArray23 {
> - public:
> - ValueArray23(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9
> v9,
> - T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17
> v17,
> - T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23) : v1_(v1),
> v2_(v2),
> - v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9),
> v10_(v10),
> - v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16),
> - v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22),
> - v23_(v23) {}
> -
> - template <typename T>
> - operator ParamGenerator<T>() const {
> - const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> - static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> - static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> - static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
> - static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
> - static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
> - static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
> - static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_)};
> - return ValuesIn(array);
> - }
> -
> - ValueArray23(const ValueArray23& other) : v1_(other.v1_),
> v2_(other.v2_),
> - v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
> - v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
> - v11_(other.v11_), v12_(other.v12_), v13_(other.v13_),
> v14_(other.v14_),
> - v15_(other.v15_), v16_(other.v16_), v17_(other.v17_),
> v18_(other.v18_),
> - v19_(other.v19_), v20_(other.v20_), v21_(other.v21_),
> v22_(other.v22_),
> - v23_(other.v23_) {}
> -
> - private:
> - // No implementation - assignment is unsupported.
> - void operator=(const ValueArray23& other);
> -
> - const T1 v1_;
> - const T2 v2_;
> - const T3 v3_;
> - const T4 v4_;
> - const T5 v5_;
> - const T6 v6_;
> - const T7 v7_;
> - const T8 v8_;
> - const T9 v9_;
> - const T10 v10_;
> - const T11 v11_;
> - const T12 v12_;
> - const T13 v13_;
> - const T14 v14_;
> - const T15 v15_;
> - const T16 v16_;
> - const T17 v17_;
> - const T18 v18_;
> - const T19 v19_;
> - const T20 v20_;
> - const T21 v21_;
> - const T22 v22_;
> - const T23 v23_;
> -};
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11, typename T12, typename T13, typename T14, typename T15,
> - typename T16, typename T17, typename T18, typename T19, typename T20,
> - typename T21, typename T22, typename T23, typename T24>
> -class ValueArray24 {
> - public:
> - ValueArray24(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9
> v9,
> - T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17
> v17,
> - T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24) :
> v1_(v1),
> - v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8),
> v9_(v9),
> - v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15),
> - v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21),
> - v22_(v22), v23_(v23), v24_(v24) {}
> -
> - template <typename T>
> - operator ParamGenerator<T>() const {
> - const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> - static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> - static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> - static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
> - static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
> - static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
> - static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
> - static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
> - static_cast<T>(v24_)};
> - return ValuesIn(array);
> - }
> -
> - ValueArray24(const ValueArray24& other) : v1_(other.v1_),
> v2_(other.v2_),
> - v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
> - v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
> - v11_(other.v11_), v12_(other.v12_), v13_(other.v13_),
> v14_(other.v14_),
> - v15_(other.v15_), v16_(other.v16_), v17_(other.v17_),
> v18_(other.v18_),
> - v19_(other.v19_), v20_(other.v20_), v21_(other.v21_),
> v22_(other.v22_),
> - v23_(other.v23_), v24_(other.v24_) {}
> -
> - private:
> - // No implementation - assignment is unsupported.
> - void operator=(const ValueArray24& other);
> -
> - const T1 v1_;
> - const T2 v2_;
> - const T3 v3_;
> - const T4 v4_;
> - const T5 v5_;
> - const T6 v6_;
> - const T7 v7_;
> - const T8 v8_;
> - const T9 v9_;
> - const T10 v10_;
> - const T11 v11_;
> - const T12 v12_;
> - const T13 v13_;
> - const T14 v14_;
> - const T15 v15_;
> - const T16 v16_;
> - const T17 v17_;
> - const T18 v18_;
> - const T19 v19_;
> - const T20 v20_;
> - const T21 v21_;
> - const T22 v22_;
> - const T23 v23_;
> - const T24 v24_;
> -};
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11, typename T12, typename T13, typename T14, typename T15,
> - typename T16, typename T17, typename T18, typename T19, typename T20,
> - typename T21, typename T22, typename T23, typename T24, typename T25>
> -class ValueArray25 {
> - public:
> - ValueArray25(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9
> v9,
> - T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17
> v17,
> - T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24,
> - T25 v25) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6),
> v7_(v7),
> - v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13),
> v14_(v14),
> - v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20),
> - v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25) {}
> -
> - template <typename T>
> - operator ParamGenerator<T>() const {
> - const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> - static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> - static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> - static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
> - static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
> - static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
> - static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
> - static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
> - static_cast<T>(v24_), static_cast<T>(v25_)};
> - return ValuesIn(array);
> - }
> -
> - ValueArray25(const ValueArray25& other) : v1_(other.v1_),
> v2_(other.v2_),
> - v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
> - v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
> - v11_(other.v11_), v12_(other.v12_), v13_(other.v13_),
> v14_(other.v14_),
> - v15_(other.v15_), v16_(other.v16_), v17_(other.v17_),
> v18_(other.v18_),
> - v19_(other.v19_), v20_(other.v20_), v21_(other.v21_),
> v22_(other.v22_),
> - v23_(other.v23_), v24_(other.v24_), v25_(other.v25_) {}
> -
> - private:
> - // No implementation - assignment is unsupported.
> - void operator=(const ValueArray25& other);
> -
> - const T1 v1_;
> - const T2 v2_;
> - const T3 v3_;
> - const T4 v4_;
> - const T5 v5_;
> - const T6 v6_;
> - const T7 v7_;
> - const T8 v8_;
> - const T9 v9_;
> - const T10 v10_;
> - const T11 v11_;
> - const T12 v12_;
> - const T13 v13_;
> - const T14 v14_;
> - const T15 v15_;
> - const T16 v16_;
> - const T17 v17_;
> - const T18 v18_;
> - const T19 v19_;
> - const T20 v20_;
> - const T21 v21_;
> - const T22 v22_;
> - const T23 v23_;
> - const T24 v24_;
> - const T25 v25_;
> -};
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11, typename T12, typename T13, typename T14, typename T15,
> - typename T16, typename T17, typename T18, typename T19, typename T20,
> - typename T21, typename T22, typename T23, typename T24, typename T25,
> - typename T26>
> -class ValueArray26 {
> - public:
> - ValueArray26(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9
> v9,
> - T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17
> v17,
> - T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25
> v25,
> - T26 v26) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6),
> v7_(v7),
> - v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13),
> v14_(v14),
> - v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20),
> - v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26) {}
> -
> - template <typename T>
> - operator ParamGenerator<T>() const {
> - const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> - static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> - static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> - static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
> - static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
> - static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
> - static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
> - static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
> - static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_)};
> - return ValuesIn(array);
> - }
> -
> - ValueArray26(const ValueArray26& other) : v1_(other.v1_),
> v2_(other.v2_),
> - v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
> - v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
> - v11_(other.v11_), v12_(other.v12_), v13_(other.v13_),
> v14_(other.v14_),
> - v15_(other.v15_), v16_(other.v16_), v17_(other.v17_),
> v18_(other.v18_),
> - v19_(other.v19_), v20_(other.v20_), v21_(other.v21_),
> v22_(other.v22_),
> - v23_(other.v23_), v24_(other.v24_), v25_(other.v25_),
> v26_(other.v26_) {}
> -
> - private:
> - // No implementation - assignment is unsupported.
> - void operator=(const ValueArray26& other);
> -
> - const T1 v1_;
> - const T2 v2_;
> - const T3 v3_;
> - const T4 v4_;
> - const T5 v5_;
> - const T6 v6_;
> - const T7 v7_;
> - const T8 v8_;
> - const T9 v9_;
> - const T10 v10_;
> - const T11 v11_;
> - const T12 v12_;
> - const T13 v13_;
> - const T14 v14_;
> - const T15 v15_;
> - const T16 v16_;
> - const T17 v17_;
> - const T18 v18_;
> - const T19 v19_;
> - const T20 v20_;
> - const T21 v21_;
> - const T22 v22_;
> - const T23 v23_;
> - const T24 v24_;
> - const T25 v25_;
> - const T26 v26_;
> -};
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11, typename T12, typename T13, typename T14, typename T15,
> - typename T16, typename T17, typename T18, typename T19, typename T20,
> - typename T21, typename T22, typename T23, typename T24, typename T25,
> - typename T26, typename T27>
> -class ValueArray27 {
> - public:
> - ValueArray27(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9
> v9,
> - T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17
> v17,
> - T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25
> v25,
> - T26 v26, T27 v27) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5),
> v6_(v6),
> - v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12),
> v13_(v13),
> - v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19),
> - v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25),
> - v26_(v26), v27_(v27) {}
> -
> - template <typename T>
> - operator ParamGenerator<T>() const {
> - const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> - static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> - static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> - static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
> - static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
> - static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
> - static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
> - static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
> - static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
> - static_cast<T>(v27_)};
> - return ValuesIn(array);
> - }
> -
> - ValueArray27(const ValueArray27& other) : v1_(other.v1_),
> v2_(other.v2_),
> - v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
> - v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
> - v11_(other.v11_), v12_(other.v12_), v13_(other.v13_),
> v14_(other.v14_),
> - v15_(other.v15_), v16_(other.v16_), v17_(other.v17_),
> v18_(other.v18_),
> - v19_(other.v19_), v20_(other.v20_), v21_(other.v21_),
> v22_(other.v22_),
> - v23_(other.v23_), v24_(other.v24_), v25_(other.v25_),
> v26_(other.v26_),
> - v27_(other.v27_) {}
> -
> - private:
> - // No implementation - assignment is unsupported.
> - void operator=(const ValueArray27& other);
> -
> - const T1 v1_;
> - const T2 v2_;
> - const T3 v3_;
> - const T4 v4_;
> - const T5 v5_;
> - const T6 v6_;
> - const T7 v7_;
> - const T8 v8_;
> - const T9 v9_;
> - const T10 v10_;
> - const T11 v11_;
> - const T12 v12_;
> - const T13 v13_;
> - const T14 v14_;
> - const T15 v15_;
> - const T16 v16_;
> - const T17 v17_;
> - const T18 v18_;
> - const T19 v19_;
> - const T20 v20_;
> - const T21 v21_;
> - const T22 v22_;
> - const T23 v23_;
> - const T24 v24_;
> - const T25 v25_;
> - const T26 v26_;
> - const T27 v27_;
> -};
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11, typename T12, typename T13, typename T14, typename T15,
> - typename T16, typename T17, typename T18, typename T19, typename T20,
> - typename T21, typename T22, typename T23, typename T24, typename T25,
> - typename T26, typename T27, typename T28>
> -class ValueArray28 {
> - public:
> - ValueArray28(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9
> v9,
> - T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17
> v17,
> - T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25
> v25,
> - T26 v26, T27 v27, T28 v28) : v1_(v1), v2_(v2), v3_(v3), v4_(v4),
> v5_(v5),
> - v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12),
> - v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18),
> - v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24),
> - v25_(v25), v26_(v26), v27_(v27), v28_(v28) {}
> -
> - template <typename T>
> - operator ParamGenerator<T>() const {
> - const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> - static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> - static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> - static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
> - static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
> - static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
> - static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
> - static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
> - static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
> - static_cast<T>(v27_), static_cast<T>(v28_)};
> - return ValuesIn(array);
> - }
> -
> - ValueArray28(const ValueArray28& other) : v1_(other.v1_),
> v2_(other.v2_),
> - v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
> - v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
> - v11_(other.v11_), v12_(other.v12_), v13_(other.v13_),
> v14_(other.v14_),
> - v15_(other.v15_), v16_(other.v16_), v17_(other.v17_),
> v18_(other.v18_),
> - v19_(other.v19_), v20_(other.v20_), v21_(other.v21_),
> v22_(other.v22_),
> - v23_(other.v23_), v24_(other.v24_), v25_(other.v25_),
> v26_(other.v26_),
> - v27_(other.v27_), v28_(other.v28_) {}
> -
> - private:
> - // No implementation - assignment is unsupported.
> - void operator=(const ValueArray28& other);
> -
> - const T1 v1_;
> - const T2 v2_;
> - const T3 v3_;
> - const T4 v4_;
> - const T5 v5_;
> - const T6 v6_;
> - const T7 v7_;
> - const T8 v8_;
> - const T9 v9_;
> - const T10 v10_;
> - const T11 v11_;
> - const T12 v12_;
> - const T13 v13_;
> - const T14 v14_;
> - const T15 v15_;
> - const T16 v16_;
> - const T17 v17_;
> - const T18 v18_;
> - const T19 v19_;
> - const T20 v20_;
> - const T21 v21_;
> - const T22 v22_;
> - const T23 v23_;
> - const T24 v24_;
> - const T25 v25_;
> - const T26 v26_;
> - const T27 v27_;
> - const T28 v28_;
> -};
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11, typename T12, typename T13, typename T14, typename T15,
> - typename T16, typename T17, typename T18, typename T19, typename T20,
> - typename T21, typename T22, typename T23, typename T24, typename T25,
> - typename T26, typename T27, typename T28, typename T29>
> -class ValueArray29 {
> - public:
> - ValueArray29(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9
> v9,
> - T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17
> v17,
> - T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25
> v25,
> - T26 v26, T27 v27, T28 v28, T29 v29) : v1_(v1), v2_(v2), v3_(v3),
> v4_(v4),
> - v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11),
> - v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17),
> - v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23),
> - v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28), v29_(v29) {}
> -
> - template <typename T>
> - operator ParamGenerator<T>() const {
> - const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> - static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> - static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> - static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
> - static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
> - static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
> - static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
> - static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
> - static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
> - static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_)};
> - return ValuesIn(array);
> - }
> -
> - ValueArray29(const ValueArray29& other) : v1_(other.v1_),
> v2_(other.v2_),
> - v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
> - v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
> - v11_(other.v11_), v12_(other.v12_), v13_(other.v13_),
> v14_(other.v14_),
> - v15_(other.v15_), v16_(other.v16_), v17_(other.v17_),
> v18_(other.v18_),
> - v19_(other.v19_), v20_(other.v20_), v21_(other.v21_),
> v22_(other.v22_),
> - v23_(other.v23_), v24_(other.v24_), v25_(other.v25_),
> v26_(other.v26_),
> - v27_(other.v27_), v28_(other.v28_), v29_(other.v29_) {}
> -
> - private:
> - // No implementation - assignment is unsupported.
> - void operator=(const ValueArray29& other);
> -
> - const T1 v1_;
> - const T2 v2_;
> - const T3 v3_;
> - const T4 v4_;
> - const T5 v5_;
> - const T6 v6_;
> - const T7 v7_;
> - const T8 v8_;
> - const T9 v9_;
> - const T10 v10_;
> - const T11 v11_;
> - const T12 v12_;
> - const T13 v13_;
> - const T14 v14_;
> - const T15 v15_;
> - const T16 v16_;
> - const T17 v17_;
> - const T18 v18_;
> - const T19 v19_;
> - const T20 v20_;
> - const T21 v21_;
> - const T22 v22_;
> - const T23 v23_;
> - const T24 v24_;
> - const T25 v25_;
> - const T26 v26_;
> - const T27 v27_;
> - const T28 v28_;
> - const T29 v29_;
> -};
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11, typename T12, typename T13, typename T14, typename T15,
> - typename T16, typename T17, typename T18, typename T19, typename T20,
> - typename T21, typename T22, typename T23, typename T24, typename T25,
> - typename T26, typename T27, typename T28, typename T29, typename T30>
> -class ValueArray30 {
> - public:
> - ValueArray30(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9
> v9,
> - T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17
> v17,
> - T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25
> v25,
> - T26 v26, T27 v27, T28 v28, T29 v29, T30 v30) : v1_(v1), v2_(v2),
> v3_(v3),
> - v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),
> - v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16),
> - v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22),
> - v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28),
> - v29_(v29), v30_(v30) {}
> -
> - template <typename T>
> - operator ParamGenerator<T>() const {
> - const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> - static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> - static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> - static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
> - static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
> - static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
> - static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
> - static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
> - static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
> - static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
> - static_cast<T>(v30_)};
> - return ValuesIn(array);
> - }
> -
> - ValueArray30(const ValueArray30& other) : v1_(other.v1_),
> v2_(other.v2_),
> - v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
> - v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
> - v11_(other.v11_), v12_(other.v12_), v13_(other.v13_),
> v14_(other.v14_),
> - v15_(other.v15_), v16_(other.v16_), v17_(other.v17_),
> v18_(other.v18_),
> - v19_(other.v19_), v20_(other.v20_), v21_(other.v21_),
> v22_(other.v22_),
> - v23_(other.v23_), v24_(other.v24_), v25_(other.v25_),
> v26_(other.v26_),
> - v27_(other.v27_), v28_(other.v28_), v29_(other.v29_),
> v30_(other.v30_) {}
> -
> - private:
> - // No implementation - assignment is unsupported.
> - void operator=(const ValueArray30& other);
> -
> - const T1 v1_;
> - const T2 v2_;
> - const T3 v3_;
> - const T4 v4_;
> - const T5 v5_;
> - const T6 v6_;
> - const T7 v7_;
> - const T8 v8_;
> - const T9 v9_;
> - const T10 v10_;
> - const T11 v11_;
> - const T12 v12_;
> - const T13 v13_;
> - const T14 v14_;
> - const T15 v15_;
> - const T16 v16_;
> - const T17 v17_;
> - const T18 v18_;
> - const T19 v19_;
> - const T20 v20_;
> - const T21 v21_;
> - const T22 v22_;
> - const T23 v23_;
> - const T24 v24_;
> - const T25 v25_;
> - const T26 v26_;
> - const T27 v27_;
> - const T28 v28_;
> - const T29 v29_;
> - const T30 v30_;
> -};
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11, typename T12, typename T13, typename T14, typename T15,
> - typename T16, typename T17, typename T18, typename T19, typename T20,
> - typename T21, typename T22, typename T23, typename T24, typename T25,
> - typename T26, typename T27, typename T28, typename T29, typename T30,
> - typename T31>
> -class ValueArray31 {
> - public:
> - ValueArray31(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9
> v9,
> - T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17
> v17,
> - T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25
> v25,
> - T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31) : v1_(v1),
> v2_(v2),
> - v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9),
> v10_(v10),
> - v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16),
> - v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22),
> - v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28),
> - v29_(v29), v30_(v30), v31_(v31) {}
> -
> - template <typename T>
> - operator ParamGenerator<T>() const {
> - const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> - static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> - static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> - static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
> - static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
> - static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
> - static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
> - static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
> - static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
> - static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
> - static_cast<T>(v30_), static_cast<T>(v31_)};
> - return ValuesIn(array);
> - }
> -
> - ValueArray31(const ValueArray31& other) : v1_(other.v1_),
> v2_(other.v2_),
> - v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
> - v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
> - v11_(other.v11_), v12_(other.v12_), v13_(other.v13_),
> v14_(other.v14_),
> - v15_(other.v15_), v16_(other.v16_), v17_(other.v17_),
> v18_(other.v18_),
> - v19_(other.v19_), v20_(other.v20_), v21_(other.v21_),
> v22_(other.v22_),
> - v23_(other.v23_), v24_(other.v24_), v25_(other.v25_),
> v26_(other.v26_),
> - v27_(other.v27_), v28_(other.v28_), v29_(other.v29_),
> v30_(other.v30_),
> - v31_(other.v31_) {}
> -
> - private:
> - // No implementation - assignment is unsupported.
> - void operator=(const ValueArray31& other);
> -
> - const T1 v1_;
> - const T2 v2_;
> - const T3 v3_;
> - const T4 v4_;
> - const T5 v5_;
> - const T6 v6_;
> - const T7 v7_;
> - const T8 v8_;
> - const T9 v9_;
> - const T10 v10_;
> - const T11 v11_;
> - const T12 v12_;
> - const T13 v13_;
> - const T14 v14_;
> - const T15 v15_;
> - const T16 v16_;
> - const T17 v17_;
> - const T18 v18_;
> - const T19 v19_;
> - const T20 v20_;
> - const T21 v21_;
> - const T22 v22_;
> - const T23 v23_;
> - const T24 v24_;
> - const T25 v25_;
> - const T26 v26_;
> - const T27 v27_;
> - const T28 v28_;
> - const T29 v29_;
> - const T30 v30_;
> - const T31 v31_;
> -};
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11, typename T12, typename T13, typename T14, typename T15,
> - typename T16, typename T17, typename T18, typename T19, typename T20,
> - typename T21, typename T22, typename T23, typename T24, typename T25,
> - typename T26, typename T27, typename T28, typename T29, typename T30,
> - typename T31, typename T32>
> -class ValueArray32 {
> - public:
> - ValueArray32(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9
> v9,
> - T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17
> v17,
> - T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25
> v25,
> - T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32) :
> v1_(v1),
> - v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8),
> v9_(v9),
> - v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15),
> - v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21),
> - v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27),
> - v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32) {}
> -
> - template <typename T>
> - operator ParamGenerator<T>() const {
> - const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> - static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> - static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> - static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
> - static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
> - static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
> - static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
> - static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
> - static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
> - static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
> - static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_)};
> - return ValuesIn(array);
> - }
> -
> - ValueArray32(const ValueArray32& other) : v1_(other.v1_),
> v2_(other.v2_),
> - v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
> - v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
> - v11_(other.v11_), v12_(other.v12_), v13_(other.v13_),
> v14_(other.v14_),
> - v15_(other.v15_), v16_(other.v16_), v17_(other.v17_),
> v18_(other.v18_),
> - v19_(other.v19_), v20_(other.v20_), v21_(other.v21_),
> v22_(other.v22_),
> - v23_(other.v23_), v24_(other.v24_), v25_(other.v25_),
> v26_(other.v26_),
> - v27_(other.v27_), v28_(other.v28_), v29_(other.v29_),
> v30_(other.v30_),
> - v31_(other.v31_), v32_(other.v32_) {}
> -
> - private:
> - // No implementation - assignment is unsupported.
> - void operator=(const ValueArray32& other);
> -
> - const T1 v1_;
> - const T2 v2_;
> - const T3 v3_;
> - const T4 v4_;
> - const T5 v5_;
> - const T6 v6_;
> - const T7 v7_;
> - const T8 v8_;
> - const T9 v9_;
> - const T10 v10_;
> - const T11 v11_;
> - const T12 v12_;
> - const T13 v13_;
> - const T14 v14_;
> - const T15 v15_;
> - const T16 v16_;
> - const T17 v17_;
> - const T18 v18_;
> - const T19 v19_;
> - const T20 v20_;
> - const T21 v21_;
> - const T22 v22_;
> - const T23 v23_;
> - const T24 v24_;
> - const T25 v25_;
> - const T26 v26_;
> - const T27 v27_;
> - const T28 v28_;
> - const T29 v29_;
> - const T30 v30_;
> - const T31 v31_;
> - const T32 v32_;
> -};
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11, typename T12, typename T13, typename T14, typename T15,
> - typename T16, typename T17, typename T18, typename T19, typename T20,
> - typename T21, typename T22, typename T23, typename T24, typename T25,
> - typename T26, typename T27, typename T28, typename T29, typename T30,
> - typename T31, typename T32, typename T33>
> -class ValueArray33 {
> - public:
> - ValueArray33(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9
> v9,
> - T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17
> v17,
> - T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25
> v25,
> - T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32,
> - T33 v33) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6),
> v7_(v7),
> - v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13),
> v14_(v14),
> - v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20),
> - v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26),
> - v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32),
> - v33_(v33) {}
> -
> - template <typename T>
> - operator ParamGenerator<T>() const {
> - const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> - static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> - static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> - static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
> - static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
> - static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
> - static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
> - static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
> - static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
> - static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
> - static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
> - static_cast<T>(v33_)};
> - return ValuesIn(array);
> - }
> -
> - ValueArray33(const ValueArray33& other) : v1_(other.v1_),
> v2_(other.v2_),
> - v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
> - v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
> - v11_(other.v11_), v12_(other.v12_), v13_(other.v13_),
> v14_(other.v14_),
> - v15_(other.v15_), v16_(other.v16_), v17_(other.v17_),
> v18_(other.v18_),
> - v19_(other.v19_), v20_(other.v20_), v21_(other.v21_),
> v22_(other.v22_),
> - v23_(other.v23_), v24_(other.v24_), v25_(other.v25_),
> v26_(other.v26_),
> - v27_(other.v27_), v28_(other.v28_), v29_(other.v29_),
> v30_(other.v30_),
> - v31_(other.v31_), v32_(other.v32_), v33_(other.v33_) {}
> -
> - private:
> - // No implementation - assignment is unsupported.
> - void operator=(const ValueArray33& other);
> -
> - const T1 v1_;
> - const T2 v2_;
> - const T3 v3_;
> - const T4 v4_;
> - const T5 v5_;
> - const T6 v6_;
> - const T7 v7_;
> - const T8 v8_;
> - const T9 v9_;
> - const T10 v10_;
> - const T11 v11_;
> - const T12 v12_;
> - const T13 v13_;
> - const T14 v14_;
> - const T15 v15_;
> - const T16 v16_;
> - const T17 v17_;
> - const T18 v18_;
> - const T19 v19_;
> - const T20 v20_;
> - const T21 v21_;
> - const T22 v22_;
> - const T23 v23_;
> - const T24 v24_;
> - const T25 v25_;
> - const T26 v26_;
> - const T27 v27_;
> - const T28 v28_;
> - const T29 v29_;
> - const T30 v30_;
> - const T31 v31_;
> - const T32 v32_;
> - const T33 v33_;
> -};
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11, typename T12, typename T13, typename T14, typename T15,
> - typename T16, typename T17, typename T18, typename T19, typename T20,
> - typename T21, typename T22, typename T23, typename T24, typename T25,
> - typename T26, typename T27, typename T28, typename T29, typename T30,
> - typename T31, typename T32, typename T33, typename T34>
> -class ValueArray34 {
> - public:
> - ValueArray34(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9
> v9,
> - T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17
> v17,
> - T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25
> v25,
> - T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33
> v33,
> - T34 v34) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6),
> v7_(v7),
> - v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13),
> v14_(v14),
> - v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20),
> - v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26),
> - v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32),
> - v33_(v33), v34_(v34) {}
> -
> - template <typename T>
> - operator ParamGenerator<T>() const {
> - const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> - static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> - static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> - static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
> - static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
> - static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
> - static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
> - static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
> - static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
> - static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
> - static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
> - static_cast<T>(v33_), static_cast<T>(v34_)};
> - return ValuesIn(array);
> - }
> -
> - ValueArray34(const ValueArray34& other) : v1_(other.v1_),
> v2_(other.v2_),
> - v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
> - v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
> - v11_(other.v11_), v12_(other.v12_), v13_(other.v13_),
> v14_(other.v14_),
> - v15_(other.v15_), v16_(other.v16_), v17_(other.v17_),
> v18_(other.v18_),
> - v19_(other.v19_), v20_(other.v20_), v21_(other.v21_),
> v22_(other.v22_),
> - v23_(other.v23_), v24_(other.v24_), v25_(other.v25_),
> v26_(other.v26_),
> - v27_(other.v27_), v28_(other.v28_), v29_(other.v29_),
> v30_(other.v30_),
> - v31_(other.v31_), v32_(other.v32_), v33_(other.v33_),
> v34_(other.v34_) {}
> -
> - private:
> - // No implementation - assignment is unsupported.
> - void operator=(const ValueArray34& other);
> -
> - const T1 v1_;
> - const T2 v2_;
> - const T3 v3_;
> - const T4 v4_;
> - const T5 v5_;
> - const T6 v6_;
> - const T7 v7_;
> - const T8 v8_;
> - const T9 v9_;
> - const T10 v10_;
> - const T11 v11_;
> - const T12 v12_;
> - const T13 v13_;
> - const T14 v14_;
> - const T15 v15_;
> - const T16 v16_;
> - const T17 v17_;
> - const T18 v18_;
> - const T19 v19_;
> - const T20 v20_;
> - const T21 v21_;
> - const T22 v22_;
> - const T23 v23_;
> - const T24 v24_;
> - const T25 v25_;
> - const T26 v26_;
> - const T27 v27_;
> - const T28 v28_;
> - const T29 v29_;
> - const T30 v30_;
> - const T31 v31_;
> - const T32 v32_;
> - const T33 v33_;
> - const T34 v34_;
> -};
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11, typename T12, typename T13, typename T14, typename T15,
> - typename T16, typename T17, typename T18, typename T19, typename T20,
> - typename T21, typename T22, typename T23, typename T24, typename T25,
> - typename T26, typename T27, typename T28, typename T29, typename T30,
> - typename T31, typename T32, typename T33, typename T34, typename T35>
> -class ValueArray35 {
> - public:
> - ValueArray35(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9
> v9,
> - T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17
> v17,
> - T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25
> v25,
> - T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33
> v33,
> - T34 v34, T35 v35) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5),
> v6_(v6),
> - v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12),
> v13_(v13),
> - v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19),
> - v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25),
> - v26_(v26), v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31),
> - v32_(v32), v33_(v33), v34_(v34), v35_(v35) {}
> -
> - template <typename T>
> - operator ParamGenerator<T>() const {
> - const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> - static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> - static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> - static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
> - static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
> - static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
> - static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
> - static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
> - static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
> - static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
> - static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
> - static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_)};
> - return ValuesIn(array);
> - }
> -
> - ValueArray35(const ValueArray35& other) : v1_(other.v1_),
> v2_(other.v2_),
> - v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
> - v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
> - v11_(other.v11_), v12_(other.v12_), v13_(other.v13_),
> v14_(other.v14_),
> - v15_(other.v15_), v16_(other.v16_), v17_(other.v17_),
> v18_(other.v18_),
> - v19_(other.v19_), v20_(other.v20_), v21_(other.v21_),
> v22_(other.v22_),
> - v23_(other.v23_), v24_(other.v24_), v25_(other.v25_),
> v26_(other.v26_),
> - v27_(other.v27_), v28_(other.v28_), v29_(other.v29_),
> v30_(other.v30_),
> - v31_(other.v31_), v32_(other.v32_), v33_(other.v33_),
> v34_(other.v34_),
> - v35_(other.v35_) {}
> -
> - private:
> - // No implementation - assignment is unsupported.
> - void operator=(const ValueArray35& other);
> -
> - const T1 v1_;
> - const T2 v2_;
> - const T3 v3_;
> - const T4 v4_;
> - const T5 v5_;
> - const T6 v6_;
> - const T7 v7_;
> - const T8 v8_;
> - const T9 v9_;
> - const T10 v10_;
> - const T11 v11_;
> - const T12 v12_;
> - const T13 v13_;
> - const T14 v14_;
> - const T15 v15_;
> - const T16 v16_;
> - const T17 v17_;
> - const T18 v18_;
> - const T19 v19_;
> - const T20 v20_;
> - const T21 v21_;
> - const T22 v22_;
> - const T23 v23_;
> - const T24 v24_;
> - const T25 v25_;
> - const T26 v26_;
> - const T27 v27_;
> - const T28 v28_;
> - const T29 v29_;
> - const T30 v30_;
> - const T31 v31_;
> - const T32 v32_;
> - const T33 v33_;
> - const T34 v34_;
> - const T35 v35_;
> -};
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11, typename T12, typename T13, typename T14, typename T15,
> - typename T16, typename T17, typename T18, typename T19, typename T20,
> - typename T21, typename T22, typename T23, typename T24, typename T25,
> - typename T26, typename T27, typename T28, typename T29, typename T30,
> - typename T31, typename T32, typename T33, typename T34, typename T35,
> - typename T36>
> -class ValueArray36 {
> - public:
> - ValueArray36(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9
> v9,
> - T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17
> v17,
> - T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25
> v25,
> - T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33
> v33,
> - T34 v34, T35 v35, T36 v36) : v1_(v1), v2_(v2), v3_(v3), v4_(v4),
> v5_(v5),
> - v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12),
> - v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18),
> - v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24),
> - v25_(v25), v26_(v26), v27_(v27), v28_(v28), v29_(v29), v30_(v30),
> - v31_(v31), v32_(v32), v33_(v33), v34_(v34), v35_(v35), v36_(v36) {}
> -
> - template <typename T>
> - operator ParamGenerator<T>() const {
> - const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> - static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> - static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> - static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
> - static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
> - static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
> - static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
> - static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
> - static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
> - static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
> - static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
> - static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
> - static_cast<T>(v36_)};
> - return ValuesIn(array);
> - }
> -
> - ValueArray36(const ValueArray36& other) : v1_(other.v1_),
> v2_(other.v2_),
> - v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
> - v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
> - v11_(other.v11_), v12_(other.v12_), v13_(other.v13_),
> v14_(other.v14_),
> - v15_(other.v15_), v16_(other.v16_), v17_(other.v17_),
> v18_(other.v18_),
> - v19_(other.v19_), v20_(other.v20_), v21_(other.v21_),
> v22_(other.v22_),
> - v23_(other.v23_), v24_(other.v24_), v25_(other.v25_),
> v26_(other.v26_),
> - v27_(other.v27_), v28_(other.v28_), v29_(other.v29_),
> v30_(other.v30_),
> - v31_(other.v31_), v32_(other.v32_), v33_(other.v33_),
> v34_(other.v34_),
> - v35_(other.v35_), v36_(other.v36_) {}
> -
> - private:
> - // No implementation - assignment is unsupported.
> - void operator=(const ValueArray36& other);
> -
> - const T1 v1_;
> - const T2 v2_;
> - const T3 v3_;
> - const T4 v4_;
> - const T5 v5_;
> - const T6 v6_;
> - const T7 v7_;
> - const T8 v8_;
> - const T9 v9_;
> - const T10 v10_;
> - const T11 v11_;
> - const T12 v12_;
> - const T13 v13_;
> - const T14 v14_;
> - const T15 v15_;
> - const T16 v16_;
> - const T17 v17_;
> - const T18 v18_;
> - const T19 v19_;
> - const T20 v20_;
> - const T21 v21_;
> - const T22 v22_;
> - const T23 v23_;
> - const T24 v24_;
> - const T25 v25_;
> - const T26 v26_;
> - const T27 v27_;
> - const T28 v28_;
> - const T29 v29_;
> - const T30 v30_;
> - const T31 v31_;
> - const T32 v32_;
> - const T33 v33_;
> - const T34 v34_;
> - const T35 v35_;
> - const T36 v36_;
> -};
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11, typename T12, typename T13, typename T14, typename T15,
> - typename T16, typename T17, typename T18, typename T19, typename T20,
> - typename T21, typename T22, typename T23, typename T24, typename T25,
> - typename T26, typename T27, typename T28, typename T29, typename T30,
> - typename T31, typename T32, typename T33, typename T34, typename T35,
> - typename T36, typename T37>
> -class ValueArray37 {
> - public:
> - ValueArray37(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9
> v9,
> - T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17
> v17,
> - T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25
> v25,
> - T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33
> v33,
> - T34 v34, T35 v35, T36 v36, T37 v37) : v1_(v1), v2_(v2), v3_(v3),
> v4_(v4),
> - v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11),
> - v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17),
> - v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23),
> - v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28), v29_(v29),
> - v30_(v30), v31_(v31), v32_(v32), v33_(v33), v34_(v34), v35_(v35),
> - v36_(v36), v37_(v37) {}
> -
> - template <typename T>
> - operator ParamGenerator<T>() const {
> - const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> - static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> - static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> - static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
> - static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
> - static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
> - static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
> - static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
> - static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
> - static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
> - static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
> - static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
> - static_cast<T>(v36_), static_cast<T>(v37_)};
> - return ValuesIn(array);
> - }
> -
> - ValueArray37(const ValueArray37& other) : v1_(other.v1_),
> v2_(other.v2_),
> - v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
> - v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
> - v11_(other.v11_), v12_(other.v12_), v13_(other.v13_),
> v14_(other.v14_),
> - v15_(other.v15_), v16_(other.v16_), v17_(other.v17_),
> v18_(other.v18_),
> - v19_(other.v19_), v20_(other.v20_), v21_(other.v21_),
> v22_(other.v22_),
> - v23_(other.v23_), v24_(other.v24_), v25_(other.v25_),
> v26_(other.v26_),
> - v27_(other.v27_), v28_(other.v28_), v29_(other.v29_),
> v30_(other.v30_),
> - v31_(other.v31_), v32_(other.v32_), v33_(other.v33_),
> v34_(other.v34_),
> - v35_(other.v35_), v36_(other.v36_), v37_(other.v37_) {}
> -
> - private:
> - // No implementation - assignment is unsupported.
> - void operator=(const ValueArray37& other);
> -
> - const T1 v1_;
> - const T2 v2_;
> - const T3 v3_;
> - const T4 v4_;
> - const T5 v5_;
> - const T6 v6_;
> - const T7 v7_;
> - const T8 v8_;
> - const T9 v9_;
> - const T10 v10_;
> - const T11 v11_;
> - const T12 v12_;
> - const T13 v13_;
> - const T14 v14_;
> - const T15 v15_;
> - const T16 v16_;
> - const T17 v17_;
> - const T18 v18_;
> - const T19 v19_;
> - const T20 v20_;
> - const T21 v21_;
> - const T22 v22_;
> - const T23 v23_;
> - const T24 v24_;
> - const T25 v25_;
> - const T26 v26_;
> - const T27 v27_;
> - const T28 v28_;
> - const T29 v29_;
> - const T30 v30_;
> - const T31 v31_;
> - const T32 v32_;
> - const T33 v33_;
> - const T34 v34_;
> - const T35 v35_;
> - const T36 v36_;
> - const T37 v37_;
> -};
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11, typename T12, typename T13, typename T14, typename T15,
> - typename T16, typename T17, typename T18, typename T19, typename T20,
> - typename T21, typename T22, typename T23, typename T24, typename T25,
> - typename T26, typename T27, typename T28, typename T29, typename T30,
> - typename T31, typename T32, typename T33, typename T34, typename T35,
> - typename T36, typename T37, typename T38>
> -class ValueArray38 {
> - public:
> - ValueArray38(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9
> v9,
> - T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17
> v17,
> - T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25
> v25,
> - T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33
> v33,
> - T34 v34, T35 v35, T36 v36, T37 v37, T38 v38) : v1_(v1), v2_(v2),
> v3_(v3),
> - v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),
> - v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16),
> - v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22),
> - v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28),
> - v29_(v29), v30_(v30), v31_(v31), v32_(v32), v33_(v33), v34_(v34),
> - v35_(v35), v36_(v36), v37_(v37), v38_(v38) {}
> -
> - template <typename T>
> - operator ParamGenerator<T>() const {
> - const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> - static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> - static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> - static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
> - static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
> - static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
> - static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
> - static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
> - static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
> - static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
> - static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
> - static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
> - static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_)};
> - return ValuesIn(array);
> - }
> -
> - ValueArray38(const ValueArray38& other) : v1_(other.v1_),
> v2_(other.v2_),
> - v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
> - v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
> - v11_(other.v11_), v12_(other.v12_), v13_(other.v13_),
> v14_(other.v14_),
> - v15_(other.v15_), v16_(other.v16_), v17_(other.v17_),
> v18_(other.v18_),
> - v19_(other.v19_), v20_(other.v20_), v21_(other.v21_),
> v22_(other.v22_),
> - v23_(other.v23_), v24_(other.v24_), v25_(other.v25_),
> v26_(other.v26_),
> - v27_(other.v27_), v28_(other.v28_), v29_(other.v29_),
> v30_(other.v30_),
> - v31_(other.v31_), v32_(other.v32_), v33_(other.v33_),
> v34_(other.v34_),
> - v35_(other.v35_), v36_(other.v36_), v37_(other.v37_),
> v38_(other.v38_) {}
> -
> - private:
> - // No implementation - assignment is unsupported.
> - void operator=(const ValueArray38& other);
> -
> - const T1 v1_;
> - const T2 v2_;
> - const T3 v3_;
> - const T4 v4_;
> - const T5 v5_;
> - const T6 v6_;
> - const T7 v7_;
> - const T8 v8_;
> - const T9 v9_;
> - const T10 v10_;
> - const T11 v11_;
> - const T12 v12_;
> - const T13 v13_;
> - const T14 v14_;
> - const T15 v15_;
> - const T16 v16_;
> - const T17 v17_;
> - const T18 v18_;
> - const T19 v19_;
> - const T20 v20_;
> - const T21 v21_;
> - const T22 v22_;
> - const T23 v23_;
> - const T24 v24_;
> - const T25 v25_;
> - const T26 v26_;
> - const T27 v27_;
> - const T28 v28_;
> - const T29 v29_;
> - const T30 v30_;
> - const T31 v31_;
> - const T32 v32_;
> - const T33 v33_;
> - const T34 v34_;
> - const T35 v35_;
> - const T36 v36_;
> - const T37 v37_;
> - const T38 v38_;
> -};
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11, typename T12, typename T13, typename T14, typename T15,
> - typename T16, typename T17, typename T18, typename T19, typename T20,
> - typename T21, typename T22, typename T23, typename T24, typename T25,
> - typename T26, typename T27, typename T28, typename T29, typename T30,
> - typename T31, typename T32, typename T33, typename T34, typename T35,
> - typename T36, typename T37, typename T38, typename T39>
> -class ValueArray39 {
> - public:
> - ValueArray39(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9
> v9,
> - T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17
> v17,
> - T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25
> v25,
> - T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33
> v33,
> - T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39) : v1_(v1),
> v2_(v2),
> - v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9),
> v10_(v10),
> - v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16),
> - v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22),
> - v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28),
> - v29_(v29), v30_(v30), v31_(v31), v32_(v32), v33_(v33), v34_(v34),
> - v35_(v35), v36_(v36), v37_(v37), v38_(v38), v39_(v39) {}
> -
> - template <typename T>
> - operator ParamGenerator<T>() const {
> - const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> - static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> - static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> - static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
> - static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
> - static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
> - static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
> - static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
> - static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
> - static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
> - static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
> - static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
> - static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
> - static_cast<T>(v39_)};
> - return ValuesIn(array);
> - }
> -
> - ValueArray39(const ValueArray39& other) : v1_(other.v1_),
> v2_(other.v2_),
> - v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
> - v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
> - v11_(other.v11_), v12_(other.v12_), v13_(other.v13_),
> v14_(other.v14_),
> - v15_(other.v15_), v16_(other.v16_), v17_(other.v17_),
> v18_(other.v18_),
> - v19_(other.v19_), v20_(other.v20_), v21_(other.v21_),
> v22_(other.v22_),
> - v23_(other.v23_), v24_(other.v24_), v25_(other.v25_),
> v26_(other.v26_),
> - v27_(other.v27_), v28_(other.v28_), v29_(other.v29_),
> v30_(other.v30_),
> - v31_(other.v31_), v32_(other.v32_), v33_(other.v33_),
> v34_(other.v34_),
> - v35_(other.v35_), v36_(other.v36_), v37_(other.v37_),
> v38_(other.v38_),
> - v39_(other.v39_) {}
> -
> - private:
> - // No implementation - assignment is unsupported.
> - void operator=(const ValueArray39& other);
> -
> - const T1 v1_;
> - const T2 v2_;
> - const T3 v3_;
> - const T4 v4_;
> - const T5 v5_;
> - const T6 v6_;
> - const T7 v7_;
> - const T8 v8_;
> - const T9 v9_;
> - const T10 v10_;
> - const T11 v11_;
> - const T12 v12_;
> - const T13 v13_;
> - const T14 v14_;
> - const T15 v15_;
> - const T16 v16_;
> - const T17 v17_;
> - const T18 v18_;
> - const T19 v19_;
> - const T20 v20_;
> - const T21 v21_;
> - const T22 v22_;
> - const T23 v23_;
> - const T24 v24_;
> - const T25 v25_;
> - const T26 v26_;
> - const T27 v27_;
> - const T28 v28_;
> - const T29 v29_;
> - const T30 v30_;
> - const T31 v31_;
> - const T32 v32_;
> - const T33 v33_;
> - const T34 v34_;
> - const T35 v35_;
> - const T36 v36_;
> - const T37 v37_;
> - const T38 v38_;
> - const T39 v39_;
> -};
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11, typename T12, typename T13, typename T14, typename T15,
> - typename T16, typename T17, typename T18, typename T19, typename T20,
> - typename T21, typename T22, typename T23, typename T24, typename T25,
> - typename T26, typename T27, typename T28, typename T29, typename T30,
> - typename T31, typename T32, typename T33, typename T34, typename T35,
> - typename T36, typename T37, typename T38, typename T39, typename T40>
> -class ValueArray40 {
> - public:
> - ValueArray40(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9
> v9,
> - T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17
> v17,
> - T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25
> v25,
> - T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33
> v33,
> - T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40) :
> v1_(v1),
> - v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8),
> v9_(v9),
> - v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15),
> - v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21),
> - v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27),
> - v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32), v33_(v33),
> - v34_(v34), v35_(v35), v36_(v36), v37_(v37), v38_(v38), v39_(v39),
> - v40_(v40) {}
> -
> - template <typename T>
> - operator ParamGenerator<T>() const {
> - const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> - static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> - static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> - static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
> - static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
> - static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
> - static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
> - static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
> - static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
> - static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
> - static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
> - static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
> - static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
> - static_cast<T>(v39_), static_cast<T>(v40_)};
> - return ValuesIn(array);
> - }
> -
> - ValueArray40(const ValueArray40& other) : v1_(other.v1_),
> v2_(other.v2_),
> - v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
> - v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
> - v11_(other.v11_), v12_(other.v12_), v13_(other.v13_),
> v14_(other.v14_),
> - v15_(other.v15_), v16_(other.v16_), v17_(other.v17_),
> v18_(other.v18_),
> - v19_(other.v19_), v20_(other.v20_), v21_(other.v21_),
> v22_(other.v22_),
> - v23_(other.v23_), v24_(other.v24_), v25_(other.v25_),
> v26_(other.v26_),
> - v27_(other.v27_), v28_(other.v28_), v29_(other.v29_),
> v30_(other.v30_),
> - v31_(other.v31_), v32_(other.v32_), v33_(other.v33_),
> v34_(other.v34_),
> - v35_(other.v35_), v36_(other.v36_), v37_(other.v37_),
> v38_(other.v38_),
> - v39_(other.v39_), v40_(other.v40_) {}
> -
> - private:
> - // No implementation - assignment is unsupported.
> - void operator=(const ValueArray40& other);
> -
> - const T1 v1_;
> - const T2 v2_;
> - const T3 v3_;
> - const T4 v4_;
> - const T5 v5_;
> - const T6 v6_;
> - const T7 v7_;
> - const T8 v8_;
> - const T9 v9_;
> - const T10 v10_;
> - const T11 v11_;
> - const T12 v12_;
> - const T13 v13_;
> - const T14 v14_;
> - const T15 v15_;
> - const T16 v16_;
> - const T17 v17_;
> - const T18 v18_;
> - const T19 v19_;
> - const T20 v20_;
> - const T21 v21_;
> - const T22 v22_;
> - const T23 v23_;
> - const T24 v24_;
> - const T25 v25_;
> - const T26 v26_;
> - const T27 v27_;
> - const T28 v28_;
> - const T29 v29_;
> - const T30 v30_;
> - const T31 v31_;
> - const T32 v32_;
> - const T33 v33_;
> - const T34 v34_;
> - const T35 v35_;
> - const T36 v36_;
> - const T37 v37_;
> - const T38 v38_;
> - const T39 v39_;
> - const T40 v40_;
> -};
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11, typename T12, typename T13, typename T14, typename T15,
> - typename T16, typename T17, typename T18, typename T19, typename T20,
> - typename T21, typename T22, typename T23, typename T24, typename T25,
> - typename T26, typename T27, typename T28, typename T29, typename T30,
> - typename T31, typename T32, typename T33, typename T34, typename T35,
> - typename T36, typename T37, typename T38, typename T39, typename T40,
> - typename T41>
> -class ValueArray41 {
> - public:
> - ValueArray41(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9
> v9,
> - T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17
> v17,
> - T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25
> v25,
> - T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33
> v33,
> - T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40,
> - T41 v41) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6),
> v7_(v7),
> - v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13),
> v14_(v14),
> - v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20),
> - v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26),
> - v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32),
> - v33_(v33), v34_(v34), v35_(v35), v36_(v36), v37_(v37), v38_(v38),
> - v39_(v39), v40_(v40), v41_(v41) {}
> -
> - template <typename T>
> - operator ParamGenerator<T>() const {
> - const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> - static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> - static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> - static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
> - static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
> - static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
> - static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
> - static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
> - static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
> - static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
> - static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
> - static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
> - static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
> - static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_)};
> - return ValuesIn(array);
> - }
> -
> - ValueArray41(const ValueArray41& other) : v1_(other.v1_),
> v2_(other.v2_),
> - v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
> - v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
> - v11_(other.v11_), v12_(other.v12_), v13_(other.v13_),
> v14_(other.v14_),
> - v15_(other.v15_), v16_(other.v16_), v17_(other.v17_),
> v18_(other.v18_),
> - v19_(other.v19_), v20_(other.v20_), v21_(other.v21_),
> v22_(other.v22_),
> - v23_(other.v23_), v24_(other.v24_), v25_(other.v25_),
> v26_(other.v26_),
> - v27_(other.v27_), v28_(other.v28_), v29_(other.v29_),
> v30_(other.v30_),
> - v31_(other.v31_), v32_(other.v32_), v33_(other.v33_),
> v34_(other.v34_),
> - v35_(other.v35_), v36_(other.v36_), v37_(other.v37_),
> v38_(other.v38_),
> - v39_(other.v39_), v40_(other.v40_), v41_(other.v41_) {}
> -
> - private:
> - // No implementation - assignment is unsupported.
> - void operator=(const ValueArray41& other);
> -
> - const T1 v1_;
> - const T2 v2_;
> - const T3 v3_;
> - const T4 v4_;
> - const T5 v5_;
> - const T6 v6_;
> - const T7 v7_;
> - const T8 v8_;
> - const T9 v9_;
> - const T10 v10_;
> - const T11 v11_;
> - const T12 v12_;
> - const T13 v13_;
> - const T14 v14_;
> - const T15 v15_;
> - const T16 v16_;
> - const T17 v17_;
> - const T18 v18_;
> - const T19 v19_;
> - const T20 v20_;
> - const T21 v21_;
> - const T22 v22_;
> - const T23 v23_;
> - const T24 v24_;
> - const T25 v25_;
> - const T26 v26_;
> - const T27 v27_;
> - const T28 v28_;
> - const T29 v29_;
> - const T30 v30_;
> - const T31 v31_;
> - const T32 v32_;
> - const T33 v33_;
> - const T34 v34_;
> - const T35 v35_;
> - const T36 v36_;
> - const T37 v37_;
> - const T38 v38_;
> - const T39 v39_;
> - const T40 v40_;
> - const T41 v41_;
> -};
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11, typename T12, typename T13, typename T14, typename T15,
> - typename T16, typename T17, typename T18, typename T19, typename T20,
> - typename T21, typename T22, typename T23, typename T24, typename T25,
> - typename T26, typename T27, typename T28, typename T29, typename T30,
> - typename T31, typename T32, typename T33, typename T34, typename T35,
> - typename T36, typename T37, typename T38, typename T39, typename T40,
> - typename T41, typename T42>
> -class ValueArray42 {
> - public:
> - ValueArray42(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9
> v9,
> - T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17
> v17,
> - T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25
> v25,
> - T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33
> v33,
> - T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41
> v41,
> - T42 v42) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6),
> v7_(v7),
> - v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13),
> v14_(v14),
> - v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20),
> - v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26),
> - v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32),
> - v33_(v33), v34_(v34), v35_(v35), v36_(v36), v37_(v37), v38_(v38),
> - v39_(v39), v40_(v40), v41_(v41), v42_(v42) {}
> -
> - template <typename T>
> - operator ParamGenerator<T>() const {
> - const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> - static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> - static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> - static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
> - static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
> - static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
> - static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
> - static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
> - static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
> - static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
> - static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
> - static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
> - static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
> - static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
> - static_cast<T>(v42_)};
> - return ValuesIn(array);
> - }
> -
> - ValueArray42(const ValueArray42& other) : v1_(other.v1_),
> v2_(other.v2_),
> - v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
> - v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
> - v11_(other.v11_), v12_(other.v12_), v13_(other.v13_),
> v14_(other.v14_),
> - v15_(other.v15_), v16_(other.v16_), v17_(other.v17_),
> v18_(other.v18_),
> - v19_(other.v19_), v20_(other.v20_), v21_(other.v21_),
> v22_(other.v22_),
> - v23_(other.v23_), v24_(other.v24_), v25_(other.v25_),
> v26_(other.v26_),
> - v27_(other.v27_), v28_(other.v28_), v29_(other.v29_),
> v30_(other.v30_),
> - v31_(other.v31_), v32_(other.v32_), v33_(other.v33_),
> v34_(other.v34_),
> - v35_(other.v35_), v36_(other.v36_), v37_(other.v37_),
> v38_(other.v38_),
> - v39_(other.v39_), v40_(other.v40_), v41_(other.v41_),
> v42_(other.v42_) {}
> -
> - private:
> - // No implementation - assignment is unsupported.
> - void operator=(const ValueArray42& other);
> -
> - const T1 v1_;
> - const T2 v2_;
> - const T3 v3_;
> - const T4 v4_;
> - const T5 v5_;
> - const T6 v6_;
> - const T7 v7_;
> - const T8 v8_;
> - const T9 v9_;
> - const T10 v10_;
> - const T11 v11_;
> - const T12 v12_;
> - const T13 v13_;
> - const T14 v14_;
> - const T15 v15_;
> - const T16 v16_;
> - const T17 v17_;
> - const T18 v18_;
> - const T19 v19_;
> - const T20 v20_;
> - const T21 v21_;
> - const T22 v22_;
> - const T23 v23_;
> - const T24 v24_;
> - const T25 v25_;
> - const T26 v26_;
> - const T27 v27_;
> - const T28 v28_;
> - const T29 v29_;
> - const T30 v30_;
> - const T31 v31_;
> - const T32 v32_;
> - const T33 v33_;
> - const T34 v34_;
> - const T35 v35_;
> - const T36 v36_;
> - const T37 v37_;
> - const T38 v38_;
> - const T39 v39_;
> - const T40 v40_;
> - const T41 v41_;
> - const T42 v42_;
> -};
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11, typename T12, typename T13, typename T14, typename T15,
> - typename T16, typename T17, typename T18, typename T19, typename T20,
> - typename T21, typename T22, typename T23, typename T24, typename T25,
> - typename T26, typename T27, typename T28, typename T29, typename T30,
> - typename T31, typename T32, typename T33, typename T34, typename T35,
> - typename T36, typename T37, typename T38, typename T39, typename T40,
> - typename T41, typename T42, typename T43>
> -class ValueArray43 {
> - public:
> - ValueArray43(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9
> v9,
> - T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17
> v17,
> - T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25
> v25,
> - T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33
> v33,
> - T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41
> v41,
> - T42 v42, T43 v43) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5),
> v6_(v6),
> - v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12),
> v13_(v13),
> - v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19),
> - v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25),
> - v26_(v26), v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31),
> - v32_(v32), v33_(v33), v34_(v34), v35_(v35), v36_(v36), v37_(v37),
> - v38_(v38), v39_(v39), v40_(v40), v41_(v41), v42_(v42), v43_(v43) {}
> -
> - template <typename T>
> - operator ParamGenerator<T>() const {
> - const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> - static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> - static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> - static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
> - static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
> - static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
> - static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
> - static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
> - static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
> - static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
> - static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
> - static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
> - static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
> - static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
> - static_cast<T>(v42_), static_cast<T>(v43_)};
> - return ValuesIn(array);
> - }
> -
> - ValueArray43(const ValueArray43& other) : v1_(other.v1_),
> v2_(other.v2_),
> - v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
> - v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
> - v11_(other.v11_), v12_(other.v12_), v13_(other.v13_),
> v14_(other.v14_),
> - v15_(other.v15_), v16_(other.v16_), v17_(other.v17_),
> v18_(other.v18_),
> - v19_(other.v19_), v20_(other.v20_), v21_(other.v21_),
> v22_(other.v22_),
> - v23_(other.v23_), v24_(other.v24_), v25_(other.v25_),
> v26_(other.v26_),
> - v27_(other.v27_), v28_(other.v28_), v29_(other.v29_),
> v30_(other.v30_),
> - v31_(other.v31_), v32_(other.v32_), v33_(other.v33_),
> v34_(other.v34_),
> - v35_(other.v35_), v36_(other.v36_), v37_(other.v37_),
> v38_(other.v38_),
> - v39_(other.v39_), v40_(other.v40_), v41_(other.v41_),
> v42_(other.v42_),
> - v43_(other.v43_) {}
> -
> - private:
> - // No implementation - assignment is unsupported.
> - void operator=(const ValueArray43& other);
> -
> - const T1 v1_;
> - const T2 v2_;
> - const T3 v3_;
> - const T4 v4_;
> - const T5 v5_;
> - const T6 v6_;
> - const T7 v7_;
> - const T8 v8_;
> - const T9 v9_;
> - const T10 v10_;
> - const T11 v11_;
> - const T12 v12_;
> - const T13 v13_;
> - const T14 v14_;
> - const T15 v15_;
> - const T16 v16_;
> - const T17 v17_;
> - const T18 v18_;
> - const T19 v19_;
> - const T20 v20_;
> - const T21 v21_;
> - const T22 v22_;
> - const T23 v23_;
> - const T24 v24_;
> - const T25 v25_;
> - const T26 v26_;
> - const T27 v27_;
> - const T28 v28_;
> - const T29 v29_;
> - const T30 v30_;
> - const T31 v31_;
> - const T32 v32_;
> - const T33 v33_;
> - const T34 v34_;
> - const T35 v35_;
> - const T36 v36_;
> - const T37 v37_;
> - const T38 v38_;
> - const T39 v39_;
> - const T40 v40_;
> - const T41 v41_;
> - const T42 v42_;
> - const T43 v43_;
> -};
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11, typename T12, typename T13, typename T14, typename T15,
> - typename T16, typename T17, typename T18, typename T19, typename T20,
> - typename T21, typename T22, typename T23, typename T24, typename T25,
> - typename T26, typename T27, typename T28, typename T29, typename T30,
> - typename T31, typename T32, typename T33, typename T34, typename T35,
> - typename T36, typename T37, typename T38, typename T39, typename T40,
> - typename T41, typename T42, typename T43, typename T44>
> -class ValueArray44 {
> - public:
> - ValueArray44(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9
> v9,
> - T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17
> v17,
> - T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25
> v25,
> - T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33
> v33,
> - T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41
> v41,
> - T42 v42, T43 v43, T44 v44) : v1_(v1), v2_(v2), v3_(v3), v4_(v4),
> v5_(v5),
> - v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12),
> - v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18),
> - v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24),
> - v25_(v25), v26_(v26), v27_(v27), v28_(v28), v29_(v29), v30_(v30),
> - v31_(v31), v32_(v32), v33_(v33), v34_(v34), v35_(v35), v36_(v36),
> - v37_(v37), v38_(v38), v39_(v39), v40_(v40), v41_(v41), v42_(v42),
> - v43_(v43), v44_(v44) {}
> -
> - template <typename T>
> - operator ParamGenerator<T>() const {
> - const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> - static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> - static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> - static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
> - static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
> - static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
> - static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
> - static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
> - static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
> - static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
> - static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
> - static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
> - static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
> - static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
> - static_cast<T>(v42_), static_cast<T>(v43_), static_cast<T>(v44_)};
> - return ValuesIn(array);
> - }
> -
> - ValueArray44(const ValueArray44& other) : v1_(other.v1_),
> v2_(other.v2_),
> - v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
> - v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
> - v11_(other.v11_), v12_(other.v12_), v13_(other.v13_),
> v14_(other.v14_),
> - v15_(other.v15_), v16_(other.v16_), v17_(other.v17_),
> v18_(other.v18_),
> - v19_(other.v19_), v20_(other.v20_), v21_(other.v21_),
> v22_(other.v22_),
> - v23_(other.v23_), v24_(other.v24_), v25_(other.v25_),
> v26_(other.v26_),
> - v27_(other.v27_), v28_(other.v28_), v29_(other.v29_),
> v30_(other.v30_),
> - v31_(other.v31_), v32_(other.v32_), v33_(other.v33_),
> v34_(other.v34_),
> - v35_(other.v35_), v36_(other.v36_), v37_(other.v37_),
> v38_(other.v38_),
> - v39_(other.v39_), v40_(other.v40_), v41_(other.v41_),
> v42_(other.v42_),
> - v43_(other.v43_), v44_(other.v44_) {}
> -
> - private:
> - // No implementation - assignment is unsupported.
> - void operator=(const ValueArray44& other);
> -
> - const T1 v1_;
> - const T2 v2_;
> - const T3 v3_;
> - const T4 v4_;
> - const T5 v5_;
> - const T6 v6_;
> - const T7 v7_;
> - const T8 v8_;
> - const T9 v9_;
> - const T10 v10_;
> - const T11 v11_;
> - const T12 v12_;
> - const T13 v13_;
> - const T14 v14_;
> - const T15 v15_;
> - const T16 v16_;
> - const T17 v17_;
> - const T18 v18_;
> - const T19 v19_;
> - const T20 v20_;
> - const T21 v21_;
> - const T22 v22_;
> - const T23 v23_;
> - const T24 v24_;
> - const T25 v25_;
> - const T26 v26_;
> - const T27 v27_;
> - const T28 v28_;
> - const T29 v29_;
> - const T30 v30_;
> - const T31 v31_;
> - const T32 v32_;
> - const T33 v33_;
> - const T34 v34_;
> - const T35 v35_;
> - const T36 v36_;
> - const T37 v37_;
> - const T38 v38_;
> - const T39 v39_;
> - const T40 v40_;
> - const T41 v41_;
> - const T42 v42_;
> - const T43 v43_;
> - const T44 v44_;
> -};
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11, typename T12, typename T13, typename T14, typename T15,
> - typename T16, typename T17, typename T18, typename T19, typename T20,
> - typename T21, typename T22, typename T23, typename T24, typename T25,
> - typename T26, typename T27, typename T28, typename T29, typename T30,
> - typename T31, typename T32, typename T33, typename T34, typename T35,
> - typename T36, typename T37, typename T38, typename T39, typename T40,
> - typename T41, typename T42, typename T43, typename T44, typename T45>
> -class ValueArray45 {
> - public:
> - ValueArray45(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9
> v9,
> - T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17
> v17,
> - T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25
> v25,
> - T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33
> v33,
> - T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41
> v41,
> - T42 v42, T43 v43, T44 v44, T45 v45) : v1_(v1), v2_(v2), v3_(v3),
> v4_(v4),
> - v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11),
> - v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17),
> - v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23),
> - v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28), v29_(v29),
> - v30_(v30), v31_(v31), v32_(v32), v33_(v33), v34_(v34), v35_(v35),
> - v36_(v36), v37_(v37), v38_(v38), v39_(v39), v40_(v40), v41_(v41),
> - v42_(v42), v43_(v43), v44_(v44), v45_(v45) {}
> -
> - template <typename T>
> - operator ParamGenerator<T>() const {
> - const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> - static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> - static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> - static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
> - static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
> - static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
> - static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
> - static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
> - static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
> - static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
> - static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
> - static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
> - static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
> - static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
> - static_cast<T>(v42_), static_cast<T>(v43_), static_cast<T>(v44_),
> - static_cast<T>(v45_)};
> - return ValuesIn(array);
> - }
> -
> - ValueArray45(const ValueArray45& other) : v1_(other.v1_),
> v2_(other.v2_),
> - v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
> - v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
> - v11_(other.v11_), v12_(other.v12_), v13_(other.v13_),
> v14_(other.v14_),
> - v15_(other.v15_), v16_(other.v16_), v17_(other.v17_),
> v18_(other.v18_),
> - v19_(other.v19_), v20_(other.v20_), v21_(other.v21_),
> v22_(other.v22_),
> - v23_(other.v23_), v24_(other.v24_), v25_(other.v25_),
> v26_(other.v26_),
> - v27_(other.v27_), v28_(other.v28_), v29_(other.v29_),
> v30_(other.v30_),
> - v31_(other.v31_), v32_(other.v32_), v33_(other.v33_),
> v34_(other.v34_),
> - v35_(other.v35_), v36_(other.v36_), v37_(other.v37_),
> v38_(other.v38_),
> - v39_(other.v39_), v40_(other.v40_), v41_(other.v41_),
> v42_(other.v42_),
> - v43_(other.v43_), v44_(other.v44_), v45_(other.v45_) {}
> -
> - private:
> - // No implementation - assignment is unsupported.
> - void operator=(const ValueArray45& other);
> -
> - const T1 v1_;
> - const T2 v2_;
> - const T3 v3_;
> - const T4 v4_;
> - const T5 v5_;
> - const T6 v6_;
> - const T7 v7_;
> - const T8 v8_;
> - const T9 v9_;
> - const T10 v10_;
> - const T11 v11_;
> - const T12 v12_;
> - const T13 v13_;
> - const T14 v14_;
> - const T15 v15_;
> - const T16 v16_;
> - const T17 v17_;
> - const T18 v18_;
> - const T19 v19_;
> - const T20 v20_;
> - const T21 v21_;
> - const T22 v22_;
> - const T23 v23_;
> - const T24 v24_;
> - const T25 v25_;
> - const T26 v26_;
> - const T27 v27_;
> - const T28 v28_;
> - const T29 v29_;
> - const T30 v30_;
> - const T31 v31_;
> - const T32 v32_;
> - const T33 v33_;
> - const T34 v34_;
> - const T35 v35_;
> - const T36 v36_;
> - const T37 v37_;
> - const T38 v38_;
> - const T39 v39_;
> - const T40 v40_;
> - const T41 v41_;
> - const T42 v42_;
> - const T43 v43_;
> - const T44 v44_;
> - const T45 v45_;
> -};
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11, typename T12, typename T13, typename T14, typename T15,
> - typename T16, typename T17, typename T18, typename T19, typename T20,
> - typename T21, typename T22, typename T23, typename T24, typename T25,
> - typename T26, typename T27, typename T28, typename T29, typename T30,
> - typename T31, typename T32, typename T33, typename T34, typename T35,
> - typename T36, typename T37, typename T38, typename T39, typename T40,
> - typename T41, typename T42, typename T43, typename T44, typename T45,
> - typename T46>
> -class ValueArray46 {
> - public:
> - ValueArray46(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9
> v9,
> - T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17
> v17,
> - T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25
> v25,
> - T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33
> v33,
> - T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41
> v41,
> - T42 v42, T43 v43, T44 v44, T45 v45, T46 v46) : v1_(v1), v2_(v2),
> v3_(v3),
> - v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),
> - v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16),
> - v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22),
> - v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28),
> - v29_(v29), v30_(v30), v31_(v31), v32_(v32), v33_(v33), v34_(v34),
> - v35_(v35), v36_(v36), v37_(v37), v38_(v38), v39_(v39), v40_(v40),
> - v41_(v41), v42_(v42), v43_(v43), v44_(v44), v45_(v45), v46_(v46) {}
> -
> - template <typename T>
> - operator ParamGenerator<T>() const {
> - const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> - static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> - static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> - static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
> - static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
> - static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
> - static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
> - static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
> - static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
> - static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
> - static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
> - static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
> - static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
> - static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
> - static_cast<T>(v42_), static_cast<T>(v43_), static_cast<T>(v44_),
> - static_cast<T>(v45_), static_cast<T>(v46_)};
> - return ValuesIn(array);
> - }
> -
> - ValueArray46(const ValueArray46& other) : v1_(other.v1_),
> v2_(other.v2_),
> - v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
> - v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
> - v11_(other.v11_), v12_(other.v12_), v13_(other.v13_),
> v14_(other.v14_),
> - v15_(other.v15_), v16_(other.v16_), v17_(other.v17_),
> v18_(other.v18_),
> - v19_(other.v19_), v20_(other.v20_), v21_(other.v21_),
> v22_(other.v22_),
> - v23_(other.v23_), v24_(other.v24_), v25_(other.v25_),
> v26_(other.v26_),
> - v27_(other.v27_), v28_(other.v28_), v29_(other.v29_),
> v30_(other.v30_),
> - v31_(other.v31_), v32_(other.v32_), v33_(other.v33_),
> v34_(other.v34_),
> - v35_(other.v35_), v36_(other.v36_), v37_(other.v37_),
> v38_(other.v38_),
> - v39_(other.v39_), v40_(other.v40_), v41_(other.v41_),
> v42_(other.v42_),
> - v43_(other.v43_), v44_(other.v44_), v45_(other.v45_),
> v46_(other.v46_) {}
> -
> - private:
> - // No implementation - assignment is unsupported.
> - void operator=(const ValueArray46& other);
> -
> - const T1 v1_;
> - const T2 v2_;
> - const T3 v3_;
> - const T4 v4_;
> - const T5 v5_;
> - const T6 v6_;
> - const T7 v7_;
> - const T8 v8_;
> - const T9 v9_;
> - const T10 v10_;
> - const T11 v11_;
> - const T12 v12_;
> - const T13 v13_;
> - const T14 v14_;
> - const T15 v15_;
> - const T16 v16_;
> - const T17 v17_;
> - const T18 v18_;
> - const T19 v19_;
> - const T20 v20_;
> - const T21 v21_;
> - const T22 v22_;
> - const T23 v23_;
> - const T24 v24_;
> - const T25 v25_;
> - const T26 v26_;
> - const T27 v27_;
> - const T28 v28_;
> - const T29 v29_;
> - const T30 v30_;
> - const T31 v31_;
> - const T32 v32_;
> - const T33 v33_;
> - const T34 v34_;
> - const T35 v35_;
> - const T36 v36_;
> - const T37 v37_;
> - const T38 v38_;
> - const T39 v39_;
> - const T40 v40_;
> - const T41 v41_;
> - const T42 v42_;
> - const T43 v43_;
> - const T44 v44_;
> - const T45 v45_;
> - const T46 v46_;
> -};
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11, typename T12, typename T13, typename T14, typename T15,
> - typename T16, typename T17, typename T18, typename T19, typename T20,
> - typename T21, typename T22, typename T23, typename T24, typename T25,
> - typename T26, typename T27, typename T28, typename T29, typename T30,
> - typename T31, typename T32, typename T33, typename T34, typename T35,
> - typename T36, typename T37, typename T38, typename T39, typename T40,
> - typename T41, typename T42, typename T43, typename T44, typename T45,
> - typename T46, typename T47>
> -class ValueArray47 {
> - public:
> - ValueArray47(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9
> v9,
> - T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17
> v17,
> - T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25
> v25,
> - T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33
> v33,
> - T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41
> v41,
> - T42 v42, T43 v43, T44 v44, T45 v45, T46 v46, T47 v47) : v1_(v1),
> v2_(v2),
> - v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9),
> v10_(v10),
> - v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16),
> - v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22),
> - v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28),
> - v29_(v29), v30_(v30), v31_(v31), v32_(v32), v33_(v33), v34_(v34),
> - v35_(v35), v36_(v36), v37_(v37), v38_(v38), v39_(v39), v40_(v40),
> - v41_(v41), v42_(v42), v43_(v43), v44_(v44), v45_(v45), v46_(v46),
> - v47_(v47) {}
> -
> - template <typename T>
> - operator ParamGenerator<T>() const {
> - const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> - static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> - static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> - static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
> - static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
> - static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
> - static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
> - static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
> - static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
> - static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
> - static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
> - static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
> - static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
> - static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
> - static_cast<T>(v42_), static_cast<T>(v43_), static_cast<T>(v44_),
> - static_cast<T>(v45_), static_cast<T>(v46_), static_cast<T>(v47_)};
> - return ValuesIn(array);
> - }
> -
> - ValueArray47(const ValueArray47& other) : v1_(other.v1_),
> v2_(other.v2_),
> - v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
> - v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
> - v11_(other.v11_), v12_(other.v12_), v13_(other.v13_),
> v14_(other.v14_),
> - v15_(other.v15_), v16_(other.v16_), v17_(other.v17_),
> v18_(other.v18_),
> - v19_(other.v19_), v20_(other.v20_), v21_(other.v21_),
> v22_(other.v22_),
> - v23_(other.v23_), v24_(other.v24_), v25_(other.v25_),
> v26_(other.v26_),
> - v27_(other.v27_), v28_(other.v28_), v29_(other.v29_),
> v30_(other.v30_),
> - v31_(other.v31_), v32_(other.v32_), v33_(other.v33_),
> v34_(other.v34_),
> - v35_(other.v35_), v36_(other.v36_), v37_(other.v37_),
> v38_(other.v38_),
> - v39_(other.v39_), v40_(other.v40_), v41_(other.v41_),
> v42_(other.v42_),
> - v43_(other.v43_), v44_(other.v44_), v45_(other.v45_),
> v46_(other.v46_),
> - v47_(other.v47_) {}
> -
> - private:
> - // No implementation - assignment is unsupported.
> - void operator=(const ValueArray47& other);
> -
> - const T1 v1_;
> - const T2 v2_;
> - const T3 v3_;
> - const T4 v4_;
> - const T5 v5_;
> - const T6 v6_;
> - const T7 v7_;
> - const T8 v8_;
> - const T9 v9_;
> - const T10 v10_;
> - const T11 v11_;
> - const T12 v12_;
> - const T13 v13_;
> - const T14 v14_;
> - const T15 v15_;
> - const T16 v16_;
> - const T17 v17_;
> - const T18 v18_;
> - const T19 v19_;
> - const T20 v20_;
> - const T21 v21_;
> - const T22 v22_;
> - const T23 v23_;
> - const T24 v24_;
> - const T25 v25_;
> - const T26 v26_;
> - const T27 v27_;
> - const T28 v28_;
> - const T29 v29_;
> - const T30 v30_;
> - const T31 v31_;
> - const T32 v32_;
> - const T33 v33_;
> - const T34 v34_;
> - const T35 v35_;
> - const T36 v36_;
> - const T37 v37_;
> - const T38 v38_;
> - const T39 v39_;
> - const T40 v40_;
> - const T41 v41_;
> - const T42 v42_;
> - const T43 v43_;
> - const T44 v44_;
> - const T45 v45_;
> - const T46 v46_;
> - const T47 v47_;
> -};
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11, typename T12, typename T13, typename T14, typename T15,
> - typename T16, typename T17, typename T18, typename T19, typename T20,
> - typename T21, typename T22, typename T23, typename T24, typename T25,
> - typename T26, typename T27, typename T28, typename T29, typename T30,
> - typename T31, typename T32, typename T33, typename T34, typename T35,
> - typename T36, typename T37, typename T38, typename T39, typename T40,
> - typename T41, typename T42, typename T43, typename T44, typename T45,
> - typename T46, typename T47, typename T48>
> -class ValueArray48 {
> - public:
> - ValueArray48(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9
> v9,
> - T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17
> v17,
> - T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25
> v25,
> - T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33
> v33,
> - T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41
> v41,
> - T42 v42, T43 v43, T44 v44, T45 v45, T46 v46, T47 v47, T48 v48) :
> v1_(v1),
> - v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8),
> v9_(v9),
> - v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15),
> - v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21),
> - v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27),
> - v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32), v33_(v33),
> - v34_(v34), v35_(v35), v36_(v36), v37_(v37), v38_(v38), v39_(v39),
> - v40_(v40), v41_(v41), v42_(v42), v43_(v43), v44_(v44), v45_(v45),
> - v46_(v46), v47_(v47), v48_(v48) {}
> -
> - template <typename T>
> - operator ParamGenerator<T>() const {
> - const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> - static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> - static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> - static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
> - static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
> - static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
> - static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
> - static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
> - static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
> - static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
> - static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
> - static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
> - static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
> - static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
> - static_cast<T>(v42_), static_cast<T>(v43_), static_cast<T>(v44_),
> - static_cast<T>(v45_), static_cast<T>(v46_), static_cast<T>(v47_),
> - static_cast<T>(v48_)};
> - return ValuesIn(array);
> - }
> -
> - ValueArray48(const ValueArray48& other) : v1_(other.v1_),
> v2_(other.v2_),
> - v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
> - v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
> - v11_(other.v11_), v12_(other.v12_), v13_(other.v13_),
> v14_(other.v14_),
> - v15_(other.v15_), v16_(other.v16_), v17_(other.v17_),
> v18_(other.v18_),
> - v19_(other.v19_), v20_(other.v20_), v21_(other.v21_),
> v22_(other.v22_),
> - v23_(other.v23_), v24_(other.v24_), v25_(other.v25_),
> v26_(other.v26_),
> - v27_(other.v27_), v28_(other.v28_), v29_(other.v29_),
> v30_(other.v30_),
> - v31_(other.v31_), v32_(other.v32_), v33_(other.v33_),
> v34_(other.v34_),
> - v35_(other.v35_), v36_(other.v36_), v37_(other.v37_),
> v38_(other.v38_),
> - v39_(other.v39_), v40_(other.v40_), v41_(other.v41_),
> v42_(other.v42_),
> - v43_(other.v43_), v44_(other.v44_), v45_(other.v45_),
> v46_(other.v46_),
> - v47_(other.v47_), v48_(other.v48_) {}
> -
> - private:
> - // No implementation - assignment is unsupported.
> - void operator=(const ValueArray48& other);
> -
> - const T1 v1_;
> - const T2 v2_;
> - const T3 v3_;
> - const T4 v4_;
> - const T5 v5_;
> - const T6 v6_;
> - const T7 v7_;
> - const T8 v8_;
> - const T9 v9_;
> - const T10 v10_;
> - const T11 v11_;
> - const T12 v12_;
> - const T13 v13_;
> - const T14 v14_;
> - const T15 v15_;
> - const T16 v16_;
> - const T17 v17_;
> - const T18 v18_;
> - const T19 v19_;
> - const T20 v20_;
> - const T21 v21_;
> - const T22 v22_;
> - const T23 v23_;
> - const T24 v24_;
> - const T25 v25_;
> - const T26 v26_;
> - const T27 v27_;
> - const T28 v28_;
> - const T29 v29_;
> - const T30 v30_;
> - const T31 v31_;
> - const T32 v32_;
> - const T33 v33_;
> - const T34 v34_;
> - const T35 v35_;
> - const T36 v36_;
> - const T37 v37_;
> - const T38 v38_;
> - const T39 v39_;
> - const T40 v40_;
> - const T41 v41_;
> - const T42 v42_;
> - const T43 v43_;
> - const T44 v44_;
> - const T45 v45_;
> - const T46 v46_;
> - const T47 v47_;
> - const T48 v48_;
> -};
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11, typename T12, typename T13, typename T14, typename T15,
> - typename T16, typename T17, typename T18, typename T19, typename T20,
> - typename T21, typename T22, typename T23, typename T24, typename T25,
> - typename T26, typename T27, typename T28, typename T29, typename T30,
> - typename T31, typename T32, typename T33, typename T34, typename T35,
> - typename T36, typename T37, typename T38, typename T39, typename T40,
> - typename T41, typename T42, typename T43, typename T44, typename T45,
> - typename T46, typename T47, typename T48, typename T49>
> -class ValueArray49 {
> - public:
> - ValueArray49(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9
> v9,
> - T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17
> v17,
> - T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25
> v25,
> - T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33
> v33,
> - T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41
> v41,
> - T42 v42, T43 v43, T44 v44, T45 v45, T46 v46, T47 v47, T48 v48,
> - T49 v49) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6),
> v7_(v7),
> - v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13),
> v14_(v14),
> - v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20),
> - v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26),
> - v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32),
> - v33_(v33), v34_(v34), v35_(v35), v36_(v36), v37_(v37), v38_(v38),
> - v39_(v39), v40_(v40), v41_(v41), v42_(v42), v43_(v43), v44_(v44),
> - v45_(v45), v46_(v46), v47_(v47), v48_(v48), v49_(v49) {}
> -
> - template <typename T>
> - operator ParamGenerator<T>() const {
> - const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> - static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> - static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> - static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
> - static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
> - static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
> - static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
> - static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
> - static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
> - static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
> - static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
> - static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
> - static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
> - static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
> - static_cast<T>(v42_), static_cast<T>(v43_), static_cast<T>(v44_),
> - static_cast<T>(v45_), static_cast<T>(v46_), static_cast<T>(v47_),
> - static_cast<T>(v48_), static_cast<T>(v49_)};
> - return ValuesIn(array);
> - }
> -
> - ValueArray49(const ValueArray49& other) : v1_(other.v1_),
> v2_(other.v2_),
> - v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
> - v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
> - v11_(other.v11_), v12_(other.v12_), v13_(other.v13_),
> v14_(other.v14_),
> - v15_(other.v15_), v16_(other.v16_), v17_(other.v17_),
> v18_(other.v18_),
> - v19_(other.v19_), v20_(other.v20_), v21_(other.v21_),
> v22_(other.v22_),
> - v23_(other.v23_), v24_(other.v24_), v25_(other.v25_),
> v26_(other.v26_),
> - v27_(other.v27_), v28_(other.v28_), v29_(other.v29_),
> v30_(other.v30_),
> - v31_(other.v31_), v32_(other.v32_), v33_(other.v33_),
> v34_(other.v34_),
> - v35_(other.v35_), v36_(other.v36_), v37_(other.v37_),
> v38_(other.v38_),
> - v39_(other.v39_), v40_(other.v40_), v41_(other.v41_),
> v42_(other.v42_),
> - v43_(other.v43_), v44_(other.v44_), v45_(other.v45_),
> v46_(other.v46_),
> - v47_(other.v47_), v48_(other.v48_), v49_(other.v49_) {}
> -
> - private:
> - // No implementation - assignment is unsupported.
> - void operator=(const ValueArray49& other);
> -
> - const T1 v1_;
> - const T2 v2_;
> - const T3 v3_;
> - const T4 v4_;
> - const T5 v5_;
> - const T6 v6_;
> - const T7 v7_;
> - const T8 v8_;
> - const T9 v9_;
> - const T10 v10_;
> - const T11 v11_;
> - const T12 v12_;
> - const T13 v13_;
> - const T14 v14_;
> - const T15 v15_;
> - const T16 v16_;
> - const T17 v17_;
> - const T18 v18_;
> - const T19 v19_;
> - const T20 v20_;
> - const T21 v21_;
> - const T22 v22_;
> - const T23 v23_;
> - const T24 v24_;
> - const T25 v25_;
> - const T26 v26_;
> - const T27 v27_;
> - const T28 v28_;
> - const T29 v29_;
> - const T30 v30_;
> - const T31 v31_;
> - const T32 v32_;
> - const T33 v33_;
> - const T34 v34_;
> - const T35 v35_;
> - const T36 v36_;
> - const T37 v37_;
> - const T38 v38_;
> - const T39 v39_;
> - const T40 v40_;
> - const T41 v41_;
> - const T42 v42_;
> - const T43 v43_;
> - const T44 v44_;
> - const T45 v45_;
> - const T46 v46_;
> - const T47 v47_;
> - const T48 v48_;
> - const T49 v49_;
> -};
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10,
> - typename T11, typename T12, typename T13, typename T14, typename T15,
> - typename T16, typename T17, typename T18, typename T19, typename T20,
> - typename T21, typename T22, typename T23, typename T24, typename T25,
> - typename T26, typename T27, typename T28, typename T29, typename T30,
> - typename T31, typename T32, typename T33, typename T34, typename T35,
> - typename T36, typename T37, typename T38, typename T39, typename T40,
> - typename T41, typename T42, typename T43, typename T44, typename T45,
> - typename T46, typename T47, typename T48, typename T49, typename T50>
> -class ValueArray50 {
> - public:
> - ValueArray50(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9
> v9,
> - T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17
> v17,
> - T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25
> v25,
> - T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33
> v33,
> - T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41
> v41,
> - T42 v42, T43 v43, T44 v44, T45 v45, T46 v46, T47 v47, T48 v48, T49
> v49,
> - T50 v50) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6),
> v7_(v7),
> - v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13),
> v14_(v14),
> - v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20),
> - v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26),
> - v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32),
> - v33_(v33), v34_(v34), v35_(v35), v36_(v36), v37_(v37), v38_(v38),
> - v39_(v39), v40_(v40), v41_(v41), v42_(v42), v43_(v43), v44_(v44),
> - v45_(v45), v46_(v46), v47_(v47), v48_(v48), v49_(v49), v50_(v50) {}
> -
> - template <typename T>
> - operator ParamGenerator<T>() const {
> - const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
> - static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
> - static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
> - static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
> - static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
> - static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
> - static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
> - static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
> - static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
> - static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
> - static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
> - static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
> - static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
> - static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
> - static_cast<T>(v42_), static_cast<T>(v43_), static_cast<T>(v44_),
> - static_cast<T>(v45_), static_cast<T>(v46_), static_cast<T>(v47_),
> - static_cast<T>(v48_), static_cast<T>(v49_), static_cast<T>(v50_)};
> - return ValuesIn(array);
> - }
> -
> - ValueArray50(const ValueArray50& other) : v1_(other.v1_),
> v2_(other.v2_),
> - v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
> - v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
> - v11_(other.v11_), v12_(other.v12_), v13_(other.v13_),
> v14_(other.v14_),
> - v15_(other.v15_), v16_(other.v16_), v17_(other.v17_),
> v18_(other.v18_),
> - v19_(other.v19_), v20_(other.v20_), v21_(other.v21_),
> v22_(other.v22_),
> - v23_(other.v23_), v24_(other.v24_), v25_(other.v25_),
> v26_(other.v26_),
> - v27_(other.v27_), v28_(other.v28_), v29_(other.v29_),
> v30_(other.v30_),
> - v31_(other.v31_), v32_(other.v32_), v33_(other.v33_),
> v34_(other.v34_),
> - v35_(other.v35_), v36_(other.v36_), v37_(other.v37_),
> v38_(other.v38_),
> - v39_(other.v39_), v40_(other.v40_), v41_(other.v41_),
> v42_(other.v42_),
> - v43_(other.v43_), v44_(other.v44_), v45_(other.v45_),
> v46_(other.v46_),
> - v47_(other.v47_), v48_(other.v48_), v49_(other.v49_),
> v50_(other.v50_) {}
> -
> - private:
> - // No implementation - assignment is unsupported.
> - void operator=(const ValueArray50& other);
> -
> - const T1 v1_;
> - const T2 v2_;
> - const T3 v3_;
> - const T4 v4_;
> - const T5 v5_;
> - const T6 v6_;
> - const T7 v7_;
> - const T8 v8_;
> - const T9 v9_;
> - const T10 v10_;
> - const T11 v11_;
> - const T12 v12_;
> - const T13 v13_;
> - const T14 v14_;
> - const T15 v15_;
> - const T16 v16_;
> - const T17 v17_;
> - const T18 v18_;
> - const T19 v19_;
> - const T20 v20_;
> - const T21 v21_;
> - const T22 v22_;
> - const T23 v23_;
> - const T24 v24_;
> - const T25 v25_;
> - const T26 v26_;
> - const T27 v27_;
> - const T28 v28_;
> - const T29 v29_;
> - const T30 v30_;
> - const T31 v31_;
> - const T32 v32_;
> - const T33 v33_;
> - const T34 v34_;
> - const T35 v35_;
> - const T36 v36_;
> - const T37 v37_;
> - const T38 v38_;
> - const T39 v39_;
> - const T40 v40_;
> - const T41 v41_;
> - const T42 v42_;
> - const T43 v43_;
> - const T44 v44_;
> - const T45 v45_;
> - const T46 v46_;
> - const T47 v47_;
> - const T48 v48_;
> - const T49 v49_;
> - const T50 v50_;
> -};
> -
> -# if GTEST_HAS_COMBINE
> -// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
> -//
> -// Generates values from the Cartesian product of values produced
> -// by the argument generators.
> -//
> -template <typename T1, typename T2>
> -class CartesianProductGenerator2
> - : public ParamGeneratorInterface< ::testing::tuple<T1, T2> > {
> - public:
> - typedef ::testing::tuple<T1, T2> ParamType;
> -
> - CartesianProductGenerator2(const ParamGenerator<T1>& g1,
> - const ParamGenerator<T2>& g2)
> - : g1_(g1), g2_(g2) {}
> - virtual ~CartesianProductGenerator2() {}
> -
> - virtual ParamIteratorInterface<ParamType>* Begin() const {
> - return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin());
> - }
> - virtual ParamIteratorInterface<ParamType>* End() const {
> - return new Iterator(this, g1_, g1_.end(), g2_, g2_.end());
> - }
> -
> - private:
> - class Iterator : public ParamIteratorInterface<ParamType> {
> - public:
> - Iterator(const ParamGeneratorInterface<ParamType>* base,
> - const ParamGenerator<T1>& g1,
> - const typename ParamGenerator<T1>::iterator& current1,
> - const ParamGenerator<T2>& g2,
> - const typename ParamGenerator<T2>::iterator& current2)
> - : base_(base),
> - begin1_(g1.begin()), end1_(g1.end()), current1_(current1),
> - begin2_(g2.begin()), end2_(g2.end()), current2_(current2) {
> - ComputeCurrentValue();
> - }
> - virtual ~Iterator() {}
> -
> - virtual const ParamGeneratorInterface<ParamType>* BaseGenerator()
> const {
> - return base_;
> - }
> - // Advance should not be called on beyond-of-range iterators
> - // so no component iterators must be beyond end of range, either.
> - virtual void Advance() {
> - assert(!AtEnd());
> - ++current2_;
> - if (current2_ == end2_) {
> - current2_ = begin2_;
> - ++current1_;
> - }
> - ComputeCurrentValue();
> - }
> - virtual ParamIteratorInterface<ParamType>* Clone() const {
> - return new Iterator(*this);
> - }
> - virtual const ParamType* Current() const { return
> current_value_.get(); }
> - virtual bool Equals(const ParamIteratorInterface<ParamType>& other)
> const {
> - // Having the same base generator guarantees that the other
> - // iterator is of the same type and we can downcast.
> - GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
> - << "The program attempted to compare iterators "
> - << "from
> diff erent generators." << std::endl;
> - const Iterator* typed_other =
> - CheckedDowncastToActualType<const Iterator>(&other);
> - // We must report iterators equal if they both point beyond their
> - // respective ranges. That can happen in a variety of fashions,
> - // so we have to consult AtEnd().
> - return (AtEnd() && typed_other->AtEnd()) ||
> - (
> - current1_ == typed_other->current1_ &&
> - current2_ == typed_other->current2_);
> - }
> -
> - private:
> - Iterator(const Iterator& other)
> - : base_(other.base_),
> - begin1_(other.begin1_),
> - end1_(other.end1_),
> - current1_(other.current1_),
> - begin2_(other.begin2_),
> - end2_(other.end2_),
> - current2_(other.current2_) {
> - ComputeCurrentValue();
> - }
> -
> - void ComputeCurrentValue() {
> - if (!AtEnd())
> - current_value_.reset(new ParamType(*current1_, *current2_));
> - }
> - bool AtEnd() const {
> - // We must report iterator past the end of the range when either of
> the
> - // component iterators has reached the end of its range.
> - return
> - current1_ == end1_ ||
> - current2_ == end2_;
> - }
> -
> - // No implementation - assignment is unsupported.
> - void operator=(const Iterator& other);
> -
> - const ParamGeneratorInterface<ParamType>* const base_;
> - // begin[i]_ and end[i]_ define the i-th range that Iterator
> traverses.
> - // current[i]_ is the actual traversing iterator.
> - const typename ParamGenerator<T1>::iterator begin1_;
> - const typename ParamGenerator<T1>::iterator end1_;
> - typename ParamGenerator<T1>::iterator current1_;
> - const typename ParamGenerator<T2>::iterator begin2_;
> - const typename ParamGenerator<T2>::iterator end2_;
> - typename ParamGenerator<T2>::iterator current2_;
> - linked_ptr<ParamType> current_value_;
> - }; // class CartesianProductGenerator2::Iterator
> -
> - // No implementation - assignment is unsupported.
> - void operator=(const CartesianProductGenerator2& other);
> -
> - const ParamGenerator<T1> g1_;
> - const ParamGenerator<T2> g2_;
> -}; // class CartesianProductGenerator2
> -
> -
> -template <typename T1, typename T2, typename T3>
> -class CartesianProductGenerator3
> - : public ParamGeneratorInterface< ::testing::tuple<T1, T2, T3> > {
> - public:
> - typedef ::testing::tuple<T1, T2, T3> ParamType;
> -
> - CartesianProductGenerator3(const ParamGenerator<T1>& g1,
> - const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3)
> - : g1_(g1), g2_(g2), g3_(g3) {}
> - virtual ~CartesianProductGenerator3() {}
> -
> - virtual ParamIteratorInterface<ParamType>* Begin() const {
> - return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_,
> - g3_.begin());
> - }
> - virtual ParamIteratorInterface<ParamType>* End() const {
> - return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_,
> g3_.end());
> - }
> -
> - private:
> - class Iterator : public ParamIteratorInterface<ParamType> {
> - public:
> - Iterator(const ParamGeneratorInterface<ParamType>* base,
> - const ParamGenerator<T1>& g1,
> - const typename ParamGenerator<T1>::iterator& current1,
> - const ParamGenerator<T2>& g2,
> - const typename ParamGenerator<T2>::iterator& current2,
> - const ParamGenerator<T3>& g3,
> - const typename ParamGenerator<T3>::iterator& current3)
> - : base_(base),
> - begin1_(g1.begin()), end1_(g1.end()), current1_(current1),
> - begin2_(g2.begin()), end2_(g2.end()), current2_(current2),
> - begin3_(g3.begin()), end3_(g3.end()), current3_(current3) {
> - ComputeCurrentValue();
> - }
> - virtual ~Iterator() {}
> -
> - virtual const ParamGeneratorInterface<ParamType>* BaseGenerator()
> const {
> - return base_;
> - }
> - // Advance should not be called on beyond-of-range iterators
> - // so no component iterators must be beyond end of range, either.
> - virtual void Advance() {
> - assert(!AtEnd());
> - ++current3_;
> - if (current3_ == end3_) {
> - current3_ = begin3_;
> - ++current2_;
> - }
> - if (current2_ == end2_) {
> - current2_ = begin2_;
> - ++current1_;
> - }
> - ComputeCurrentValue();
> - }
> - virtual ParamIteratorInterface<ParamType>* Clone() const {
> - return new Iterator(*this);
> - }
> - virtual const ParamType* Current() const { return
> current_value_.get(); }
> - virtual bool Equals(const ParamIteratorInterface<ParamType>& other)
> const {
> - // Having the same base generator guarantees that the other
> - // iterator is of the same type and we can downcast.
> - GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
> - << "The program attempted to compare iterators "
> - << "from
> diff erent generators." << std::endl;
> - const Iterator* typed_other =
> - CheckedDowncastToActualType<const Iterator>(&other);
> - // We must report iterators equal if they both point beyond their
> - // respective ranges. That can happen in a variety of fashions,
> - // so we have to consult AtEnd().
> - return (AtEnd() && typed_other->AtEnd()) ||
> - (
> - current1_ == typed_other->current1_ &&
> - current2_ == typed_other->current2_ &&
> - current3_ == typed_other->current3_);
> - }
> -
> - private:
> - Iterator(const Iterator& other)
> - : base_(other.base_),
> - begin1_(other.begin1_),
> - end1_(other.end1_),
> - current1_(other.current1_),
> - begin2_(other.begin2_),
> - end2_(other.end2_),
> - current2_(other.current2_),
> - begin3_(other.begin3_),
> - end3_(other.end3_),
> - current3_(other.current3_) {
> - ComputeCurrentValue();
> - }
> -
> - void ComputeCurrentValue() {
> - if (!AtEnd())
> - current_value_.reset(new ParamType(*current1_, *current2_,
> *current3_));
> - }
> - bool AtEnd() const {
> - // We must report iterator past the end of the range when either of
> the
> - // component iterators has reached the end of its range.
> - return
> - current1_ == end1_ ||
> - current2_ == end2_ ||
> - current3_ == end3_;
> - }
> -
> - // No implementation - assignment is unsupported.
> - void operator=(const Iterator& other);
> -
> - const ParamGeneratorInterface<ParamType>* const base_;
> - // begin[i]_ and end[i]_ define the i-th range that Iterator
> traverses.
> - // current[i]_ is the actual traversing iterator.
> - const typename ParamGenerator<T1>::iterator begin1_;
> - const typename ParamGenerator<T1>::iterator end1_;
> - typename ParamGenerator<T1>::iterator current1_;
> - const typename ParamGenerator<T2>::iterator begin2_;
> - const typename ParamGenerator<T2>::iterator end2_;
> - typename ParamGenerator<T2>::iterator current2_;
> - const typename ParamGenerator<T3>::iterator begin3_;
> - const typename ParamGenerator<T3>::iterator end3_;
> - typename ParamGenerator<T3>::iterator current3_;
> - linked_ptr<ParamType> current_value_;
> - }; // class CartesianProductGenerator3::Iterator
> -
> - // No implementation - assignment is unsupported.
> - void operator=(const CartesianProductGenerator3& other);
> -
> - const ParamGenerator<T1> g1_;
> - const ParamGenerator<T2> g2_;
> - const ParamGenerator<T3> g3_;
> -}; // class CartesianProductGenerator3
> -
> -
> -template <typename T1, typename T2, typename T3, typename T4>
> -class CartesianProductGenerator4
> - : public ParamGeneratorInterface< ::testing::tuple<T1, T2, T3, T4> > {
> - public:
> - typedef ::testing::tuple<T1, T2, T3, T4> ParamType;
> -
> - CartesianProductGenerator4(const ParamGenerator<T1>& g1,
> - const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3,
> - const ParamGenerator<T4>& g4)
> - : g1_(g1), g2_(g2), g3_(g3), g4_(g4) {}
> - virtual ~CartesianProductGenerator4() {}
> -
> - virtual ParamIteratorInterface<ParamType>* Begin() const {
> - return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_,
> - g3_.begin(), g4_, g4_.begin());
> - }
> - virtual ParamIteratorInterface<ParamType>* End() const {
> - return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_,
> g3_.end(),
> - g4_, g4_.end());
> - }
> -
> - private:
> - class Iterator : public ParamIteratorInterface<ParamType> {
> - public:
> - Iterator(const ParamGeneratorInterface<ParamType>* base,
> - const ParamGenerator<T1>& g1,
> - const typename ParamGenerator<T1>::iterator& current1,
> - const ParamGenerator<T2>& g2,
> - const typename ParamGenerator<T2>::iterator& current2,
> - const ParamGenerator<T3>& g3,
> - const typename ParamGenerator<T3>::iterator& current3,
> - const ParamGenerator<T4>& g4,
> - const typename ParamGenerator<T4>::iterator& current4)
> - : base_(base),
> - begin1_(g1.begin()), end1_(g1.end()), current1_(current1),
> - begin2_(g2.begin()), end2_(g2.end()), current2_(current2),
> - begin3_(g3.begin()), end3_(g3.end()), current3_(current3),
> - begin4_(g4.begin()), end4_(g4.end()), current4_(current4) {
> - ComputeCurrentValue();
> - }
> - virtual ~Iterator() {}
> -
> - virtual const ParamGeneratorInterface<ParamType>* BaseGenerator()
> const {
> - return base_;
> - }
> - // Advance should not be called on beyond-of-range iterators
> - // so no component iterators must be beyond end of range, either.
> - virtual void Advance() {
> - assert(!AtEnd());
> - ++current4_;
> - if (current4_ == end4_) {
> - current4_ = begin4_;
> - ++current3_;
> - }
> - if (current3_ == end3_) {
> - current3_ = begin3_;
> - ++current2_;
> - }
> - if (current2_ == end2_) {
> - current2_ = begin2_;
> - ++current1_;
> - }
> - ComputeCurrentValue();
> - }
> - virtual ParamIteratorInterface<ParamType>* Clone() const {
> - return new Iterator(*this);
> - }
> - virtual const ParamType* Current() const { return
> current_value_.get(); }
> - virtual bool Equals(const ParamIteratorInterface<ParamType>& other)
> const {
> - // Having the same base generator guarantees that the other
> - // iterator is of the same type and we can downcast.
> - GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
> - << "The program attempted to compare iterators "
> - << "from
> diff erent generators." << std::endl;
> - const Iterator* typed_other =
> - CheckedDowncastToActualType<const Iterator>(&other);
> - // We must report iterators equal if they both point beyond their
> - // respective ranges. That can happen in a variety of fashions,
> - // so we have to consult AtEnd().
> - return (AtEnd() && typed_other->AtEnd()) ||
> - (
> - current1_ == typed_other->current1_ &&
> - current2_ == typed_other->current2_ &&
> - current3_ == typed_other->current3_ &&
> - current4_ == typed_other->current4_);
> - }
> -
> - private:
> - Iterator(const Iterator& other)
> - : base_(other.base_),
> - begin1_(other.begin1_),
> - end1_(other.end1_),
> - current1_(other.current1_),
> - begin2_(other.begin2_),
> - end2_(other.end2_),
> - current2_(other.current2_),
> - begin3_(other.begin3_),
> - end3_(other.end3_),
> - current3_(other.current3_),
> - begin4_(other.begin4_),
> - end4_(other.end4_),
> - current4_(other.current4_) {
> - ComputeCurrentValue();
> - }
> -
> - void ComputeCurrentValue() {
> - if (!AtEnd())
> - current_value_.reset(new ParamType(*current1_, *current2_,
> *current3_,
> - *current4_));
> - }
> - bool AtEnd() const {
> - // We must report iterator past the end of the range when either of
> the
> - // component iterators has reached the end of its range.
> - return
> - current1_ == end1_ ||
> - current2_ == end2_ ||
> - current3_ == end3_ ||
> - current4_ == end4_;
> - }
> -
> - // No implementation - assignment is unsupported.
> - void operator=(const Iterator& other);
> -
> - const ParamGeneratorInterface<ParamType>* const base_;
> - // begin[i]_ and end[i]_ define the i-th range that Iterator
> traverses.
> - // current[i]_ is the actual traversing iterator.
> - const typename ParamGenerator<T1>::iterator begin1_;
> - const typename ParamGenerator<T1>::iterator end1_;
> - typename ParamGenerator<T1>::iterator current1_;
> - const typename ParamGenerator<T2>::iterator begin2_;
> - const typename ParamGenerator<T2>::iterator end2_;
> - typename ParamGenerator<T2>::iterator current2_;
> - const typename ParamGenerator<T3>::iterator begin3_;
> - const typename ParamGenerator<T3>::iterator end3_;
> - typename ParamGenerator<T3>::iterator current3_;
> - const typename ParamGenerator<T4>::iterator begin4_;
> - const typename ParamGenerator<T4>::iterator end4_;
> - typename ParamGenerator<T4>::iterator current4_;
> - linked_ptr<ParamType> current_value_;
> - }; // class CartesianProductGenerator4::Iterator
> -
> - // No implementation - assignment is unsupported.
> - void operator=(const CartesianProductGenerator4& other);
> -
> - const ParamGenerator<T1> g1_;
> - const ParamGenerator<T2> g2_;
> - const ParamGenerator<T3> g3_;
> - const ParamGenerator<T4> g4_;
> -}; // class CartesianProductGenerator4
> -
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5>
> -class CartesianProductGenerator5
> - : public ParamGeneratorInterface< ::testing::tuple<T1, T2, T3, T4,
> T5> > {
> - public:
> - typedef ::testing::tuple<T1, T2, T3, T4, T5> ParamType;
> -
> - CartesianProductGenerator5(const ParamGenerator<T1>& g1,
> - const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3,
> - const ParamGenerator<T4>& g4, const ParamGenerator<T5>& g5)
> - : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5) {}
> - virtual ~CartesianProductGenerator5() {}
> -
> - virtual ParamIteratorInterface<ParamType>* Begin() const {
> - return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_,
> - g3_.begin(), g4_, g4_.begin(), g5_, g5_.begin());
> - }
> - virtual ParamIteratorInterface<ParamType>* End() const {
> - return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_,
> g3_.end(),
> - g4_, g4_.end(), g5_, g5_.end());
> - }
> -
> - private:
> - class Iterator : public ParamIteratorInterface<ParamType> {
> - public:
> - Iterator(const ParamGeneratorInterface<ParamType>* base,
> - const ParamGenerator<T1>& g1,
> - const typename ParamGenerator<T1>::iterator& current1,
> - const ParamGenerator<T2>& g2,
> - const typename ParamGenerator<T2>::iterator& current2,
> - const ParamGenerator<T3>& g3,
> - const typename ParamGenerator<T3>::iterator& current3,
> - const ParamGenerator<T4>& g4,
> - const typename ParamGenerator<T4>::iterator& current4,
> - const ParamGenerator<T5>& g5,
> - const typename ParamGenerator<T5>::iterator& current5)
> - : base_(base),
> - begin1_(g1.begin()), end1_(g1.end()), current1_(current1),
> - begin2_(g2.begin()), end2_(g2.end()), current2_(current2),
> - begin3_(g3.begin()), end3_(g3.end()), current3_(current3),
> - begin4_(g4.begin()), end4_(g4.end()), current4_(current4),
> - begin5_(g5.begin()), end5_(g5.end()), current5_(current5) {
> - ComputeCurrentValue();
> - }
> - virtual ~Iterator() {}
> -
> - virtual const ParamGeneratorInterface<ParamType>* BaseGenerator()
> const {
> - return base_;
> - }
> - // Advance should not be called on beyond-of-range iterators
> - // so no component iterators must be beyond end of range, either.
> - virtual void Advance() {
> - assert(!AtEnd());
> - ++current5_;
> - if (current5_ == end5_) {
> - current5_ = begin5_;
> - ++current4_;
> - }
> - if (current4_ == end4_) {
> - current4_ = begin4_;
> - ++current3_;
> - }
> - if (current3_ == end3_) {
> - current3_ = begin3_;
> - ++current2_;
> - }
> - if (current2_ == end2_) {
> - current2_ = begin2_;
> - ++current1_;
> - }
> - ComputeCurrentValue();
> - }
> - virtual ParamIteratorInterface<ParamType>* Clone() const {
> - return new Iterator(*this);
> - }
> - virtual const ParamType* Current() const { return
> current_value_.get(); }
> - virtual bool Equals(const ParamIteratorInterface<ParamType>& other)
> const {
> - // Having the same base generator guarantees that the other
> - // iterator is of the same type and we can downcast.
> - GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
> - << "The program attempted to compare iterators "
> - << "from
> diff erent generators." << std::endl;
> - const Iterator* typed_other =
> - CheckedDowncastToActualType<const Iterator>(&other);
> - // We must report iterators equal if they both point beyond their
> - // respective ranges. That can happen in a variety of fashions,
> - // so we have to consult AtEnd().
> - return (AtEnd() && typed_other->AtEnd()) ||
> - (
> - current1_ == typed_other->current1_ &&
> - current2_ == typed_other->current2_ &&
> - current3_ == typed_other->current3_ &&
> - current4_ == typed_other->current4_ &&
> - current5_ == typed_other->current5_);
> - }
> -
> - private:
> - Iterator(const Iterator& other)
> - : base_(other.base_),
> - begin1_(other.begin1_),
> - end1_(other.end1_),
> - current1_(other.current1_),
> - begin2_(other.begin2_),
> - end2_(other.end2_),
> - current2_(other.current2_),
> - begin3_(other.begin3_),
> - end3_(other.end3_),
> - current3_(other.current3_),
> - begin4_(other.begin4_),
> - end4_(other.end4_),
> - current4_(other.current4_),
> - begin5_(other.begin5_),
> - end5_(other.end5_),
> - current5_(other.current5_) {
> - ComputeCurrentValue();
> - }
> -
> - void ComputeCurrentValue() {
> - if (!AtEnd())
> - current_value_.reset(new ParamType(*current1_, *current2_,
> *current3_,
> - *current4_, *current5_));
> - }
> - bool AtEnd() const {
> - // We must report iterator past the end of the range when either of
> the
> - // component iterators has reached the end of its range.
> - return
> - current1_ == end1_ ||
> - current2_ == end2_ ||
> - current3_ == end3_ ||
> - current4_ == end4_ ||
> - current5_ == end5_;
> - }
> -
> - // No implementation - assignment is unsupported.
> - void operator=(const Iterator& other);
> -
> - const ParamGeneratorInterface<ParamType>* const base_;
> - // begin[i]_ and end[i]_ define the i-th range that Iterator
> traverses.
> - // current[i]_ is the actual traversing iterator.
> - const typename ParamGenerator<T1>::iterator begin1_;
> - const typename ParamGenerator<T1>::iterator end1_;
> - typename ParamGenerator<T1>::iterator current1_;
> - const typename ParamGenerator<T2>::iterator begin2_;
> - const typename ParamGenerator<T2>::iterator end2_;
> - typename ParamGenerator<T2>::iterator current2_;
> - const typename ParamGenerator<T3>::iterator begin3_;
> - const typename ParamGenerator<T3>::iterator end3_;
> - typename ParamGenerator<T3>::iterator current3_;
> - const typename ParamGenerator<T4>::iterator begin4_;
> - const typename ParamGenerator<T4>::iterator end4_;
> - typename ParamGenerator<T4>::iterator current4_;
> - const typename ParamGenerator<T5>::iterator begin5_;
> - const typename ParamGenerator<T5>::iterator end5_;
> - typename ParamGenerator<T5>::iterator current5_;
> - linked_ptr<ParamType> current_value_;
> - }; // class CartesianProductGenerator5::Iterator
> -
> - // No implementation - assignment is unsupported.
> - void operator=(const CartesianProductGenerator5& other);
> -
> - const ParamGenerator<T1> g1_;
> - const ParamGenerator<T2> g2_;
> - const ParamGenerator<T3> g3_;
> - const ParamGenerator<T4> g4_;
> - const ParamGenerator<T5> g5_;
> -}; // class CartesianProductGenerator5
> -
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6>
> -class CartesianProductGenerator6
> - : public ParamGeneratorInterface< ::testing::tuple<T1, T2, T3, T4, T5,
> - T6> > {
> - public:
> - typedef ::testing::tuple<T1, T2, T3, T4, T5, T6> ParamType;
> -
> - CartesianProductGenerator6(const ParamGenerator<T1>& g1,
> - const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3,
> - const ParamGenerator<T4>& g4, const ParamGenerator<T5>& g5,
> - const ParamGenerator<T6>& g6)
> - : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6) {}
> - virtual ~CartesianProductGenerator6() {}
> -
> - virtual ParamIteratorInterface<ParamType>* Begin() const {
> - return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_,
> - g3_.begin(), g4_, g4_.begin(), g5_, g5_.begin(), g6_,
> g6_.begin());
> - }
> - virtual ParamIteratorInterface<ParamType>* End() const {
> - return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_,
> g3_.end(),
> - g4_, g4_.end(), g5_, g5_.end(), g6_, g6_.end());
> - }
> -
> - private:
> - class Iterator : public ParamIteratorInterface<ParamType> {
> - public:
> - Iterator(const ParamGeneratorInterface<ParamType>* base,
> - const ParamGenerator<T1>& g1,
> - const typename ParamGenerator<T1>::iterator& current1,
> - const ParamGenerator<T2>& g2,
> - const typename ParamGenerator<T2>::iterator& current2,
> - const ParamGenerator<T3>& g3,
> - const typename ParamGenerator<T3>::iterator& current3,
> - const ParamGenerator<T4>& g4,
> - const typename ParamGenerator<T4>::iterator& current4,
> - const ParamGenerator<T5>& g5,
> - const typename ParamGenerator<T5>::iterator& current5,
> - const ParamGenerator<T6>& g6,
> - const typename ParamGenerator<T6>::iterator& current6)
> - : base_(base),
> - begin1_(g1.begin()), end1_(g1.end()), current1_(current1),
> - begin2_(g2.begin()), end2_(g2.end()), current2_(current2),
> - begin3_(g3.begin()), end3_(g3.end()), current3_(current3),
> - begin4_(g4.begin()), end4_(g4.end()), current4_(current4),
> - begin5_(g5.begin()), end5_(g5.end()), current5_(current5),
> - begin6_(g6.begin()), end6_(g6.end()), current6_(current6) {
> - ComputeCurrentValue();
> - }
> - virtual ~Iterator() {}
> -
> - virtual const ParamGeneratorInterface<ParamType>* BaseGenerator()
> const {
> - return base_;
> - }
> - // Advance should not be called on beyond-of-range iterators
> - // so no component iterators must be beyond end of range, either.
> - virtual void Advance() {
> - assert(!AtEnd());
> - ++current6_;
> - if (current6_ == end6_) {
> - current6_ = begin6_;
> - ++current5_;
> - }
> - if (current5_ == end5_) {
> - current5_ = begin5_;
> - ++current4_;
> - }
> - if (current4_ == end4_) {
> - current4_ = begin4_;
> - ++current3_;
> - }
> - if (current3_ == end3_) {
> - current3_ = begin3_;
> - ++current2_;
> - }
> - if (current2_ == end2_) {
> - current2_ = begin2_;
> - ++current1_;
> - }
> - ComputeCurrentValue();
> - }
> - virtual ParamIteratorInterface<ParamType>* Clone() const {
> - return new Iterator(*this);
> - }
> - virtual const ParamType* Current() const { return
> current_value_.get(); }
> - virtual bool Equals(const ParamIteratorInterface<ParamType>& other)
> const {
> - // Having the same base generator guarantees that the other
> - // iterator is of the same type and we can downcast.
> - GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
> - << "The program attempted to compare iterators "
> - << "from
> diff erent generators." << std::endl;
> - const Iterator* typed_other =
> - CheckedDowncastToActualType<const Iterator>(&other);
> - // We must report iterators equal if they both point beyond their
> - // respective ranges. That can happen in a variety of fashions,
> - // so we have to consult AtEnd().
> - return (AtEnd() && typed_other->AtEnd()) ||
> - (
> - current1_ == typed_other->current1_ &&
> - current2_ == typed_other->current2_ &&
> - current3_ == typed_other->current3_ &&
> - current4_ == typed_other->current4_ &&
> - current5_ == typed_other->current5_ &&
> - current6_ == typed_other->current6_);
> - }
> -
> - private:
> - Iterator(const Iterator& other)
> - : base_(other.base_),
> - begin1_(other.begin1_),
> - end1_(other.end1_),
> - current1_(other.current1_),
> - begin2_(other.begin2_),
> - end2_(other.end2_),
> - current2_(other.current2_),
> - begin3_(other.begin3_),
> - end3_(other.end3_),
> - current3_(other.current3_),
> - begin4_(other.begin4_),
> - end4_(other.end4_),
> - current4_(other.current4_),
> - begin5_(other.begin5_),
> - end5_(other.end5_),
> - current5_(other.current5_),
> - begin6_(other.begin6_),
> - end6_(other.end6_),
> - current6_(other.current6_) {
> - ComputeCurrentValue();
> - }
> -
> - void ComputeCurrentValue() {
> - if (!AtEnd())
> - current_value_.reset(new ParamType(*current1_, *current2_,
> *current3_,
> - *current4_, *current5_, *current6_));
> - }
> - bool AtEnd() const {
> - // We must report iterator past the end of the range when either of
> the
> - // component iterators has reached the end of its range.
> - return
> - current1_ == end1_ ||
> - current2_ == end2_ ||
> - current3_ == end3_ ||
> - current4_ == end4_ ||
> - current5_ == end5_ ||
> - current6_ == end6_;
> - }
> -
> - // No implementation - assignment is unsupported.
> - void operator=(const Iterator& other);
> -
> - const ParamGeneratorInterface<ParamType>* const base_;
> - // begin[i]_ and end[i]_ define the i-th range that Iterator
> traverses.
> - // current[i]_ is the actual traversing iterator.
> - const typename ParamGenerator<T1>::iterator begin1_;
> - const typename ParamGenerator<T1>::iterator end1_;
> - typename ParamGenerator<T1>::iterator current1_;
> - const typename ParamGenerator<T2>::iterator begin2_;
> - const typename ParamGenerator<T2>::iterator end2_;
> - typename ParamGenerator<T2>::iterator current2_;
> - const typename ParamGenerator<T3>::iterator begin3_;
> - const typename ParamGenerator<T3>::iterator end3_;
> - typename ParamGenerator<T3>::iterator current3_;
> - const typename ParamGenerator<T4>::iterator begin4_;
> - const typename ParamGenerator<T4>::iterator end4_;
> - typename ParamGenerator<T4>::iterator current4_;
> - const typename ParamGenerator<T5>::iterator begin5_;
> - const typename ParamGenerator<T5>::iterator end5_;
> - typename ParamGenerator<T5>::iterator current5_;
> - const typename ParamGenerator<T6>::iterator begin6_;
> - const typename ParamGenerator<T6>::iterator end6_;
> - typename ParamGenerator<T6>::iterator current6_;
> - linked_ptr<ParamType> current_value_;
> - }; // class CartesianProductGenerator6::Iterator
> -
> - // No implementation - assignment is unsupported.
> - void operator=(const CartesianProductGenerator6& other);
> -
> - const ParamGenerator<T1> g1_;
> - const ParamGenerator<T2> g2_;
> - const ParamGenerator<T3> g3_;
> - const ParamGenerator<T4> g4_;
> - const ParamGenerator<T5> g5_;
> - const ParamGenerator<T6> g6_;
> -}; // class CartesianProductGenerator6
> -
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7>
> -class CartesianProductGenerator7
> - : public ParamGeneratorInterface< ::testing::tuple<T1, T2, T3, T4,
> T5, T6,
> - T7> > {
> - public:
> - typedef ::testing::tuple<T1, T2, T3, T4, T5, T6, T7> ParamType;
> -
> - CartesianProductGenerator7(const ParamGenerator<T1>& g1,
> - const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3,
> - const ParamGenerator<T4>& g4, const ParamGenerator<T5>& g5,
> - const ParamGenerator<T6>& g6, const ParamGenerator<T7>& g7)
> - : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7) {}
> - virtual ~CartesianProductGenerator7() {}
> -
> - virtual ParamIteratorInterface<ParamType>* Begin() const {
> - return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_,
> - g3_.begin(), g4_, g4_.begin(), g5_, g5_.begin(), g6_,
> g6_.begin(), g7_,
> - g7_.begin());
> - }
> - virtual ParamIteratorInterface<ParamType>* End() const {
> - return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_,
> g3_.end(),
> - g4_, g4_.end(), g5_, g5_.end(), g6_, g6_.end(), g7_, g7_.end());
> - }
> -
> - private:
> - class Iterator : public ParamIteratorInterface<ParamType> {
> - public:
> - Iterator(const ParamGeneratorInterface<ParamType>* base,
> - const ParamGenerator<T1>& g1,
> - const typename ParamGenerator<T1>::iterator& current1,
> - const ParamGenerator<T2>& g2,
> - const typename ParamGenerator<T2>::iterator& current2,
> - const ParamGenerator<T3>& g3,
> - const typename ParamGenerator<T3>::iterator& current3,
> - const ParamGenerator<T4>& g4,
> - const typename ParamGenerator<T4>::iterator& current4,
> - const ParamGenerator<T5>& g5,
> - const typename ParamGenerator<T5>::iterator& current5,
> - const ParamGenerator<T6>& g6,
> - const typename ParamGenerator<T6>::iterator& current6,
> - const ParamGenerator<T7>& g7,
> - const typename ParamGenerator<T7>::iterator& current7)
> - : base_(base),
> - begin1_(g1.begin()), end1_(g1.end()), current1_(current1),
> - begin2_(g2.begin()), end2_(g2.end()), current2_(current2),
> - begin3_(g3.begin()), end3_(g3.end()), current3_(current3),
> - begin4_(g4.begin()), end4_(g4.end()), current4_(current4),
> - begin5_(g5.begin()), end5_(g5.end()), current5_(current5),
> - begin6_(g6.begin()), end6_(g6.end()), current6_(current6),
> - begin7_(g7.begin()), end7_(g7.end()), current7_(current7) {
> - ComputeCurrentValue();
> - }
> - virtual ~Iterator() {}
> -
> - virtual const ParamGeneratorInterface<ParamType>* BaseGenerator()
> const {
> - return base_;
> - }
> - // Advance should not be called on beyond-of-range iterators
> - // so no component iterators must be beyond end of range, either.
> - virtual void Advance() {
> - assert(!AtEnd());
> - ++current7_;
> - if (current7_ == end7_) {
> - current7_ = begin7_;
> - ++current6_;
> - }
> - if (current6_ == end6_) {
> - current6_ = begin6_;
> - ++current5_;
> - }
> - if (current5_ == end5_) {
> - current5_ = begin5_;
> - ++current4_;
> - }
> - if (current4_ == end4_) {
> - current4_ = begin4_;
> - ++current3_;
> - }
> - if (current3_ == end3_) {
> - current3_ = begin3_;
> - ++current2_;
> - }
> - if (current2_ == end2_) {
> - current2_ = begin2_;
> - ++current1_;
> - }
> - ComputeCurrentValue();
> - }
> - virtual ParamIteratorInterface<ParamType>* Clone() const {
> - return new Iterator(*this);
> - }
> - virtual const ParamType* Current() const { return
> current_value_.get(); }
> - virtual bool Equals(const ParamIteratorInterface<ParamType>& other)
> const {
> - // Having the same base generator guarantees that the other
> - // iterator is of the same type and we can downcast.
> - GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
> - << "The program attempted to compare iterators "
> - << "from
> diff erent generators." << std::endl;
> - const Iterator* typed_other =
> - CheckedDowncastToActualType<const Iterator>(&other);
> - // We must report iterators equal if they both point beyond their
> - // respective ranges. That can happen in a variety of fashions,
> - // so we have to consult AtEnd().
> - return (AtEnd() && typed_other->AtEnd()) ||
> - (
> - current1_ == typed_other->current1_ &&
> - current2_ == typed_other->current2_ &&
> - current3_ == typed_other->current3_ &&
> - current4_ == typed_other->current4_ &&
> - current5_ == typed_other->current5_ &&
> - current6_ == typed_other->current6_ &&
> - current7_ == typed_other->current7_);
> - }
> -
> - private:
> - Iterator(const Iterator& other)
> - : base_(other.base_),
> - begin1_(other.begin1_),
> - end1_(other.end1_),
> - current1_(other.current1_),
> - begin2_(other.begin2_),
> - end2_(other.end2_),
> - current2_(other.current2_),
> - begin3_(other.begin3_),
> - end3_(other.end3_),
> - current3_(other.current3_),
> - begin4_(other.begin4_),
> - end4_(other.end4_),
> - current4_(other.current4_),
> - begin5_(other.begin5_),
> - end5_(other.end5_),
> - current5_(other.current5_),
> - begin6_(other.begin6_),
> - end6_(other.end6_),
> - current6_(other.current6_),
> - begin7_(other.begin7_),
> - end7_(other.end7_),
> - current7_(other.current7_) {
> - ComputeCurrentValue();
> - }
> -
> - void ComputeCurrentValue() {
> - if (!AtEnd())
> - current_value_.reset(new ParamType(*current1_, *current2_,
> *current3_,
> - *current4_, *current5_, *current6_, *current7_));
> - }
> - bool AtEnd() const {
> - // We must report iterator past the end of the range when either of
> the
> - // component iterators has reached the end of its range.
> - return
> - current1_ == end1_ ||
> - current2_ == end2_ ||
> - current3_ == end3_ ||
> - current4_ == end4_ ||
> - current5_ == end5_ ||
> - current6_ == end6_ ||
> - current7_ == end7_;
> - }
> -
> - // No implementation - assignment is unsupported.
> - void operator=(const Iterator& other);
> -
> - const ParamGeneratorInterface<ParamType>* const base_;
> - // begin[i]_ and end[i]_ define the i-th range that Iterator
> traverses.
> - // current[i]_ is the actual traversing iterator.
> - const typename ParamGenerator<T1>::iterator begin1_;
> - const typename ParamGenerator<T1>::iterator end1_;
> - typename ParamGenerator<T1>::iterator current1_;
> - const typename ParamGenerator<T2>::iterator begin2_;
> - const typename ParamGenerator<T2>::iterator end2_;
> - typename ParamGenerator<T2>::iterator current2_;
> - const typename ParamGenerator<T3>::iterator begin3_;
> - const typename ParamGenerator<T3>::iterator end3_;
> - typename ParamGenerator<T3>::iterator current3_;
> - const typename ParamGenerator<T4>::iterator begin4_;
> - const typename ParamGenerator<T4>::iterator end4_;
> - typename ParamGenerator<T4>::iterator current4_;
> - const typename ParamGenerator<T5>::iterator begin5_;
> - const typename ParamGenerator<T5>::iterator end5_;
> - typename ParamGenerator<T5>::iterator current5_;
> - const typename ParamGenerator<T6>::iterator begin6_;
> - const typename ParamGenerator<T6>::iterator end6_;
> - typename ParamGenerator<T6>::iterator current6_;
> - const typename ParamGenerator<T7>::iterator begin7_;
> - const typename ParamGenerator<T7>::iterator end7_;
> - typename ParamGenerator<T7>::iterator current7_;
> - linked_ptr<ParamType> current_value_;
> - }; // class CartesianProductGenerator7::Iterator
> -
> - // No implementation - assignment is unsupported.
> - void operator=(const CartesianProductGenerator7& other);
> -
> - const ParamGenerator<T1> g1_;
> - const ParamGenerator<T2> g2_;
> - const ParamGenerator<T3> g3_;
> - const ParamGenerator<T4> g4_;
> - const ParamGenerator<T5> g5_;
> - const ParamGenerator<T6> g6_;
> - const ParamGenerator<T7> g7_;
> -}; // class CartesianProductGenerator7
> -
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8>
> -class CartesianProductGenerator8
> - : public ParamGeneratorInterface< ::testing::tuple<T1, T2, T3, T4,
> T5, T6,
> - T7, T8> > {
> - public:
> - typedef ::testing::tuple<T1, T2, T3, T4, T5, T6, T7, T8> ParamType;
> -
> - CartesianProductGenerator8(const ParamGenerator<T1>& g1,
> - const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3,
> - const ParamGenerator<T4>& g4, const ParamGenerator<T5>& g5,
> - const ParamGenerator<T6>& g6, const ParamGenerator<T7>& g7,
> - const ParamGenerator<T8>& g8)
> - : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7),
> - g8_(g8) {}
> - virtual ~CartesianProductGenerator8() {}
> -
> - virtual ParamIteratorInterface<ParamType>* Begin() const {
> - return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_,
> - g3_.begin(), g4_, g4_.begin(), g5_, g5_.begin(), g6_,
> g6_.begin(), g7_,
> - g7_.begin(), g8_, g8_.begin());
> - }
> - virtual ParamIteratorInterface<ParamType>* End() const {
> - return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_,
> g3_.end(),
> - g4_, g4_.end(), g5_, g5_.end(), g6_, g6_.end(), g7_, g7_.end(),
> g8_,
> - g8_.end());
> - }
> -
> - private:
> - class Iterator : public ParamIteratorInterface<ParamType> {
> - public:
> - Iterator(const ParamGeneratorInterface<ParamType>* base,
> - const ParamGenerator<T1>& g1,
> - const typename ParamGenerator<T1>::iterator& current1,
> - const ParamGenerator<T2>& g2,
> - const typename ParamGenerator<T2>::iterator& current2,
> - const ParamGenerator<T3>& g3,
> - const typename ParamGenerator<T3>::iterator& current3,
> - const ParamGenerator<T4>& g4,
> - const typename ParamGenerator<T4>::iterator& current4,
> - const ParamGenerator<T5>& g5,
> - const typename ParamGenerator<T5>::iterator& current5,
> - const ParamGenerator<T6>& g6,
> - const typename ParamGenerator<T6>::iterator& current6,
> - const ParamGenerator<T7>& g7,
> - const typename ParamGenerator<T7>::iterator& current7,
> - const ParamGenerator<T8>& g8,
> - const typename ParamGenerator<T8>::iterator& current8)
> - : base_(base),
> - begin1_(g1.begin()), end1_(g1.end()), current1_(current1),
> - begin2_(g2.begin()), end2_(g2.end()), current2_(current2),
> - begin3_(g3.begin()), end3_(g3.end()), current3_(current3),
> - begin4_(g4.begin()), end4_(g4.end()), current4_(current4),
> - begin5_(g5.begin()), end5_(g5.end()), current5_(current5),
> - begin6_(g6.begin()), end6_(g6.end()), current6_(current6),
> - begin7_(g7.begin()), end7_(g7.end()), current7_(current7),
> - begin8_(g8.begin()), end8_(g8.end()), current8_(current8) {
> - ComputeCurrentValue();
> - }
> - virtual ~Iterator() {}
> -
> - virtual const ParamGeneratorInterface<ParamType>* BaseGenerator()
> const {
> - return base_;
> - }
> - // Advance should not be called on beyond-of-range iterators
> - // so no component iterators must be beyond end of range, either.
> - virtual void Advance() {
> - assert(!AtEnd());
> - ++current8_;
> - if (current8_ == end8_) {
> - current8_ = begin8_;
> - ++current7_;
> - }
> - if (current7_ == end7_) {
> - current7_ = begin7_;
> - ++current6_;
> - }
> - if (current6_ == end6_) {
> - current6_ = begin6_;
> - ++current5_;
> - }
> - if (current5_ == end5_) {
> - current5_ = begin5_;
> - ++current4_;
> - }
> - if (current4_ == end4_) {
> - current4_ = begin4_;
> - ++current3_;
> - }
> - if (current3_ == end3_) {
> - current3_ = begin3_;
> - ++current2_;
> - }
> - if (current2_ == end2_) {
> - current2_ = begin2_;
> - ++current1_;
> - }
> - ComputeCurrentValue();
> - }
> - virtual ParamIteratorInterface<ParamType>* Clone() const {
> - return new Iterator(*this);
> - }
> - virtual const ParamType* Current() const { return
> current_value_.get(); }
> - virtual bool Equals(const ParamIteratorInterface<ParamType>& other)
> const {
> - // Having the same base generator guarantees that the other
> - // iterator is of the same type and we can downcast.
> - GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
> - << "The program attempted to compare iterators "
> - << "from
> diff erent generators." << std::endl;
> - const Iterator* typed_other =
> - CheckedDowncastToActualType<const Iterator>(&other);
> - // We must report iterators equal if they both point beyond their
> - // respective ranges. That can happen in a variety of fashions,
> - // so we have to consult AtEnd().
> - return (AtEnd() && typed_other->AtEnd()) ||
> - (
> - current1_ == typed_other->current1_ &&
> - current2_ == typed_other->current2_ &&
> - current3_ == typed_other->current3_ &&
> - current4_ == typed_other->current4_ &&
> - current5_ == typed_other->current5_ &&
> - current6_ == typed_other->current6_ &&
> - current7_ == typed_other->current7_ &&
> - current8_ == typed_other->current8_);
> - }
> -
> - private:
> - Iterator(const Iterator& other)
> - : base_(other.base_),
> - begin1_(other.begin1_),
> - end1_(other.end1_),
> - current1_(other.current1_),
> - begin2_(other.begin2_),
> - end2_(other.end2_),
> - current2_(other.current2_),
> - begin3_(other.begin3_),
> - end3_(other.end3_),
> - current3_(other.current3_),
> - begin4_(other.begin4_),
> - end4_(other.end4_),
> - current4_(other.current4_),
> - begin5_(other.begin5_),
> - end5_(other.end5_),
> - current5_(other.current5_),
> - begin6_(other.begin6_),
> - end6_(other.end6_),
> - current6_(other.current6_),
> - begin7_(other.begin7_),
> - end7_(other.end7_),
> - current7_(other.current7_),
> - begin8_(other.begin8_),
> - end8_(other.end8_),
> - current8_(other.current8_) {
> - ComputeCurrentValue();
> - }
> -
> - void ComputeCurrentValue() {
> - if (!AtEnd())
> - current_value_.reset(new ParamType(*current1_, *current2_,
> *current3_,
> - *current4_, *current5_, *current6_, *current7_, *current8_));
> - }
> - bool AtEnd() const {
> - // We must report iterator past the end of the range when either of
> the
> - // component iterators has reached the end of its range.
> - return
> - current1_ == end1_ ||
> - current2_ == end2_ ||
> - current3_ == end3_ ||
> - current4_ == end4_ ||
> - current5_ == end5_ ||
> - current6_ == end6_ ||
> - current7_ == end7_ ||
> - current8_ == end8_;
> - }
> -
> - // No implementation - assignment is unsupported.
> - void operator=(const Iterator& other);
> -
> - const ParamGeneratorInterface<ParamType>* const base_;
> - // begin[i]_ and end[i]_ define the i-th range that Iterator
> traverses.
> - // current[i]_ is the actual traversing iterator.
> - const typename ParamGenerator<T1>::iterator begin1_;
> - const typename ParamGenerator<T1>::iterator end1_;
> - typename ParamGenerator<T1>::iterator current1_;
> - const typename ParamGenerator<T2>::iterator begin2_;
> - const typename ParamGenerator<T2>::iterator end2_;
> - typename ParamGenerator<T2>::iterator current2_;
> - const typename ParamGenerator<T3>::iterator begin3_;
> - const typename ParamGenerator<T3>::iterator end3_;
> - typename ParamGenerator<T3>::iterator current3_;
> - const typename ParamGenerator<T4>::iterator begin4_;
> - const typename ParamGenerator<T4>::iterator end4_;
> - typename ParamGenerator<T4>::iterator current4_;
> - const typename ParamGenerator<T5>::iterator begin5_;
> - const typename ParamGenerator<T5>::iterator end5_;
> - typename ParamGenerator<T5>::iterator current5_;
> - const typename ParamGenerator<T6>::iterator begin6_;
> - const typename ParamGenerator<T6>::iterator end6_;
> - typename ParamGenerator<T6>::iterator current6_;
> - const typename ParamGenerator<T7>::iterator begin7_;
> - const typename ParamGenerator<T7>::iterator end7_;
> - typename ParamGenerator<T7>::iterator current7_;
> - const typename ParamGenerator<T8>::iterator begin8_;
> - const typename ParamGenerator<T8>::iterator end8_;
> - typename ParamGenerator<T8>::iterator current8_;
> - linked_ptr<ParamType> current_value_;
> - }; // class CartesianProductGenerator8::Iterator
> -
> - // No implementation - assignment is unsupported.
> - void operator=(const CartesianProductGenerator8& other);
> -
> - const ParamGenerator<T1> g1_;
> - const ParamGenerator<T2> g2_;
> - const ParamGenerator<T3> g3_;
> - const ParamGenerator<T4> g4_;
> - const ParamGenerator<T5> g5_;
> - const ParamGenerator<T6> g6_;
> - const ParamGenerator<T7> g7_;
> - const ParamGenerator<T8> g8_;
> -}; // class CartesianProductGenerator8
> -
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9>
> -class CartesianProductGenerator9
> - : public ParamGeneratorInterface< ::testing::tuple<T1, T2, T3, T4,
> T5, T6,
> - T7, T8, T9> > {
> - public:
> - typedef ::testing::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9> ParamType;
> -
> - CartesianProductGenerator9(const ParamGenerator<T1>& g1,
> - const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3,
> - const ParamGenerator<T4>& g4, const ParamGenerator<T5>& g5,
> - const ParamGenerator<T6>& g6, const ParamGenerator<T7>& g7,
> - const ParamGenerator<T8>& g8, const ParamGenerator<T9>& g9)
> - : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7),
> g8_(g8),
> - g9_(g9) {}
> - virtual ~CartesianProductGenerator9() {}
> -
> - virtual ParamIteratorInterface<ParamType>* Begin() const {
> - return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_,
> - g3_.begin(), g4_, g4_.begin(), g5_, g5_.begin(), g6_,
> g6_.begin(), g7_,
> - g7_.begin(), g8_, g8_.begin(), g9_, g9_.begin());
> - }
> - virtual ParamIteratorInterface<ParamType>* End() const {
> - return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_,
> g3_.end(),
> - g4_, g4_.end(), g5_, g5_.end(), g6_, g6_.end(), g7_, g7_.end(),
> g8_,
> - g8_.end(), g9_, g9_.end());
> - }
> -
> - private:
> - class Iterator : public ParamIteratorInterface<ParamType> {
> - public:
> - Iterator(const ParamGeneratorInterface<ParamType>* base,
> - const ParamGenerator<T1>& g1,
> - const typename ParamGenerator<T1>::iterator& current1,
> - const ParamGenerator<T2>& g2,
> - const typename ParamGenerator<T2>::iterator& current2,
> - const ParamGenerator<T3>& g3,
> - const typename ParamGenerator<T3>::iterator& current3,
> - const ParamGenerator<T4>& g4,
> - const typename ParamGenerator<T4>::iterator& current4,
> - const ParamGenerator<T5>& g5,
> - const typename ParamGenerator<T5>::iterator& current5,
> - const ParamGenerator<T6>& g6,
> - const typename ParamGenerator<T6>::iterator& current6,
> - const ParamGenerator<T7>& g7,
> - const typename ParamGenerator<T7>::iterator& current7,
> - const ParamGenerator<T8>& g8,
> - const typename ParamGenerator<T8>::iterator& current8,
> - const ParamGenerator<T9>& g9,
> - const typename ParamGenerator<T9>::iterator& current9)
> - : base_(base),
> - begin1_(g1.begin()), end1_(g1.end()), current1_(current1),
> - begin2_(g2.begin()), end2_(g2.end()), current2_(current2),
> - begin3_(g3.begin()), end3_(g3.end()), current3_(current3),
> - begin4_(g4.begin()), end4_(g4.end()), current4_(current4),
> - begin5_(g5.begin()), end5_(g5.end()), current5_(current5),
> - begin6_(g6.begin()), end6_(g6.end()), current6_(current6),
> - begin7_(g7.begin()), end7_(g7.end()), current7_(current7),
> - begin8_(g8.begin()), end8_(g8.end()), current8_(current8),
> - begin9_(g9.begin()), end9_(g9.end()), current9_(current9) {
> - ComputeCurrentValue();
> - }
> - virtual ~Iterator() {}
> -
> - virtual const ParamGeneratorInterface<ParamType>* BaseGenerator()
> const {
> - return base_;
> - }
> - // Advance should not be called on beyond-of-range iterators
> - // so no component iterators must be beyond end of range, either.
> - virtual void Advance() {
> - assert(!AtEnd());
> - ++current9_;
> - if (current9_ == end9_) {
> - current9_ = begin9_;
> - ++current8_;
> - }
> - if (current8_ == end8_) {
> - current8_ = begin8_;
> - ++current7_;
> - }
> - if (current7_ == end7_) {
> - current7_ = begin7_;
> - ++current6_;
> - }
> - if (current6_ == end6_) {
> - current6_ = begin6_;
> - ++current5_;
> - }
> - if (current5_ == end5_) {
> - current5_ = begin5_;
> - ++current4_;
> - }
> - if (current4_ == end4_) {
> - current4_ = begin4_;
> - ++current3_;
> - }
> - if (current3_ == end3_) {
> - current3_ = begin3_;
> - ++current2_;
> - }
> - if (current2_ == end2_) {
> - current2_ = begin2_;
> - ++current1_;
> - }
> - ComputeCurrentValue();
> - }
> - virtual ParamIteratorInterface<ParamType>* Clone() const {
> - return new Iterator(*this);
> - }
> - virtual const ParamType* Current() const { return
> current_value_.get(); }
> - virtual bool Equals(const ParamIteratorInterface<ParamType>& other)
> const {
> - // Having the same base generator guarantees that the other
> - // iterator is of the same type and we can downcast.
> - GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
> - << "The program attempted to compare iterators "
> - << "from
> diff erent generators." << std::endl;
> - const Iterator* typed_other =
> - CheckedDowncastToActualType<const Iterator>(&other);
> - // We must report iterators equal if they both point beyond their
> - // respective ranges. That can happen in a variety of fashions,
> - // so we have to consult AtEnd().
> - return (AtEnd() && typed_other->AtEnd()) ||
> - (
> - current1_ == typed_other->current1_ &&
> - current2_ == typed_other->current2_ &&
> - current3_ == typed_other->current3_ &&
> - current4_ == typed_other->current4_ &&
> - current5_ == typed_other->current5_ &&
> - current6_ == typed_other->current6_ &&
> - current7_ == typed_other->current7_ &&
> - current8_ == typed_other->current8_ &&
> - current9_ == typed_other->current9_);
> - }
> -
> - private:
> - Iterator(const Iterator& other)
> - : base_(other.base_),
> - begin1_(other.begin1_),
> - end1_(other.end1_),
> - current1_(other.current1_),
> - begin2_(other.begin2_),
> - end2_(other.end2_),
> - current2_(other.current2_),
> - begin3_(other.begin3_),
> - end3_(other.end3_),
> - current3_(other.current3_),
> - begin4_(other.begin4_),
> - end4_(other.end4_),
> - current4_(other.current4_),
> - begin5_(other.begin5_),
> - end5_(other.end5_),
> - current5_(other.current5_),
> - begin6_(other.begin6_),
> - end6_(other.end6_),
> - current6_(other.current6_),
> - begin7_(other.begin7_),
> - end7_(other.end7_),
> - current7_(other.current7_),
> - begin8_(other.begin8_),
> - end8_(other.end8_),
> - current8_(other.current8_),
> - begin9_(other.begin9_),
> - end9_(other.end9_),
> - current9_(other.current9_) {
> - ComputeCurrentValue();
> - }
> -
> - void ComputeCurrentValue() {
> - if (!AtEnd())
> - current_value_.reset(new ParamType(*current1_, *current2_,
> *current3_,
> - *current4_, *current5_, *current6_, *current7_, *current8_,
> - *current9_));
> - }
> - bool AtEnd() const {
> - // We must report iterator past the end of the range when either of
> the
> - // component iterators has reached the end of its range.
> - return
> - current1_ == end1_ ||
> - current2_ == end2_ ||
> - current3_ == end3_ ||
> - current4_ == end4_ ||
> - current5_ == end5_ ||
> - current6_ == end6_ ||
> - current7_ == end7_ ||
> - current8_ == end8_ ||
> - current9_ == end9_;
> - }
> -
> - // No implementation - assignment is unsupported.
> - void operator=(const Iterator& other);
> -
> - const ParamGeneratorInterface<ParamType>* const base_;
> - // begin[i]_ and end[i]_ define the i-th range that Iterator
> traverses.
> - // current[i]_ is the actual traversing iterator.
> - const typename ParamGenerator<T1>::iterator begin1_;
> - const typename ParamGenerator<T1>::iterator end1_;
> - typename ParamGenerator<T1>::iterator current1_;
> - const typename ParamGenerator<T2>::iterator begin2_;
> - const typename ParamGenerator<T2>::iterator end2_;
> - typename ParamGenerator<T2>::iterator current2_;
> - const typename ParamGenerator<T3>::iterator begin3_;
> - const typename ParamGenerator<T3>::iterator end3_;
> - typename ParamGenerator<T3>::iterator current3_;
> - const typename ParamGenerator<T4>::iterator begin4_;
> - const typename ParamGenerator<T4>::iterator end4_;
> - typename ParamGenerator<T4>::iterator current4_;
> - const typename ParamGenerator<T5>::iterator begin5_;
> - const typename ParamGenerator<T5>::iterator end5_;
> - typename ParamGenerator<T5>::iterator current5_;
> - const typename ParamGenerator<T6>::iterator begin6_;
> - const typename ParamGenerator<T6>::iterator end6_;
> - typename ParamGenerator<T6>::iterator current6_;
> - const typename ParamGenerator<T7>::iterator begin7_;
> - const typename ParamGenerator<T7>::iterator end7_;
> - typename ParamGenerator<T7>::iterator current7_;
> - const typename ParamGenerator<T8>::iterator begin8_;
> - const typename ParamGenerator<T8>::iterator end8_;
> - typename ParamGenerator<T8>::iterator current8_;
> - const typename ParamGenerator<T9>::iterator begin9_;
> - const typename ParamGenerator<T9>::iterator end9_;
> - typename ParamGenerator<T9>::iterator current9_;
> - linked_ptr<ParamType> current_value_;
> - }; // class CartesianProductGenerator9::Iterator
> -
> - // No implementation - assignment is unsupported.
> - void operator=(const CartesianProductGenerator9& other);
> -
> - const ParamGenerator<T1> g1_;
> - const ParamGenerator<T2> g2_;
> - const ParamGenerator<T3> g3_;
> - const ParamGenerator<T4> g4_;
> - const ParamGenerator<T5> g5_;
> - const ParamGenerator<T6> g6_;
> - const ParamGenerator<T7> g7_;
> - const ParamGenerator<T8> g8_;
> - const ParamGenerator<T9> g9_;
> -}; // class CartesianProductGenerator9
> -
> -
> -template <typename T1, typename T2, typename T3, typename T4, typename T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10>
> -class CartesianProductGenerator10
> - : public ParamGeneratorInterface< ::testing::tuple<T1, T2, T3, T4,
> T5, T6,
> - T7, T8, T9, T10> > {
> - public:
> - typedef ::testing::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>
> ParamType;
> -
> - CartesianProductGenerator10(const ParamGenerator<T1>& g1,
> - const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3,
> - const ParamGenerator<T4>& g4, const ParamGenerator<T5>& g5,
> - const ParamGenerator<T6>& g6, const ParamGenerator<T7>& g7,
> - const ParamGenerator<T8>& g8, const ParamGenerator<T9>& g9,
> - const ParamGenerator<T10>& g10)
> - : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7),
> g8_(g8),
> - g9_(g9), g10_(g10) {}
> - virtual ~CartesianProductGenerator10() {}
> -
> - virtual ParamIteratorInterface<ParamType>* Begin() const {
> - return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_,
> - g3_.begin(), g4_, g4_.begin(), g5_, g5_.begin(), g6_,
> g6_.begin(), g7_,
> - g7_.begin(), g8_, g8_.begin(), g9_, g9_.begin(), g10_,
> g10_.begin());
> - }
> - virtual ParamIteratorInterface<ParamType>* End() const {
> - return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_,
> g3_.end(),
> - g4_, g4_.end(), g5_, g5_.end(), g6_, g6_.end(), g7_, g7_.end(),
> g8_,
> - g8_.end(), g9_, g9_.end(), g10_, g10_.end());
> - }
> -
> - private:
> - class Iterator : public ParamIteratorInterface<ParamType> {
> - public:
> - Iterator(const ParamGeneratorInterface<ParamType>* base,
> - const ParamGenerator<T1>& g1,
> - const typename ParamGenerator<T1>::iterator& current1,
> - const ParamGenerator<T2>& g2,
> - const typename ParamGenerator<T2>::iterator& current2,
> - const ParamGenerator<T3>& g3,
> - const typename ParamGenerator<T3>::iterator& current3,
> - const ParamGenerator<T4>& g4,
> - const typename ParamGenerator<T4>::iterator& current4,
> - const ParamGenerator<T5>& g5,
> - const typename ParamGenerator<T5>::iterator& current5,
> - const ParamGenerator<T6>& g6,
> - const typename ParamGenerator<T6>::iterator& current6,
> - const ParamGenerator<T7>& g7,
> - const typename ParamGenerator<T7>::iterator& current7,
> - const ParamGenerator<T8>& g8,
> - const typename ParamGenerator<T8>::iterator& current8,
> - const ParamGenerator<T9>& g9,
> - const typename ParamGenerator<T9>::iterator& current9,
> - const ParamGenerator<T10>& g10,
> - const typename ParamGenerator<T10>::iterator& current10)
> - : base_(base),
> - begin1_(g1.begin()), end1_(g1.end()), current1_(current1),
> - begin2_(g2.begin()), end2_(g2.end()), current2_(current2),
> - begin3_(g3.begin()), end3_(g3.end()), current3_(current3),
> - begin4_(g4.begin()), end4_(g4.end()), current4_(current4),
> - begin5_(g5.begin()), end5_(g5.end()), current5_(current5),
> - begin6_(g6.begin()), end6_(g6.end()), current6_(current6),
> - begin7_(g7.begin()), end7_(g7.end()), current7_(current7),
> - begin8_(g8.begin()), end8_(g8.end()), current8_(current8),
> - begin9_(g9.begin()), end9_(g9.end()), current9_(current9),
> - begin10_(g10.begin()), end10_(g10.end()),
> current10_(current10) {
> - ComputeCurrentValue();
> - }
> - virtual ~Iterator() {}
> -
> - virtual const ParamGeneratorInterface<ParamType>* BaseGenerator()
> const {
> - return base_;
> - }
> - // Advance should not be called on beyond-of-range iterators
> - // so no component iterators must be beyond end of range, either.
> - virtual void Advance() {
> - assert(!AtEnd());
> - ++current10_;
> - if (current10_ == end10_) {
> - current10_ = begin10_;
> - ++current9_;
> - }
> - if (current9_ == end9_) {
> - current9_ = begin9_;
> - ++current8_;
> - }
> - if (current8_ == end8_) {
> - current8_ = begin8_;
> - ++current7_;
> - }
> - if (current7_ == end7_) {
> - current7_ = begin7_;
> - ++current6_;
> - }
> - if (current6_ == end6_) {
> - current6_ = begin6_;
> - ++current5_;
> - }
> - if (current5_ == end5_) {
> - current5_ = begin5_;
> - ++current4_;
> - }
> - if (current4_ == end4_) {
> - current4_ = begin4_;
> - ++current3_;
> - }
> - if (current3_ == end3_) {
> - current3_ = begin3_;
> - ++current2_;
> - }
> - if (current2_ == end2_) {
> - current2_ = begin2_;
> - ++current1_;
> - }
> - ComputeCurrentValue();
> - }
> - virtual ParamIteratorInterface<ParamType>* Clone() const {
> - return new Iterator(*this);
> - }
> - virtual const ParamType* Current() const { return
> current_value_.get(); }
> - virtual bool Equals(const ParamIteratorInterface<ParamType>& other)
> const {
> - // Having the same base generator guarantees that the other
> - // iterator is of the same type and we can downcast.
> - GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
> - << "The program attempted to compare iterators "
> - << "from
> diff erent generators." << std::endl;
> - const Iterator* typed_other =
> - CheckedDowncastToActualType<const Iterator>(&other);
> - // We must report iterators equal if they both point beyond their
> - // respective ranges. That can happen in a variety of fashions,
> - // so we have to consult AtEnd().
> - return (AtEnd() && typed_other->AtEnd()) ||
> - (
> - current1_ == typed_other->current1_ &&
> - current2_ == typed_other->current2_ &&
> - current3_ == typed_other->current3_ &&
> - current4_ == typed_other->current4_ &&
> - current5_ == typed_other->current5_ &&
> - current6_ == typed_other->current6_ &&
> - current7_ == typed_other->current7_ &&
> - current8_ == typed_other->current8_ &&
> - current9_ == typed_other->current9_ &&
> - current10_ == typed_other->current10_);
> - }
> -
> - private:
> - Iterator(const Iterator& other)
> - : base_(other.base_),
> - begin1_(other.begin1_),
> - end1_(other.end1_),
> - current1_(other.current1_),
> - begin2_(other.begin2_),
> - end2_(other.end2_),
> - current2_(other.current2_),
> - begin3_(other.begin3_),
> - end3_(other.end3_),
> - current3_(other.current3_),
> - begin4_(other.begin4_),
> - end4_(other.end4_),
> - current4_(other.current4_),
> - begin5_(other.begin5_),
> - end5_(other.end5_),
> - current5_(other.current5_),
> - begin6_(other.begin6_),
> - end6_(other.end6_),
> - current6_(other.current6_),
> - begin7_(other.begin7_),
> - end7_(other.end7_),
> - current7_(other.current7_),
> - begin8_(other.begin8_),
> - end8_(other.end8_),
> - current8_(other.current8_),
> - begin9_(other.begin9_),
> - end9_(other.end9_),
> - current9_(other.current9_),
> - begin10_(other.begin10_),
> - end10_(other.end10_),
> - current10_(other.current10_) {
> - ComputeCurrentValue();
> - }
> -
> - void ComputeCurrentValue() {
> - if (!AtEnd())
> - current_value_.reset(new ParamType(*current1_, *current2_,
> *current3_,
> - *current4_, *current5_, *current6_, *current7_, *current8_,
> - *current9_, *current10_));
> - }
> - bool AtEnd() const {
> - // We must report iterator past the end of the range when either of
> the
> - // component iterators has reached the end of its range.
> - return
> - current1_ == end1_ ||
> - current2_ == end2_ ||
> - current3_ == end3_ ||
> - current4_ == end4_ ||
> - current5_ == end5_ ||
> - current6_ == end6_ ||
> - current7_ == end7_ ||
> - current8_ == end8_ ||
> - current9_ == end9_ ||
> - current10_ == end10_;
> - }
> -
> - // No implementation - assignment is unsupported.
> - void operator=(const Iterator& other);
> -
> - const ParamGeneratorInterface<ParamType>* const base_;
> - // begin[i]_ and end[i]_ define the i-th range that Iterator
> traverses.
> - // current[i]_ is the actual traversing iterator.
> - const typename ParamGenerator<T1>::iterator begin1_;
> - const typename ParamGenerator<T1>::iterator end1_;
> - typename ParamGenerator<T1>::iterator current1_;
> - const typename ParamGenerator<T2>::iterator begin2_;
> - const typename ParamGenerator<T2>::iterator end2_;
> - typename ParamGenerator<T2>::iterator current2_;
> - const typename ParamGenerator<T3>::iterator begin3_;
> - const typename ParamGenerator<T3>::iterator end3_;
> - typename ParamGenerator<T3>::iterator current3_;
> - const typename ParamGenerator<T4>::iterator begin4_;
> - const typename ParamGenerator<T4>::iterator end4_;
> - typename ParamGenerator<T4>::iterator current4_;
> - const typename ParamGenerator<T5>::iterator begin5_;
> - const typename ParamGenerator<T5>::iterator end5_;
> - typename ParamGenerator<T5>::iterator current5_;
> - const typename ParamGenerator<T6>::iterator begin6_;
> - const typename ParamGenerator<T6>::iterator end6_;
> - typename ParamGenerator<T6>::iterator current6_;
> - const typename ParamGenerator<T7>::iterator begin7_;
> - const typename ParamGenerator<T7>::iterator end7_;
> - typename ParamGenerator<T7>::iterator current7_;
> - const typename ParamGenerator<T8>::iterator begin8_;
> - const typename ParamGenerator<T8>::iterator end8_;
> - typename ParamGenerator<T8>::iterator current8_;
> - const typename ParamGenerator<T9>::iterator begin9_;
> - const typename ParamGenerator<T9>::iterator end9_;
> - typename ParamGenerator<T9>::iterator current9_;
> - const typename ParamGenerator<T10>::iterator begin10_;
> - const typename ParamGenerator<T10>::iterator end10_;
> - typename ParamGenerator<T10>::iterator current10_;
> - linked_ptr<ParamType> current_value_;
> - }; // class CartesianProductGenerator10::Iterator
> -
> - // No implementation - assignment is unsupported.
> - void operator=(const CartesianProductGenerator10& other);
> -
> - const ParamGenerator<T1> g1_;
> - const ParamGenerator<T2> g2_;
> - const ParamGenerator<T3> g3_;
> - const ParamGenerator<T4> g4_;
> - const ParamGenerator<T5> g5_;
> - const ParamGenerator<T6> g6_;
> - const ParamGenerator<T7> g7_;
> - const ParamGenerator<T8> g8_;
> - const ParamGenerator<T9> g9_;
> - const ParamGenerator<T10> g10_;
> -}; // class CartesianProductGenerator10
> -
> -
> -// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
> -//
> -// Helper classes providing Combine() with polymorphic features. They
> allow
> -// casting CartesianProductGeneratorN<T> to ParamGenerator<U> if T is
> -// convertible to U.
> -//
> -template <class Generator1, class Generator2>
> -class CartesianProductHolder2 {
> - public:
> -CartesianProductHolder2(const Generator1& g1, const Generator2& g2)
> - : g1_(g1), g2_(g2) {}
> - template <typename T1, typename T2>
> - operator ParamGenerator< ::testing::tuple<T1, T2> >() const {
> - return ParamGenerator< ::testing::tuple<T1, T2> >(
> - new CartesianProductGenerator2<T1, T2>(
> - static_cast<ParamGenerator<T1> >(g1_),
> - static_cast<ParamGenerator<T2> >(g2_)));
> - }
> -
> - private:
> - // No implementation - assignment is unsupported.
> - void operator=(const CartesianProductHolder2& other);
> -
> - const Generator1 g1_;
> - const Generator2 g2_;
> -}; // class CartesianProductHolder2
> -
> -template <class Generator1, class Generator2, class Generator3>
> -class CartesianProductHolder3 {
> - public:
> -CartesianProductHolder3(const Generator1& g1, const Generator2& g2,
> - const Generator3& g3)
> - : g1_(g1), g2_(g2), g3_(g3) {}
> - template <typename T1, typename T2, typename T3>
> - operator ParamGenerator< ::testing::tuple<T1, T2, T3> >() const {
> - return ParamGenerator< ::testing::tuple<T1, T2, T3> >(
> - new CartesianProductGenerator3<T1, T2, T3>(
> - static_cast<ParamGenerator<T1> >(g1_),
> - static_cast<ParamGenerator<T2> >(g2_),
> - static_cast<ParamGenerator<T3> >(g3_)));
> - }
> -
> - private:
> - // No implementation - assignment is unsupported.
> - void operator=(const CartesianProductHolder3& other);
> -
> - const Generator1 g1_;
> - const Generator2 g2_;
> - const Generator3 g3_;
> -}; // class CartesianProductHolder3
> -
> -template <class Generator1, class Generator2, class Generator3,
> - class Generator4>
> -class CartesianProductHolder4 {
> - public:
> -CartesianProductHolder4(const Generator1& g1, const Generator2& g2,
> - const Generator3& g3, const Generator4& g4)
> - : g1_(g1), g2_(g2), g3_(g3), g4_(g4) {}
> - template <typename T1, typename T2, typename T3, typename T4>
> - operator ParamGenerator< ::testing::tuple<T1, T2, T3, T4> >() const {
> - return ParamGenerator< ::testing::tuple<T1, T2, T3, T4> >(
> - new CartesianProductGenerator4<T1, T2, T3, T4>(
> - static_cast<ParamGenerator<T1> >(g1_),
> - static_cast<ParamGenerator<T2> >(g2_),
> - static_cast<ParamGenerator<T3> >(g3_),
> - static_cast<ParamGenerator<T4> >(g4_)));
> - }
> -
> - private:
> - // No implementation - assignment is unsupported.
> - void operator=(const CartesianProductHolder4& other);
> -
> - const Generator1 g1_;
> - const Generator2 g2_;
> - const Generator3 g3_;
> - const Generator4 g4_;
> -}; // class CartesianProductHolder4
> -
> -template <class Generator1, class Generator2, class Generator3,
> - class Generator4, class Generator5>
> -class CartesianProductHolder5 {
> - public:
> -CartesianProductHolder5(const Generator1& g1, const Generator2& g2,
> - const Generator3& g3, const Generator4& g4, const Generator5& g5)
> - : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5) {}
> - template <typename T1, typename T2, typename T3, typename T4, typename
> T5>
> - operator ParamGenerator< ::testing::tuple<T1, T2, T3, T4, T5> >() const
> {
> - return ParamGenerator< ::testing::tuple<T1, T2, T3, T4, T5> >(
> - new CartesianProductGenerator5<T1, T2, T3, T4, T5>(
> - static_cast<ParamGenerator<T1> >(g1_),
> - static_cast<ParamGenerator<T2> >(g2_),
> - static_cast<ParamGenerator<T3> >(g3_),
> - static_cast<ParamGenerator<T4> >(g4_),
> - static_cast<ParamGenerator<T5> >(g5_)));
> - }
> -
> - private:
> - // No implementation - assignment is unsupported.
> - void operator=(const CartesianProductHolder5& other);
> -
> - const Generator1 g1_;
> - const Generator2 g2_;
> - const Generator3 g3_;
> - const Generator4 g4_;
> - const Generator5 g5_;
> -}; // class CartesianProductHolder5
> -
> -template <class Generator1, class Generator2, class Generator3,
> - class Generator4, class Generator5, class Generator6>
> -class CartesianProductHolder6 {
> - public:
> -CartesianProductHolder6(const Generator1& g1, const Generator2& g2,
> - const Generator3& g3, const Generator4& g4, const Generator5& g5,
> - const Generator6& g6)
> - : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6) {}
> - template <typename T1, typename T2, typename T3, typename T4, typename
> T5,
> - typename T6>
> - operator ParamGenerator< ::testing::tuple<T1, T2, T3, T4, T5, T6> >()
> const {
> - return ParamGenerator< ::testing::tuple<T1, T2, T3, T4, T5, T6> >(
> - new CartesianProductGenerator6<T1, T2, T3, T4, T5, T6>(
> - static_cast<ParamGenerator<T1> >(g1_),
> - static_cast<ParamGenerator<T2> >(g2_),
> - static_cast<ParamGenerator<T3> >(g3_),
> - static_cast<ParamGenerator<T4> >(g4_),
> - static_cast<ParamGenerator<T5> >(g5_),
> - static_cast<ParamGenerator<T6> >(g6_)));
> - }
> -
> - private:
> - // No implementation - assignment is unsupported.
> - void operator=(const CartesianProductHolder6& other);
> -
> - const Generator1 g1_;
> - const Generator2 g2_;
> - const Generator3 g3_;
> - const Generator4 g4_;
> - const Generator5 g5_;
> - const Generator6 g6_;
> -}; // class CartesianProductHolder6
> -
> -template <class Generator1, class Generator2, class Generator3,
> - class Generator4, class Generator5, class Generator6, class
> Generator7>
> -class CartesianProductHolder7 {
> - public:
> -CartesianProductHolder7(const Generator1& g1, const Generator2& g2,
> - const Generator3& g3, const Generator4& g4, const Generator5& g5,
> - const Generator6& g6, const Generator7& g7)
> - : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7) {}
> - template <typename T1, typename T2, typename T3, typename T4, typename
> T5,
> - typename T6, typename T7>
> - operator ParamGenerator< ::testing::tuple<T1, T2, T3, T4, T5, T6,
> - T7> >() const {
> - return ParamGenerator< ::testing::tuple<T1, T2, T3, T4, T5, T6, T7> >(
> - new CartesianProductGenerator7<T1, T2, T3, T4, T5, T6, T7>(
> - static_cast<ParamGenerator<T1> >(g1_),
> - static_cast<ParamGenerator<T2> >(g2_),
> - static_cast<ParamGenerator<T3> >(g3_),
> - static_cast<ParamGenerator<T4> >(g4_),
> - static_cast<ParamGenerator<T5> >(g5_),
> - static_cast<ParamGenerator<T6> >(g6_),
> - static_cast<ParamGenerator<T7> >(g7_)));
> - }
> -
> - private:
> - // No implementation - assignment is unsupported.
> - void operator=(const CartesianProductHolder7& other);
> -
> - const Generator1 g1_;
> - const Generator2 g2_;
> - const Generator3 g3_;
> - const Generator4 g4_;
> - const Generator5 g5_;
> - const Generator6 g6_;
> - const Generator7 g7_;
> -}; // class CartesianProductHolder7
> -
> -template <class Generator1, class Generator2, class Generator3,
> - class Generator4, class Generator5, class Generator6, class
> Generator7,
> - class Generator8>
> -class CartesianProductHolder8 {
> - public:
> -CartesianProductHolder8(const Generator1& g1, const Generator2& g2,
> - const Generator3& g3, const Generator4& g4, const Generator5& g5,
> - const Generator6& g6, const Generator7& g7, const Generator8& g8)
> - : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7),
> - g8_(g8) {}
> - template <typename T1, typename T2, typename T3, typename T4, typename
> T5,
> - typename T6, typename T7, typename T8>
> - operator ParamGenerator< ::testing::tuple<T1, T2, T3, T4, T5, T6, T7,
> - T8> >() const {
> - return ParamGenerator< ::testing::tuple<T1, T2, T3, T4, T5, T6, T7,
> T8> >(
> - new CartesianProductGenerator8<T1, T2, T3, T4, T5, T6, T7, T8>(
> - static_cast<ParamGenerator<T1> >(g1_),
> - static_cast<ParamGenerator<T2> >(g2_),
> - static_cast<ParamGenerator<T3> >(g3_),
> - static_cast<ParamGenerator<T4> >(g4_),
> - static_cast<ParamGenerator<T5> >(g5_),
> - static_cast<ParamGenerator<T6> >(g6_),
> - static_cast<ParamGenerator<T7> >(g7_),
> - static_cast<ParamGenerator<T8> >(g8_)));
> - }
> -
> - private:
> - // No implementation - assignment is unsupported.
> - void operator=(const CartesianProductHolder8& other);
> -
> - const Generator1 g1_;
> - const Generator2 g2_;
> - const Generator3 g3_;
> - const Generator4 g4_;
> - const Generator5 g5_;
> - const Generator6 g6_;
> - const Generator7 g7_;
> - const Generator8 g8_;
> -}; // class CartesianProductHolder8
> -
> -template <class Generator1, class Generator2, class Generator3,
> - class Generator4, class Generator5, class Generator6, class
> Generator7,
> - class Generator8, class Generator9>
> -class CartesianProductHolder9 {
> - public:
> -CartesianProductHolder9(const Generator1& g1, const Generator2& g2,
> - const Generator3& g3, const Generator4& g4, const Generator5& g5,
> - const Generator6& g6, const Generator7& g7, const Generator8& g8,
> - const Generator9& g9)
> - : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7),
> g8_(g8),
> - g9_(g9) {}
> - template <typename T1, typename T2, typename T3, typename T4, typename
> T5,
> - typename T6, typename T7, typename T8, typename T9>
> - operator ParamGenerator< ::testing::tuple<T1, T2, T3, T4, T5, T6, T7,
> T8,
> - T9> >() const {
> - return ParamGenerator< ::testing::tuple<T1, T2, T3, T4, T5, T6, T7,
> T8,
> - T9> >(
> - new CartesianProductGenerator9<T1, T2, T3, T4, T5, T6, T7, T8,
> T9>(
> - static_cast<ParamGenerator<T1> >(g1_),
> - static_cast<ParamGenerator<T2> >(g2_),
> - static_cast<ParamGenerator<T3> >(g3_),
> - static_cast<ParamGenerator<T4> >(g4_),
> - static_cast<ParamGenerator<T5> >(g5_),
> - static_cast<ParamGenerator<T6> >(g6_),
> - static_cast<ParamGenerator<T7> >(g7_),
> - static_cast<ParamGenerator<T8> >(g8_),
> - static_cast<ParamGenerator<T9> >(g9_)));
> - }
> -
> - private:
> - // No implementation - assignment is unsupported.
> - void operator=(const CartesianProductHolder9& other);
> -
> - const Generator1 g1_;
> - const Generator2 g2_;
> - const Generator3 g3_;
> - const Generator4 g4_;
> - const Generator5 g5_;
> - const Generator6 g6_;
> - const Generator7 g7_;
> - const Generator8 g8_;
> - const Generator9 g9_;
> -}; // class CartesianProductHolder9
> -
> -template <class Generator1, class Generator2, class Generator3,
> - class Generator4, class Generator5, class Generator6, class
> Generator7,
> - class Generator8, class Generator9, class Generator10>
> -class CartesianProductHolder10 {
> - public:
> -CartesianProductHolder10(const Generator1& g1, const Generator2& g2,
> - const Generator3& g3, const Generator4& g4, const Generator5& g5,
> - const Generator6& g6, const Generator7& g7, const Generator8& g8,
> - const Generator9& g9, const Generator10& g10)
> - : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7),
> g8_(g8),
> - g9_(g9), g10_(g10) {}
> - template <typename T1, typename T2, typename T3, typename T4, typename
> T5,
> - typename T6, typename T7, typename T8, typename T9, typename T10>
> - operator ParamGenerator< ::testing::tuple<T1, T2, T3, T4, T5, T6, T7,
> T8, T9,
> - T10> >() const {
> - return ParamGenerator< ::testing::tuple<T1, T2, T3, T4, T5, T6, T7,
> T8, T9,
> - T10> >(
> - new CartesianProductGenerator10<T1, T2, T3, T4, T5, T6, T7, T8,
> T9,
> - T10>(
> - static_cast<ParamGenerator<T1> >(g1_),
> - static_cast<ParamGenerator<T2> >(g2_),
> - static_cast<ParamGenerator<T3> >(g3_),
> - static_cast<ParamGenerator<T4> >(g4_),
> - static_cast<ParamGenerator<T5> >(g5_),
> - static_cast<ParamGenerator<T6> >(g6_),
> - static_cast<ParamGenerator<T7> >(g7_),
> - static_cast<ParamGenerator<T8> >(g8_),
> - static_cast<ParamGenerator<T9> >(g9_),
> - static_cast<ParamGenerator<T10> >(g10_)));
> - }
> -
> - private:
> - // No implementation - assignment is unsupported.
> - void operator=(const CartesianProductHolder10& other);
> -
> - const Generator1 g1_;
> - const Generator2 g2_;
> - const Generator3 g3_;
> - const Generator4 g4_;
> - const Generator5 g5_;
> - const Generator6 g6_;
> - const Generator7 g7_;
> - const Generator8 g8_;
> - const Generator9 g9_;
> - const Generator10 g10_;
> -}; // class CartesianProductHolder10
> -
> -# endif // GTEST_HAS_COMBINE
> -
> -} // namespace internal
> -} // namespace testing
> -
> -#ifdef __clang__
> -#if __has_warning("-Wdeprecated-copy")
> -#pragma clang diagnostic pop
> -#endif
> -#endif
> -
> -#endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_GENERATED_H_
>
> diff --git
> a/llvm/utils/unittest/googletest/include/gtest/internal/gtest-param-util.h
> b/llvm/utils/unittest/googletest/include/gtest/internal/gtest-param-util.h
> index d64f620c4c674..97533993c0c3c 100644
> ---
> a/llvm/utils/unittest/googletest/include/gtest/internal/gtest-param-util.h
> +++
> b/llvm/utils/unittest/googletest/include/gtest/internal/gtest-param-util.h
> @@ -37,18 +37,19 @@
>
> #include <ctype.h>
>
> +#include <cassert>
> #include <iterator>
> +#include <memory>
> #include <set>
> +#include <tuple>
> #include <utility>
> #include <vector>
>
> #include "gtest/internal/gtest-internal.h"
> -#include "gtest/internal/gtest-linked_ptr.h"
> #include "gtest/internal/gtest-port.h"
> #include "gtest/gtest-printers.h"
>
> namespace testing {
> -
> // Input to a parameterized test name generator, describing a test
> parameter.
> // Consists of the parameter value and the integer parameter index.
> template <class ParamType>
> @@ -72,13 +73,14 @@ struct PrintToStringParamName {
> namespace internal {
>
> // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
> -//
> +// Utility Functions
> +
> // Outputs a message explaining invalid registration of
> diff erent
> -// fixture class for the same test case. This may happen when
> +// fixture class for the same test suite. This may happen when
> // TEST_P macro is used to define two tests with the same name
> // but in
> diff erent namespaces.
> -GTEST_API_ void ReportInvalidTestCaseType(const char* test_case_name,
> - CodeLocation code_location);
> +GTEST_API_ void ReportInvalidTestSuiteType(const char* test_suite_name,
> + CodeLocation code_location);
>
> template <typename> class ParamGeneratorInterface;
> template <typename> class ParamGenerator;
> @@ -153,7 +155,7 @@ class ParamIterator {
> private:
> friend class ParamGenerator<T>;
> explicit ParamIterator(ParamIteratorInterface<T>* impl) : impl_(impl) {}
> - scoped_ptr<ParamIteratorInterface<T> > impl_;
> + std::unique_ptr<ParamIteratorInterface<T> > impl_;
> };
>
> // ParamGeneratorInterface<T> is the binary interface to access generators
> @@ -192,7 +194,7 @@ class ParamGenerator {
> iterator end() const { return iterator(impl_->End()); }
>
> private:
> - linked_ptr<const ParamGeneratorInterface<T> > impl_;
> + std::shared_ptr<const ParamGeneratorInterface<T> > impl_;
> };
>
> // Generates values from a range of two comparable values. Can be used to
> @@ -205,12 +207,12 @@ class RangeGenerator : public
> ParamGeneratorInterface<T> {
> RangeGenerator(T begin, T end, IncrementT step)
> : begin_(begin), end_(end),
> step_(step), end_index_(CalculateEndIndex(begin, end, step)) {}
> - virtual ~RangeGenerator() {}
> + ~RangeGenerator() override {}
>
> - virtual ParamIteratorInterface<T>* Begin() const {
> + ParamIteratorInterface<T>* Begin() const override {
> return new Iterator(this, begin_, 0, step_);
> }
> - virtual ParamIteratorInterface<T>* End() const {
> + ParamIteratorInterface<T>* End() const override {
> return new Iterator(this, end_, end_index_, step_);
> }
>
> @@ -220,20 +222,20 @@ class RangeGenerator : public
> ParamGeneratorInterface<T> {
> Iterator(const ParamGeneratorInterface<T>* base, T value, int index,
> IncrementT step)
> : base_(base), value_(value), index_(index), step_(step) {}
> - virtual ~Iterator() {}
> + ~Iterator() override {}
>
> - virtual const ParamGeneratorInterface<T>* BaseGenerator() const {
> + const ParamGeneratorInterface<T>* BaseGenerator() const override {
> return base_;
> }
> - virtual void Advance() {
> + void Advance() override {
> value_ = static_cast<T>(value_ + step_);
> index_++;
> }
> - virtual ParamIteratorInterface<T>* Clone() const {
> + ParamIteratorInterface<T>* Clone() const override {
> return new Iterator(*this);
> }
> - virtual const T* Current() const { return &value_; }
> - virtual bool Equals(const ParamIteratorInterface<T>& other) const {
> + const T* Current() const override { return &value_; }
> + bool Equals(const ParamIteratorInterface<T>& other) const override {
> // Having the same base generator guarantees that the other
> // iterator is of the same type and we can downcast.
> GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
> @@ -290,12 +292,12 @@ class ValuesInIteratorRangeGenerator : public
> ParamGeneratorInterface<T> {
> template <typename ForwardIterator>
> ValuesInIteratorRangeGenerator(ForwardIterator begin, ForwardIterator
> end)
> : container_(begin, end) {}
> - virtual ~ValuesInIteratorRangeGenerator() {}
> + ~ValuesInIteratorRangeGenerator() override {}
>
> - virtual ParamIteratorInterface<T>* Begin() const {
> + ParamIteratorInterface<T>* Begin() const override {
> return new Iterator(this, container_.begin());
> }
> - virtual ParamIteratorInterface<T>* End() const {
> + ParamIteratorInterface<T>* End() const override {
> return new Iterator(this, container_.end());
> }
>
> @@ -307,16 +309,16 @@ class ValuesInIteratorRangeGenerator : public
> ParamGeneratorInterface<T> {
> Iterator(const ParamGeneratorInterface<T>* base,
> typename ContainerType::const_iterator iterator)
> : base_(base), iterator_(iterator) {}
> - virtual ~Iterator() {}
> + ~Iterator() override {}
>
> - virtual const ParamGeneratorInterface<T>* BaseGenerator() const {
> + const ParamGeneratorInterface<T>* BaseGenerator() const override {
> return base_;
> }
> - virtual void Advance() {
> + void Advance() override {
> ++iterator_;
> value_.reset();
> }
> - virtual ParamIteratorInterface<T>* Clone() const {
> + ParamIteratorInterface<T>* Clone() const override {
> return new Iterator(*this);
> }
> // We need to use cached value referenced by iterator_ because
> *iterator_
> @@ -326,12 +328,11 @@ class ValuesInIteratorRangeGenerator : public
> ParamGeneratorInterface<T> {
> // can advance iterator_ beyond the end of the range, and we cannot
> // detect that fact. The client code, on the other hand, is
> // responsible for not calling Current() on an out-of-range iterator.
> - virtual const T* Current() const {
> - if (value_.get() == NULL)
> - value_.reset(new T(*iterator_));
> + const T* Current() const override {
> + if (value_.get() == nullptr) value_.reset(new T(*iterator_));
> return value_.get();
> }
> - virtual bool Equals(const ParamIteratorInterface<T>& other) const {
> + bool Equals(const ParamIteratorInterface<T>& other) const override {
> // Having the same base generator guarantees that the other
> // iterator is of the same type and we can downcast.
> GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
> @@ -354,9 +355,9 @@ class ValuesInIteratorRangeGenerator : public
> ParamGeneratorInterface<T> {
> // A cached value of *iterator_. We keep it here to allow access by
> // pointer in the wrapping iterator's operator->().
> // value_ needs to be mutable to be accessed in Current().
> - // Use of scoped_ptr helps manage cached value's lifetime,
> + // Use of std::unique_ptr helps manage cached value's lifetime,
> // which is bound by the lifespan of the iterator itself.
> - mutable scoped_ptr<const T> value_;
> + mutable std::unique_ptr<const T> value_;
> }; // class ValuesInIteratorRangeGenerator::Iterator
>
> // No implementation - assignment is unsupported.
> @@ -376,25 +377,12 @@ std::string DefaultParamName(const
> TestParamInfo<ParamType>& info) {
> return name_stream.GetString();
> }
>
> -// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
> -//
> -// Parameterized test name overload helpers, which help the
> -// INSTANTIATE_TEST_CASE_P macro choose between the default parameterized
> -// test name generator and user param name generator.
> -template <class ParamType, class ParamNameGenFunctor>
> -ParamNameGenFunctor GetParamNameGen(ParamNameGenFunctor func) {
> - return func;
> -}
> -
> -template <class ParamType>
> -struct ParamNameGenFunc {
> - typedef std::string Type(const TestParamInfo<ParamType>&);
> -};
> -
> -template <class ParamType>
> -typename ParamNameGenFunc<ParamType>::Type *GetParamNameGen() {
> - return DefaultParamName;
> +template <typename T = int>
> +void TestNotEmpty() {
> + static_assert(sizeof(T) == 0, "Empty arguments are not allowed.");
> }
> +template <typename T = int>
> +void TestNotEmpty(const T&) {}
>
> // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
> //
> @@ -406,7 +394,7 @@ class ParameterizedTestFactory : public
> TestFactoryBase {
> typedef typename TestClass::ParamType ParamType;
> explicit ParameterizedTestFactory(ParamType parameter) :
> parameter_(parameter) {}
> - virtual Test* CreateTest() {
> + Test* CreateTest() override {
> TestClass::SetParam(¶meter_);
> return new TestClass();
> }
> @@ -434,19 +422,19 @@ class TestMetaFactoryBase {
> // TestMetaFactory creates test factories for passing into
> // MakeAndRegisterTestInfo function. Since MakeAndRegisterTestInfo
> receives
> // ownership of test factory pointer, same factory object cannot be passed
> -// into that method twice. But ParameterizedTestCaseInfo is going to call
> +// into that method twice. But ParameterizedTestSuiteInfo is going to call
> // it for each Test/Parameter value combination. Thus it needs meta
> factory
> // creator class.
> -template <class TestCase>
> +template <class TestSuite>
> class TestMetaFactory
> - : public TestMetaFactoryBase<typename TestCase::ParamType> {
> + : public TestMetaFactoryBase<typename TestSuite::ParamType> {
> public:
> - typedef typename TestCase::ParamType ParamType;
> + using ParamType = typename TestSuite::ParamType;
>
> TestMetaFactory() {}
>
> - virtual TestFactoryBase* CreateTestFactory(ParamType parameter) {
> - return new ParameterizedTestFactory<TestCase>(parameter);
> + TestFactoryBase* CreateTestFactory(ParamType parameter) override {
> + return new ParameterizedTestFactory<TestSuite>(parameter);
> }
>
> private:
> @@ -455,93 +443,93 @@ class TestMetaFactory
>
> // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
> //
> -// ParameterizedTestCaseInfoBase is a generic interface
> -// to ParameterizedTestCaseInfo classes. ParameterizedTestCaseInfoBase
> +// ParameterizedTestSuiteInfoBase is a generic interface
> +// to ParameterizedTestSuiteInfo classes. ParameterizedTestSuiteInfoBase
> // accumulates test information provided by TEST_P macro invocations
> -// and generators provided by INSTANTIATE_TEST_CASE_P macro invocations
> +// and generators provided by INSTANTIATE_TEST_SUITE_P macro invocations
> // and uses that information to register all resulting test instances
> -// in RegisterTests method. The ParameterizeTestCaseRegistry class holds
> -// a collection of pointers to the ParameterizedTestCaseInfo objects
> +// in RegisterTests method. The ParameterizeTestSuiteRegistry class holds
> +// a collection of pointers to the ParameterizedTestSuiteInfo objects
> // and calls RegisterTests() on each of them when asked.
> -class ParameterizedTestCaseInfoBase {
> +class ParameterizedTestSuiteInfoBase {
> public:
> - virtual ~ParameterizedTestCaseInfoBase() {}
> + virtual ~ParameterizedTestSuiteInfoBase() {}
>
> - // Base part of test case name for display purposes.
> - virtual const std::string& GetTestCaseName() const = 0;
> + // Base part of test suite name for display purposes.
> + virtual const std::string& GetTestSuiteName() const = 0;
> // Test case id to verify identity.
> - virtual TypeId GetTestCaseTypeId() const = 0;
> + virtual TypeId GetTestSuiteTypeId() const = 0;
> // UnitTest class invokes this method to register tests in this
> - // test case right before running them in RUN_ALL_TESTS macro.
> - // This method should not be called more then once on any single
> - // instance of a ParameterizedTestCaseInfoBase derived class.
> + // test suite right before running them in RUN_ALL_TESTS macro.
> + // This method should not be called more than once on any single
> + // instance of a ParameterizedTestSuiteInfoBase derived class.
> virtual void RegisterTests() = 0;
>
> protected:
> - ParameterizedTestCaseInfoBase() {}
> + ParameterizedTestSuiteInfoBase() {}
>
> private:
> - GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestCaseInfoBase);
> + GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestSuiteInfoBase);
> };
>
> // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
> //
> -// ParameterizedTestCaseInfo accumulates tests obtained from TEST_P
> -// macro invocations for a particular test case and generators
> -// obtained from INSTANTIATE_TEST_CASE_P macro invocations for that
> -// test case. It registers tests with all values generated by all
> +// ParameterizedTestSuiteInfo accumulates tests obtained from TEST_P
> +// macro invocations for a particular test suite and generators
> +// obtained from INSTANTIATE_TEST_SUITE_P macro invocations for that
> +// test suite. It registers tests with all values generated by all
> // generators when asked.
> -template <class TestCase>
> -class ParameterizedTestCaseInfo : public ParameterizedTestCaseInfoBase {
> +template <class TestSuite>
> +class ParameterizedTestSuiteInfo : public ParameterizedTestSuiteInfoBase {
> public:
> // ParamType and GeneratorCreationFunc are private types but are
> required
> // for declarations of public methods AddTestPattern() and
> - // AddTestCaseInstantiation().
> - typedef typename TestCase::ParamType ParamType;
> + // AddTestSuiteInstantiation().
> + using ParamType = typename TestSuite::ParamType;
> // A function that returns an instance of appropriate generator type.
> typedef ParamGenerator<ParamType>(GeneratorCreationFunc)();
> - typedef typename ParamNameGenFunc<ParamType>::Type
> ParamNameGeneratorFunc;
> + using ParamNameGeneratorFunc = std::string(const
> TestParamInfo<ParamType>&);
>
> - explicit ParameterizedTestCaseInfo(
> - const char* name, CodeLocation code_location)
> - : test_case_name_(name), code_location_(code_location) {}
> + explicit ParameterizedTestSuiteInfo(const char* name,
> + CodeLocation code_location)
> + : test_suite_name_(name), code_location_(code_location) {}
>
> // Test case base name for display purposes.
> - virtual const std::string& GetTestCaseName() const { return
> test_case_name_; }
> + const std::string& GetTestSuiteName() const override {
> + return test_suite_name_;
> + }
> // Test case id to verify identity.
> - virtual TypeId GetTestCaseTypeId() const { return
> GetTypeId<TestCase>(); }
> + TypeId GetTestSuiteTypeId() const override { return
> GetTypeId<TestSuite>(); }
> // TEST_P macro uses AddTestPattern() to record information
> // about a single test in a LocalTestInfo structure.
> - // test_case_name is the base name of the test case (without invocation
> + // test_suite_name is the base name of the test suite (without
> invocation
> // prefix). test_base_name is the name of an individual test without
> // parameter index. For the test SequenceA/FooTest.DoBar/1 FooTest is
> - // test case base name and DoBar is test base name.
> - void AddTestPattern(const char* test_case_name,
> - const char* test_base_name,
> + // test suite base name and DoBar is test base name.
> + void AddTestPattern(const char* test_suite_name, const char*
> test_base_name,
> TestMetaFactoryBase<ParamType>* meta_factory) {
> - tests_.push_back(linked_ptr<TestInfo>(new TestInfo(test_case_name,
> - test_base_name,
> - meta_factory)));
> + tests_.push_back(std::shared_ptr<TestInfo>(
> + new TestInfo(test_suite_name, test_base_name, meta_factory)));
> }
> - // INSTANTIATE_TEST_CASE_P macro uses AddGenerator() to record
> information
> + // INSTANTIATE_TEST_SUITE_P macro uses AddGenerator() to record
> information
> // about a generator.
> - int AddTestCaseInstantiation(const std::string& instantiation_name,
> - GeneratorCreationFunc* func,
> - ParamNameGeneratorFunc* name_func,
> - const char* file, int line) {
> + int AddTestSuiteInstantiation(const std::string& instantiation_name,
> + GeneratorCreationFunc* func,
> + ParamNameGeneratorFunc* name_func,
> + const char* file, int line) {
> instantiations_.push_back(
> InstantiationInfo(instantiation_name, func, name_func, file,
> line));
> return 0; // Return value used only to run this method in namespace
> scope.
> }
> - // UnitTest class invokes this method to register tests in this test
> case
> - // test cases right before running tests in RUN_ALL_TESTS macro.
> - // This method should not be called more then once on any single
> - // instance of a ParameterizedTestCaseInfoBase derived class.
> - // UnitTest has a guard to prevent from calling this method more then
> once.
> - virtual void RegisterTests() {
> + // UnitTest class invokes this method to register tests in this test
> suite
> + // test suites right before running tests in RUN_ALL_TESTS macro.
> + // This method should not be called more than once on any single
> + // instance of a ParameterizedTestSuiteInfoBase derived class.
> + // UnitTest has a guard to prevent from calling this method more than
> once.
> + void RegisterTests() override {
> for (typename TestInfoContainer::iterator test_it = tests_.begin();
> test_it != tests_.end(); ++test_it) {
> - linked_ptr<TestInfo> test_info = *test_it;
> + std::shared_ptr<TestInfo> test_info = *test_it;
> for (typename InstantiationContainer::iterator gen_it =
> instantiations_.begin(); gen_it != instantiations_.end();
> ++gen_it) {
> @@ -551,10 +539,10 @@ class ParameterizedTestCaseInfo : public
> ParameterizedTestCaseInfoBase {
> const char* file = gen_it->file;
> int line = gen_it->line;
>
> - std::string test_case_name;
> + std::string test_suite_name;
> if ( !instantiation_name.empty() )
> - test_case_name = instantiation_name + "/";
> - test_case_name += test_info->test_case_base_name;
> + test_suite_name = instantiation_name + "/";
> + test_suite_name += test_info->test_suite_base_name;
>
> size_t i = 0;
> std::set<std::string> test_param_names;
> @@ -577,39 +565,39 @@ class ParameterizedTestCaseInfo : public
> ParameterizedTestCaseInfoBase {
>
> test_param_names.insert(param_name);
>
> - test_name_stream << test_info->test_base_name << "/" <<
> param_name;
> + if (!test_info->test_base_name.empty()) {
> + test_name_stream << test_info->test_base_name << "/";
> + }
> + test_name_stream << param_name;
> MakeAndRegisterTestInfo(
> - test_case_name.c_str(),
> - test_name_stream.GetString().c_str(),
> - NULL, // No type parameter.
> - PrintToString(*param_it).c_str(),
> - code_location_,
> - GetTestCaseTypeId(),
> - TestCase::SetUpTestCase,
> - TestCase::TearDownTestCase,
> + test_suite_name.c_str(),
> test_name_stream.GetString().c_str(),
> + nullptr, // No type parameter.
> + PrintToString(*param_it).c_str(), code_location_,
> + GetTestSuiteTypeId(),
> + SuiteApiResolver<TestSuite>::GetSetUpCaseOrSuite(file,
> line),
> + SuiteApiResolver<TestSuite>::GetTearDownCaseOrSuite(file,
> line),
> test_info->test_meta_factory->CreateTestFactory(*param_it));
> } // for param_it
> } // for gen_it
> } // for test_it
> - } // RegisterTests
> + } // RegisterTests
>
> private:
> // LocalTestInfo structure keeps information about a single test
> registered
> // with TEST_P macro.
> struct TestInfo {
> - TestInfo(const char* a_test_case_base_name,
> - const char* a_test_base_name,
> - TestMetaFactoryBase<ParamType>* a_test_meta_factory) :
> - test_case_base_name(a_test_case_base_name),
> - test_base_name(a_test_base_name),
> - test_meta_factory(a_test_meta_factory) {}
> -
> - const std::string test_case_base_name;
> + TestInfo(const char* a_test_suite_base_name, const char*
> a_test_base_name,
> + TestMetaFactoryBase<ParamType>* a_test_meta_factory)
> + : test_suite_base_name(a_test_suite_base_name),
> + test_base_name(a_test_base_name),
> + test_meta_factory(a_test_meta_factory) {}
> +
> + const std::string test_suite_base_name;
> const std::string test_base_name;
> - const scoped_ptr<TestMetaFactoryBase<ParamType> > test_meta_factory;
> + const std::unique_ptr<TestMetaFactoryBase<ParamType> >
> test_meta_factory;
> };
> - typedef ::std::vector<linked_ptr<TestInfo> > TestInfoContainer;
> - // Records data received from INSTANTIATE_TEST_CASE_P macros:
> + using TestInfoContainer = ::std::vector<std::shared_ptr<TestInfo> >;
> + // Records data received from INSTANTIATE_TEST_SUITE_P macros:
> // <Instantiation name, Sequence generator creation function,
> // Name generator function, Source file, Source line>
> struct InstantiationInfo {
> @@ -646,76 +634,247 @@ class ParameterizedTestCaseInfo : public
> ParameterizedTestCaseInfoBase {
> return true;
> }
>
> - const std::string test_case_name_;
> + const std::string test_suite_name_;
> CodeLocation code_location_;
> TestInfoContainer tests_;
> InstantiationContainer instantiations_;
>
> - GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestCaseInfo);
> -}; // class ParameterizedTestCaseInfo
> + GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestSuiteInfo);
> +}; // class ParameterizedTestSuiteInfo
> +
> +// Legacy API is deprecated but still available
> +#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
> +template <class TestCase>
> +using ParameterizedTestCaseInfo = ParameterizedTestSuiteInfo<TestCase>;
> +#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
>
> // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
> //
> -// ParameterizedTestCaseRegistry contains a map of
> ParameterizedTestCaseInfoBase
> -// classes accessed by test case names. TEST_P and INSTANTIATE_TEST_CASE_P
> -// macros use it to locate their corresponding ParameterizedTestCaseInfo
> -// descriptors.
> -class ParameterizedTestCaseRegistry {
> +// ParameterizedTestSuiteRegistry contains a map of
> +// ParameterizedTestSuiteInfoBase classes accessed by test suite names.
> TEST_P
> +// and INSTANTIATE_TEST_SUITE_P macros use it to locate their
> corresponding
> +// ParameterizedTestSuiteInfo descriptors.
> +class ParameterizedTestSuiteRegistry {
> public:
> - ParameterizedTestCaseRegistry() {}
> - ~ParameterizedTestCaseRegistry() {
> - for (TestCaseInfoContainer::iterator it = test_case_infos_.begin();
> - it != test_case_infos_.end(); ++it) {
> - delete *it;
> + ParameterizedTestSuiteRegistry() {}
> + ~ParameterizedTestSuiteRegistry() {
> + for (auto& test_suite_info : test_suite_infos_) {
> + delete test_suite_info;
> }
> }
>
> // Looks up or creates and returns a structure containing information
> about
> - // tests and instantiations of a particular test case.
> - template <class TestCase>
> - ParameterizedTestCaseInfo<TestCase>* GetTestCasePatternHolder(
> - const char* test_case_name,
> - CodeLocation code_location) {
> - ParameterizedTestCaseInfo<TestCase>* typed_test_info = NULL;
> - for (TestCaseInfoContainer::iterator it = test_case_infos_.begin();
> - it != test_case_infos_.end(); ++it) {
> - if ((*it)->GetTestCaseName() == test_case_name) {
> - if ((*it)->GetTestCaseTypeId() != GetTypeId<TestCase>()) {
> + // tests and instantiations of a particular test suite.
> + template <class TestSuite>
> + ParameterizedTestSuiteInfo<TestSuite>* GetTestSuitePatternHolder(
> + const char* test_suite_name, CodeLocation code_location) {
> + ParameterizedTestSuiteInfo<TestSuite>* typed_test_info = nullptr;
> + for (auto& test_suite_info : test_suite_infos_) {
> + if (test_suite_info->GetTestSuiteName() == test_suite_name) {
> + if (test_suite_info->GetTestSuiteTypeId() !=
> GetTypeId<TestSuite>()) {
> // Complain about incorrect usage of Google Test facilities
> // and terminate the program since we cannot guaranty correct
> - // test case setup and tear-down in this case.
> - ReportInvalidTestCaseType(test_case_name, code_location);
> + // test suite setup and tear-down in this case.
> + ReportInvalidTestSuiteType(test_suite_name, code_location);
> posix::Abort();
> } else {
> // At this point we are sure that the object we found is of the
> same
> // type we are looking for, so we downcast it to that type
> // without further checks.
> typed_test_info = CheckedDowncastToActualType<
> - ParameterizedTestCaseInfo<TestCase> >(*it);
> + ParameterizedTestSuiteInfo<TestSuite> >(test_suite_info);
> }
> break;
> }
> }
> - if (typed_test_info == NULL) {
> - typed_test_info = new ParameterizedTestCaseInfo<TestCase>(
> - test_case_name, code_location);
> - test_case_infos_.push_back(typed_test_info);
> + if (typed_test_info == nullptr) {
> + typed_test_info = new ParameterizedTestSuiteInfo<TestSuite>(
> + test_suite_name, code_location);
> + test_suite_infos_.push_back(typed_test_info);
> }
> return typed_test_info;
> }
> void RegisterTests() {
> - for (TestCaseInfoContainer::iterator it = test_case_infos_.begin();
> - it != test_case_infos_.end(); ++it) {
> - (*it)->RegisterTests();
> + for (auto& test_suite_info : test_suite_infos_) {
> + test_suite_info->RegisterTests();
> }
> }
> +// Legacy API is deprecated but still available
> +#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
> + template <class TestCase>
> + ParameterizedTestCaseInfo<TestCase>* GetTestCasePatternHolder(
> + const char* test_case_name, CodeLocation code_location) {
> + return GetTestSuitePatternHolder<TestCase>(test_case_name,
> code_location);
> + }
> +
> +#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
> +
> + private:
> + using TestSuiteInfoContainer =
> ::std::vector<ParameterizedTestSuiteInfoBase*>;
> +
> + TestSuiteInfoContainer test_suite_infos_;
> +
> + GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestSuiteRegistry);
> +};
> +
> +} // namespace internal
> +
> +// Forward declarations of ValuesIn(), which is implemented in
> +// include/gtest/gtest-param-test.h.
> +template <class Container>
> +internal::ParamGenerator<typename Container::value_type> ValuesIn(
> + const Container& container);
> +
> +namespace internal {
> +// Used in the Values() function to provide polymorphic capabilities.
> +
> +template <typename... Ts>
> +class ValueArray {
> + public:
> + ValueArray(Ts... v) : v_{std::move(v)...} {}
> +
> + template <typename T>
> + operator ParamGenerator<T>() const { // NOLINT
> + return ValuesIn(MakeVector<T>(MakeIndexSequence<sizeof...(Ts)>()));
> + }
>
> private:
> - typedef ::std::vector<ParameterizedTestCaseInfoBase*>
> TestCaseInfoContainer;
> + template <typename T, size_t... I>
> + std::vector<T> MakeVector(IndexSequence<I...>) const {
> + return std::vector<T>{static_cast<T>(v_.template Get<I>())...};
> + }
>
> - TestCaseInfoContainer test_case_infos_;
> + FlatTuple<Ts...> v_;
> +};
>
> - GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestCaseRegistry);
> +template <typename... T>
> +class CartesianProductGenerator
> + : public ParamGeneratorInterface<::std::tuple<T...>> {
> + public:
> + typedef ::std::tuple<T...> ParamType;
> +
> + CartesianProductGenerator(const std::tuple<ParamGenerator<T>...>& g)
> + : generators_(g) {}
> + ~CartesianProductGenerator() override {}
> +
> + ParamIteratorInterface<ParamType>* Begin() const override {
> + return new Iterator(this, generators_, false);
> + }
> + ParamIteratorInterface<ParamType>* End() const override {
> + return new Iterator(this, generators_, true);
> + }
> +
> + private:
> + template <class I>
> + class IteratorImpl;
> + template <size_t... I>
> + class IteratorImpl<IndexSequence<I...>>
> + : public ParamIteratorInterface<ParamType> {
> + public:
> + IteratorImpl(const ParamGeneratorInterface<ParamType>* base,
> + const std::tuple<ParamGenerator<T>...>& generators, bool
> is_end)
> + : base_(base),
> + begin_(std::get<I>(generators).begin()...),
> + end_(std::get<I>(generators).end()...),
> + current_(is_end ? end_ : begin_) {
> + ComputeCurrentValue();
> + }
> + ~IteratorImpl() override {}
> +
> + const ParamGeneratorInterface<ParamType>* BaseGenerator() const
> override {
> + return base_;
> + }
> + // Advance should not be called on beyond-of-range iterators
> + // so no component iterators must be beyond end of range, either.
> + void Advance() override {
> + assert(!AtEnd());
> + // Advance the last iterator.
> + ++std::get<sizeof...(T) - 1>(current_);
> + // if that reaches end, propagate that up.
> + AdvanceIfEnd<sizeof...(T) - 1>();
> + ComputeCurrentValue();
> + }
> + ParamIteratorInterface<ParamType>* Clone() const override {
> + return new IteratorImpl(*this);
> + }
> +
> + const ParamType* Current() const override { return
> current_value_.get(); }
> +
> + bool Equals(const ParamIteratorInterface<ParamType>& other) const
> override {
> + // Having the same base generator guarantees that the other
> + // iterator is of the same type and we can downcast.
> + GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
> + << "The program attempted to compare iterators "
> + << "from
> diff erent generators." << std::endl;
> + const IteratorImpl* typed_other =
> + CheckedDowncastToActualType<const IteratorImpl>(&other);
> +
> + // We must report iterators equal if they both point beyond their
> + // respective ranges. That can happen in a variety of fashions,
> + // so we have to consult AtEnd().
> + if (AtEnd() && typed_other->AtEnd()) return true;
> +
> + bool same = true;
> + bool dummy[] = {
> + (same = same && std::get<I>(current_) ==
> + std::get<I>(typed_other->current_))...};
> + (void)dummy;
> + return same;
> + }
> +
> + private:
> + template <size_t ThisI>
> + void AdvanceIfEnd() {
> + if (std::get<ThisI>(current_) != std::get<ThisI>(end_)) return;
> +
> + bool last = ThisI == 0;
> + if (last) {
> + // We are done. Nothing else to propagate.
> + return;
> + }
> +
> + constexpr size_t NextI = ThisI - (ThisI != 0);
> + std::get<ThisI>(current_) = std::get<ThisI>(begin_);
> + ++std::get<NextI>(current_);
> + AdvanceIfEnd<NextI>();
> + }
> +
> + void ComputeCurrentValue() {
> + if (!AtEnd())
> + current_value_ =
> std::make_shared<ParamType>(*std::get<I>(current_)...);
> + }
> + bool AtEnd() const {
> + bool at_end = false;
> + bool dummy[] = {
> + (at_end = at_end || std::get<I>(current_) ==
> std::get<I>(end_))...};
> + (void)dummy;
> + return at_end;
> + }
> +
> + const ParamGeneratorInterface<ParamType>* const base_;
> + std::tuple<typename ParamGenerator<T>::iterator...> begin_;
> + std::tuple<typename ParamGenerator<T>::iterator...> end_;
> + std::tuple<typename ParamGenerator<T>::iterator...> current_;
> + std::shared_ptr<ParamType> current_value_;
> + };
> +
> + using Iterator = IteratorImpl<typename
> MakeIndexSequence<sizeof...(T)>::type>;
> +
> + std::tuple<ParamGenerator<T>...> generators_;
> +};
> +
> +template <class... Gen>
> +class CartesianProductHolder {
> + public:
> + CartesianProductHolder(const Gen&... g) : generators_(g...) {}
> + template <typename... T>
> + operator ParamGenerator<::std::tuple<T...>>() const {
> + return ParamGenerator<::std::tuple<T...>>(
> + new CartesianProductGenerator<T...>(generators_));
> + }
> +
> + private:
> + std::tuple<Gen...> generators_;
> };
>
> } // namespace internal
>
> diff --git
> a/llvm/utils/unittest/googletest/include/gtest/internal/gtest-port-arch.h
> b/llvm/utils/unittest/googletest/include/gtest/internal/gtest-port-arch.h
> index f83700e06d98c..cece93dba12d4 100644
> ---
> a/llvm/utils/unittest/googletest/include/gtest/internal/gtest-port-arch.h
> +++
> b/llvm/utils/unittest/googletest/include/gtest/internal/gtest-port-arch.h
> @@ -38,14 +38,13 @@
> // Determines the platform on which Google Test is compiled.
> #ifdef __CYGWIN__
> # define GTEST_OS_CYGWIN 1
> -#elif defined __SYMBIAN32__
> -# define GTEST_OS_SYMBIAN 1
> +# elif defined(__MINGW__) || defined(__MINGW32__) || defined(__MINGW64__)
> +# define GTEST_OS_WINDOWS_MINGW 1
> +# define GTEST_OS_WINDOWS 1
> #elif defined _WIN32
> # define GTEST_OS_WINDOWS 1
> # ifdef _WIN32_WCE
> # define GTEST_OS_WINDOWS_MOBILE 1
> -# elif defined(__MINGW__) || defined(__MINGW32__)
> -# define GTEST_OS_WINDOWS_MINGW 1
> # elif defined(WINAPI_FAMILY)
> # include <winapifamily.h>
> # if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
> @@ -65,15 +64,21 @@
> # else
> # define GTEST_OS_WINDOWS_DESKTOP 1
> # endif // _WIN32_WCE
> +#elif defined __OS2__
> +# define GTEST_OS_OS2 1
> #elif defined __APPLE__
> # define GTEST_OS_MAC 1
> # if TARGET_OS_IPHONE
> # define GTEST_OS_IOS 1
> # endif
> +#elif defined __DragonFly__
> +# define GTEST_OS_DRAGONFLY 1
> #elif defined __FreeBSD__
> # define GTEST_OS_FREEBSD 1
> #elif defined __Fuchsia__
> # define GTEST_OS_FUCHSIA 1
> +#elif defined(__GLIBC__) && defined(__FreeBSD_kernel__)
> +# define GTEST_OS_GNU_KFREEBSD 1
> #elif defined __linux__
> # define GTEST_OS_LINUX 1
> # if defined __ANDROID__
> @@ -95,6 +100,8 @@
> # define GTEST_OS_OPENBSD 1
> #elif defined __QNX__
> # define GTEST_OS_QNX 1
> +#elif defined(__HAIKU__)
> +#define GTEST_OS_HAIKU 1
> #endif // __CYGWIN__
>
> #endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_ARCH_H_
>
> diff --git
> a/llvm/utils/unittest/googletest/include/gtest/internal/gtest-port.h
> b/llvm/utils/unittest/googletest/include/gtest/internal/gtest-port.h
> index 786497d854c97..063fcb1083bab 100644
> --- a/llvm/utils/unittest/googletest/include/gtest/internal/gtest-port.h
> +++ b/llvm/utils/unittest/googletest/include/gtest/internal/gtest-port.h
> @@ -72,10 +72,6 @@
> // is/isn't available.
> // GTEST_HAS_EXCEPTIONS - Define it to 1/0 to indicate that
> exceptions
> // are enabled.
> -// GTEST_HAS_GLOBAL_STRING - Define it to 1/0 to indicate that ::string
> -// is/isn't available
> -// GTEST_HAS_GLOBAL_WSTRING - Define it to 1/0 to indicate that
> ::wstring
> -// is/isn't available
> // GTEST_HAS_POSIX_RE - Define it to 1/0 to indicate that POSIX
> regular
> // expressions are/aren't available.
> // GTEST_HAS_PTHREAD - Define it to 1/0 to indicate that
> <pthread.h>
> @@ -85,8 +81,6 @@
> // GTEST_HAS_STD_WSTRING - Define it to 1/0 to indicate that
> // std::wstring does/doesn't work (Google
> Test can
> // be used where std::wstring is
> unavailable).
> -// GTEST_HAS_TR1_TUPLE - Define it to 1/0 to indicate tr1::tuple
> -// is/isn't available.
> // GTEST_HAS_SEH - Define it to 1/0 to indicate whether the
> // compiler supports Microsoft's "Structured
> // Exception Handling".
> @@ -94,12 +88,6 @@
> // - Define it to 1/0 to indicate whether the
> // platform supports I/O stream redirection
> using
> // dup() and dup2().
> -// GTEST_USE_OWN_TR1_TUPLE - Define it to 1/0 to indicate whether
> Google
> -// Test's own tr1 tuple implementation
> should be
> -// used. Unused when the user sets
> -// GTEST_HAS_TR1_TUPLE to 0.
> -// GTEST_LANG_CXX11 - Define it to 1/0 to indicate that Google
> Test
> -// is building in C++11/C++98 mode.
> // GTEST_LINKED_AS_SHARED_LIBRARY
> // - Define to 1 when compiling tests that use
> // Google Test as a shared library (known as
> @@ -125,8 +113,11 @@
> //
> // GTEST_OS_AIX - IBM AIX
> // GTEST_OS_CYGWIN - Cygwin
> +// GTEST_OS_DRAGONFLY - DragonFlyBSD
> // GTEST_OS_FREEBSD - FreeBSD
> // GTEST_OS_FUCHSIA - Fuchsia
> +// GTEST_OS_GNU_KFREEBSD - GNU/kFreeBSD
> +// GTEST_OS_HAIKU - Haiku
> // GTEST_OS_HPUX - HP-UX
> // GTEST_OS_LINUX - Linux
> // GTEST_OS_LINUX_ANDROID - Google Android
> @@ -135,9 +126,9 @@
> // GTEST_OS_NACL - Google Native Client (NaCl)
> // GTEST_OS_NETBSD - NetBSD
> // GTEST_OS_OPENBSD - OpenBSD
> +// GTEST_OS_OS2 - OS/2
> // GTEST_OS_QNX - QNX
> // GTEST_OS_SOLARIS - Sun Solaris
> -// GTEST_OS_SYMBIAN - Symbian
> // GTEST_OS_WINDOWS - Windows (Desktop, MinGW, or Mobile)
> // GTEST_OS_WINDOWS_DESKTOP - Windows Desktop
> // GTEST_OS_WINDOWS_MINGW - MinGW
> @@ -146,7 +137,7 @@
> // GTEST_OS_WINDOWS_RT - Windows Store App/WinRT
> // GTEST_OS_ZOS - z/OS
> //
> -// Among the platforms, Cygwin, Linux, Max OS X, and Windows have the
> +// Among the platforms, Cygwin, Linux, Mac OS X, and Windows have the
> // most stable support. Since core members of the Google Test project
> // don't have access to other platforms, support for them may be less
> // stable. If you notice any problems on your platform, please notify
> @@ -172,8 +163,6 @@
> // EXPECT_DEATH(DoSomethingDeadly());
> // #endif
> //
> -// GTEST_HAS_COMBINE - the Combine() function (for
> value-parameterized
> -// tests)
> // GTEST_HAS_DEATH_TEST - death tests
> // GTEST_HAS_TYPED_TEST - typed tests
> // GTEST_HAS_TYPED_TEST_P - type-parameterized tests
> @@ -184,7 +173,6 @@
> // define themselves.
> // GTEST_USES_SIMPLE_RE - our own simple regex is used;
> // the above RE\b(s) are mutually exclusive.
> -// GTEST_CAN_COMPARE_NULL - accepts untyped NULL in EXPECT_EQ().
>
> // Misc public macros
> // ------------------
> @@ -210,23 +198,10 @@
> // GTEST_INTENTIONAL_CONST_COND_POP_ - finish code section where MSVC
> C4127
> // is suppressed.
> //
> -// C++11 feature wrappers:
> -//
> -// testing::internal::forward - portability wrapper for std::forward.
> -// testing::internal::move - portability wrapper for std::move.
> -//
> // Synchronization:
> // Mutex, MutexLock, ThreadLocal, GetThreadCount()
> // - synchronization primitives.
> //
> -// Template meta programming:
> -// is_pointer - as in TR1; needed on Symbian and IBM XL C/C++ only.
> -// IteratorTraits - partial implementation of std::iterator_traits,
> which
> -// is not available in libCstd when compiled with Sun
> C++.
> -//
> -// Smart pointers:
> -// scoped_ptr - as in TR2.
> -//
> // Regular expressions:
> // RE - a simple regular expression class using the POSIX
> // Extended Regular Expression syntax on UNIX-like
> platforms
> @@ -262,12 +237,20 @@
> // BoolFromGTestEnv() - parses a bool environment variable.
> // Int32FromGTestEnv() - parses an Int32 environment variable.
> // StringFromGTestEnv() - parses a string environment variable.
> +//
> +// Deprecation warnings:
> +// GTEST_INTERNAL_DEPRECATED(message) - attribute marking a function as
> +// deprecated; calling a marked
> function
> +// should generate a compiler
> warning
>
> #include <ctype.h> // for isspace, etc
> #include <stddef.h> // for ptr
> diff _t
> -#include <stdlib.h>
> #include <stdio.h>
> +#include <stdlib.h>
> #include <string.h>
> +#include <memory>
> +#include <type_traits>
> +
> #ifndef _WIN32_WCE
> # include <sys/types.h>
> # include <sys/stat.h>
> @@ -278,12 +261,11 @@
> # include <TargetConditionals.h>
> #endif
>
> -// Brings in the definition of HAS_GLOBAL_STRING. This must be done
> -// BEFORE we test HAS_GLOBAL_STRING.
> -#include <string> // NOLINT
> #include <algorithm> // NOLINT
> -#include <iostream> // NOLINT
> -#include <sstream> // NOLINT
> +#include <iostream> // NOLINT
> +#include <sstream> // NOLINT
> +#include <string> // NOLINT
> +#include <tuple>
> #include <utility>
> #include <vector> // NOLINT
>
> @@ -315,14 +297,14 @@
> // GTEST_DISABLE_MSC_WARNINGS_PUSH_(4800 4385)
> // /* code that triggers warnings C4800 and C4385 */
> // GTEST_DISABLE_MSC_WARNINGS_POP_()
> -#if _MSC_VER >= 1400
> +#if defined(_MSC_VER)
> # define GTEST_DISABLE_MSC_WARNINGS_PUSH_(warnings) \
> __pragma(warning(push)) \
> __pragma(warning(disable: warnings))
> # define GTEST_DISABLE_MSC_WARNINGS_POP_() \
> __pragma(warning(pop))
> #else
> -// Older versions of MSVC don't have __pragma.
> +// Not all compilers are MSVC
> # define GTEST_DISABLE_MSC_WARNINGS_PUSH_(warnings)
> # define GTEST_DISABLE_MSC_WARNINGS_POP_()
> #endif
> @@ -343,80 +325,6 @@
> GTEST_DISABLE_MSC_WARNINGS_POP_()
> #endif
>
> -#ifndef GTEST_LANG_CXX11
> -// gcc and clang define __GXX_EXPERIMENTAL_CXX0X__ when
> -// -std={c,gnu}++{0x,11} is passed. The C++11 standard specifies a
> -// value for __cplusplus, and recent versions of clang, gcc, and
> -// probably other compilers set that too in C++11 mode.
> -# if __GXX_EXPERIMENTAL_CXX0X__ || __cplusplus >= 201103L || _MSC_VER >=
> 1900
> -// Compiling in at least C++11 mode.
> -# define GTEST_LANG_CXX11 1
> -# else
> -# define GTEST_LANG_CXX11 0
> -# endif
> -#endif
> -
> -// Distinct from C++11 language support, some environments don't provide
> -// proper C++11 library support. Notably, it's possible to build in
> -// C++11 mode when targeting Mac OS X 10.6, which has an old libstdc++
> -// with no C++11 support.
> -//
> -// libstdc++ has sufficient C++11 support as of GCC 4.6.0, __GLIBCXX__
> -// 20110325, but maintenance releases in the 4.4 and 4.5 series followed
> -// this date, so check for those versions by their date stamps.
> -//
> https://gcc.gnu.org/onlinedocs/libstdc++/manual/abi.html#abi.versioning
> -#if
> <https://gcc.gnu.org/onlinedocs/libstdc++/manual/abi.html#abi.versioning-%23if>
> GTEST_LANG_CXX11 && \
> - (!defined(__GLIBCXX__) || ( \
> - __GLIBCXX__ >= 20110325ul && /* GCC >= 4.6.0 */ \
> - /* Blacklist of patch releases of older branches: */ \
> - __GLIBCXX__ != 20110416ul && /* GCC 4.4.6 */ \
> - __GLIBCXX__ != 20120313ul && /* GCC 4.4.7 */ \
> - __GLIBCXX__ != 20110428ul && /* GCC 4.5.3 */ \
> - __GLIBCXX__ != 20120702ul)) /* GCC 4.5.4 */
> -# define GTEST_STDLIB_CXX11 1
> -#endif
> -
> -// Only use C++11 library features if the library provides them.
> -#if GTEST_STDLIB_CXX11
> -# define GTEST_HAS_STD_BEGIN_AND_END_ 1
> -# define GTEST_HAS_STD_FORWARD_LIST_ 1
> -# if !defined(_MSC_VER) || (_MSC_FULL_VER >= 190023824)
> -// works only with VS2015U2 and better
> -# define GTEST_HAS_STD_FUNCTION_ 1
> -# endif
> -# define GTEST_HAS_STD_INITIALIZER_LIST_ 1
> -# define GTEST_HAS_STD_MOVE_ 1
> -# define GTEST_HAS_STD_UNIQUE_PTR_ 1
> -# define GTEST_HAS_STD_SHARED_PTR_ 1
> -# define GTEST_HAS_UNORDERED_MAP_ 1
> -# define GTEST_HAS_UNORDERED_SET_ 1
> -#endif
> -
> -// C++11 specifies that <tuple> provides std::tuple.
> -// Some platforms still might not have it, however.
> -#if GTEST_LANG_CXX11
> -# define GTEST_HAS_STD_TUPLE_ 1
> -# if defined(__clang__)
> -// Inspired by
> -//
> https://clang.llvm.org/docs/LanguageExtensions.html#include-file-checking-macros
> -# if defined(__has_include) && !__has_include(<tuple>)
> -# undef GTEST_HAS_STD_TUPLE_
> -# endif
> -# elif defined(_MSC_VER)
> -// Inspired by boost/config/stdlib/dinkumware.hpp
> -# if defined(_CPPLIB_VER) && _CPPLIB_VER < 520
> -# undef GTEST_HAS_STD_TUPLE_
> -# endif
> -# elif defined(__GLIBCXX__)
> -// Inspired by boost/config/stdlib/libstdcpp3.hpp,
> -// http://gcc.gnu.org/gcc-4.2/changes.html and
> -//
> https://web.archive.org/web/20140227044429/gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt01ch01.html#manual.intro.status.standard.200x
> -# if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 2)
> -# undef GTEST_HAS_STD_TUPLE_
> -# endif
> -# endif
> -#endif
> -
> // Brings in definitions for functions used in the
> testing::internal::posix
> // namespace (read, write, close, chdir, isatty, stat). We do not
> currently
> // use them on Windows Mobile.
> @@ -449,7 +357,8 @@ typedef struct _RTL_CRITICAL_SECTION
> GTEST_CRITICAL_SECTION;
> # include <android/api-level.h> // NOLINT
> #endif
>
> -// Defines this to true iff Google Test can use POSIX regular expressions.
> +// Defines this to true if and only if Google Test can use POSIX regular
> +// expressions.
> #ifndef GTEST_HAS_POSIX_RE
> # if GTEST_OS_LINUX_ANDROID
> // On Android, <regex.h> is only available starting with Gingerbread.
> @@ -490,7 +399,7 @@ typedef struct _RTL_CRITICAL_SECTION
> GTEST_CRITICAL_SECTION;
> // The user didn't tell us whether exceptions are enabled, so we need
> // to figure it out.
> # if defined(_MSC_VER) && defined(_CPPUNWIND)
> -// MSVC defines _CPPUNWIND to 1 iff exceptions are enabled.
> +// MSVC defines _CPPUNWIND to 1 if and only if exceptions are enabled.
> # define GTEST_HAS_EXCEPTIONS 1
> # elif defined(__BORLANDC__)
> // C++Builder's implementation of the STL uses the _HAS_EXCEPTIONS
> @@ -501,16 +410,17 @@ typedef struct _RTL_CRITICAL_SECTION
> GTEST_CRITICAL_SECTION;
> # endif // _HAS_EXCEPTIONS
> # define GTEST_HAS_EXCEPTIONS _HAS_EXCEPTIONS
> # elif defined(__clang__)
> -// clang defines __EXCEPTIONS iff exceptions are enabled before clang
> 220714,
> -// but iff cleanups are enabled after that. In Obj-C++ files, there can be
> -// cleanups for ObjC exceptions which also need cleanups, even if C++
> exceptions
> -// are disabled. clang has __has_feature(cxx_exceptions) which checks for
> C++
> -// exceptions starting at clang r206352, but which checked for cleanups
> prior to
> -// that. To reliably check for C++ exception availability with clang,
> check for
> +// clang defines __EXCEPTIONS if and only if exceptions are enabled
> before clang
> +// 220714, but if and only if cleanups are enabled after that. In Obj-C++
> files,
> +// there can be cleanups for ObjC exceptions which also need cleanups,
> even if
> +// C++ exceptions are disabled. clang has __has_feature(cxx_exceptions)
> which
> +// checks for C++ exceptions starting at clang r206352, but which checked
> for
> +// cleanups prior to that. To reliably check for C++ exception
> availability with
> +// clang, check for
> // __EXCEPTIONS && __has_feature(cxx_exceptions).
> # define GTEST_HAS_EXCEPTIONS (__EXCEPTIONS &&
> __has_feature(cxx_exceptions))
> # elif defined(__GNUC__) && __EXCEPTIONS
> -// gcc defines __EXCEPTIONS to 1 iff exceptions are enabled.
> +// gcc defines __EXCEPTIONS to 1 if and only if exceptions are enabled.
> # define GTEST_HAS_EXCEPTIONS 1
> # elif defined(__SUNPRO_CC)
> // Sun Pro CC supports exceptions. However, there is no compile-time way
> of
> @@ -518,7 +428,7 @@ typedef struct _RTL_CRITICAL_SECTION
> GTEST_CRITICAL_SECTION;
> // they are enabled unless the user tells us otherwise.
> # define GTEST_HAS_EXCEPTIONS 1
> # elif defined(__IBMCPP__) && __EXCEPTIONS
> -// xlC defines __EXCEPTIONS to 1 iff exceptions are enabled.
> +// xlC defines __EXCEPTIONS to 1 if and only if exceptions are enabled.
> # define GTEST_HAS_EXCEPTIONS 1
> # elif defined(__HP_aCC)
> // Exception handling is in effect by default in HP aCC compiler. It has
> to
> @@ -540,31 +450,18 @@ typedef struct _RTL_CRITICAL_SECTION
> GTEST_CRITICAL_SECTION;
> # error "::std::string isn't available."
> #endif // !defined(GTEST_HAS_STD_STRING)
>
> -#ifndef GTEST_HAS_GLOBAL_STRING
> -# define GTEST_HAS_GLOBAL_STRING 0
> -#endif // GTEST_HAS_GLOBAL_STRING
> -
> #ifndef GTEST_HAS_STD_WSTRING
> // The user didn't tell us whether ::std::wstring is available, so we need
> // to figure it out.
> -// FIXME: uses autoconf to detect whether ::std::wstring
> -// is available.
> -
> // Cygwin 1.7 and below doesn't support ::std::wstring.
> // Solaris' libc++ doesn't support it either. Android has
> // no support for it at least as recent as Froyo (2.2).
> -# define GTEST_HAS_STD_WSTRING \
> - (!(GTEST_OS_LINUX_ANDROID || GTEST_OS_CYGWIN || GTEST_OS_SOLARIS))
> +#define GTEST_HAS_STD_WSTRING \
> + (!(GTEST_OS_LINUX_ANDROID || GTEST_OS_CYGWIN || GTEST_OS_SOLARIS || \
> + GTEST_OS_HAIKU))
>
> #endif // GTEST_HAS_STD_WSTRING
>
> -#ifndef GTEST_HAS_GLOBAL_WSTRING
> -// The user didn't tell us whether ::wstring is available, so we need
> -// to figure it out.
> -# define GTEST_HAS_GLOBAL_WSTRING \
> - (GTEST_HAS_STD_WSTRING && GTEST_HAS_GLOBAL_STRING)
> -#endif // GTEST_HAS_GLOBAL_WSTRING
> -
> // Determines whether RTTI is available.
> #ifndef GTEST_HAS_RTTI
> // The user didn't tell us whether RTTI is enabled, so we need to
> @@ -572,14 +469,15 @@ typedef struct _RTL_CRITICAL_SECTION
> GTEST_CRITICAL_SECTION;
>
> # ifdef _MSC_VER
>
> -# ifdef _CPPRTTI // MSVC defines this macro iff RTTI is enabled.
> +#ifdef _CPPRTTI // MSVC defines this macro if and only if RTTI is
> enabled.
> # define GTEST_HAS_RTTI 1
> # else
> # define GTEST_HAS_RTTI 0
> # endif
>
> -// Starting with version 4.3.2, gcc defines __GXX_RTTI iff RTTI is
> enabled.
> -# elif defined(__GNUC__) && (GTEST_GCC_VER_ >= 40302)
> +// Starting with version 4.3.2, gcc defines __GXX_RTTI if and only if
> RTTI is
> +// enabled.
> +# elif defined(__GNUC__)
>
> # ifdef __GXX_RTTI
> // When building against STLport with the Android NDK and with
> @@ -635,9 +533,11 @@ typedef struct _RTL_CRITICAL_SECTION
> GTEST_CRITICAL_SECTION;
> //
> // To disable threading support in Google Test, add -DGTEST_HAS_PTHREAD=0
> // to your compiler flags.
> -#define GTEST_HAS_PTHREAD \
> - (GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_HPUX || GTEST_OS_QNX || \
> - GTEST_OS_FREEBSD || GTEST_OS_NACL || GTEST_OS_NETBSD ||
> GTEST_OS_FUCHSIA)
> +#define GTEST_HAS_PTHREAD
> \
> + (GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_HPUX || GTEST_OS_QNX ||
> \
> + GTEST_OS_FREEBSD || GTEST_OS_NACL || GTEST_OS_NETBSD ||
> GTEST_OS_FUCHSIA || \
> + GTEST_OS_DRAGONFLY || GTEST_OS_GNU_KFREEBSD || GTEST_OS_OPENBSD ||
> \
> + GTEST_OS_HAIKU)
> #endif // GTEST_HAS_PTHREAD
>
> #if GTEST_HAS_PTHREAD
> @@ -649,136 +549,6 @@ typedef struct _RTL_CRITICAL_SECTION
> GTEST_CRITICAL_SECTION;
> # include <time.h> // NOLINT
> #endif
>
> -// Determines if hash_map/hash_set are available.
> -// Only used for testing against those containers.
> -#if !defined(GTEST_HAS_HASH_MAP_)
> -# if defined(_MSC_VER) && (_MSC_VER < 1900)
> -# define GTEST_HAS_HASH_MAP_ 1 // Indicates that hash_map is available.
> -# define GTEST_HAS_HASH_SET_ 1 // Indicates that hash_set is available.
> -# endif // _MSC_VER
> -#endif // !defined(GTEST_HAS_HASH_MAP_)
> -
> -// Determines whether Google Test can use tr1/tuple. You can define
> -// this macro to 0 to prevent Google Test from using tuple (any
> -// feature depending on tuple with be disabled in this mode).
> -#ifndef GTEST_HAS_TR1_TUPLE
> -# if GTEST_OS_LINUX_ANDROID && defined(_STLPORT_MAJOR)
> -// STLport, provided with the Android NDK, has neither <tr1/tuple> or
> <tuple>.
> -# define GTEST_HAS_TR1_TUPLE 0
> -# elif defined(_MSC_VER) && (_MSC_VER >= 1910)
> -// Prevent `warning C4996: 'std::tr1': warning STL4002:
> -// The non-Standard std::tr1 namespace and TR1-only machinery
> -// are deprecated and will be REMOVED.`
> -# define GTEST_HAS_TR1_TUPLE 0
> -# elif GTEST_LANG_CXX11 && defined(_LIBCPP_VERSION)
> -// libc++ doesn't support TR1.
> -# define GTEST_HAS_TR1_TUPLE 0
> -# else
> -// The user didn't tell us not to do it, so we assume it's OK.
> -# define GTEST_HAS_TR1_TUPLE 1
> -# endif
> -#endif // GTEST_HAS_TR1_TUPLE
> -
> -// Determines whether Google Test's own tr1 tuple implementation
> -// should be used.
> -#ifndef GTEST_USE_OWN_TR1_TUPLE
> -// We use our own tuple implementation on Symbian.
> -# if GTEST_OS_SYMBIAN
> -# define GTEST_USE_OWN_TR1_TUPLE 1
> -# else
> -// The user didn't tell us, so we need to figure it out.
> -
> -// We use our own TR1 tuple if we aren't sure the user has an
> -// implementation of it already. At this time, libstdc++ 4.0.0+ and
> -// MSVC 2010 are the only mainstream standard libraries that come
> -// with a TR1 tuple implementation. NVIDIA's CUDA NVCC compiler
> -// pretends to be GCC by defining __GNUC__ and friends, but cannot
> -// compile GCC's tuple implementation. MSVC 2008 (9.0) provides TR1
> -// tuple in a 323 MB Feature Pack download, which we cannot assume the
> -// user has. QNX's QCC compiler is a modified GCC but it doesn't
> -// support TR1 tuple. libc++ only provides std::tuple, in C++11 mode,
> -// and it can be used with some compilers that define __GNUC__.
> -# if (defined(__GNUC__) && !defined(__CUDACC__) && (GTEST_GCC_VER_ >=
> 40000) \
> - && !GTEST_OS_QNX && !defined(_LIBCPP_VERSION)) \
> - || (_MSC_VER >= 1600 && _MSC_VER < 1900)
> -# define GTEST_ENV_HAS_TR1_TUPLE_ 1
> -# endif
> -
> -// C++11 specifies that <tuple> provides std::tuple. Use that if gtest is
> used
> -// in C++11 mode and libstdc++ isn't very old (binaries targeting OS X
> 10.6
> -// can build with clang but need to use gcc4.2's libstdc++).
> -# if GTEST_LANG_CXX11 && (!defined(__GLIBCXX__) || __GLIBCXX__ > 20110325)
> -# define GTEST_ENV_HAS_STD_TUPLE_ 1
> -# endif
> -
> -# if GTEST_ENV_HAS_TR1_TUPLE_ || GTEST_ENV_HAS_STD_TUPLE_
> -# define GTEST_USE_OWN_TR1_TUPLE 0
> -# else
> -# define GTEST_USE_OWN_TR1_TUPLE 1
> -# endif
> -# endif // GTEST_OS_SYMBIAN
> -#endif // GTEST_USE_OWN_TR1_TUPLE
> -
> -// To avoid conditional compilation we make it gtest-port.h's
> responsibility
> -// to #include the header implementing tuple.
> -#if GTEST_HAS_STD_TUPLE_
> -# include <tuple> // IWYU pragma: export
> -# define GTEST_TUPLE_NAMESPACE_ ::std
> -#endif // GTEST_HAS_STD_TUPLE_
> -
> -// We include tr1::tuple even if std::tuple is available to define
> printers for
> -// them.
> -#if GTEST_HAS_TR1_TUPLE
> -# ifndef GTEST_TUPLE_NAMESPACE_
> -# define GTEST_TUPLE_NAMESPACE_ ::std::tr1
> -# endif // GTEST_TUPLE_NAMESPACE_
> -
> -# if GTEST_USE_OWN_TR1_TUPLE
> -# include "gtest/internal/gtest-tuple.h" // IWYU pragma: export //
> NOLINT
> -# elif GTEST_OS_SYMBIAN
> -
> -// On Symbian, BOOST_HAS_TR1_TUPLE causes Boost's TR1 tuple library to
> -// use STLport's tuple implementation, which unfortunately doesn't
> -// work as the copy of STLport distributed with Symbian is incomplete.
> -// By making sure BOOST_HAS_TR1_TUPLE is undefined, we force Boost to
> -// use its own tuple implementation.
> -# ifdef BOOST_HAS_TR1_TUPLE
> -# undef BOOST_HAS_TR1_TUPLE
> -# endif // BOOST_HAS_TR1_TUPLE
> -
> -// This prevents <boost/tr1/detail/config.hpp>, which defines
> -// BOOST_HAS_TR1_TUPLE, from being #included by Boost's <tuple>.
> -# define BOOST_TR1_DETAIL_CONFIG_HPP_INCLUDED
> -# include <tuple> // IWYU pragma: export // NOLINT
> -
> -# elif defined(__GNUC__) && (GTEST_GCC_VER_ >= 40000)
> -// GCC 4.0+ implements tr1/tuple in the <tr1/tuple> header. This does
> -// not conform to the TR1 spec, which requires the header to be <tuple>.
> -
> -# if !GTEST_HAS_RTTI && GTEST_GCC_VER_ < 40302
> -// Until version 4.3.2, gcc has a bug that causes <tr1/functional>,
> -// which is #included by <tr1/tuple>, to not compile when RTTI is
> -// disabled. _TR1_FUNCTIONAL is the header guard for
> -// <tr1/functional>. Hence the following #define is used to prevent
> -// <tr1/functional> from being included.
> -# define _TR1_FUNCTIONAL 1
> -# include <tr1/tuple>
> -# undef _TR1_FUNCTIONAL // Allows the user to #include
> - // <tr1/functional> if they choose to.
> -# else
> -# include <tr1/tuple> // NOLINT
> -# endif // !GTEST_HAS_RTTI && GTEST_GCC_VER_ < 40302
> -
> -// VS 2010 now has tr1 support.
> -# elif _MSC_VER >= 1600
> -# include <tuple> // IWYU pragma: export // NOLINT
> -
> -# else // GTEST_USE_OWN_TR1_TUPLE
> -# include <tr1/tuple> // IWYU pragma: export // NOLINT
> -# endif // GTEST_USE_OWN_TR1_TUPLE
> -
> -#endif // GTEST_HAS_TR1_TUPLE
> -
> // Determines whether clone(2) is supported.
> // Usually it will only be available on Linux, excluding
> // Linux on the Itanium architecture.
> @@ -812,24 +582,21 @@ typedef struct _RTL_CRITICAL_SECTION
> GTEST_CRITICAL_SECTION;
> #ifndef GTEST_HAS_STREAM_REDIRECTION
> // By default, we assume that stream redirection is supported on all
> // platforms except known mobile ones.
> -# if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_SYMBIAN || \
> - GTEST_OS_WINDOWS_PHONE || GTEST_OS_WINDOWS_RT
> +# if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_WINDOWS_PHONE ||
> GTEST_OS_WINDOWS_RT
> # define GTEST_HAS_STREAM_REDIRECTION 0
> # else
> # define GTEST_HAS_STREAM_REDIRECTION 1
> -# endif // !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_SYMBIAN
> +# endif // !GTEST_OS_WINDOWS_MOBILE
> #endif // GTEST_HAS_STREAM_REDIRECTION
>
> // Determines whether to support death tests.
> -// Google Test does not support death tests for VC 7.1 and earlier as
> -// abort() in a VC 7.1 application compiled as GUI in debug config
> // pops up a dialog window that cannot be suppressed programmatically.
> -#if (GTEST_OS_LINUX || GTEST_OS_CYGWIN || GTEST_OS_SOLARIS || \
> - (GTEST_OS_MAC && !GTEST_OS_IOS) || \
> - (GTEST_OS_WINDOWS_DESKTOP && _MSC_VER >= 1400) || \
> - GTEST_OS_WINDOWS_MINGW || GTEST_OS_AIX || GTEST_OS_HPUX || \
> - GTEST_OS_OPENBSD || GTEST_OS_QNX || GTEST_OS_FREEBSD || \
> - GTEST_OS_NETBSD || GTEST_OS_FUCHSIA)
> +#if (GTEST_OS_LINUX || GTEST_OS_CYGWIN || GTEST_OS_SOLARIS ||
> \
> + (GTEST_OS_MAC && !GTEST_OS_IOS) ||
> \
> + (GTEST_OS_WINDOWS_DESKTOP && _MSC_VER) || GTEST_OS_WINDOWS_MINGW ||
> \
> + GTEST_OS_AIX || GTEST_OS_HPUX || GTEST_OS_OPENBSD || GTEST_OS_QNX ||
> \
> + GTEST_OS_FREEBSD || GTEST_OS_NETBSD || GTEST_OS_FUCHSIA ||
> \
> + GTEST_OS_DRAGONFLY || GTEST_OS_GNU_KFREEBSD || GTEST_OS_HAIKU)
> # define GTEST_HAS_DEATH_TEST 1
> #endif
>
> @@ -837,26 +604,19 @@ typedef struct _RTL_CRITICAL_SECTION
> GTEST_CRITICAL_SECTION;
>
> // Typed tests need <typeinfo> and variadic macros, which GCC, VC++ 8.0,
> // Sun Pro CC, IBM Visual Age, and HP aCC support.
> -#if defined(__GNUC__) || (_MSC_VER >= 1400) || defined(__SUNPRO_CC) || \
> +#if defined(__GNUC__) || defined(_MSC_VER) || defined(__SUNPRO_CC) || \
> defined(__IBMCPP__) || defined(__HP_aCC)
> # define GTEST_HAS_TYPED_TEST 1
> # define GTEST_HAS_TYPED_TEST_P 1
> #endif
>
> -// Determines whether to support Combine(). This only makes sense when
> -// value-parameterized tests are enabled. The implementation doesn't
> -// work on Sun Studio since it doesn't understand templated conversion
> -// operators.
> -#if (GTEST_HAS_TR1_TUPLE || GTEST_HAS_STD_TUPLE_) && !defined(__SUNPRO_CC)
> -# define GTEST_HAS_COMBINE 1
> -#endif
> -
> // Determines whether the system compiler uses UTF-16 for encoding wide
> strings.
> #define GTEST_WIDE_STRING_USES_UTF16_ \
> - (GTEST_OS_WINDOWS || GTEST_OS_CYGWIN || GTEST_OS_SYMBIAN ||
> GTEST_OS_AIX)
> + (GTEST_OS_WINDOWS || GTEST_OS_CYGWIN || GTEST_OS_AIX || GTEST_OS_OS2)
>
> // Determines whether test results can be streamed to a socket.
> -#if GTEST_OS_LINUX
> +#if GTEST_OS_LINUX || GTEST_OS_GNU_KFREEBSD || GTEST_OS_DRAGONFLY || \
> + GTEST_OS_FREEBSD || GTEST_OS_NETBSD || GTEST_OS_OPENBSD
> # define GTEST_CAN_STREAM_RESULTS_ 1
> #endif
>
> @@ -898,12 +658,6 @@ typedef struct _RTL_CRITICAL_SECTION
> GTEST_CRITICAL_SECTION;
> # define GTEST_ATTRIBUTE_UNUSED_
> #endif
>
> -#if GTEST_LANG_CXX11
> -# define GTEST_CXX11_EQUALS_DELETE_ = delete
> -#else // GTEST_LANG_CXX11
> -# define GTEST_CXX11_EQUALS_DELETE_
> -#endif // GTEST_LANG_CXX11
> -
> // Use this annotation before a function that takes a printf format
> string.
> #if (defined(__GNUC__) || defined(__clang__)) && !defined(COMPILER_ICC)
> # if defined(__MINGW_PRINTF_FORMAT)
> @@ -925,12 +679,12 @@ typedef struct _RTL_CRITICAL_SECTION
> GTEST_CRITICAL_SECTION;
> // A macro to disallow operator=
> // This should be used in the private: declarations for a class.
> #define GTEST_DISALLOW_ASSIGN_(type) \
> - void operator=(type const &) GTEST_CXX11_EQUALS_DELETE_
> + void operator=(type const &) = delete
>
> // A macro to disallow copy constructor and operator=
> // This should be used in the private: declarations for a class.
> #define GTEST_DISALLOW_COPY_AND_ASSIGN_(type) \
> - type(type const &) GTEST_CXX11_EQUALS_DELETE_; \
> + type(type const &) = delete; \
> GTEST_DISALLOW_ASSIGN_(type)
>
> // Tell the compiler to warn about unused return values for functions
> declared
> @@ -938,11 +692,11 @@ typedef struct _RTL_CRITICAL_SECTION
> GTEST_CRITICAL_SECTION;
> // following the argument list:
> //
> // Sprocket* AllocateSprocket() GTEST_MUST_USE_RESULT_;
> -#if defined(__GNUC__) && (GTEST_GCC_VER_ >= 30400) &&
> !defined(COMPILER_ICC)
> +#if defined(__GNUC__) && !defined(COMPILER_ICC)
> # define GTEST_MUST_USE_RESULT_ __attribute__ ((warn_unused_result))
> #else
> # define GTEST_MUST_USE_RESULT_
> -#endif // __GNUC__ && (GTEST_GCC_VER_ >= 30400) && !COMPILER_ICC
> +#endif // __GNUC__ && !COMPILER_ICC
>
> // MS C++ compiler emits warning when a conditional expression is compile
> time
> // constant. In some contexts this warning is false positive and needs to
> be
> @@ -971,13 +725,17 @@ typedef struct _RTL_CRITICAL_SECTION
> GTEST_CRITICAL_SECTION;
> # define GTEST_HAS_SEH 0
> # endif
>
> -#define GTEST_IS_THREADSAFE \
> - (GTEST_HAS_MUTEX_AND_THREAD_LOCAL_ \
> - || (GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE &&
> !GTEST_OS_WINDOWS_RT) \
> - || GTEST_HAS_PTHREAD)
> -
> #endif // GTEST_HAS_SEH
>
> +#ifndef GTEST_IS_THREADSAFE
> +
> +#define GTEST_IS_THREADSAFE
> \
> + (GTEST_HAS_MUTEX_AND_THREAD_LOCAL_ ||
> \
> + (GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT)
> || \
> + GTEST_HAS_PTHREAD)
> +
> +#endif // GTEST_IS_THREADSAFE
> +
> // GTEST_API_ qualifies all symbols that must be exported. The
> definitions below
> // are guarded by #ifndef to give embedders a chance to define GTEST_API_
> in
> // gtest/internal/custom/gtest-port.h
> @@ -1044,6 +802,18 @@ typedef struct _RTL_CRITICAL_SECTION
> GTEST_CRITICAL_SECTION;
> # define GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
> #endif // __clang__
>
> +// A function level attribute to disable HWAddressSanitizer
> instrumentation.
> +#if defined(__clang__)
> +# if __has_feature(hwaddress_sanitizer)
> +# define GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_ \
> + __attribute__((no_sanitize("hwaddress")))
> +# else
> +# define GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_
> +# endif // __has_feature(hwaddress_sanitizer)
> +#else
> +# define GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_
> +#endif // __clang__
> +
> // A function level attribute to disable ThreadSanitizer instrumentation.
> #if defined(__clang__)
> # if __has_feature(thread_sanitizer)
> @@ -1060,16 +830,13 @@ namespace testing {
>
> class Message;
>
> -#if defined(GTEST_TUPLE_NAMESPACE_)
> -// Import tuple and friends into the ::testing namespace.
> -// It is part of our interface, having them in ::testing allows us to
> change
> -// their types as needed.
> -using GTEST_TUPLE_NAMESPACE_::get;
> -using GTEST_TUPLE_NAMESPACE_::make_tuple;
> -using GTEST_TUPLE_NAMESPACE_::tuple;
> -using GTEST_TUPLE_NAMESPACE_::tuple_size;
> -using GTEST_TUPLE_NAMESPACE_::tuple_element;
> -#endif // defined(GTEST_TUPLE_NAMESPACE_)
> +// Legacy imports for backwards compatibility.
> +// New code should use std:: names directly.
> +using std::get;
> +using std::make_tuple;
> +using std::tuple;
> +using std::tuple_element;
> +using std::tuple_size;
>
> namespace internal {
>
> @@ -1078,158 +845,24 @@ namespace internal {
> // Secret object, which is what we want.
> class Secret;
>
> -// The GTEST_COMPILE_ASSERT_ macro can be used to verify that a compile
> time
> -// expression is true. For example, you could use it to verify the
> -// size of a static array:
> +// The GTEST_COMPILE_ASSERT_ is a legacy macro used to verify that a
> compile
> +// time expression is true (in new code, use static_assert instead). For
> +// example, you could use it to verify the size of a static array:
> //
> // GTEST_COMPILE_ASSERT_(GTEST_ARRAY_SIZE_(names) == NUM_NAMES,
> // names_incorrect_size);
> //
> -// or to make sure a struct is smaller than a certain size:
> -//
> -// GTEST_COMPILE_ASSERT_(sizeof(foo) < 128, foo_too_large);
> -//
> -// The second argument to the macro is the name of the variable. If
> -// the expression is false, most compilers will issue a warning/error
> -// containing the name of the variable.
> -
> -#if GTEST_LANG_CXX11
> -# define GTEST_COMPILE_ASSERT_(expr, msg) static_assert(expr, #msg)
> -#else // !GTEST_LANG_CXX11
> -template <bool>
> - struct CompileAssert {
> -};
> -
> -# define GTEST_COMPILE_ASSERT_(expr, msg) \
> - typedef ::testing::internal::CompileAssert<(static_cast<bool>(expr))> \
> - msg[static_cast<bool>(expr) ? 1 : -1] GTEST_ATTRIBUTE_UNUSED_
> -#endif // !GTEST_LANG_CXX11
> -
> -// Implementation details of GTEST_COMPILE_ASSERT_:
> -//
> -// (In C++11, we simply use static_assert instead of the following)
> -//
> -// - GTEST_COMPILE_ASSERT_ works by defining an array type that has -1
> -// elements (and thus is invalid) when the expression is false.
> -//
> -// - The simpler definition
> -//
> -// #define GTEST_COMPILE_ASSERT_(expr, msg) typedef char msg[(expr) ?
> 1 : -1]
> -//
> -// does not work, as gcc supports variable-length arrays whose sizes
> -// are determined at run-time (this is gcc's extension and not part
> -// of the C++ standard). As a result, gcc fails to reject the
> -// following code with the simple definition:
> -//
> -// int foo;
> -// GTEST_COMPILE_ASSERT_(foo, msg); // not supposed to compile as foo
> is
> -// // not a compile-time constant.
> -//
> -// - By using the type CompileAssert<(bool(expr))>, we ensures that
> -// expr is a compile-time constant. (Template arguments must be
> -// determined at compile-time.)
> -//
> -// - The outter parentheses in CompileAssert<(bool(expr))> are necessary
> -// to work around a bug in gcc 3.4.4 and 4.0.1. If we had written
> -//
> -// CompileAssert<bool(expr)>
> -//
> -// instead, these compilers will refuse to compile
> -//
> -// GTEST_COMPILE_ASSERT_(5 > 0, some_message);
> -//
> -// (They seem to think the ">" in "5 > 0" marks the end of the
> -// template argument list.)
> -//
> -// - The array size is (bool(expr) ? 1 : -1), instead of simply
> -//
> -// ((expr) ? 1 : -1).
> -//
> -// This is to avoid running into a bug in MS VC 7.1, which
> -// causes ((0.0) ? 1 : -1) to incorrectly evaluate to 1.
> -
> -// StaticAssertTypeEqHelper is used by StaticAssertTypeEq defined in
> gtest.h.
> -//
> -// This template is declared, but intentionally undefined.
> -template <typename T1, typename T2>
> -struct StaticAssertTypeEqHelper;
> -
> -template <typename T>
> -struct StaticAssertTypeEqHelper<T, T> {
> - enum { value = true };
> -};
> -
> -// Same as std::is_same<>.
> -template <typename T, typename U>
> -struct IsSame {
> - enum { value = false };
> -};
> -template <typename T>
> -struct IsSame<T, T> {
> - enum { value = true };
> -};
> +// The second argument to the macro must be a valid C++ identifier. If the
> +// expression is false, compiler will issue an error containing this
> identifier.
> +#define GTEST_COMPILE_ASSERT_(expr, msg) static_assert(expr, #msg)
>
> // Evaluates to the number of elements in 'array'.
> #define GTEST_ARRAY_SIZE_(array) (sizeof(array) / sizeof(array[0]))
>
> -#if GTEST_HAS_GLOBAL_STRING
> -typedef ::string string;
> -#else
> -typedef ::std::string string;
> -#endif // GTEST_HAS_GLOBAL_STRING
> -
> -#if GTEST_HAS_GLOBAL_WSTRING
> -typedef ::wstring wstring;
> -#elif GTEST_HAS_STD_WSTRING
> -typedef ::std::wstring wstring;
> -#endif // GTEST_HAS_GLOBAL_WSTRING
> -
> // A helper for suppressing warnings on constant condition. It just
> // returns 'condition'.
> GTEST_API_ bool IsTrue(bool condition);
>
> -// Defines scoped_ptr.
> -
> -// This implementation of scoped_ptr is PARTIAL - it only contains
> -// enough stuff to satisfy Google Test's need.
> -template <typename T>
> -class scoped_ptr {
> - public:
> - typedef T element_type;
> -
> - explicit scoped_ptr(T* p = NULL) : ptr_(p) {}
> - ~scoped_ptr() { reset(); }
> -
> - T& operator*() const { return *ptr_; }
> - T* operator->() const { return ptr_; }
> - T* get() const { return ptr_; }
> -
> - T* release() {
> - T* const ptr = ptr_;
> - ptr_ = NULL;
> - return ptr;
> - }
> -
> - void reset(T* p = NULL) {
> - if (p != ptr_) {
> - if (IsTrue(sizeof(T) > 0)) { // Makes sure T is a complete type.
> - delete ptr_;
> - }
> - ptr_ = p;
> - }
> - }
> -
> - friend void swap(scoped_ptr& a, scoped_ptr& b) {
> - using std::swap;
> - swap(a.ptr_, b.ptr_);
> - }
> -
> - private:
> - T* ptr_;
> -
> - GTEST_DISALLOW_COPY_AND_ASSIGN_(scoped_ptr);
> -};
> -
> // Defines RE.
>
> #if GTEST_USES_PCRE
> @@ -1247,25 +880,16 @@ class GTEST_API_ RE {
> // Constructs an RE from a string.
> RE(const ::std::string& regex) { Init(regex.c_str()); } // NOLINT
>
> -# if GTEST_HAS_GLOBAL_STRING
> -
> - RE(const ::string& regex) { Init(regex.c_str()); } // NOLINT
> -
> -# endif // GTEST_HAS_GLOBAL_STRING
> -
> RE(const char* regex) { Init(regex); } // NOLINT
> ~RE();
>
> // Returns the string representation of the regex.
> const char* pattern() const { return pattern_; }
>
> - // FullMatch(str, re) returns true iff regular expression re matches
> - // the entire str.
> - // PartialMatch(str, re) returns true iff regular expression re
> + // FullMatch(str, re) returns true if and only if regular expression re
> + // matches the entire str.
> + // PartialMatch(str, re) returns true if and only if regular expression
> re
> // matches a substring of str (including str itself).
> - //
> - // FIXME: make FullMatch() and PartialMatch() work
> - // when str contains NUL characters.
> static bool FullMatch(const ::std::string& str, const RE& re) {
> return FullMatch(str.c_str(), re);
> }
> @@ -1273,26 +897,11 @@ class GTEST_API_ RE {
> return PartialMatch(str.c_str(), re);
> }
>
> -# if GTEST_HAS_GLOBAL_STRING
> -
> - static bool FullMatch(const ::string& str, const RE& re) {
> - return FullMatch(str.c_str(), re);
> - }
> - static bool PartialMatch(const ::string& str, const RE& re) {
> - return PartialMatch(str.c_str(), re);
> - }
> -
> -# endif // GTEST_HAS_GLOBAL_STRING
> -
> static bool FullMatch(const char* str, const RE& re);
> static bool PartialMatch(const char* str, const RE& re);
>
> private:
> void Init(const char* regex);
> -
> - // We use a const char* instead of an std::string, as Google Test used
> to be
> - // used where std::string is not available. FIXME: change to
> - // std::string.
> const char* pattern_;
> bool is_valid_;
>
> @@ -1360,7 +969,7 @@ class GTEST_API_ GTestLog {
> __FILE__, __LINE__).GetStream()
>
> inline void LogToStderr() {}
> -inline void FlushInfoLog() { fflush(NULL); }
> +inline void FlushInfoLog() { fflush(nullptr); }
>
> #endif // !defined(GTEST_LOG_)
>
> @@ -1397,19 +1006,6 @@ inline void FlushInfoLog() { fflush(NULL); }
> GTEST_LOG_(FATAL) << #posix_call << "failed with error " \
> << gtest_error
>
> -// Adds reference to a type if it is not a reference type,
> -// otherwise leaves it unchanged. This is the same as
> -// tr1::add_reference, which is not widely available yet.
> -template <typename T>
> -struct AddReference { typedef T& type; }; // NOLINT
> -template <typename T>
> -struct AddReference<T&> { typedef T& type; }; // NOLINT
> -
> -// A handy wrapper around AddReference that works when the argument T
> -// depends on template parameters.
> -#define GTEST_ADD_REFERENCE_(T) \
> - typename ::testing::internal::AddReference<T>::type
> -
> // Transforms "T" into "const T&" according to standard reference
> collapsing
> // rules (this is only needed as a backport for C++98 compilers that do
> not
> // support reference collapsing). Specifically, it transforms:
> @@ -1430,28 +1026,6 @@ struct ConstRef<T&> { typedef T& type; };
> #define GTEST_REFERENCE_TO_CONST_(T) \
> typename ::testing::internal::ConstRef<T>::type
>
> -#if GTEST_HAS_STD_MOVE_
> -using std::forward;
> -using std::move;
> -
> -template <typename T>
> -struct RvalueRef {
> - typedef T&& type;
> -};
> -#else // GTEST_HAS_STD_MOVE_
> -template <typename T>
> -const T& move(const T& t) {
> - return t;
> -}
> -template <typename T>
> -GTEST_ADD_REFERENCE_(T) forward(GTEST_ADD_REFERENCE_(T) t) { return t; }
> -
> -template <typename T>
> -struct RvalueRef {
> - typedef const T& type;
> -};
> -#endif // GTEST_HAS_STD_MOVE_
> -
> // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
> //
> // Use ImplicitCast_ as a safe version of static_cast for upcasting in
> @@ -1505,13 +1079,13 @@ inline To DownCast_(From* f) { // so we only
> accept pointers
> GTEST_INTENTIONAL_CONST_COND_PUSH_()
> if (false) {
> GTEST_INTENTIONAL_CONST_COND_POP_()
> - const To to = NULL;
> - ::testing::internal::ImplicitCast_<From*>(to);
> + const To to = nullptr;
> + ::testing::internal::ImplicitCast_<From*>(to);
> }
>
> #if GTEST_HAS_RTTI
> // RTTI: debug mode only!
> - GTEST_CHECK_(f == NULL || dynamic_cast<To>(f) != NULL);
> + GTEST_CHECK_(f == nullptr || dynamic_cast<To>(f) != nullptr);
> #endif
> return static_cast<To>(f);
> }
> @@ -1565,9 +1139,6 @@ std::vector<std::string> GetInjectableArgvs();
> // Deprecated: pass the args vector by value instead.
> void SetInjectableArgvs(const std::vector<std::string>* new_argvs);
> void SetInjectableArgvs(const std::vector<std::string>& new_argvs);
> -#if GTEST_HAS_GLOBAL_STRING
> -void SetInjectableArgvs(const std::vector< ::string>& new_argvs);
> -#endif // GTEST_HAS_GLOBAL_STRING
> void ClearInjectableArgvs();
>
> #endif // GTEST_HAS_DEATH_TEST
> @@ -1583,7 +1154,7 @@ inline void SleepMilliseconds(int n) {
> 0, // 0 seconds.
> n * 1000L * 1000L, // And n ms.
> };
> - nanosleep(&time, NULL);
> + nanosleep(&time, nullptr);
> }
> # endif // GTEST_HAS_PTHREAD
>
> @@ -1601,7 +1172,7 @@ inline void SleepMilliseconds(int n) {
> class Notification {
> public:
> Notification() : notified_(false) {
> - GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_, NULL));
> + GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_, nullptr));
> }
> ~Notification() {
> pthread_mutex_destroy(&mutex_);
> @@ -1659,7 +1230,8 @@ class GTEST_API_ AutoHandle {
> void Reset(Handle handle);
>
> private:
> - // Returns true iff the handle is a valid handle object that can be
> closed.
> + // Returns true if and only if the handle is a valid handle object that
> can be
> + // closed.
> bool IsCloseable() const;
>
> Handle handle_;
> @@ -1710,7 +1282,7 @@ class ThreadWithParamBase {
> // pass into pthread_create().
> extern "C" inline void* ThreadFuncWithCLinkage(void* thread) {
> static_cast<ThreadWithParamBase*>(thread)->Run();
> - return NULL;
> + return nullptr;
> }
>
> // Helper class for testing Google Test's multi-threading constructs.
> @@ -1739,20 +1311,19 @@ class ThreadWithParam : public ThreadWithParamBase
> {
> // The thread can be created only after all fields except thread_
> // have been initialized.
> GTEST_CHECK_POSIX_SUCCESS_(
> - pthread_create(&thread_, 0, &ThreadFuncWithCLinkage, base));
> + pthread_create(&thread_, nullptr, &ThreadFuncWithCLinkage, base));
> }
> - ~ThreadWithParam() { Join(); }
> + ~ThreadWithParam() override { Join(); }
>
> void Join() {
> if (!finished_) {
> - GTEST_CHECK_POSIX_SUCCESS_(pthread_join(thread_, 0));
> + GTEST_CHECK_POSIX_SUCCESS_(pthread_join(thread_, nullptr));
> finished_ = true;
> }
> }
>
> - virtual void Run() {
> - if (thread_can_start_ != NULL)
> - thread_can_start_->WaitForNotification();
> + void Run() override {
> + if (thread_can_start_ != nullptr)
> thread_can_start_->WaitForNotification();
> func_(param_);
> }
>
> @@ -1762,7 +1333,8 @@ class ThreadWithParam : public ThreadWithParamBase {
> // When non-NULL, used to block execution until the controller thread
> // notifies.
> Notification* const thread_can_start_;
> - bool finished_; // true iff we know that the thread function has
> finished.
> + bool finished_; // true if and only if we know that the thread
> function has
> + // finished.
> pthread_t thread_; // The native thread object.
>
> GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadWithParam);
> @@ -2046,7 +1618,7 @@ class ThreadLocal : public ThreadLocalBase {
> GTEST_DISALLOW_COPY_AND_ASSIGN_(InstanceValueHolderFactory);
> };
>
> - scoped_ptr<ValueHolderFactory> default_factory_;
> + std::unique_ptr<ValueHolderFactory> default_factory_;
>
> GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadLocal);
> };
> @@ -2115,7 +1687,7 @@ class MutexBase {
> class Mutex : public MutexBase {
> public:
> Mutex() {
> - GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_, NULL));
> + GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_, nullptr));
> has_owner_ = false;
> }
> ~Mutex() {
> @@ -2213,7 +1785,7 @@ class GTEST_API_ ThreadLocal {
> T* GetOrCreateValue() const {
> ThreadLocalValueHolderBase* const holder =
>
> static_cast<ThreadLocalValueHolderBase*>(pthread_getspecific(key_));
> - if (holder != NULL) {
> + if (holder != nullptr) {
> return CheckedDowncastToActualType<ValueHolder>(holder)->pointer();
> }
>
> @@ -2257,7 +1829,7 @@ class GTEST_API_ ThreadLocal {
>
> // A key pthreads uses for looking up per-thread values.
> const pthread_key_t key_;
> - scoped_ptr<ValueHolderFactory> default_factory_;
> + std::unique_ptr<ValueHolderFactory> default_factory_;
>
> GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadLocal);
> };
> @@ -2315,67 +1887,8 @@ class GTEST_API_ ThreadLocal {
> // we cannot detect it.
> GTEST_API_ size_t GetThreadCount();
>
> -// Passing non-POD classes through ellipsis (...) crashes the ARM
> -// compiler and generates a warning in Sun Studio before 12u4. The Nokia
> Symbian
> -// and the IBM XL C/C++ compiler try to instantiate a copy constructor
> -// for objects passed through ellipsis (...), failing for uncopyable
> -// objects. We define this to ensure that only POD is passed through
> -// ellipsis on these systems.
> -#if defined(__SYMBIAN32__) || defined(__IBMCPP__) || \
> - (defined(__SUNPRO_CC) && __SUNPRO_CC < 0x5130)
> -// We lose support for NULL detection where the compiler doesn't like
> -// passing non-POD classes through ellipsis (...).
> -# define GTEST_ELLIPSIS_NEEDS_POD_ 1
> -#else
> -# define GTEST_CAN_COMPARE_NULL 1
> -#endif
> -
> -// The Nokia Symbian and IBM XL C/C++ compilers cannot decide between
> -// const T& and const T* in a function template. These compilers
> -// _can_ decide between class template specializations for T and T*,
> -// so a tr1::type_traits-like is_pointer works.
> -#if defined(__SYMBIAN32__) || defined(__IBMCPP__)
> -# define GTEST_NEEDS_IS_POINTER_ 1
> -#endif
> -
> -template <bool bool_value>
> -struct bool_constant {
> - typedef bool_constant<bool_value> type;
> - static const bool value = bool_value;
> -};
> -template <bool bool_value> const bool bool_constant<bool_value>::value;
> -
> -typedef bool_constant<false> false_type;
> -typedef bool_constant<true> true_type;
> -
> -template <typename T, typename U>
> -struct is_same : public false_type {};
> -
> -template <typename T>
> -struct is_same<T, T> : public true_type {};
> -
> -
> -template <typename T>
> -struct is_pointer : public false_type {};
> -
> -template <typename T>
> -struct is_pointer<T*> : public true_type {};
> -
> -template <typename Iterator>
> -struct IteratorTraits {
> - typedef typename Iterator::value_type value_type;
> -};
> -
> -
> -template <typename T>
> -struct IteratorTraits<T*> {
> - typedef T value_type;
> -};
> -
> -template <typename T>
> -struct IteratorTraits<const T*> {
> - typedef T value_type;
> -};
> +template <bool B>
> +using bool_constant = std::integral_constant<bool, B>;
>
> #if GTEST_OS_WINDOWS
> # define GTEST_PATH_SEP_ "\\"
> @@ -2535,12 +2048,12 @@ inline const char* GetEnv(const char* name) {
> #if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_WINDOWS_PHONE ||
> GTEST_OS_WINDOWS_RT
> // We are on Windows CE, which has no environment variables.
> static_cast<void>(name); // To prevent 'unused argument' warning.
> - return NULL;
> + return nullptr;
> #elif defined(__BORLANDC__) || defined(__SunOS_5_8) ||
> defined(__SunOS_5_9)
> // Environment variables which we programmatically clear will be set to
> the
> // empty string rather than unset (NULL). Handle that case.
> const char* const env = getenv(name);
> - return (env != NULL && env[0] != '\0') ? env : NULL;
> + return (env != nullptr && env[0] != '\0') ? env : nullptr;
> #else
> return getenv(name);
> #endif
> @@ -2552,9 +2065,9 @@ GTEST_DISABLE_MSC_DEPRECATED_POP_()
> // Windows CE has no C library. The abort() function is used in
> // several places in Google Test. This implementation provides a
> reasonable
> // imitation of standard behaviour.
> -void Abort();
> +[[noreturn]] void Abort();
> #else
> -inline void Abort() { abort(); }
> +[[noreturn]] inline void Abort() { abort(); }
> #endif // GTEST_OS_WINDOWS_MOBILE
>
> } // namespace posix
> @@ -2564,13 +2077,12 @@ inline void Abort() { abort(); }
> // MSVC-based platforms. We map the GTEST_SNPRINTF_ macro to the
> appropriate
> // function in order to achieve that. We use macro definition here
> because
> // snprintf is a variadic function.
> -#if _MSC_VER >= 1400 && !GTEST_OS_WINDOWS_MOBILE
> +#if _MSC_VER && !GTEST_OS_WINDOWS_MOBILE
> // MSVC 2005 and above support variadic macros.
> # define GTEST_SNPRINTF_(buffer, size, format, ...) \
> _snprintf_s(buffer, size, size, format, __VA_ARGS__)
> #elif defined(_MSC_VER)
> -// Windows CE does not define _snprintf_s and MSVC prior to 2005 doesn't
> -// complain about _snprintf.
> +// Windows CE does not define _snprintf_s
> # define GTEST_SNPRINTF_ _snprintf
> #else
> # define GTEST_SNPRINTF_ snprintf
> @@ -2684,9 +2196,6 @@ typedef TypeWithSize<8>::Int TimeInMillis; //
> Represents time in milliseconds.
> // Parses 'str' for a 32-bit signed integer. If successful, writes the
> result
> // to *value and returns true; otherwise leaves *value unchanged and
> returns
> // false.
> -// FIXME: Find a better way to refactor flag and environment parsing
> -// out of both gtest-port.cc and gtest.cc to avoid exporting this utility
> -// function.
> bool ParseInt32(const Message& src_text, const char* str, Int32* value);
>
> // Parses a bool/Int32/string from the environment variable
> @@ -2699,4 +2208,24 @@ const char* StringFromGTestEnv(const char* flag,
> const char* default_val);
> } // namespace internal
> } // namespace testing
>
> +#if !defined(GTEST_INTERNAL_DEPRECATED)
> +
> +// Internal Macro to mark an API deprecated, for googletest usage only
> +// Usage: class GTEST_INTERNAL_DEPRECATED(message) MyClass or
> +// GTEST_INTERNAL_DEPRECATED(message) <return_type> myFunction(); Every
> usage of
> +// a deprecated entity will trigger a warning when compiled with
> +// `-Wdeprecated-declarations` option (clang, gcc, any __GNUC__ compiler).
> +// For msvc /W3 option will need to be used
> +// Note that for 'other' compilers this macro evaluates to nothing to
> prevent
> +// compilations errors.
> +#if defined(_MSC_VER)
> +#define GTEST_INTERNAL_DEPRECATED(message) __declspec(deprecated(message))
> +#elif defined(__GNUC__)
> +#define GTEST_INTERNAL_DEPRECATED(message)
> __attribute__((deprecated(message)))
> +#else
> +#define GTEST_INTERNAL_DEPRECATED(message)
> +#endif
> +
> +#endif // !defined(GTEST_INTERNAL_DEPRECATED)
> +
> #endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_
>
> diff --git
> a/llvm/utils/unittest/googletest/include/gtest/internal/gtest-string.h
> b/llvm/utils/unittest/googletest/include/gtest/internal/gtest-string.h
> index 4c9b6262c3c10..82aaa63bf4657 100644
> --- a/llvm/utils/unittest/googletest/include/gtest/internal/gtest-string.h
> +++ b/llvm/utils/unittest/googletest/include/gtest/internal/gtest-string.h
> @@ -94,7 +94,8 @@ class GTEST_API_ String {
> static const char* Utf16ToAnsi(LPCWSTR utf16_str);
> #endif
>
> - // Compares two C strings. Returns true iff they have the same content.
> + // Compares two C strings. Returns true if and only if they have the
> same
> + // content.
> //
> // Unlike strcmp(), this function can handle NULL argument(s). A
> // NULL C string is considered
> diff erent to any non-NULL C string,
> @@ -107,16 +108,16 @@ class GTEST_API_ String {
> // returned.
> static std::string ShowWideCString(const wchar_t* wide_c_str);
>
> - // Compares two wide C strings. Returns true iff they have the same
> - // content.
> + // Compares two wide C strings. Returns true if and only if they have
> the
> + // same content.
> //
> // Unlike wcscmp(), this function can handle NULL argument(s). A
> // NULL C string is considered
> diff erent to any non-NULL C string,
> // including the empty string.
> static bool WideCStringEquals(const wchar_t* lhs, const wchar_t* rhs);
>
> - // Compares two C strings, ignoring case. Returns true iff they
> - // have the same content.
> + // Compares two C strings, ignoring case. Returns true if and only if
> + // they have the same content.
> //
> // Unlike strcasecmp(), this function can handle NULL argument(s).
> // A NULL C string is considered
> diff erent to any non-NULL C string,
> @@ -124,8 +125,8 @@ class GTEST_API_ String {
> static bool CaseInsensitiveCStringEquals(const char* lhs,
> const char* rhs);
>
> - // Compares two wide C strings, ignoring case. Returns true iff they
> - // have the same content.
> + // Compares two wide C strings, ignoring case. Returns true if and
> only if
> + // they have the same content.
> //
> // Unlike wcscasecmp(), this function can handle NULL argument(s).
> // A NULL C string is considered
> diff erent to any non-NULL wide C string,
> @@ -139,8 +140,8 @@ class GTEST_API_ String {
> static bool CaseInsensitiveWideCStringEquals(const wchar_t* lhs,
> const wchar_t* rhs);
>
> - // Returns true iff the given string ends with the given suffix,
> ignoring
> - // case. Any string is considered to end with an empty suffix.
> + // Returns true if and only if the given string ends with the given
> suffix,
> + // ignoring case. Any string is considered to end with an empty suffix.
> static bool EndsWithCaseInsensitive(
> const std::string& str, const std::string& suffix);
>
> @@ -150,6 +151,9 @@ class GTEST_API_ String {
> // Formats an int value as "%X".
> static std::string FormatHexInt(int value);
>
> + // Formats an int value as "%X".
> + static std::string FormatHexUInt32(UInt32 value);
> +
> // Formats a byte as "%02X".
> static std::string FormatByte(unsigned char value);
>
>
> diff --git
> a/llvm/utils/unittest/googletest/include/gtest/internal/gtest-tuple.h
> b/llvm/utils/unittest/googletest/include/gtest/internal/gtest-tuple.h
> deleted file mode 100644
> index 78a3a6a01fac7..0000000000000
> --- a/llvm/utils/unittest/googletest/include/gtest/internal/gtest-tuple.h
> +++ /dev/null
> @@ -1,1021 +0,0 @@
> -// This file was GENERATED by command:
> -// pump.py gtest-tuple.h.pump
> -// DO NOT EDIT BY HAND!!!
> -
> -// Copyright 2009 Google Inc.
> -// All Rights Reserved.
> -//
> -// Redistribution and use in source and binary forms, with or without
> -// modification, are permitted provided that the following conditions are
> -// met:
> -//
> -// * Redistributions of source code must retain the above copyright
> -// notice, this list of conditions and the following disclaimer.
> -// * Redistributions in binary form must reproduce the above
> -// copyright notice, this list of conditions and the following disclaimer
> -// in the documentation and/or other materials provided with the
> -// distribution.
> -// * Neither the name of Google Inc. nor the names of its
> -// contributors may be used to endorse or promote products derived from
> -// this software without specific prior written permission.
> -//
> -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
> -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
> -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
> -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
> -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
> -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
> -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
> -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
> -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
> -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
> -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
> -
> -
> -// Implements a subset of TR1 tuple needed by Google Test and Google Mock.
> -
> -// GOOGLETEST_CM0001 DO NOT DELETE
> -
> -#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_
> -#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_
> -
> -#include <utility> // For ::std::pair.
> -
> -// The compiler used in Symbian has a bug that prevents us from declaring
> the
> -// tuple template as a friend (it complains that tuple is redefined).
> This
> -// bypasses the bug by declaring the members that should otherwise be
> -// private as public.
> -// Sun Studio versions < 12 also have the above bug.
> -#if defined(__SYMBIAN32__) || (defined(__SUNPRO_CC) && __SUNPRO_CC <
> 0x590)
> -# define GTEST_DECLARE_TUPLE_AS_FRIEND_ public:
> -#else
> -# define GTEST_DECLARE_TUPLE_AS_FRIEND_ \
> - template <GTEST_10_TYPENAMES_(U)> friend class tuple; \
> - private:
> -#endif
> -
> -// Visual Studio 2010, 2012, and 2013 define symbols in std::tr1 that
> conflict
> -// with our own definitions. Therefore using our own tuple does not work
> on
> -// those compilers.
> -#if defined(_MSC_VER) && _MSC_VER >= 1600 /* 1600 is Visual Studio 2010
> */
> -# error "gtest's tuple doesn't compile on Visual Studio 2010 or later. \
> -GTEST_USE_OWN_TR1_TUPLE must be set to 0 on those compilers."
> -#endif
> -
> -// GTEST_n_TUPLE_(T) is the type of an n-tuple.
> -#define GTEST_0_TUPLE_(T) tuple<>
> -#define GTEST_1_TUPLE_(T) tuple<T##0, void, void, void, void, void, void,
> \
> - void, void, void>
> -#define GTEST_2_TUPLE_(T) tuple<T##0, T##1, void, void, void, void, void,
> \
> - void, void, void>
> -#define GTEST_3_TUPLE_(T) tuple<T##0, T##1, T##2, void, void, void, void,
> \
> - void, void, void>
> -#define GTEST_4_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, void, void, void,
> \
> - void, void, void>
> -#define GTEST_5_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, void, void,
> \
> - void, void, void>
> -#define GTEST_6_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, void,
> \
> - void, void, void>
> -#define GTEST_7_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, T##6,
> \
> - void, void, void>
> -#define GTEST_8_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, T##6,
> \
> - T##7, void, void>
> -#define GTEST_9_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, T##6,
> \
> - T##7, T##8, void>
> -#define GTEST_10_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5,
> T##6, \
> - T##7, T##8, T##9>
> -
> -// GTEST_n_TYPENAMES_(T) declares a list of n typenames.
> -#define GTEST_0_TYPENAMES_(T)
> -#define GTEST_1_TYPENAMES_(T) typename T##0
> -#define GTEST_2_TYPENAMES_(T) typename T##0, typename T##1
> -#define GTEST_3_TYPENAMES_(T) typename T##0, typename T##1, typename T##2
> -#define GTEST_4_TYPENAMES_(T) typename T##0, typename T##1, typename
> T##2, \
> - typename T##3
> -#define GTEST_5_TYPENAMES_(T) typename T##0, typename T##1, typename
> T##2, \
> - typename T##3, typename T##4
> -#define GTEST_6_TYPENAMES_(T) typename T##0, typename T##1, typename
> T##2, \
> - typename T##3, typename T##4, typename T##5
> -#define GTEST_7_TYPENAMES_(T) typename T##0, typename T##1, typename
> T##2, \
> - typename T##3, typename T##4, typename T##5, typename T##6
> -#define GTEST_8_TYPENAMES_(T) typename T##0, typename T##1, typename
> T##2, \
> - typename T##3, typename T##4, typename T##5, typename T##6, typename
> T##7
> -#define GTEST_9_TYPENAMES_(T) typename T##0, typename T##1, typename
> T##2, \
> - typename T##3, typename T##4, typename T##5, typename T##6, \
> - typename T##7, typename T##8
> -#define GTEST_10_TYPENAMES_(T) typename T##0, typename T##1, typename
> T##2, \
> - typename T##3, typename T##4, typename T##5, typename T##6, \
> - typename T##7, typename T##8, typename T##9
> -
> -// In theory, defining stuff in the ::std namespace is undefined
> -// behavior. We can do this as we are playing the role of a standard
> -// library vendor.
> -namespace std {
> -namespace tr1 {
> -
> -template <typename T0 = void, typename T1 = void, typename T2 = void,
> - typename T3 = void, typename T4 = void, typename T5 = void,
> - typename T6 = void, typename T7 = void, typename T8 = void,
> - typename T9 = void>
> -class tuple;
> -
> -// Anything in namespace gtest_internal is Google Test's INTERNAL
> -// IMPLEMENTATION DETAIL and MUST NOT BE USED DIRECTLY in user code.
> -namespace gtest_internal {
> -
> -// ByRef<T>::type is T if T is a reference; otherwise it's const T&.
> -template <typename T>
> -struct ByRef { typedef const T& type; }; // NOLINT
> -template <typename T>
> -struct ByRef<T&> { typedef T& type; }; // NOLINT
> -
> -// A handy wrapper for ByRef.
> -#define GTEST_BY_REF_(T) typename
> ::std::tr1::gtest_internal::ByRef<T>::type
> -
> -// AddRef<T>::type is T if T is a reference; otherwise it's T&. This
> -// is the same as tr1::add_reference<T>::type.
> -template <typename T>
> -struct AddRef { typedef T& type; }; // NOLINT
> -template <typename T>
> -struct AddRef<T&> { typedef T& type; }; // NOLINT
> -
> -// A handy wrapper for AddRef.
> -#define GTEST_ADD_REF_(T) typename
> ::std::tr1::gtest_internal::AddRef<T>::type
> -
> -// A helper for implementing get<k>().
> -template <int k> class Get;
> -
> -// A helper for implementing tuple_element<k, T>. kIndexValid is true
> -// iff k < the number of fields in tuple type T.
> -template <bool kIndexValid, int kIndex, class Tuple>
> -struct TupleElement;
> -
> -template <GTEST_10_TYPENAMES_(T)>
> -struct TupleElement<true, 0, GTEST_10_TUPLE_(T) > {
> - typedef T0 type;
> -};
> -
> -template <GTEST_10_TYPENAMES_(T)>
> -struct TupleElement<true, 1, GTEST_10_TUPLE_(T) > {
> - typedef T1 type;
> -};
> -
> -template <GTEST_10_TYPENAMES_(T)>
> -struct TupleElement<true, 2, GTEST_10_TUPLE_(T) > {
> - typedef T2 type;
> -};
> -
> -template <GTEST_10_TYPENAMES_(T)>
> -struct TupleElement<true, 3, GTEST_10_TUPLE_(T) > {
> - typedef T3 type;
> -};
> -
> -template <GTEST_10_TYPENAMES_(T)>
> -struct TupleElement<true, 4, GTEST_10_TUPLE_(T) > {
> - typedef T4 type;
> -};
> -
> -template <GTEST_10_TYPENAMES_(T)>
> -struct TupleElement<true, 5, GTEST_10_TUPLE_(T) > {
> - typedef T5 type;
> -};
> -
> -template <GTEST_10_TYPENAMES_(T)>
> -struct TupleElement<true, 6, GTEST_10_TUPLE_(T) > {
> - typedef T6 type;
> -};
> -
> -template <GTEST_10_TYPENAMES_(T)>
> -struct TupleElement<true, 7, GTEST_10_TUPLE_(T) > {
> - typedef T7 type;
> -};
> -
> -template <GTEST_10_TYPENAMES_(T)>
> -struct TupleElement<true, 8, GTEST_10_TUPLE_(T) > {
> - typedef T8 type;
> -};
> -
> -template <GTEST_10_TYPENAMES_(T)>
> -struct TupleElement<true, 9, GTEST_10_TUPLE_(T) > {
> - typedef T9 type;
> -};
> -
> -} // namespace gtest_internal
> -
> -template <>
> -class tuple<> {
> - public:
> - tuple() {}
> - tuple(const tuple& /* t */) {}
> - tuple& operator=(const tuple& /* t */) { return *this; }
> -};
> -
> -template <GTEST_1_TYPENAMES_(T)>
> -class GTEST_1_TUPLE_(T) {
> - public:
> - template <int k> friend class gtest_internal::Get;
> -
> - tuple() : f0_() {}
> -
> - explicit tuple(GTEST_BY_REF_(T0) f0) : f0_(f0) {}
> -
> - tuple(const tuple& t) : f0_(t.f0_) {}
> -
> - template <GTEST_1_TYPENAMES_(U)>
> - tuple(const GTEST_1_TUPLE_(U)& t) : f0_(t.f0_) {}
> -
> - tuple& operator=(const tuple& t) { return CopyFrom(t); }
> -
> - template <GTEST_1_TYPENAMES_(U)>
> - tuple& operator=(const GTEST_1_TUPLE_(U)& t) {
> - return CopyFrom(t);
> - }
> -
> - GTEST_DECLARE_TUPLE_AS_FRIEND_
> -
> - template <GTEST_1_TYPENAMES_(U)>
> - tuple& CopyFrom(const GTEST_1_TUPLE_(U)& t) {
> - f0_ = t.f0_;
> - return *this;
> - }
> -
> - T0 f0_;
> -};
> -
> -template <GTEST_2_TYPENAMES_(T)>
> -class GTEST_2_TUPLE_(T) {
> - public:
> - template <int k> friend class gtest_internal::Get;
> -
> - tuple() : f0_(), f1_() {}
> -
> - explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1) : f0_(f0),
> - f1_(f1) {}
> -
> - tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_) {}
> -
> - template <GTEST_2_TYPENAMES_(U)>
> - tuple(const GTEST_2_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_) {}
> - template <typename U0, typename U1>
> - tuple(const ::std::pair<U0, U1>& p) : f0_(p.first), f1_(p.second) {}
> -
> - tuple& operator=(const tuple& t) { return CopyFrom(t); }
> -
> - template <GTEST_2_TYPENAMES_(U)>
> - tuple& operator=(const GTEST_2_TUPLE_(U)& t) {
> - return CopyFrom(t);
> - }
> - template <typename U0, typename U1>
> - tuple& operator=(const ::std::pair<U0, U1>& p) {
> - f0_ = p.first;
> - f1_ = p.second;
> - return *this;
> - }
> -
> - GTEST_DECLARE_TUPLE_AS_FRIEND_
> -
> - template <GTEST_2_TYPENAMES_(U)>
> - tuple& CopyFrom(const GTEST_2_TUPLE_(U)& t) {
> - f0_ = t.f0_;
> - f1_ = t.f1_;
> - return *this;
> - }
> -
> - T0 f0_;
> - T1 f1_;
> -};
> -
> -template <GTEST_3_TYPENAMES_(T)>
> -class GTEST_3_TUPLE_(T) {
> - public:
> - template <int k> friend class gtest_internal::Get;
> -
> - tuple() : f0_(), f1_(), f2_() {}
> -
> - explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
> - GTEST_BY_REF_(T2) f2) : f0_(f0), f1_(f1), f2_(f2) {}
> -
> - tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_) {}
> -
> - template <GTEST_3_TYPENAMES_(U)>
> - tuple(const GTEST_3_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_)
> {}
> -
> - tuple& operator=(const tuple& t) { return CopyFrom(t); }
> -
> - template <GTEST_3_TYPENAMES_(U)>
> - tuple& operator=(const GTEST_3_TUPLE_(U)& t) {
> - return CopyFrom(t);
> - }
> -
> - GTEST_DECLARE_TUPLE_AS_FRIEND_
> -
> - template <GTEST_3_TYPENAMES_(U)>
> - tuple& CopyFrom(const GTEST_3_TUPLE_(U)& t) {
> - f0_ = t.f0_;
> - f1_ = t.f1_;
> - f2_ = t.f2_;
> - return *this;
> - }
> -
> - T0 f0_;
> - T1 f1_;
> - T2 f2_;
> -};
> -
> -template <GTEST_4_TYPENAMES_(T)>
> -class GTEST_4_TUPLE_(T) {
> - public:
> - template <int k> friend class gtest_internal::Get;
> -
> - tuple() : f0_(), f1_(), f2_(), f3_() {}
> -
> - explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
> - GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3) : f0_(f0), f1_(f1),
> f2_(f2),
> - f3_(f3) {}
> -
> - tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_)
> {}
> -
> - template <GTEST_4_TYPENAMES_(U)>
> - tuple(const GTEST_4_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
> - f3_(t.f3_) {}
> -
> - tuple& operator=(const tuple& t) { return CopyFrom(t); }
> -
> - template <GTEST_4_TYPENAMES_(U)>
> - tuple& operator=(const GTEST_4_TUPLE_(U)& t) {
> - return CopyFrom(t);
> - }
> -
> - GTEST_DECLARE_TUPLE_AS_FRIEND_
> -
> - template <GTEST_4_TYPENAMES_(U)>
> - tuple& CopyFrom(const GTEST_4_TUPLE_(U)& t) {
> - f0_ = t.f0_;
> - f1_ = t.f1_;
> - f2_ = t.f2_;
> - f3_ = t.f3_;
> - return *this;
> - }
> -
> - T0 f0_;
> - T1 f1_;
> - T2 f2_;
> - T3 f3_;
> -};
> -
> -template <GTEST_5_TYPENAMES_(T)>
> -class GTEST_5_TUPLE_(T) {
> - public:
> - template <int k> friend class gtest_internal::Get;
> -
> - tuple() : f0_(), f1_(), f2_(), f3_(), f4_() {}
> -
> - explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
> - GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3,
> - GTEST_BY_REF_(T4) f4) : f0_(f0), f1_(f1), f2_(f2), f3_(f3), f4_(f4)
> {}
> -
> - tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
> - f4_(t.f4_) {}
> -
> - template <GTEST_5_TYPENAMES_(U)>
> - tuple(const GTEST_5_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
> - f3_(t.f3_), f4_(t.f4_) {}
> -
> - tuple& operator=(const tuple& t) { return CopyFrom(t); }
> -
> - template <GTEST_5_TYPENAMES_(U)>
> - tuple& operator=(const GTEST_5_TUPLE_(U)& t) {
> - return CopyFrom(t);
> - }
> -
> - GTEST_DECLARE_TUPLE_AS_FRIEND_
> -
> - template <GTEST_5_TYPENAMES_(U)>
> - tuple& CopyFrom(const GTEST_5_TUPLE_(U)& t) {
> - f0_ = t.f0_;
> - f1_ = t.f1_;
> - f2_ = t.f2_;
> - f3_ = t.f3_;
> - f4_ = t.f4_;
> - return *this;
> - }
> -
> - T0 f0_;
> - T1 f1_;
> - T2 f2_;
> - T3 f3_;
> - T4 f4_;
> -};
> -
> -template <GTEST_6_TYPENAMES_(T)>
> -class GTEST_6_TUPLE_(T) {
> - public:
> - template <int k> friend class gtest_internal::Get;
> -
> - tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_() {}
> -
> - explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
> - GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4,
> - GTEST_BY_REF_(T5) f5) : f0_(f0), f1_(f1), f2_(f2), f3_(f3), f4_(f4),
> - f5_(f5) {}
> -
> - tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
> - f4_(t.f4_), f5_(t.f5_) {}
> -
> - template <GTEST_6_TYPENAMES_(U)>
> - tuple(const GTEST_6_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
> - f3_(t.f3_), f4_(t.f4_), f5_(t.f5_) {}
> -
> - tuple& operator=(const tuple& t) { return CopyFrom(t); }
> -
> - template <GTEST_6_TYPENAMES_(U)>
> - tuple& operator=(const GTEST_6_TUPLE_(U)& t) {
> - return CopyFrom(t);
> - }
> -
> - GTEST_DECLARE_TUPLE_AS_FRIEND_
> -
> - template <GTEST_6_TYPENAMES_(U)>
> - tuple& CopyFrom(const GTEST_6_TUPLE_(U)& t) {
> - f0_ = t.f0_;
> - f1_ = t.f1_;
> - f2_ = t.f2_;
> - f3_ = t.f3_;
> - f4_ = t.f4_;
> - f5_ = t.f5_;
> - return *this;
> - }
> -
> - T0 f0_;
> - T1 f1_;
> - T2 f2_;
> - T3 f3_;
> - T4 f4_;
> - T5 f5_;
> -};
> -
> -template <GTEST_7_TYPENAMES_(T)>
> -class GTEST_7_TUPLE_(T) {
> - public:
> - template <int k> friend class gtest_internal::Get;
> -
> - tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_(), f6_() {}
> -
> - explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
> - GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4,
> - GTEST_BY_REF_(T5) f5, GTEST_BY_REF_(T6) f6) : f0_(f0), f1_(f1),
> f2_(f2),
> - f3_(f3), f4_(f4), f5_(f5), f6_(f6) {}
> -
> - tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
> - f4_(t.f4_), f5_(t.f5_), f6_(t.f6_) {}
> -
> - template <GTEST_7_TYPENAMES_(U)>
> - tuple(const GTEST_7_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
> - f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_) {}
> -
> - tuple& operator=(const tuple& t) { return CopyFrom(t); }
> -
> - template <GTEST_7_TYPENAMES_(U)>
> - tuple& operator=(const GTEST_7_TUPLE_(U)& t) {
> - return CopyFrom(t);
> - }
> -
> - GTEST_DECLARE_TUPLE_AS_FRIEND_
> -
> - template <GTEST_7_TYPENAMES_(U)>
> - tuple& CopyFrom(const GTEST_7_TUPLE_(U)& t) {
> - f0_ = t.f0_;
> - f1_ = t.f1_;
> - f2_ = t.f2_;
> - f3_ = t.f3_;
> - f4_ = t.f4_;
> - f5_ = t.f5_;
> - f6_ = t.f6_;
> - return *this;
> - }
> -
> - T0 f0_;
> - T1 f1_;
> - T2 f2_;
> - T3 f3_;
> - T4 f4_;
> - T5 f5_;
> - T6 f6_;
> -};
> -
> -template <GTEST_8_TYPENAMES_(T)>
> -class GTEST_8_TUPLE_(T) {
> - public:
> - template <int k> friend class gtest_internal::Get;
> -
> - tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_(), f6_(), f7_() {}
> -
> - explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
> - GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4,
> - GTEST_BY_REF_(T5) f5, GTEST_BY_REF_(T6) f6,
> - GTEST_BY_REF_(T7) f7) : f0_(f0), f1_(f1), f2_(f2), f3_(f3), f4_(f4),
> - f5_(f5), f6_(f6), f7_(f7) {}
> -
> - tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
> - f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_) {}
> -
> - template <GTEST_8_TYPENAMES_(U)>
> - tuple(const GTEST_8_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
> - f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_) {}
> -
> - tuple& operator=(const tuple& t) { return CopyFrom(t); }
> -
> - template <GTEST_8_TYPENAMES_(U)>
> - tuple& operator=(const GTEST_8_TUPLE_(U)& t) {
> - return CopyFrom(t);
> - }
> -
> - GTEST_DECLARE_TUPLE_AS_FRIEND_
> -
> - template <GTEST_8_TYPENAMES_(U)>
> - tuple& CopyFrom(const GTEST_8_TUPLE_(U)& t) {
> - f0_ = t.f0_;
> - f1_ = t.f1_;
> - f2_ = t.f2_;
> - f3_ = t.f3_;
> - f4_ = t.f4_;
> - f5_ = t.f5_;
> - f6_ = t.f6_;
> - f7_ = t.f7_;
> - return *this;
> - }
> -
> - T0 f0_;
> - T1 f1_;
> - T2 f2_;
> - T3 f3_;
> - T4 f4_;
> - T5 f5_;
> - T6 f6_;
> - T7 f7_;
> -};
> -
> -template <GTEST_9_TYPENAMES_(T)>
> -class GTEST_9_TUPLE_(T) {
> - public:
> - template <int k> friend class gtest_internal::Get;
> -
> - tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_(), f6_(), f7_(), f8_()
> {}
> -
> - explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
> - GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4,
> - GTEST_BY_REF_(T5) f5, GTEST_BY_REF_(T6) f6, GTEST_BY_REF_(T7) f7,
> - GTEST_BY_REF_(T8) f8) : f0_(f0), f1_(f1), f2_(f2), f3_(f3), f4_(f4),
> - f5_(f5), f6_(f6), f7_(f7), f8_(f8) {}
> -
> - tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
> - f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_), f8_(t.f8_) {}
> -
> - template <GTEST_9_TYPENAMES_(U)>
> - tuple(const GTEST_9_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
> - f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_),
> f8_(t.f8_) {}
> -
> - tuple& operator=(const tuple& t) { return CopyFrom(t); }
> -
> - template <GTEST_9_TYPENAMES_(U)>
> - tuple& operator=(const GTEST_9_TUPLE_(U)& t) {
> - return CopyFrom(t);
> - }
> -
> - GTEST_DECLARE_TUPLE_AS_FRIEND_
> -
> - template <GTEST_9_TYPENAMES_(U)>
> - tuple& CopyFrom(const GTEST_9_TUPLE_(U)& t) {
> - f0_ = t.f0_;
> - f1_ = t.f1_;
> - f2_ = t.f2_;
> - f3_ = t.f3_;
> - f4_ = t.f4_;
> - f5_ = t.f5_;
> - f6_ = t.f6_;
> - f7_ = t.f7_;
> - f8_ = t.f8_;
> - return *this;
> - }
> -
> - T0 f0_;
> - T1 f1_;
> - T2 f2_;
> - T3 f3_;
> - T4 f4_;
> - T5 f5_;
> - T6 f6_;
> - T7 f7_;
> - T8 f8_;
> -};
> -
> -template <GTEST_10_TYPENAMES_(T)>
> -class tuple {
> - public:
> - template <int k> friend class gtest_internal::Get;
> -
> - tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_(), f6_(), f7_(), f8_(),
> - f9_() {}
> -
> - explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
> - GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4,
> - GTEST_BY_REF_(T5) f5, GTEST_BY_REF_(T6) f6, GTEST_BY_REF_(T7) f7,
> - GTEST_BY_REF_(T8) f8, GTEST_BY_REF_(T9) f9) : f0_(f0), f1_(f1),
> f2_(f2),
> - f3_(f3), f4_(f4), f5_(f5), f6_(f6), f7_(f7), f8_(f8), f9_(f9) {}
> -
> - tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
> - f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_), f8_(t.f8_),
> f9_(t.f9_) {}
> -
> - template <GTEST_10_TYPENAMES_(U)>
> - tuple(const GTEST_10_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
> - f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_),
> f8_(t.f8_),
> - f9_(t.f9_) {}
> -
> - tuple& operator=(const tuple& t) { return CopyFrom(t); }
> -
> - template <GTEST_10_TYPENAMES_(U)>
> - tuple& operator=(const GTEST_10_TUPLE_(U)& t) {
> - return CopyFrom(t);
> - }
> -
> - GTEST_DECLARE_TUPLE_AS_FRIEND_
> -
> - template <GTEST_10_TYPENAMES_(U)>
> - tuple& CopyFrom(const GTEST_10_TUPLE_(U)& t) {
> - f0_ = t.f0_;
> - f1_ = t.f1_;
> - f2_ = t.f2_;
> - f3_ = t.f3_;
> - f4_ = t.f4_;
> - f5_ = t.f5_;
> - f6_ = t.f6_;
> - f7_ = t.f7_;
> - f8_ = t.f8_;
> - f9_ = t.f9_;
> - return *this;
> - }
> -
> - T0 f0_;
> - T1 f1_;
> - T2 f2_;
> - T3 f3_;
> - T4 f4_;
> - T5 f5_;
> - T6 f6_;
> - T7 f7_;
> - T8 f8_;
> - T9 f9_;
> -};
> -
> -// 6.1.3.2 Tuple creation functions.
> -
> -// Known limitations: we don't support passing an
> -// std::tr1::reference_wrapper<T> to make_tuple(). And we don't
> -// implement tie().
> -
> -inline tuple<> make_tuple() { return tuple<>(); }
> -
> -template <GTEST_1_TYPENAMES_(T)>
> -inline GTEST_1_TUPLE_(T) make_tuple(const T0& f0) {
> - return GTEST_1_TUPLE_(T)(f0);
> -}
> -
> -template <GTEST_2_TYPENAMES_(T)>
> -inline GTEST_2_TUPLE_(T) make_tuple(const T0& f0, const T1& f1) {
> - return GTEST_2_TUPLE_(T)(f0, f1);
> -}
> -
> -template <GTEST_3_TYPENAMES_(T)>
> -inline GTEST_3_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2&
> f2) {
> - return GTEST_3_TUPLE_(T)(f0, f1, f2);
> -}
> -
> -template <GTEST_4_TYPENAMES_(T)>
> -inline GTEST_4_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2&
> f2,
> - const T3& f3) {
> - return GTEST_4_TUPLE_(T)(f0, f1, f2, f3);
> -}
> -
> -template <GTEST_5_TYPENAMES_(T)>
> -inline GTEST_5_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2&
> f2,
> - const T3& f3, const T4& f4) {
> - return GTEST_5_TUPLE_(T)(f0, f1, f2, f3, f4);
> -}
> -
> -template <GTEST_6_TYPENAMES_(T)>
> -inline GTEST_6_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2&
> f2,
> - const T3& f3, const T4& f4, const T5& f5) {
> - return GTEST_6_TUPLE_(T)(f0, f1, f2, f3, f4, f5);
> -}
> -
> -template <GTEST_7_TYPENAMES_(T)>
> -inline GTEST_7_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2&
> f2,
> - const T3& f3, const T4& f4, const T5& f5, const T6& f6) {
> - return GTEST_7_TUPLE_(T)(f0, f1, f2, f3, f4, f5, f6);
> -}
> -
> -template <GTEST_8_TYPENAMES_(T)>
> -inline GTEST_8_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2&
> f2,
> - const T3& f3, const T4& f4, const T5& f5, const T6& f6, const T7& f7)
> {
> - return GTEST_8_TUPLE_(T)(f0, f1, f2, f3, f4, f5, f6, f7);
> -}
> -
> -template <GTEST_9_TYPENAMES_(T)>
> -inline GTEST_9_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2&
> f2,
> - const T3& f3, const T4& f4, const T5& f5, const T6& f6, const T7& f7,
> - const T8& f8) {
> - return GTEST_9_TUPLE_(T)(f0, f1, f2, f3, f4, f5, f6, f7, f8);
> -}
> -
> -template <GTEST_10_TYPENAMES_(T)>
> -inline GTEST_10_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const
> T2& f2,
> - const T3& f3, const T4& f4, const T5& f5, const T6& f6, const T7& f7,
> - const T8& f8, const T9& f9) {
> - return GTEST_10_TUPLE_(T)(f0, f1, f2, f3, f4, f5, f6, f7, f8, f9);
> -}
> -
> -// 6.1.3.3 Tuple helper classes.
> -
> -template <typename Tuple> struct tuple_size;
> -
> -template <GTEST_0_TYPENAMES_(T)>
> -struct tuple_size<GTEST_0_TUPLE_(T) > {
> - static const int value = 0;
> -};
> -
> -template <GTEST_1_TYPENAMES_(T)>
> -struct tuple_size<GTEST_1_TUPLE_(T) > {
> - static const int value = 1;
> -};
> -
> -template <GTEST_2_TYPENAMES_(T)>
> -struct tuple_size<GTEST_2_TUPLE_(T) > {
> - static const int value = 2;
> -};
> -
> -template <GTEST_3_TYPENAMES_(T)>
> -struct tuple_size<GTEST_3_TUPLE_(T) > {
> - static const int value = 3;
> -};
> -
> -template <GTEST_4_TYPENAMES_(T)>
> -struct tuple_size<GTEST_4_TUPLE_(T) > {
> - static const int value = 4;
> -};
> -
> -template <GTEST_5_TYPENAMES_(T)>
> -struct tuple_size<GTEST_5_TUPLE_(T) > {
> - static const int value = 5;
> -};
> -
> -template <GTEST_6_TYPENAMES_(T)>
> -struct tuple_size<GTEST_6_TUPLE_(T) > {
> - static const int value = 6;
> -};
> -
> -template <GTEST_7_TYPENAMES_(T)>
> -struct tuple_size<GTEST_7_TUPLE_(T) > {
> - static const int value = 7;
> -};
> -
> -template <GTEST_8_TYPENAMES_(T)>
> -struct tuple_size<GTEST_8_TUPLE_(T) > {
> - static const int value = 8;
> -};
> -
> -template <GTEST_9_TYPENAMES_(T)>
> -struct tuple_size<GTEST_9_TUPLE_(T) > {
> - static const int value = 9;
> -};
> -
> -template <GTEST_10_TYPENAMES_(T)>
> -struct tuple_size<GTEST_10_TUPLE_(T) > {
> - static const int value = 10;
> -};
> -
> -template <int k, class Tuple>
> -struct tuple_element {
> - typedef typename gtest_internal::TupleElement<
> - k < (tuple_size<Tuple>::value), k, Tuple>::type type;
> -};
> -
> -#define GTEST_TUPLE_ELEMENT_(k, Tuple) typename tuple_element<k, Tuple
> >::type
> -
> -// 6.1.3.4 Element access.
> -
> -namespace gtest_internal {
> -
> -template <>
> -class Get<0> {
> - public:
> - template <class Tuple>
> - static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(0, Tuple))
> - Field(Tuple& t) { return t.f0_; } // NOLINT
> -
> - template <class Tuple>
> - static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(0, Tuple))
> - ConstField(const Tuple& t) { return t.f0_; }
> -};
> -
> -template <>
> -class Get<1> {
> - public:
> - template <class Tuple>
> - static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(1, Tuple))
> - Field(Tuple& t) { return t.f1_; } // NOLINT
> -
> - template <class Tuple>
> - static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(1, Tuple))
> - ConstField(const Tuple& t) { return t.f1_; }
> -};
> -
> -template <>
> -class Get<2> {
> - public:
> - template <class Tuple>
> - static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(2, Tuple))
> - Field(Tuple& t) { return t.f2_; } // NOLINT
> -
> - template <class Tuple>
> - static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(2, Tuple))
> - ConstField(const Tuple& t) { return t.f2_; }
> -};
> -
> -template <>
> -class Get<3> {
> - public:
> - template <class Tuple>
> - static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(3, Tuple))
> - Field(Tuple& t) { return t.f3_; } // NOLINT
> -
> - template <class Tuple>
> - static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(3, Tuple))
> - ConstField(const Tuple& t) { return t.f3_; }
> -};
> -
> -template <>
> -class Get<4> {
> - public:
> - template <class Tuple>
> - static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(4, Tuple))
> - Field(Tuple& t) { return t.f4_; } // NOLINT
> -
> - template <class Tuple>
> - static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(4, Tuple))
> - ConstField(const Tuple& t) { return t.f4_; }
> -};
> -
> -template <>
> -class Get<5> {
> - public:
> - template <class Tuple>
> - static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(5, Tuple))
> - Field(Tuple& t) { return t.f5_; } // NOLINT
> -
> - template <class Tuple>
> - static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(5, Tuple))
> - ConstField(const Tuple& t) { return t.f5_; }
> -};
> -
> -template <>
> -class Get<6> {
> - public:
> - template <class Tuple>
> - static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(6, Tuple))
> - Field(Tuple& t) { return t.f6_; } // NOLINT
> -
> - template <class Tuple>
> - static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(6, Tuple))
> - ConstField(const Tuple& t) { return t.f6_; }
> -};
> -
> -template <>
> -class Get<7> {
> - public:
> - template <class Tuple>
> - static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(7, Tuple))
> - Field(Tuple& t) { return t.f7_; } // NOLINT
> -
> - template <class Tuple>
> - static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(7, Tuple))
> - ConstField(const Tuple& t) { return t.f7_; }
> -};
> -
> -template <>
> -class Get<8> {
> - public:
> - template <class Tuple>
> - static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(8, Tuple))
> - Field(Tuple& t) { return t.f8_; } // NOLINT
> -
> - template <class Tuple>
> - static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(8, Tuple))
> - ConstField(const Tuple& t) { return t.f8_; }
> -};
> -
> -template <>
> -class Get<9> {
> - public:
> - template <class Tuple>
> - static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(9, Tuple))
> - Field(Tuple& t) { return t.f9_; } // NOLINT
> -
> - template <class Tuple>
> - static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(9, Tuple))
> - ConstField(const Tuple& t) { return t.f9_; }
> -};
> -
> -} // namespace gtest_internal
> -
> -template <int k, GTEST_10_TYPENAMES_(T)>
> -GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(k, GTEST_10_TUPLE_(T)))
> -get(GTEST_10_TUPLE_(T)& t) {
> - return gtest_internal::Get<k>::Field(t);
> -}
> -
> -template <int k, GTEST_10_TYPENAMES_(T)>
> -GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(k, GTEST_10_TUPLE_(T)))
> -get(const GTEST_10_TUPLE_(T)& t) {
> - return gtest_internal::Get<k>::ConstField(t);
> -}
> -
> -// 6.1.3.5 Relational operators
> -
> -// We only implement == and !=, as we don't have a need for the rest yet.
> -
> -namespace gtest_internal {
> -
> -// SameSizeTuplePrefixComparator<k, k>::Eq(t1, t2) returns true if the
> -// first k fields of t1 equals the first k fields of t2.
> -// SameSizeTuplePrefixComparator(k1, k2) would be a compiler error if
> -// k1 != k2.
> -template <int kSize1, int kSize2>
> -struct SameSizeTuplePrefixComparator;
> -
> -template <>
> -struct SameSizeTuplePrefixComparator<0, 0> {
> - template <class Tuple1, class Tuple2>
> - static bool Eq(const Tuple1& /* t1 */, const Tuple2& /* t2 */) {
> - return true;
> - }
> -};
> -
> -template <int k>
> -struct SameSizeTuplePrefixComparator<k, k> {
> - template <class Tuple1, class Tuple2>
> - static bool Eq(const Tuple1& t1, const Tuple2& t2) {
> - return SameSizeTuplePrefixComparator<k - 1, k - 1>::Eq(t1, t2) &&
> - ::std::tr1::get<k - 1>(t1) == ::std::tr1::get<k - 1>(t2);
> - }
> -};
> -
> -} // namespace gtest_internal
> -
> -template <GTEST_10_TYPENAMES_(T), GTEST_10_TYPENAMES_(U)>
> -inline bool operator==(const GTEST_10_TUPLE_(T)& t,
> - const GTEST_10_TUPLE_(U)& u) {
> - return gtest_internal::SameSizeTuplePrefixComparator<
> - tuple_size<GTEST_10_TUPLE_(T) >::value,
> - tuple_size<GTEST_10_TUPLE_(U) >::value>::Eq(t, u);
> -}
> -
> -template <GTEST_10_TYPENAMES_(T), GTEST_10_TYPENAMES_(U)>
> -inline bool operator!=(const GTEST_10_TUPLE_(T)& t,
> - const GTEST_10_TUPLE_(U)& u) { return !(t == u); }
> -
> -// 6.1.4 Pairs.
> -// Unimplemented.
> -
> -} // namespace tr1
> -} // namespace std
> -
> -#undef GTEST_0_TUPLE_
> -#undef GTEST_1_TUPLE_
> -#undef GTEST_2_TUPLE_
> -#undef GTEST_3_TUPLE_
> -#undef GTEST_4_TUPLE_
> -#undef GTEST_5_TUPLE_
> -#undef GTEST_6_TUPLE_
> -#undef GTEST_7_TUPLE_
> -#undef GTEST_8_TUPLE_
> -#undef GTEST_9_TUPLE_
> -#undef GTEST_10_TUPLE_
> -
> -#undef GTEST_0_TYPENAMES_
> -#undef GTEST_1_TYPENAMES_
> -#undef GTEST_2_TYPENAMES_
> -#undef GTEST_3_TYPENAMES_
> -#undef GTEST_4_TYPENAMES_
> -#undef GTEST_5_TYPENAMES_
> -#undef GTEST_6_TYPENAMES_
> -#undef GTEST_7_TYPENAMES_
> -#undef GTEST_8_TYPENAMES_
> -#undef GTEST_9_TYPENAMES_
> -#undef GTEST_10_TYPENAMES_
> -
> -#undef GTEST_DECLARE_TUPLE_AS_FRIEND_
> -#undef GTEST_BY_REF_
> -#undef GTEST_ADD_REF_
> -#undef GTEST_TUPLE_ELEMENT_
> -
> -#endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_
>
> diff --git
> a/llvm/utils/unittest/googletest/include/gtest/internal/gtest-type-util.h
> b/llvm/utils/unittest/googletest/include/gtest/internal/gtest-type-util.h
> index 28e411245361c..3d7542d1fb350 100644
> ---
> a/llvm/utils/unittest/googletest/include/gtest/internal/gtest-type-util.h
> +++
> b/llvm/utils/unittest/googletest/include/gtest/internal/gtest-type-util.h
> @@ -31,12 +31,11 @@
> // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
> // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
>
> -
> // Type utilities needed for implementing typed and type-parameterized
> // tests. This file is generated by a SCRIPT. DO NOT EDIT BY HAND!
> //
> // Currently we support at most 50 types in a list, and at most 50
> -// type-parameterized tests in one type-parameterized test case.
> +// type-parameterized tests in one type-parameterized test suite.
> // Please contact googletestframework at googlegroups.com if you need
> // more.
>
> @@ -89,7 +88,7 @@ std::string GetTypeName() {
> # if GTEST_HAS_CXXABI_H_
> using abi::__cxa_demangle;
> # endif // GTEST_HAS_CXXABI_H_
> - char* const readable_name = __cxa_demangle(name, 0, 0, &status);
> + char* const readable_name = __cxa_demangle(name, nullptr, nullptr,
> &status);
> const std::string name_str(status == 0 ? readable_name : name);
> free(readable_name);
> return CanonicalizeForStdLibVersioning(name_str);
> @@ -106,18 +105,6 @@ std::string GetTypeName() {
>
> #if GTEST_HAS_TYPED_TEST || GTEST_HAS_TYPED_TEST_P
>
> -// AssertyTypeEq<T1, T2>::type is defined iff T1 and T2 are the same
> -// type. This can be used as a compile-time assertion to ensure that
> -// two types are equal.
> -
> -template <typename T1, typename T2>
> -struct AssertTypeEq;
> -
> -template <typename T>
> -struct AssertTypeEq<T, T> {
> - typedef bool type;
> -};
> -
> // A unique type used as the default value for the arguments of class
> // template Types. This allows us to simulate variadic templates
> // (e.g. Types<int>, Type<int, double>, and etc), which C++ doesn't
> @@ -3312,8 +3299,8 @@ struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9,
> T10, T11, T12, T13, T14,
> };
>
> // The TypeList template makes it possible to use either a single type
> -// or a Types<...> list in TYPED_TEST_CASE() and
> -// INSTANTIATE_TYPED_TEST_CASE_P().
> +// or a Types<...> list in TYPED_TEST_SUITE() and
> +// INSTANTIATE_TYPED_TEST_SUITE_P().
>
> template <typename T>
> struct TypeList {
>
> diff --git a/llvm/utils/unittest/googletest/src/gtest-all.cc
> b/llvm/utils/unittest/googletest/src/gtest-all.cc
> index b217a18006b0c..ad292905cf381 100644
> --- a/llvm/utils/unittest/googletest/src/gtest-all.cc
> +++ b/llvm/utils/unittest/googletest/src/gtest-all.cc
> @@ -41,6 +41,7 @@
> #include "src/gtest.cc"
> #include "src/gtest-death-test.cc"
> #include "src/gtest-filepath.cc"
> +#include "src/gtest-matchers.cc"
> #include "src/gtest-port.cc"
> #include "src/gtest-printers.cc"
> #include "src/gtest-test-part.cc"
>
> diff --git a/llvm/utils/unittest/googletest/src/gtest-death-test.cc
> b/llvm/utils/unittest/googletest/src/gtest-death-test.cc
> index 09083551612e3..da09a1cfc23a5 100644
> --- a/llvm/utils/unittest/googletest/src/gtest-death-test.cc
> +++ b/llvm/utils/unittest/googletest/src/gtest-death-test.cc
> @@ -31,6 +31,9 @@
> // This file implements death tests.
>
> #include "gtest/gtest-death-test.h"
> +
> +#include <utility>
> +
> #include "gtest/internal/gtest-port.h"
> #include "gtest/internal/custom/gtest.h"
>
> @@ -62,10 +65,16 @@
> # endif // GTEST_OS_QNX
>
> # if GTEST_OS_FUCHSIA
> +# include <lib/fdio/fd.h>
> # include <lib/fdio/io.h>
> # include <lib/fdio/spawn.h>
> +# include <lib/zx/channel.h>
> +# include <lib/zx/port.h>
> +# include <lib/zx/process.h>
> +# include <lib/zx/socket.h>
> # include <zircon/processargs.h>
> # include <zircon/syscalls.h>
> +# include <zircon/syscalls/policy.h>
> # include <zircon/syscalls/port.h>
> # endif // GTEST_OS_FUCHSIA
>
> @@ -113,8 +122,8 @@ GTEST_DEFINE_string_(
> "Indicates the file, line number, temporal index of "
> "the single death test to run, and a file descriptor to "
> "which a success code may be sent, all separated by "
> - "the '|' characters. This flag is specified if and only if the
> current "
> - "process is a sub-process launched for running a thread-safe "
> + "the '|' characters. This flag is specified if and only if the "
> + "current process is a sub-process launched for running a thread-safe "
> "death test. FOR INTERNAL USE ONLY.");
> } // namespace internal
>
> @@ -266,8 +275,6 @@ static const int kFuchsiaReadPipeFd = 3;
> // statement, which is not allowed; THREW means that the test statement
> // returned control by throwing an exception. IN_PROGRESS means the test
> // has not yet concluded.
> -// FIXME: Unify names and possibly values for
> -// AbortReason, DeathTestOutcome, and flag characters above.
> enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW };
>
> // Routine for aborting the program which is safe to call from an
> @@ -281,7 +288,7 @@ static void DeathTestAbort(const std::string& message)
> {
> // the heap for any additional non-minuscule memory requirements.
> const InternalRunDeathTestFlag* const flag =
> GetUnitTestImpl()->internal_run_death_test_flag();
> - if (flag != NULL) {
> + if (flag != nullptr) {
> FILE* parent = posix::FDOpen(flag->write_fd(), "w");
> fputc(kDeathTestInternalError, parent);
> fprintf(parent, "%s", message.c_str());
> @@ -361,7 +368,7 @@ static void FailFromInternalError(int fd) {
> // for the current test.
> DeathTest::DeathTest() {
> TestInfo* const info = GetUnitTestImpl()->current_test_info();
> - if (info == NULL) {
> + if (info == nullptr) {
> DeathTestAbort("Cannot run a death test outside of a TEST or "
> "TEST_F construct");
> }
> @@ -369,10 +376,11 @@ DeathTest::DeathTest() {
>
> // Creates and returns a death test by dispatching to the current
> // death test factory.
> -bool DeathTest::Create(const char* statement, const RE* regex,
> - const char* file, int line, DeathTest** test) {
> +bool DeathTest::Create(const char* statement,
> + Matcher<const std::string&> matcher, const char*
> file,
> + int line, DeathTest** test) {
> return GetUnitTestImpl()->death_test_factory()->Create(
> - statement, regex, file, line, test);
> + statement, std::move(matcher), file, line, test);
> }
>
> const char* DeathTest::LastMessage() {
> @@ -388,9 +396,9 @@ std::string DeathTest::last_death_test_message_;
> // Provides cross platform implementation for some death functionality.
> class DeathTestImpl : public DeathTest {
> protected:
> - DeathTestImpl(const char* a_statement, const RE* a_regex)
> + DeathTestImpl(const char* a_statement, Matcher<const std::string&>
> matcher)
> : statement_(a_statement),
> - regex_(a_regex),
> + matcher_(std::move(matcher)),
> spawned_(false),
> status_(-1),
> outcome_(IN_PROGRESS),
> @@ -398,13 +406,12 @@ class DeathTestImpl : public DeathTest {
> write_fd_(-1) {}
>
> // read_fd_ is expected to be closed and cleared by a derived class.
> - ~DeathTestImpl() { GTEST_DEATH_TEST_CHECK_(read_fd_ == -1); }
> + ~DeathTestImpl() override { GTEST_DEATH_TEST_CHECK_(read_fd_ == -1); }
>
> - void Abort(AbortReason reason);
> - virtual bool Passed(bool status_ok);
> + void Abort(AbortReason reason) override;
> + bool Passed(bool status_ok) override;
>
> const char* statement() const { return statement_; }
> - const RE* regex() const { return regex_; }
> bool spawned() const { return spawned_; }
> void set_spawned(bool is_spawned) { spawned_ = is_spawned; }
> int status() const { return status_; }
> @@ -422,13 +429,15 @@ class DeathTestImpl : public DeathTest {
> // case of unexpected codes.
> void ReadAndInterpretStatusByte();
>
> + // Returns stderr output from the child process.
> + virtual std::string GetErrorLogs();
> +
> private:
> // The textual content of the code this object is testing. This class
> // doesn't own this string and should not attempt to delete it.
> const char* const statement_;
> - // The regular expression which test output must match. DeathTestImpl
> - // doesn't own this object and should not attempt to delete it.
> - const RE* const regex_;
> + // A matcher that's expected to match the stderr output by the child
> process.
> + Matcher<const std::string&> matcher_;
> // True if the death test child process has been successfully spawned.
> bool spawned_;
> // The exit status of the child process.
> @@ -490,6 +499,10 @@ void DeathTestImpl::ReadAndInterpretStatusByte() {
> set_read_fd(-1);
> }
>
> +std::string DeathTestImpl::GetErrorLogs() {
> + return GetCapturedStderr();
> +}
> +
> // Signals that the death test code which should have exited, didn't.
> // Should be called only in a death test child process.
> // Writes a status byte to the child's status file descriptor, then
> @@ -543,22 +556,21 @@ static ::std::string FormatDeathTestOutput(const
> ::std::string& output) {
> // in the format specified by wait(2). On Windows, this is the
> // value supplied to the ExitProcess() API or a numeric code
> // of the exception that terminated the program.
> -// regex: A regular expression object to be applied to
> -// the test's captured standard error output; the death test
> -// fails if it does not match.
> +// matcher_: A matcher that's expected to match the stderr output by
> the child
> +// process.
> //
> // Argument:
> // status_ok: true if exit_status is acceptable in the context of
> // this particular death test, which fails if it is false
> //
> -// Returns true iff all of the above conditions are met. Otherwise, the
> -// first failing condition, in the order given above, is the one that is
> +// Returns true if and only if all of the above conditions are met.
> Otherwise,
> +// the first failing condition, in the order given above, is the one that
> is
> // reported. Also sets the last death test message string.
> bool DeathTestImpl::Passed(bool status_ok) {
> if (!spawned())
> return false;
>
> - const std::string error_message = GetCapturedStderr();
> + const std::string error_message = GetErrorLogs();
>
> bool success = false;
> Message buffer;
> @@ -579,18 +591,15 @@ bool DeathTestImpl::Passed(bool status_ok) {
> break;
> case DIED:
> if (status_ok) {
> -# if GTEST_USES_PCRE
> - // PCRE regexes support embedded NULs.
> - const bool matched = RE::PartialMatch(error_message, *regex());
> -# else
> - const bool matched = RE::PartialMatch(error_message.c_str(),
> *regex());
> -# endif // GTEST_USES_PCRE
> - if (matched) {
> + if (matcher_.Matches(error_message)) {
> success = true;
> } else {
> + std::ostringstream stream;
> + matcher_.DescribeTo(&stream);
> buffer << " Result: died but not with expected error.\n"
> - << " Expected: " << regex()->pattern() << "\n"
> - << "Actual msg:\n" <<
> FormatDeathTestOutput(error_message);
> + << " Expected: " << stream.str() << "\n"
> + << "Actual msg:\n"
> + << FormatDeathTestOutput(error_message);
> }
> } else {
> buffer << " Result: died but not with expected exit code:\n"
> @@ -639,11 +648,11 @@ bool DeathTestImpl::Passed(bool status_ok) {
> //
> class WindowsDeathTest : public DeathTestImpl {
> public:
> - WindowsDeathTest(const char* a_statement,
> - const RE* a_regex,
> - const char* file,
> - int line)
> - : DeathTestImpl(a_statement, a_regex), file_(file), line_(line) {}
> + WindowsDeathTest(const char* a_statement, Matcher<const std::string&>
> matcher,
> + const char* file, int line)
> + : DeathTestImpl(a_statement, std::move(matcher)),
> + file_(file),
> + line_(line) {}
>
> // All of these virtual functions are inherited from DeathTest.
> virtual int Wait();
> @@ -720,7 +729,7 @@ DeathTest::TestRole WindowsDeathTest::AssumeRole() {
> const TestInfo* const info = impl->current_test_info();
> const int death_test_index = info->result()->death_test_count();
>
> - if (flag != NULL) {
> + if (flag != nullptr) {
> // ParseInternalRunDeathTestFlag() has performed all the necessary
> // processing.
> set_write_fd(flag->write_fd());
> @@ -729,8 +738,8 @@ DeathTest::TestRole WindowsDeathTest::AssumeRole() {
>
> // WindowsDeathTest uses an anonymous pipe to communicate results of
> // a death test.
> - SECURITY_ATTRIBUTES handles_are_inheritable = {
> - sizeof(SECURITY_ATTRIBUTES), NULL, TRUE };
> + SECURITY_ATTRIBUTES handles_are_inheritable =
> {sizeof(SECURITY_ATTRIBUTES),
> + nullptr, TRUE};
> HANDLE read_handle, write_handle;
> GTEST_DEATH_TEST_CHECK_(
> ::CreatePipe(&read_handle, &write_handle, &handles_are_inheritable,
> @@ -741,13 +750,13 @@ DeathTest::TestRole WindowsDeathTest::AssumeRole() {
> write_handle_.Reset(write_handle);
> event_handle_.Reset(::CreateEvent(
> &handles_are_inheritable,
> - TRUE, // The event will automatically reset to non-signaled
> state.
> - FALSE, // The initial state is non-signalled.
> - NULL)); // The even is unnamed.
> - GTEST_DEATH_TEST_CHECK_(event_handle_.Get() != NULL);
> - const std::string filter_flag =
> - std::string("--") + GTEST_FLAG_PREFIX_ + kFilterFlag + "=" +
> - info->test_case_name() + "." + info->name();
> + TRUE, // The event will automatically reset to non-signaled
> state.
> + FALSE, // The initial state is non-signalled.
> + nullptr)); // The even is unnamed.
> + GTEST_DEATH_TEST_CHECK_(event_handle_.Get() != nullptr);
> + const std::string filter_flag = std::string("--") + GTEST_FLAG_PREFIX_ +
> + kFilterFlag + "=" +
> info->test_suite_name() +
> + "." + info->name();
> const std::string internal_flag =
> std::string("--") + GTEST_FLAG_PREFIX_ + kInternalRunDeathTestFlag +
> "=" + file_ + "|" + StreamableToString(line_) + "|" +
> @@ -760,10 +769,9 @@ DeathTest::TestRole WindowsDeathTest::AssumeRole() {
> "|" +
> StreamableToString(reinterpret_cast<size_t>(event_handle_.Get()));
>
> char executable_path[_MAX_PATH + 1]; // NOLINT
> - GTEST_DEATH_TEST_CHECK_(
> - _MAX_PATH + 1 != ::GetModuleFileNameA(NULL,
> - executable_path,
> - _MAX_PATH));
> + GTEST_DEATH_TEST_CHECK_(_MAX_PATH + 1 != ::GetModuleFileNameA(nullptr,
> +
> executable_path,
> +
> _MAX_PATH));
>
> std::string command_line =
> std::string(::GetCommandLineA()) + " " + filter_flag + " \"" +
> @@ -784,17 +792,16 @@ DeathTest::TestRole WindowsDeathTest::AssumeRole() {
> startup_info.hStdError = ::GetStdHandle(STD_ERROR_HANDLE);
>
> PROCESS_INFORMATION process_info;
> - GTEST_DEATH_TEST_CHECK_(::CreateProcessA(
> - executable_path,
> - const_cast<char*>(command_line.c_str()),
> - NULL, // Retuned process handle is not inheritable.
> - NULL, // Retuned thread handle is not inheritable.
> - TRUE, // Child inherits all inheritable handles (for
> write_handle_).
> - 0x0, // Default creation flags.
> - NULL, // Inherit the parent's environment.
> - UnitTest::GetInstance()->original_working_dir(),
> - &startup_info,
> - &process_info) != FALSE);
> + GTEST_DEATH_TEST_CHECK_(
> + ::CreateProcessA(
> + executable_path, const_cast<char*>(command_line.c_str()),
> + nullptr, // Retuned process handle is not inheritable.
> + nullptr, // Retuned thread handle is not inheritable.
> + TRUE, // Child inherits all inheritable handles (for
> write_handle_).
> + 0x0, // Default creation flags.
> + nullptr, // Inherit the parent's environment.
> + UnitTest::GetInstance()->original_working_dir(), &startup_info,
> + &process_info) != FALSE);
> child_handle_.Reset(process_info.hProcess);
> ::CloseHandle(process_info.hThread);
> set_spawned(true);
> @@ -805,38 +812,34 @@ DeathTest::TestRole WindowsDeathTest::AssumeRole() {
>
> class FuchsiaDeathTest : public DeathTestImpl {
> public:
> - FuchsiaDeathTest(const char* a_statement,
> - const RE* a_regex,
> - const char* file,
> - int line)
> - : DeathTestImpl(a_statement, a_regex), file_(file), line_(line) {}
> - virtual ~FuchsiaDeathTest() {
> - zx_status_t status = zx_handle_close(child_process_);
> - GTEST_DEATH_TEST_CHECK_(status == ZX_OK);
> - status = zx_handle_close(port_);
> - GTEST_DEATH_TEST_CHECK_(status == ZX_OK);
> - }
> + FuchsiaDeathTest(const char* a_statement, Matcher<const std::string&>
> matcher,
> + const char* file, int line)
> + : DeathTestImpl(a_statement, std::move(matcher)),
> + file_(file),
> + line_(line) {}
>
> // All of these virtual functions are inherited from DeathTest.
> - virtual int Wait();
> - virtual TestRole AssumeRole();
> + int Wait() override;
> + TestRole AssumeRole() override;
> + std::string GetErrorLogs() override;
>
> private:
> // The name of the file in which the death test is located.
> const char* const file_;
> // The line number on which the death test is located.
> const int line_;
> + // The stderr data captured by the child process.
> + std::string captured_stderr_;
>
> - zx_handle_t child_process_ = ZX_HANDLE_INVALID;
> - zx_handle_t port_ = ZX_HANDLE_INVALID;
> + zx::process child_process_;
> + zx::channel exception_channel_;
> + zx::socket stderr_socket_;
> };
>
> // Utility class for accumulating command-line arguments.
> class Arguments {
> public:
> - Arguments() {
> - args_.push_back(NULL);
> - }
> + Arguments() { args_.push_back(nullptr); }
>
> ~Arguments() {
> for (std::vector<char*>::iterator i = args_.begin(); i != args_.end();
> @@ -872,51 +875,88 @@ class Arguments {
> // status, or 0 if no child process exists. As a side effect, sets the
> // outcome data member.
> int FuchsiaDeathTest::Wait() {
> + const int kProcessKey = 0;
> + const int kSocketKey = 1;
> + const int kExceptionKey = 2;
> +
> if (!spawned())
> return 0;
>
> - // Register to wait for the child process to terminate.
> + // Create a port to wait for socket/task/exception events.
> zx_status_t status_zx;
> - status_zx = zx_object_wait_async(child_process_,
> - port_,
> - 0 /* key */,
> - ZX_PROCESS_TERMINATED,
> - ZX_WAIT_ASYNC_ONCE);
> + zx::port port;
> + status_zx = zx::port::create(0, &port);
> GTEST_DEATH_TEST_CHECK_(status_zx == ZX_OK);
>
> - // Wait for it to terminate, or an exception to be received.
> - zx_port_packet_t packet;
> - status_zx = zx_port_wait(port_, ZX_TIME_INFINITE, &packet);
> + // Register to wait for the child process to terminate.
> + status_zx = child_process_.wait_async(
> + port, kProcessKey, ZX_PROCESS_TERMINATED, ZX_WAIT_ASYNC_ONCE);
> GTEST_DEATH_TEST_CHECK_(status_zx == ZX_OK);
>
> - if (ZX_PKT_IS_EXCEPTION(packet.type)) {
> - // Process encountered an exception. Kill it directly rather than
> letting
> - // other handlers process the event.
> - status_zx = zx_task_kill(child_process_);
> - GTEST_DEATH_TEST_CHECK_(status_zx == ZX_OK);
> + // Register to wait for the socket to be readable or closed.
> + status_zx = stderr_socket_.wait_async(
> + port, kSocketKey, ZX_SOCKET_READABLE | ZX_SOCKET_PEER_CLOSED,
> + ZX_WAIT_ASYNC_ONCE);
> + GTEST_DEATH_TEST_CHECK_(status_zx == ZX_OK);
>
> - // Now wait for |child_process_| to terminate.
> - zx_signals_t signals = 0;
> - status_zx = zx_object_wait_one(
> - child_process_, ZX_PROCESS_TERMINATED, ZX_TIME_INFINITE,
> &signals);
> + // Register to wait for an exception.
> + status_zx = exception_channel_.wait_async(
> + port, kExceptionKey, ZX_CHANNEL_READABLE, ZX_WAIT_ASYNC_ONCE);
> + GTEST_DEATH_TEST_CHECK_(status_zx == ZX_OK);
> +
> + bool process_terminated = false;
> + bool socket_closed = false;
> + do {
> + zx_port_packet_t packet = {};
> + status_zx = port.wait(zx::time::infinite(), &packet);
> GTEST_DEATH_TEST_CHECK_(status_zx == ZX_OK);
> - GTEST_DEATH_TEST_CHECK_(signals & ZX_PROCESS_TERMINATED);
> - } else {
> - // Process terminated.
> - GTEST_DEATH_TEST_CHECK_(ZX_PKT_IS_SIGNAL_ONE(packet.type));
> - GTEST_DEATH_TEST_CHECK_(packet.signal.observed &
> ZX_PROCESS_TERMINATED);
> - }
> +
> + if (packet.key == kExceptionKey) {
> + // Process encountered an exception. Kill it directly rather than
> + // letting other handlers process the event. We will get a
> kProcessKey
> + // event when the process actually terminates.
> + status_zx = child_process_.kill();
> + GTEST_DEATH_TEST_CHECK_(status_zx == ZX_OK);
> + } else if (packet.key == kProcessKey) {
> + // Process terminated.
> + GTEST_DEATH_TEST_CHECK_(ZX_PKT_IS_SIGNAL_ONE(packet.type));
> + GTEST_DEATH_TEST_CHECK_(packet.signal.observed &
> ZX_PROCESS_TERMINATED);
> + process_terminated = true;
> + } else if (packet.key == kSocketKey) {
> + GTEST_DEATH_TEST_CHECK_(ZX_PKT_IS_SIGNAL_ONE(packet.type));
> + if (packet.signal.observed & ZX_SOCKET_READABLE) {
> + // Read data from the socket.
> + constexpr size_t kBufferSize = 1024;
> + do {
> + size_t old_length = captured_stderr_.length();
> + size_t bytes_read = 0;
> + captured_stderr_.resize(old_length + kBufferSize);
> + status_zx = stderr_socket_.read(
> + 0, &captured_stderr_.front() + old_length, kBufferSize,
> + &bytes_read);
> + captured_stderr_.resize(old_length + bytes_read);
> + } while (status_zx == ZX_OK);
> + if (status_zx == ZX_ERR_PEER_CLOSED) {
> + socket_closed = true;
> + } else {
> + GTEST_DEATH_TEST_CHECK_(status_zx == ZX_ERR_SHOULD_WAIT);
> + status_zx = stderr_socket_.wait_async(
> + port, kSocketKey, ZX_SOCKET_READABLE |
> ZX_SOCKET_PEER_CLOSED,
> + ZX_WAIT_ASYNC_ONCE);
> + GTEST_DEATH_TEST_CHECK_(status_zx == ZX_OK);
> + }
> + } else {
> + GTEST_DEATH_TEST_CHECK_(packet.signal.observed &
> ZX_SOCKET_PEER_CLOSED);
> + socket_closed = true;
> + }
> + }
> + } while (!process_terminated && !socket_closed);
>
> ReadAndInterpretStatusByte();
>
> zx_info_process_t buffer;
> - status_zx = zx_object_get_info(
> - child_process_,
> - ZX_INFO_PROCESS,
> - &buffer,
> - sizeof(buffer),
> - nullptr,
> - nullptr);
> + status_zx = child_process_.get_info(
> + ZX_INFO_PROCESS, &buffer, sizeof(buffer), nullptr, nullptr);
> GTEST_DEATH_TEST_CHECK_(status_zx == ZX_OK);
>
> GTEST_DEATH_TEST_CHECK_(buffer.exited);
> @@ -936,21 +976,20 @@ DeathTest::TestRole FuchsiaDeathTest::AssumeRole() {
> const TestInfo* const info = impl->current_test_info();
> const int death_test_index = info->result()->death_test_count();
>
> - if (flag != NULL) {
> + if (flag != nullptr) {
> // ParseInternalRunDeathTestFlag() has performed all the necessary
> // processing.
> set_write_fd(kFuchsiaReadPipeFd);
> return EXECUTE_TEST;
> }
>
> - CaptureStderr();
> // Flush the log buffers since the log streams are shared with the
> child.
> FlushInfoLog();
>
> // Build the child process command line.
> - const std::string filter_flag =
> - std::string("--") + GTEST_FLAG_PREFIX_ + kFilterFlag + "="
> - + info->test_case_name() + "." + info->name();
> + const std::string filter_flag = std::string("--") + GTEST_FLAG_PREFIX_ +
> + kFilterFlag + "=" +
> info->test_suite_name() +
> + "." + info->name();
> const std::string internal_flag =
> std::string("--") + GTEST_FLAG_PREFIX_ + kInternalRunDeathTestFlag
> + "="
> + file_ + "|"
> @@ -964,35 +1003,68 @@ DeathTest::TestRole FuchsiaDeathTest::AssumeRole() {
> // Build the pipe for communication with the child.
> zx_status_t status;
> zx_handle_t child_pipe_handle;
> - uint32_t type;
> - status = fdio_pipe_half(&child_pipe_handle, &type);
> - GTEST_DEATH_TEST_CHECK_(status >= 0);
> - set_read_fd(status);
> + int child_pipe_fd;
> + status = fdio_pipe_half(&child_pipe_fd, &child_pipe_handle);
> + GTEST_DEATH_TEST_CHECK_(status == ZX_OK);
> + set_read_fd(child_pipe_fd);
>
> // Set the pipe handle for the child.
> - fdio_spawn_action_t add_handle_action = {};
> - add_handle_action.action = FDIO_SPAWN_ACTION_ADD_HANDLE;
> - add_handle_action.h.id = PA_HND(type, kFuchsiaReadPipeFd);
> - add_handle_action.h.handle = child_pipe_handle;
> + fdio_spawn_action_t spawn_actions[2] = {};
> + fdio_spawn_action_t* add_handle_action = &spawn_actions[0];
> + add_handle_action->action = FDIO_SPAWN_ACTION_ADD_HANDLE;
> + add_handle_action->h.id = PA_HND(PA_FD, kFuchsiaReadPipeFd);
> + add_handle_action->h.handle = child_pipe_handle;
> +
> + // Create a socket pair will be used to receive the child process'
> stderr.
> + zx::socket stderr_producer_socket;
> + status =
> + zx::socket::create(0, &stderr_producer_socket, &stderr_socket_);
> + GTEST_DEATH_TEST_CHECK_(status >= 0);
> + int stderr_producer_fd = -1;
> + status =
> + fdio_fd_create(stderr_producer_socket.release(),
> &stderr_producer_fd);
> + GTEST_DEATH_TEST_CHECK_(status >= 0);
>
> - // Spawn the child process.
> - status = fdio_spawn_etc(ZX_HANDLE_INVALID, FDIO_SPAWN_CLONE_ALL,
> - args.Argv()[0], args.Argv(), nullptr, 1,
> - &add_handle_action, &child_process_, nullptr);
> + // Make the stderr socket nonblocking.
> + GTEST_DEATH_TEST_CHECK_(fcntl(stderr_producer_fd, F_SETFL, 0) == 0);
> +
> + fdio_spawn_action_t* add_stderr_action = &spawn_actions[1];
> + add_stderr_action->action = FDIO_SPAWN_ACTION_CLONE_FD;
> + add_stderr_action->fd.local_fd = stderr_producer_fd;
> + add_stderr_action->fd.target_fd = STDERR_FILENO;
> +
> + // Create a child job.
> + zx_handle_t child_job = ZX_HANDLE_INVALID;
> + status = zx_job_create(zx_job_default(), 0, & child_job);
> + GTEST_DEATH_TEST_CHECK_(status == ZX_OK);
> + zx_policy_basic_t policy;
> + policy.condition = ZX_POL_NEW_ANY;
> + policy.policy = ZX_POL_ACTION_ALLOW;
> + status = zx_job_set_policy(
> + child_job, ZX_JOB_POL_RELATIVE, ZX_JOB_POL_BASIC, &policy, 1);
> GTEST_DEATH_TEST_CHECK_(status == ZX_OK);
>
> - // Create an exception port and attach it to the |child_process_|, to
> allow
> + // Create an exception channel attached to the |child_job|, to allow
> // us to suppress the system default exception handler from firing.
> - status = zx_port_create(0, &port_);
> + status =
> + zx_task_create_exception_channel(
> + child_job, 0, exception_channel_.reset_and_get_address());
> GTEST_DEATH_TEST_CHECK_(status == ZX_OK);
> - status = zx_task_bind_exception_port(
> - child_process_, port_, 0 /* key */, 0 /*options */);
> +
> + // Spawn the child process.
> + status = fdio_spawn_etc(
> + child_job, FDIO_SPAWN_CLONE_ALL, args.Argv()[0], args.Argv(),
> nullptr,
> + 2, spawn_actions, child_process_.reset_and_get_address(), nullptr);
> GTEST_DEATH_TEST_CHECK_(status == ZX_OK);
>
> set_spawned(true);
> return OVERSEE_TEST;
> }
>
> +std::string FuchsiaDeathTest::GetErrorLogs() {
> + return captured_stderr_;
> +}
> +
> #else // We are neither on Windows, nor on Fuchsia.
>
> // ForkingDeathTest provides implementations for most of the abstract
> @@ -1000,10 +1072,10 @@ DeathTest::TestRole FuchsiaDeathTest::AssumeRole()
> {
> // left undefined.
> class ForkingDeathTest : public DeathTestImpl {
> public:
> - ForkingDeathTest(const char* statement, const RE* regex);
> + ForkingDeathTest(const char* statement, Matcher<const std::string&>
> matcher);
>
> // All of these virtual functions are inherited from DeathTest.
> - virtual int Wait();
> + int Wait() override;
>
> protected:
> void set_child_pid(pid_t child_pid) { child_pid_ = child_pid; }
> @@ -1014,9 +1086,9 @@ class ForkingDeathTest : public DeathTestImpl {
> };
>
> // Constructs a ForkingDeathTest.
> -ForkingDeathTest::ForkingDeathTest(const char* a_statement, const RE*
> a_regex)
> - : DeathTestImpl(a_statement, a_regex),
> - child_pid_(-1) {}
> +ForkingDeathTest::ForkingDeathTest(const char* a_statement,
> + Matcher<const std::string&> matcher)
> + : DeathTestImpl(a_statement, std::move(matcher)), child_pid_(-1) {}
>
> // Waits for the child in a death test to exit, returning its exit
> // status, or 0 if no child process exists. As a side effect, sets the
> @@ -1037,9 +1109,9 @@ int ForkingDeathTest::Wait() {
> // in the child process.
> class NoExecDeathTest : public ForkingDeathTest {
> public:
> - NoExecDeathTest(const char* a_statement, const RE* a_regex) :
> - ForkingDeathTest(a_statement, a_regex) { }
> - virtual TestRole AssumeRole();
> + NoExecDeathTest(const char* a_statement, Matcher<const std::string&>
> matcher)
> + : ForkingDeathTest(a_statement, std::move(matcher)) {}
> + TestRole AssumeRole() override;
> };
>
> // The AssumeRole process for a fork-and-run death test. It implements a
> @@ -1092,10 +1164,13 @@ DeathTest::TestRole NoExecDeathTest::AssumeRole() {
> // only this specific death test to be run.
> class ExecDeathTest : public ForkingDeathTest {
> public:
> - ExecDeathTest(const char* a_statement, const RE* a_regex,
> - const char* file, int line) :
> - ForkingDeathTest(a_statement, a_regex), file_(file), line_(line) { }
> - virtual TestRole AssumeRole();
> + ExecDeathTest(const char* a_statement, Matcher<const std::string&>
> matcher,
> + const char* file, int line)
> + : ForkingDeathTest(a_statement, std::move(matcher)),
> + file_(file),
> + line_(line) {}
> + TestRole AssumeRole() override;
> +
> private:
> static ::std::vector<std::string> GetArgvsForDeathTestChildProcess() {
> ::std::vector<std::string> args = GetInjectableArgvs();
> @@ -1115,9 +1190,7 @@ class ExecDeathTest : public ForkingDeathTest {
> // Utility class for accumulating command-line arguments.
> class Arguments {
> public:
> - Arguments() {
> - args_.push_back(NULL);
> - }
> + Arguments() { args_.push_back(nullptr); }
>
> ~Arguments() {
> for (std::vector<char*>::iterator i = args_.begin(); i != args_.end();
> @@ -1211,6 +1284,9 @@ static int ExecDeathTestChildMain(void* child_arg) {
> // correct answer.
> static void StackLowerThanAddress(const void* ptr,
> bool* result) GTEST_NO_INLINE_;
> +// HWAddressSanitizer add a random tag to the MSB of the local variable
> address,
> +// making comparison result unpredictable.
> +GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_
> static void StackLowerThanAddress(const void* ptr, bool* result) {
> int dummy;
> *result = (&dummy < ptr);
> @@ -1218,6 +1294,7 @@ static void StackLowerThanAddress(const void* ptr,
> bool* result) {
>
> // Make sure AddressSanitizer does not tamper with the stack here.
> GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
> +GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_
> static bool StackGrowsDown() {
> int dummy;
> bool result;
> @@ -1262,7 +1339,8 @@ static pid_t ExecDeathTestSpawnChild(char* const*
> argv, int close_fd) {
> fd_flags | FD_CLOEXEC));
> struct inheritance inherit = {0};
> // spawn is a system call.
> - child_pid = spawn(args.argv[0], 0, NULL, &inherit, args.argv,
> GetEnviron());
> + child_pid =
> + spawn(args.argv[0], 0, nullptr, &inherit, args.argv, GetEnviron());
> // Restores the current working directory.
> GTEST_DEATH_TEST_CHECK_(fchdir(cwd_fd) != -1);
> GTEST_DEATH_TEST_CHECK_SYSCALL_(close(cwd_fd));
> @@ -1286,9 +1364,9 @@ static pid_t ExecDeathTestSpawnChild(char* const*
> argv, int close_fd) {
>
> if (!use_fork) {
> static const bool stack_grows_down = StackGrowsDown();
> - const size_t stack_size = getpagesize();
> + const auto stack_size = static_cast<size_t>(getpagesize());
> // MMAP_ANONYMOUS is not defined on Mac, so we use MAP_ANON instead.
> - void* const stack = mmap(NULL, stack_size, PROT_READ | PROT_WRITE,
> + void* const stack = mmap(nullptr, stack_size, PROT_READ | PROT_WRITE,
> MAP_ANON | MAP_PRIVATE, -1, 0);
> GTEST_DEATH_TEST_CHECK_(stack != MAP_FAILED);
>
> @@ -1302,8 +1380,9 @@ static pid_t ExecDeathTestSpawnChild(char* const*
> argv, int close_fd) {
> void* const stack_top =
> static_cast<char*>(stack) +
> (stack_grows_down ? stack_size - kMaxStackAlignment : 0);
> - GTEST_DEATH_TEST_CHECK_(stack_size > kMaxStackAlignment &&
> - reinterpret_cast<intptr_t>(stack_top) % kMaxStackAlignment == 0);
> + GTEST_DEATH_TEST_CHECK_(
> + static_cast<size_t>(stack_size) > kMaxStackAlignment &&
> + reinterpret_cast<uintptr_t>(stack_top) % kMaxStackAlignment == 0);
>
> child_pid = clone(&ExecDeathTestChildMain, stack_top, SIGCHLD, &args);
>
> @@ -1320,7 +1399,7 @@ static pid_t ExecDeathTestSpawnChild(char* const*
> argv, int close_fd) {
> # endif // GTEST_OS_QNX
> # if GTEST_OS_LINUX
> GTEST_DEATH_TEST_CHECK_SYSCALL_(
> - sigaction(SIGPROF, &saved_sigprof_action, NULL));
> + sigaction(SIGPROF, &saved_sigprof_action, nullptr));
> # endif // GTEST_OS_LINUX
>
> GTEST_DEATH_TEST_CHECK_(child_pid != -1);
> @@ -1338,7 +1417,7 @@ DeathTest::TestRole ExecDeathTest::AssumeRole() {
> const TestInfo* const info = impl->current_test_info();
> const int death_test_index = info->result()->death_test_count();
>
> - if (flag != NULL) {
> + if (flag != nullptr) {
> set_write_fd(flag->write_fd());
> return EXECUTE_TEST;
> }
> @@ -1349,9 +1428,9 @@ DeathTest::TestRole ExecDeathTest::AssumeRole() {
> // it be closed when the child process does an exec:
> GTEST_DEATH_TEST_CHECK_(fcntl(pipe_fd[1], F_SETFD, 0) != -1);
>
> - const std::string filter_flag =
> - std::string("--") + GTEST_FLAG_PREFIX_ + kFilterFlag + "="
> - + info->test_case_name() + "." + info->name();
> + const std::string filter_flag = std::string("--") + GTEST_FLAG_PREFIX_ +
> + kFilterFlag + "=" +
> info->test_suite_name() +
> + "." + info->name();
> const std::string internal_flag =
> std::string("--") + GTEST_FLAG_PREFIX_ + kInternalRunDeathTestFlag
> + "="
> + file_ + "|" + StreamableToString(line_) + "|"
> @@ -1384,7 +1463,8 @@ DeathTest::TestRole ExecDeathTest::AssumeRole() {
> // by the "test" argument to its address. If the test should be
> // skipped, sets that pointer to NULL. Returns true, unless the
> // flag is set to an invalid value.
> -bool DefaultDeathTestFactory::Create(const char* statement, const RE*
> regex,
> +bool DefaultDeathTestFactory::Create(const char* statement,
> + Matcher<const std::string&> matcher,
> const char* file, int line,
> DeathTest** test) {
> UnitTestImpl* const impl = GetUnitTestImpl();
> @@ -1393,7 +1473,7 @@ bool DefaultDeathTestFactory::Create(const char*
> statement, const RE* regex,
> const int death_test_index = impl->current_test_info()
> ->increment_death_test_count();
>
> - if (flag != NULL) {
> + if (flag != nullptr) {
> if (death_test_index > flag->index()) {
> DeathTest::set_last_death_test_message(
> "Death test count (" + StreamableToString(death_test_index)
> @@ -1404,7 +1484,7 @@ bool DefaultDeathTestFactory::Create(const char*
> statement, const RE* regex,
>
> if (!(flag->file() == file && flag->line() == line &&
> flag->index() == death_test_index)) {
> - *test = NULL;
> + *test = nullptr;
> return true;
> }
> }
> @@ -1413,22 +1493,22 @@ bool DefaultDeathTestFactory::Create(const char*
> statement, const RE* regex,
>
> if (GTEST_FLAG(death_test_style) == "threadsafe" ||
> GTEST_FLAG(death_test_style) == "fast") {
> - *test = new WindowsDeathTest(statement, regex, file, line);
> + *test = new WindowsDeathTest(statement, std::move(matcher), file,
> line);
> }
>
> # elif GTEST_OS_FUCHSIA
>
> if (GTEST_FLAG(death_test_style) == "threadsafe" ||
> GTEST_FLAG(death_test_style) == "fast") {
> - *test = new FuchsiaDeathTest(statement, regex, file, line);
> + *test = new FuchsiaDeathTest(statement, std::move(matcher), file,
> line);
> }
>
> # else
>
> if (GTEST_FLAG(death_test_style) == "threadsafe") {
> - *test = new ExecDeathTest(statement, regex, file, line);
> + *test = new ExecDeathTest(statement, std::move(matcher), file, line);
> } else if (GTEST_FLAG(death_test_style) == "fast") {
> - *test = new NoExecDeathTest(statement, regex);
> + *test = new NoExecDeathTest(statement, std::move(matcher));
> }
>
> # endif // GTEST_OS_WINDOWS
> @@ -1458,8 +1538,6 @@ static int GetStatusFileDescriptor(unsigned int
> parent_process_id,
> StreamableToString(parent_process_id));
> }
>
> - // FIXME: Replace the following check with a
> - // compile-time assertion when available.
> GTEST_CHECK_(sizeof(HANDLE) <= sizeof(size_t));
>
> const HANDLE write_handle =
> @@ -1515,7 +1593,7 @@ static int GetStatusFileDescriptor(unsigned int
> parent_process_id,
> // initialized from the GTEST_FLAG(internal_run_death_test) flag if
> // the flag is specified; otherwise returns NULL.
> InternalRunDeathTestFlag* ParseInternalRunDeathTestFlag() {
> - if (GTEST_FLAG(internal_run_death_test) == "") return NULL;
> + if (GTEST_FLAG(internal_run_death_test) == "") return nullptr;
>
> // GTEST_HAS_DEATH_TEST implies that we have ::std::string, so we
> // can use it here.
>
> diff --git a/llvm/utils/unittest/googletest/src/gtest-filepath.cc
> b/llvm/utils/unittest/googletest/src/gtest-filepath.cc
> index a7e65c082a75f..bd7b99ff03e49 100644
> --- a/llvm/utils/unittest/googletest/src/gtest-filepath.cc
> +++ b/llvm/utils/unittest/googletest/src/gtest-filepath.cc
> @@ -38,9 +38,6 @@
> #elif GTEST_OS_WINDOWS
> # include <direct.h>
> # include <io.h>
> -#elif GTEST_OS_SYMBIAN
> -// Symbian OpenC has PATH_MAX in sys/syslimits.h
> -# include <sys/syslimits.h>
> #else
> # include <limits.h>
> # include <climits> // Some Linux distributions define PATH_MAX here.
> @@ -95,13 +92,14 @@ static bool IsPathSeparator(char c) {
>
> // Returns the current working directory, or "" if unsuccessful.
> FilePath FilePath::GetCurrentDir() {
> -#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_WINDOWS_PHONE ||
> GTEST_OS_WINDOWS_RT
> - // Windows CE doesn't have a current directory, so we just return
> +#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_WINDOWS_PHONE || \
> + GTEST_OS_WINDOWS_RT || ARDUINO || defined(ESP_PLATFORM)
> + // These platforms do not have a current directory, so we just return
> // something reasonable.
> return FilePath(kCurrentDirectoryString);
> #elif GTEST_OS_WINDOWS
> char cwd[GTEST_PATH_MAX_ + 1] = { '\0' };
> - return FilePath(_getcwd(cwd, sizeof(cwd)) == NULL ? "" : cwd);
> + return FilePath(_getcwd(cwd, sizeof(cwd)) == nullptr ? "" : cwd);
> #else
> char cwd[GTEST_PATH_MAX_ + 1] = { '\0' };
> char* result = getcwd(cwd, sizeof(cwd));
> @@ -109,9 +107,9 @@ FilePath FilePath::GetCurrentDir() {
> // getcwd will likely fail in NaCl due to the sandbox, so return
> something
> // reasonable. The user may have provided a shim implementation for
> getcwd,
> // however, so fallback only when failure is detected.
> - return FilePath(result == NULL ? kCurrentDirectoryString : cwd);
> + return FilePath(result == nullptr ? kCurrentDirectoryString : cwd);
> # endif // GTEST_OS_NACL
> - return FilePath(result == NULL ? "" : cwd);
> + return FilePath(result == nullptr ? "" : cwd);
> #endif // GTEST_OS_WINDOWS_MOBILE
> }
>
> @@ -136,8 +134,8 @@ const char* FilePath::FindLastPathSeparator() const {
> #if GTEST_HAS_ALT_PATH_SEP_
> const char* const last_alt_sep = strrchr(c_str(),
> kAlternatePathSeparator);
> // Comparing two pointers of which only one is NULL is undefined.
> - if (last_alt_sep != NULL &&
> - (last_sep == NULL || last_alt_sep > last_sep)) {
> + if (last_alt_sep != nullptr &&
> + (last_sep == nullptr || last_alt_sep > last_sep)) {
> return last_alt_sep;
> }
> #endif
> @@ -165,7 +163,7 @@ FilePath FilePath::RemoveFileName() const {
> const char* const last_sep = FindLastPathSeparator();
> std::string dir;
> if (last_sep) {
> - dir = std::string(c_str(), last_sep + 1 - c_str());
> + dir = std::string(c_str(), static_cast<size_t>(last_sep + 1 -
> c_str()));
> } else {
> dir = kCurrentDirectoryString;
> }
> @@ -250,9 +248,6 @@ bool FilePath::DirectoryExists() const {
> // root directory per disk drive.)
> bool FilePath::IsRootDirectory() const {
> #if GTEST_OS_WINDOWS
> - // FIXME: on Windows a network share like
> - // \\server\share can be a root directory, although it cannot be the
> - // current directory. Handle this properly.
> return pathname_.length() == 3 && IsAbsolutePath();
> #else
> return pathname_.length() == 1 && IsPathSeparator(pathname_.c_str()[0]);
> @@ -324,7 +319,7 @@ bool FilePath::CreateFolder() const {
> #if GTEST_OS_WINDOWS_MOBILE
> FilePath removed_sep(this->RemoveTrailingPathSeparator());
> LPCWSTR unicode = String::AnsiToUtf16(removed_sep.c_str());
> - int result = CreateDirectory(unicode, NULL) ? 0 : -1;
> + int result = CreateDirectory(unicode, nullptr) ? 0 : -1;
> delete [] unicode;
> #elif GTEST_OS_WINDOWS
> int result = _mkdir(pathname_.c_str());
> @@ -350,9 +345,8 @@ FilePath FilePath::RemoveTrailingPathSeparator() const
> {
> // Removes any redundant separators that might be in the pathname.
> // For example, "bar///foo" becomes "bar/foo". Does not eliminate other
> // redundancies that might be in a pathname involving "." or "..".
> -// FIXME: handle Windows network shares (e.g. \\server\share).
> void FilePath::Normalize() {
> - if (pathname_.c_str() == NULL) {
> + if (pathname_.c_str() == nullptr) {
> pathname_ = "";
> return;
> }
>
> diff --git a/llvm/utils/unittest/googletest/src/gtest-internal-inl.h
> b/llvm/utils/unittest/googletest/src/gtest-internal-inl.h
> index 479004149b48c..8ed70daab0943 100644
> --- a/llvm/utils/unittest/googletest/src/gtest-internal-inl.h
> +++ b/llvm/utils/unittest/googletest/src/gtest-internal-inl.h
> @@ -42,6 +42,7 @@
> #include <string.h> // For memmove.
>
> #include <algorithm>
> +#include <memory>
> #include <string>
> #include <vector>
>
> @@ -98,14 +99,14 @@ const char kFlagfileFlag[] = "flagfile";
> // A valid random seed must be in [1, kMaxRandomSeed].
> const int kMaxRandomSeed = 99999;
>
> -// g_help_flag is true iff the --help flag or an equivalent form is
> -// specified on the command line.
> +// g_help_flag is true if and only if the --help flag or an equivalent
> form
> +// is specified on the command line.
> GTEST_API_ extern bool g_help_flag;
>
> // Returns the current time in milliseconds.
> GTEST_API_ TimeInMillis GetTimeInMillis();
>
> -// Returns true iff Google Test should use colors in the output.
> +// Returns true if and only if Google Test should use colors in the
> output.
> GTEST_API_ bool ShouldUseColor(bool stdout_is_tty);
>
> // Formats the given time in milliseconds as seconds.
> @@ -230,7 +231,7 @@ GTEST_API_ std::string CodePointToUtf8(UInt32
> code_point);
>
> // Converts a wide string to a narrow string in UTF-8 encoding.
> // The wide string is assumed to have the following encoding:
> -// UTF-16 if sizeof(wchar_t) == 2 (on Windows, Cygwin, Symbian OS)
> +// UTF-16 if sizeof(wchar_t) == 2 (on Windows, Cygwin)
> // UTF-32 if sizeof(wchar_t) == 4 (on Linux)
> // Parameter str points to a null-terminated wide string.
> // Parameter num_chars may additionally limit the number
> @@ -265,8 +266,8 @@ GTEST_API_ bool ShouldShard(const char*
> total_shards_str,
> GTEST_API_ Int32 Int32FromEnvOrDie(const char* env_var, Int32
> default_val);
>
> // Given the total number of shards, the shard index, and the test id,
> -// returns true iff the test should be run on this shard. The test id is
> -// some arbitrary but unique non-negative integer assigned to each test
> +// returns true if and only if the test should be run on this shard. The
> test id
> +// is some arbitrary but unique non-negative integer assigned to each test
> // method. Assumes that 0 <= shard_index < total_shards.
> GTEST_API_ bool ShouldRunTestOnShard(
> int total_shards, int shard_index, int test_id);
> @@ -297,7 +298,8 @@ void ForEach(const Container& c, Functor functor) {
> // in range [0, v.size()).
> template <typename E>
> inline E GetElementOr(const std::vector<E>& v, int i, E default_value) {
> - return (i < 0 || i >= static_cast<int>(v.size())) ? default_value :
> v[i];
> + return (i < 0 || i >= static_cast<int>(v.size())) ? default_value
> + :
> v[static_cast<size_t>(i)];
> }
>
> // Performs an in-place shuffle of a range of the vector's elements.
> @@ -319,8 +321,11 @@ void ShuffleRange(internal::Random* random, int
> begin, int end,
> // http://en.wikipedia.org/wiki/Fisher-Yates_shuffle
> for (int range_width = end - begin; range_width >= 2; range_width--) {
> const int last_in_range = begin + range_width - 1;
> - const int selected = begin + random->Generate(range_width);
> - std::swap((*v)[selected], (*v)[last_in_range]);
> + const int selected =
> + begin +
> +
> static_cast<int>(random->Generate(static_cast<UInt32>(range_width)));
> + std::swap((*v)[static_cast<size_t>(selected)],
> + (*v)[static_cast<size_t>(last_in_range)]);
> }
> }
>
> @@ -347,7 +352,7 @@ class TestPropertyKeyIs {
> // TestPropertyKeyIs has NO default constructor.
> explicit TestPropertyKeyIs(const std::string& key) : key_(key) {}
>
> - // Returns true iff the test name of test property matches on key_.
> + // Returns true if and only if the test name of test property matches
> on key_.
> bool operator()(const TestProperty& test_property) const {
> return test_property.key() == key_;
> }
> @@ -380,17 +385,17 @@ class GTEST_API_ UnitTestOptions {
>
> // Functions for processing the gtest_filter flag.
>
> - // Returns true iff the wildcard pattern matches the string. The
> - // first ':' or '\0' character in pattern marks the end of it.
> + // Returns true if and only if the wildcard pattern matches the string.
> + // The first ':' or '\0' character in pattern marks the end of it.
> //
> // This recursive algorithm isn't very efficient, but is clear and
> // works well enough for matching test names, which are short.
> static bool PatternMatchesString(const char *pattern, const char *str);
>
> - // Returns true iff the user-specified filter matches the test case
> - // name and the test name.
> - static bool FilterMatchesTest(const std::string &test_case_name,
> - const std::string &test_name);
> + // Returns true if and only if the user-specified filter matches the
> test
> + // suite name and the test name.
> + static bool FilterMatchesTest(const std::string& test_suite_name,
> + const std::string& test_name);
>
> #if GTEST_OS_WINDOWS
> // Function for supporting the gtest_catch_exception flag.
> @@ -442,8 +447,8 @@ class OsStackTraceGetter : public
> OsStackTraceGetterInterface {
> public:
> OsStackTraceGetter() {}
>
> - virtual std::string CurrentStackTrace(int max_depth, int skip_count);
> - virtual void UponLeavingGTest();
> + std::string CurrentStackTrace(int max_depth, int skip_count) override;
> + void UponLeavingGTest() override;
>
> private:
> #if GTEST_HAS_ABSL
> @@ -474,7 +479,7 @@ class DefaultGlobalTestPartResultReporter
> explicit DefaultGlobalTestPartResultReporter(UnitTestImpl* unit_test);
> // Implements the TestPartResultReporterInterface. Reports the test part
> // result in the current test.
> - virtual void ReportTestPartResult(const TestPartResult& result);
> + void ReportTestPartResult(const TestPartResult& result) override;
>
> private:
> UnitTestImpl* const unit_test_;
> @@ -490,7 +495,7 @@ class DefaultPerThreadTestPartResultReporter
> explicit DefaultPerThreadTestPartResultReporter(UnitTestImpl*
> unit_test);
> // Implements the TestPartResultReporterInterface. The implementation
> just
> // delegates to the current global test part result reporter of
> *unit_test_.
> - virtual void ReportTestPartResult(const TestPartResult& result);
> + void ReportTestPartResult(const TestPartResult& result) override;
>
> private:
> UnitTestImpl* const unit_test_;
> @@ -528,22 +533,25 @@ class GTEST_API_ UnitTestImpl {
> void SetTestPartResultReporterForCurrentThread(
> TestPartResultReporterInterface* reporter);
>
> - // Gets the number of successful test cases.
> - int successful_test_case_count() const;
> + // Gets the number of successful test suites.
> + int successful_test_suite_count() const;
>
> - // Gets the number of failed test cases.
> - int failed_test_case_count() const;
> + // Gets the number of failed test suites.
> + int failed_test_suite_count() const;
>
> - // Gets the number of all test cases.
> - int total_test_case_count() const;
> + // Gets the number of all test suites.
> + int total_test_suite_count() const;
>
> - // Gets the number of all test cases that contain at least one test
> + // Gets the number of all test suites that contain at least one test
> // that should run.
> - int test_case_to_run_count() const;
> + int test_suite_to_run_count() const;
>
> // Gets the number of successful tests.
> int successful_test_count() const;
>
> + // Gets the number of skipped tests.
> + int skipped_test_count() const;
> +
> // Gets the number of failed tests.
> int failed_test_count() const;
>
> @@ -569,27 +577,33 @@ class GTEST_API_ UnitTestImpl {
> // Gets the elapsed time, in milliseconds.
> TimeInMillis elapsed_time() const { return elapsed_time_; }
>
> - // Returns true iff the unit test passed (i.e. all test cases passed).
> + // Returns true if and only if the unit test passed (i.e. all test
> suites
> + // passed).
> bool Passed() const { return !Failed(); }
>
> - // Returns true iff the unit test failed (i.e. some test case failed
> - // or something outside of all tests failed).
> + // Returns true if and only if the unit test failed (i.e. some test
> suite
> + // failed or something outside of all tests failed).
> bool Failed() const {
> - return failed_test_case_count() > 0 || ad_hoc_test_result()->Failed();
> + return failed_test_suite_count() > 0 ||
> ad_hoc_test_result()->Failed();
> }
>
> - // Gets the i-th test case among all the test cases. i can range from 0
> to
> - // total_test_case_count() - 1. If i is not in that range, returns NULL.
> - const TestCase* GetTestCase(int i) const {
> - const int index = GetElementOr(test_case_indices_, i, -1);
> - return index < 0 ? NULL : test_cases_[i];
> + // Gets the i-th test suite among all the test suites. i can range from
> 0 to
> + // total_test_suite_count() - 1. If i is not in that range, returns
> NULL.
> + const TestSuite* GetTestSuite(int i) const {
> + const int index = GetElementOr(test_suite_indices_, i, -1);
> + return index < 0 ? nullptr : test_suites_[static_cast<size_t>(i)];
> }
>
> - // Gets the i-th test case among all the test cases. i can range from 0
> to
> - // total_test_case_count() - 1. If i is not in that range, returns NULL.
> - TestCase* GetMutableTestCase(int i) {
> - const int index = GetElementOr(test_case_indices_, i, -1);
> - return index < 0 ? NULL : test_cases_[index];
> + // Legacy API is deprecated but still available
> +#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
> + const TestCase* GetTestCase(int i) const { return GetTestSuite(i); }
> +#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
> +
> + // Gets the i-th test suite among all the test suites. i can range from
> 0 to
> + // total_test_suite_count() - 1. If i is not in that range, returns
> NULL.
> + TestSuite* GetMutableSuiteCase(int i) {
> + const int index = GetElementOr(test_suite_indices_, i, -1);
> + return index < 0 ? nullptr : test_suites_[static_cast<size_t>(index)];
> }
>
> // Provides access to the event listener list.
> @@ -626,30 +640,38 @@ class GTEST_API_ UnitTestImpl {
> // trace but Bar() and CurrentOsStackTraceExceptTop() won't.
> std::string CurrentOsStackTraceExceptTop(int skip_count)
> GTEST_NO_INLINE_;
>
> - // Finds and returns a TestCase with the given name. If one doesn't
> + // Finds and returns a TestSuite with the given name. If one doesn't
> // exist, creates one and returns it.
> //
> // Arguments:
> //
> - // test_case_name: name of the test case
> + // test_suite_name: name of the test suite
> // type_param: the name of the test's type parameter, or NULL if
> // this is not a typed or a type-parameterized test.
> - // set_up_tc: pointer to the function that sets up the test case
> - // tear_down_tc: pointer to the function that tears down the test
> case
> - TestCase* GetTestCase(const char* test_case_name,
> - const char* type_param,
> - Test::SetUpTestCaseFunc set_up_tc,
> - Test::TearDownTestCaseFunc tear_down_tc);
> + // set_up_tc: pointer to the function that sets up the test suite
> + // tear_down_tc: pointer to the function that tears down the test
> suite
> + TestSuite* GetTestSuite(const char* test_suite_name, const char*
> type_param,
> + internal::SetUpTestSuiteFunc set_up_tc,
> + internal::TearDownTestSuiteFunc tear_down_tc);
> +
> +// Legacy API is deprecated but still available
> +#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
> + TestCase* GetTestCase(const char* test_case_name, const char*
> type_param,
> + internal::SetUpTestSuiteFunc set_up_tc,
> + internal::TearDownTestSuiteFunc tear_down_tc) {
> + return GetTestSuite(test_case_name, type_param, set_up_tc,
> tear_down_tc);
> + }
> +#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
>
> // Adds a TestInfo to the unit test.
> //
> // Arguments:
> //
> - // set_up_tc: pointer to the function that sets up the test case
> - // tear_down_tc: pointer to the function that tears down the test case
> + // set_up_tc: pointer to the function that sets up the test suite
> + // tear_down_tc: pointer to the function that tears down the test
> suite
> // test_info: the TestInfo object
> - void AddTestInfo(Test::SetUpTestCaseFunc set_up_tc,
> - Test::TearDownTestCaseFunc tear_down_tc,
> + void AddTestInfo(internal::SetUpTestSuiteFunc set_up_tc,
> + internal::TearDownTestSuiteFunc tear_down_tc,
> TestInfo* test_info) {
> // In order to support thread-safe death tests, we need to
> // remember the original working directory when the test program
> @@ -664,21 +686,20 @@ class GTEST_API_ UnitTestImpl {
> << "Failed to get the current working directory.";
> }
>
> - GetTestCase(test_info->test_case_name(),
> - test_info->type_param(),
> - set_up_tc,
> - tear_down_tc)->AddTestInfo(test_info);
> + GetTestSuite(test_info->test_suite_name(), test_info->type_param(),
> + set_up_tc, tear_down_tc)
> + ->AddTestInfo(test_info);
> }
>
> - // Returns ParameterizedTestCaseRegistry object used to keep track of
> + // Returns ParameterizedTestSuiteRegistry object used to keep track of
> // value-parameterized tests and instantiate and register them.
> - internal::ParameterizedTestCaseRegistry& parameterized_test_registry() {
> + internal::ParameterizedTestSuiteRegistry& parameterized_test_registry()
> {
> return parameterized_test_registry_;
> }
>
> - // Sets the TestCase object for the test that's currently running.
> - void set_current_test_case(TestCase* a_current_test_case) {
> - current_test_case_ = a_current_test_case;
> + // Sets the TestSuite object for the test that's currently running.
> + void set_current_test_suite(TestSuite* a_current_test_suite) {
> + current_test_suite_ = a_current_test_suite;
> }
>
> // Sets the TestInfo object for the test that's currently running. If
> @@ -689,7 +710,7 @@ class GTEST_API_ UnitTestImpl {
> }
>
> // Registers all parameterized tests defined using TEST_P and
> - // INSTANTIATE_TEST_CASE_P, creating regular tests for each
> test/parameter
> + // INSTANTIATE_TEST_SUITE_P, creating regular tests for each
> test/parameter
> // combination. This method can be called more then once; it has guards
> // protecting from registering the tests more then once. If
> // value-parameterized tests are disabled, RegisterParameterizedTests is
> @@ -704,7 +725,7 @@ class GTEST_API_ UnitTestImpl {
>
> // Clears the results of all tests, except the ad hoc tests.
> void ClearNonAdHocTestResult() {
> - ForEach(test_cases_, TestCase::ClearTestCaseResult);
> + ForEach(test_suites_, TestSuite::ClearTestSuiteResult);
> }
>
> // Clears the results of ad-hoc test assertions.
> @@ -713,7 +734,7 @@ class GTEST_API_ UnitTestImpl {
> }
>
> // Adds a TestProperty to the current TestResult object when invoked in
> a
> - // context of a test or a test case, or to the global property set. If
> the
> + // context of a test or a test suite, or to the global property set. If
> the
> // result already contains a property with the same key, the value will
> be
> // updated.
> void RecordProperty(const TestProperty& test_property);
> @@ -725,7 +746,7 @@ class GTEST_API_ UnitTestImpl {
>
> // Matches the full name of each test against the user-specified
> // filter to decide whether the test should run, then records the
> - // result in each TestCase and TestInfo object.
> + // result in each TestSuite and TestInfo object.
> // If shard_tests == HONOR_SHARDING_PROTOCOL, further filters tests
> // based on sharding variables in the environment.
> // Returns the number of tests that should run.
> @@ -734,7 +755,7 @@ class GTEST_API_ UnitTestImpl {
> // Prints the names of the tests matching the user-specified filter
> flag.
> void ListTestsMatchingFilter();
>
> - const TestCase* current_test_case() const { return current_test_case_; }
> + const TestSuite* current_test_suite() const { return
> current_test_suite_; }
> TestInfo* current_test_info() { return current_test_info_; }
> const TestInfo* current_test_info() const { return current_test_info_; }
>
> @@ -795,11 +816,11 @@ class GTEST_API_ UnitTestImpl {
> // Gets the random number generator.
> internal::Random* random() { return &random_; }
>
> - // Shuffles all test cases, and the tests within each test case,
> + // Shuffles all test suites, and the tests within each test suite,
> // making sure that death tests are still run first.
> void ShuffleTests();
>
> - // Restores the test cases and tests to their order before the first
> shuffle.
> + // Restores the test suites and tests to their order before the first
> shuffle.
> void UnshuffleTests();
>
> // Returns the value of GTEST_FLAG(catch_exceptions) at the moment
> @@ -839,31 +860,31 @@ class GTEST_API_ UnitTestImpl {
> // before/after the tests are run.
> std::vector<Environment*> environments_;
>
> - // The vector of TestCases in their original order. It owns the
> + // The vector of TestSuites in their original order. It owns the
> // elements in the vector.
> - std::vector<TestCase*> test_cases_;
> + std::vector<TestSuite*> test_suites_;
>
> - // Provides a level of indirection for the test case list to allow
> - // easy shuffling and restoring the test case order. The i-th
> - // element of this vector is the index of the i-th test case in the
> + // Provides a level of indirection for the test suite list to allow
> + // easy shuffling and restoring the test suite order. The i-th
> + // element of this vector is the index of the i-th test suite in the
> // shuffled order.
> - std::vector<int> test_case_indices_;
> + std::vector<int> test_suite_indices_;
>
> // ParameterizedTestRegistry object used to register value-parameterized
> // tests.
> - internal::ParameterizedTestCaseRegistry parameterized_test_registry_;
> + internal::ParameterizedTestSuiteRegistry parameterized_test_registry_;
>
> // Indicates whether RegisterParameterizedTests() has been called
> already.
> bool parameterized_tests_registered_;
>
> - // Index of the last death test case registered. Initially -1.
> - int last_death_test_case_;
> + // Index of the last death test suite registered. Initially -1.
> + int last_death_test_suite_;
>
> - // This points to the TestCase for the currently running test. It
> - // changes as Google Test goes through one test case after another.
> + // This points to the TestSuite for the currently running test. It
> + // changes as Google Test goes through one test suite after another.
> // When no test is running, this is set to NULL and Google Test
> // stores assertion results in ad_hoc_test_result_. Initially NULL.
> - TestCase* current_test_case_;
> + TestSuite* current_test_suite_;
>
> // This points to the TestInfo for the currently running test. It
> // changes as Google Test goes through one test after another. When
> @@ -891,7 +912,7 @@ class GTEST_API_ UnitTestImpl {
> // desired.
> OsStackTraceGetterInterface* os_stack_trace_getter_;
>
> - // True iff PostFlagParsingInit() has been called.
> + // True if and only if PostFlagParsingInit() has been called.
> bool post_flag_parse_init_performed_;
>
> // The random number seed used at the beginning of the test run.
> @@ -910,8 +931,8 @@ class GTEST_API_ UnitTestImpl {
> #if GTEST_HAS_DEATH_TEST
> // The decomposed components of the gtest_internal_run_death_test flag,
> // parsed when RUN_ALL_TESTS is called.
> - internal::scoped_ptr<InternalRunDeathTestFlag>
> internal_run_death_test_flag_;
> - internal::scoped_ptr<internal::DeathTestFactory> death_test_factory_;
> + std::unique_ptr<InternalRunDeathTestFlag> internal_run_death_test_flag_;
> + std::unique_ptr<internal::DeathTestFactory> death_test_factory_;
> #endif // GTEST_HAS_DEATH_TEST
>
> // A per-thread stack of traces created by the SCOPED_TRACE() macro.
> @@ -994,8 +1015,6 @@ bool ParseNaturalNumber(const ::std::string& str,
> Integer* number) {
>
> const bool parse_success = *end == '\0' && errno == 0;
>
> - // FIXME: Convert this to compile time assertion when it is
> - // available.
> GTEST_CHECK_(sizeof(Integer) <= sizeof(parsed));
>
> const Integer result = static_cast<Integer>(parsed);
> @@ -1059,18 +1078,18 @@ class StreamingListener : public
> EmptyTestEventListener {
> MakeConnection();
> }
>
> - virtual ~SocketWriter() {
> + ~SocketWriter() override {
> if (sockfd_ != -1)
> CloseConnection();
> }
>
> // Sends a string to the socket.
> - virtual void Send(const std::string& message) {
> + void Send(const std::string& message) override {
> GTEST_CHECK_(sockfd_ != -1)
> << "Send() can be called only when there is a connection.";
>
> - const int len = static_cast<int>(message.length());
> - if (write(sockfd_, message.c_str(), len) != len) {
> + const auto len = static_cast<size_t>(message.length());
> + if (write(sockfd_, message.c_str(), len) !=
> static_cast<ssize_t>(len)) {
> GTEST_LOG_(WARNING)
> << "stream_result_to: failed to stream to "
> << host_name_ << ":" << port_num_;
> @@ -1082,7 +1101,7 @@ class StreamingListener : public
> EmptyTestEventListener {
> void MakeConnection();
>
> // Closes the socket.
> - void CloseConnection() {
> + void CloseConnection() override {
> GTEST_CHECK_(sockfd_ != -1)
> << "CloseConnection() can be called only when there is a
> connection.";
>
> @@ -1108,11 +1127,11 @@ class StreamingListener : public
> EmptyTestEventListener {
> explicit StreamingListener(AbstractSocketWriter* socket_writer)
> : socket_writer_(socket_writer) { Start(); }
>
> - void OnTestProgramStart(const UnitTest& /* unit_test */) {
> + void OnTestProgramStart(const UnitTest& /* unit_test */) override {
> SendLn("event=TestProgramStart");
> }
>
> - void OnTestProgramEnd(const UnitTest& unit_test) {
> + void OnTestProgramEnd(const UnitTest& unit_test) override {
> // Note that Google Test current only report elapsed time for each
> // test iteration, not for the entire test program.
> SendLn("event=TestProgramEnd&passed=" +
> FormatBool(unit_test.Passed()));
> @@ -1121,42 +1140,47 @@ class StreamingListener : public
> EmptyTestEventListener {
> socket_writer_->CloseConnection();
> }
>
> - void OnTestIterationStart(const UnitTest& /* unit_test */, int
> iteration) {
> + void OnTestIterationStart(const UnitTest& /* unit_test */,
> + int iteration) override {
> SendLn("event=TestIterationStart&iteration=" +
> StreamableToString(iteration));
> }
>
> - void OnTestIterationEnd(const UnitTest& unit_test, int /* iteration */)
> {
> + void OnTestIterationEnd(const UnitTest& unit_test,
> + int /* iteration */) override {
> SendLn("event=TestIterationEnd&passed=" +
> FormatBool(unit_test.Passed()) + "&elapsed_time=" +
> StreamableToString(unit_test.elapsed_time()) + "ms");
> }
>
> - void OnTestCaseStart(const TestCase& test_case) {
> + // Note that "event=TestCaseStart" is a wire format and has to remain
> + // "case" for compatibilty
> + void OnTestCaseStart(const TestCase& test_case) override {
> SendLn(std::string("event=TestCaseStart&name=") + test_case.name());
> }
>
> - void OnTestCaseEnd(const TestCase& test_case) {
> - SendLn("event=TestCaseEnd&passed=" + FormatBool(test_case.Passed())
> - + "&elapsed_time=" +
> StreamableToString(test_case.elapsed_time())
> - + "ms");
> + // Note that "event=TestCaseEnd" is a wire format and has to remain
> + // "case" for compatibilty
> + void OnTestCaseEnd(const TestCase& test_case) override {
> + SendLn("event=TestCaseEnd&passed=" + FormatBool(test_case.Passed()) +
> + "&elapsed_time=" +
> StreamableToString(test_case.elapsed_time()) +
> + "ms");
> }
>
> - void OnTestStart(const TestInfo& test_info) {
> + void OnTestStart(const TestInfo& test_info) override {
> SendLn(std::string("event=TestStart&name=") + test_info.name());
> }
>
> - void OnTestEnd(const TestInfo& test_info) {
> + void OnTestEnd(const TestInfo& test_info) override {
> SendLn("event=TestEnd&passed=" +
> FormatBool((test_info.result())->Passed()) +
> "&elapsed_time=" +
> StreamableToString((test_info.result())->elapsed_time()) +
> "ms");
> }
>
> - void OnTestPartResult(const TestPartResult& test_part_result) {
> + void OnTestPartResult(const TestPartResult& test_part_result) override {
> const char* file_name = test_part_result.file_name();
> - if (file_name == NULL)
> - file_name = "";
> + if (file_name == nullptr) file_name = "";
> SendLn("event=TestPartResult&file=" + UrlEncode(file_name) +
> "&line=" + StreamableToString(test_part_result.line_number()) +
> "&message=" + UrlEncode(test_part_result.message()));
> @@ -1172,7 +1196,7 @@ class StreamingListener : public
> EmptyTestEventListener {
>
> std::string FormatBool(bool value) { return value ? "1" : "0"; }
>
> - const scoped_ptr<AbstractSocketWriter> socket_writer_;
> + const std::unique_ptr<AbstractSocketWriter> socket_writer_;
>
> GTEST_DISALLOW_COPY_AND_ASSIGN_(StreamingListener);
> }; // class StreamingListener
>
> diff --git a/llvm/utils/unittest/googletest/src/gtest-matchers.cc
> b/llvm/utils/unittest/googletest/src/gtest-matchers.cc
> new file mode 100644
> index 0000000000000..7d2fb6851ec41
> --- /dev/null
> +++ b/llvm/utils/unittest/googletest/src/gtest-matchers.cc
> @@ -0,0 +1,97 @@
> +// Copyright 2007, Google Inc.
> +// All rights reserved.
> +//
> +// Redistribution and use in source and binary forms, with or without
> +// modification, are permitted provided that the following conditions are
> +// met:
> +//
> +// * Redistributions of source code must retain the above copyright
> +// notice, this list of conditions and the following disclaimer.
> +// * Redistributions in binary form must reproduce the above
> +// copyright notice, this list of conditions and the following disclaimer
> +// in the documentation and/or other materials provided with the
> +// distribution.
> +// * Neither the name of Google Inc. nor the names of its
> +// contributors may be used to endorse or promote products derived from
> +// this software without specific prior written permission.
> +//
> +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
> +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
> +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
> +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
> +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
> +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
> +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
> +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
> +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
> +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
> +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
> +
> +// The Google C++ Testing and Mocking Framework (Google Test)
> +//
> +// This file implements just enough of the matcher interface to allow
> +// EXPECT_DEATH and friends to accept a matcher argument.
> +
> +#include "gtest/internal/gtest-internal.h"
> +#include "gtest/internal/gtest-port.h"
> +#include "gtest/gtest-matchers.h"
> +
> +#include <string>
> +
> +namespace testing {
> +
> +// Constructs a matcher that matches a const std::string& whose value is
> +// equal to s.
> +Matcher<const std::string&>::Matcher(const std::string& s) { *this =
> Eq(s); }
> +
> +// Constructs a matcher that matches a const std::string& whose value is
> +// equal to s.
> +Matcher<const std::string&>::Matcher(const char* s) {
> + *this = Eq(std::string(s));
> +}
> +
> +// Constructs a matcher that matches a std::string whose value is equal to
> +// s.
> +Matcher<std::string>::Matcher(const std::string& s) { *this = Eq(s); }
> +
> +// Constructs a matcher that matches a std::string whose value is equal to
> +// s.
> +Matcher<std::string>::Matcher(const char* s) { *this =
> Eq(std::string(s)); }
> +
> +#if GTEST_HAS_ABSL
> +// Constructs a matcher that matches a const absl::string_view& whose
> value is
> +// equal to s.
> +Matcher<const absl::string_view&>::Matcher(const std::string& s) {
> + *this = Eq(s);
> +}
> +
> +// Constructs a matcher that matches a const absl::string_view& whose
> value is
> +// equal to s.
> +Matcher<const absl::string_view&>::Matcher(const char* s) {
> + *this = Eq(std::string(s));
> +}
> +
> +// Constructs a matcher that matches a const absl::string_view& whose
> value is
> +// equal to s.
> +Matcher<const absl::string_view&>::Matcher(absl::string_view s) {
> + *this = Eq(std::string(s));
> +}
> +
> +// Constructs a matcher that matches a absl::string_view whose value is
> equal to
> +// s.
> +Matcher<absl::string_view>::Matcher(const std::string& s) { *this =
> Eq(s); }
> +
> +// Constructs a matcher that matches a absl::string_view whose value is
> equal to
> +// s.
> +Matcher<absl::string_view>::Matcher(const char* s) {
> + *this = Eq(std::string(s));
> +}
> +
> +// Constructs a matcher that matches a absl::string_view whose value is
> equal to
> +// s.
> +Matcher<absl::string_view>::Matcher(absl::string_view s) {
> + *this = Eq(std::string(s));
> +}
> +#endif // GTEST_HAS_ABSL
> +
> +} // namespace testing
>
> diff --git a/llvm/utils/unittest/googletest/src/gtest-port.cc
> b/llvm/utils/unittest/googletest/src/gtest-port.cc
> index fecb5d11c2129..fc5ba6becc55f 100644
> --- a/llvm/utils/unittest/googletest/src/gtest-port.cc
> +++ b/llvm/utils/unittest/googletest/src/gtest-port.cc
> @@ -31,16 +31,20 @@
> #include "gtest/internal/gtest-port.h"
>
> #include <limits.h>
> -#include <stdlib.h>
> #include <stdio.h>
> +#include <stdlib.h>
> #include <string.h>
> #include <fstream>
> +#include <memory>
>
> #if GTEST_OS_WINDOWS
> # include <windows.h>
> # include <io.h>
> # include <sys/stat.h>
> # include <map> // Used in ThreadLocal.
> +# ifdef _MSC_VER
> +# include <crtdbg.h>
> +# endif // _MSC_VER
> #else
> # include <unistd.h>
> #endif // GTEST_OS_WINDOWS
> @@ -51,6 +55,14 @@
> # include <mach/vm_map.h>
> #endif // GTEST_OS_MAC
>
> +#if GTEST_OS_DRAGONFLY || GTEST_OS_FREEBSD || GTEST_OS_GNU_KFREEBSD || \
> + GTEST_OS_NETBSD || GTEST_OS_OPENBSD
> +# include <sys/sysctl.h>
> +# if GTEST_OS_DRAGONFLY || GTEST_OS_FREEBSD || GTEST_OS_GNU_KFREEBSD
> +# include <sys/user.h>
> +# endif
> +#endif
> +
> #if GTEST_OS_QNX
> # include <devctl.h>
> # include <fcntl.h>
> @@ -105,7 +117,7 @@ T ReadProcFileField(const std::string& filename, int
> field) {
> size_t GetThreadCount() {
> const std::string filename =
> (Message() << "/proc/" << getpid() << "/stat").GetString();
> - return ReadProcFileField<int>(filename, 19);
> + return ReadProcFileField<size_t>(filename, 19);
> }
>
> #elif GTEST_OS_MAC
> @@ -127,6 +139,81 @@ size_t GetThreadCount() {
> }
> }
>
> +#elif GTEST_OS_DRAGONFLY || GTEST_OS_FREEBSD || GTEST_OS_GNU_KFREEBSD || \
> + GTEST_OS_NETBSD
> +
> +#if GTEST_OS_NETBSD
> +#undef KERN_PROC
> +#define KERN_PROC KERN_PROC2
> +#define kinfo_proc kinfo_proc2
> +#endif
> +
> +#if GTEST_OS_DRAGONFLY
> +#define KP_NLWP(kp) (kp.kp_nthreads)
> +#elif GTEST_OS_FREEBSD || GTEST_OS_GNU_KFREEBSD
> +#define KP_NLWP(kp) (kp.ki_numthreads)
> +#elif GTEST_OS_NETBSD
> +#define KP_NLWP(kp) (kp.p_nlwps)
> +#endif
> +
> +// Returns the number of threads running in the process, or 0 to indicate
> that
> +// we cannot detect it.
> +size_t GetThreadCount() {
> + int mib[] = {
> + CTL_KERN,
> + KERN_PROC,
> + KERN_PROC_PID,
> + getpid(),
> +#if GTEST_OS_NETBSD
> + sizeof(struct kinfo_proc),
> + 1,
> +#endif
> + };
> + u_int miblen = sizeof(mib) / sizeof(mib[0]);
> + struct kinfo_proc info;
> + size_t size = sizeof(info);
> + if (sysctl(mib, miblen, &info, &size, NULL, 0)) {
> + return 0;
> + }
> + return static_cast<size_t>(KP_NLWP(info));
> +}
> +#elif GTEST_OS_OPENBSD
> +
> +// Returns the number of threads running in the process, or 0 to indicate
> that
> +// we cannot detect it.
> +size_t GetThreadCount() {
> + int mib[] = {
> + CTL_KERN,
> + KERN_PROC,
> + KERN_PROC_PID | KERN_PROC_SHOW_THREADS,
> + getpid(),
> + sizeof(struct kinfo_proc),
> + 0,
> + };
> + u_int miblen = sizeof(mib) / sizeof(mib[0]);
> +
> + // get number of structs
> + size_t size;
> + if (sysctl(mib, miblen, NULL, &size, NULL, 0)) {
> + return 0;
> + }
> + mib[5] = size / mib[4];
> +
> + // populate array of structs
> + struct kinfo_proc info[mib[5]];
> + if (sysctl(mib, miblen, &info, &size, NULL, 0)) {
> + return 0;
> + }
> +
> + // exclude empty members
> + int nthreads = 0;
> + for (int i = 0; i < size / mib[4]; i++) {
> + if (info[i].p_tid != -1)
> + nthreads++;
> + }
> + return nthreads;
> +}
> +
> #elif GTEST_OS_QNX
>
> // Returns the number of threads running in the process, or 0 to indicate
> that
> @@ -138,7 +225,7 @@ size_t GetThreadCount() {
> }
> procfs_info process_info;
> const int status =
> - devctl(fd, DCMD_PROC_INFO, &process_info, sizeof(process_info),
> NULL);
> + devctl(fd, DCMD_PROC_INFO, &process_info, sizeof(process_info),
> nullptr);
> close(fd);
> if (status == EOK) {
> return static_cast<size_t>(process_info.num_threads);
> @@ -152,7 +239,7 @@ size_t GetThreadCount() {
> size_t GetThreadCount() {
> struct procentry64 entry;
> pid_t pid = getpid();
> - int status = getprocs64(&entry, sizeof(entry), NULL, 0, &pid, 1);
> + int status = getprocs64(&entry, sizeof(entry), nullptr, 0, &pid, 1);
> if (status == 1) {
> return entry.pi_thcount;
> } else {
> @@ -192,7 +279,7 @@ size_t GetThreadCount() {
> #if GTEST_IS_THREADSAFE && GTEST_OS_WINDOWS
>
> void SleepMilliseconds(int n) {
> - ::Sleep(n);
> + ::Sleep(static_cast<DWORD>(n));
> }
>
> AutoHandle::AutoHandle()
> @@ -230,15 +317,15 @@ void AutoHandle::Reset(HANDLE handle) {
> bool AutoHandle::IsCloseable() const {
> // Different Windows APIs may use either of these values to represent an
> // invalid handle.
> - return handle_ != NULL && handle_ != INVALID_HANDLE_VALUE;
> + return handle_ != nullptr && handle_ != INVALID_HANDLE_VALUE;
> }
>
> Notification::Notification()
> - : event_(::CreateEvent(NULL, // Default security attributes.
> - TRUE, // Do not reset automatically.
> - FALSE, // Initially unset.
> - NULL)) { // Anonymous event.
> - GTEST_CHECK_(event_.Get() != NULL);
> + : event_(::CreateEvent(nullptr, // Default security attributes.
> + TRUE, // Do not reset automatically.
> + FALSE, // Initially unset.
> + nullptr)) { // Anonymous event.
> + GTEST_CHECK_(event_.Get() != nullptr);
> }
>
> void Notification::Notify() {
> @@ -261,13 +348,10 @@ Mutex::Mutex()
> Mutex::~Mutex() {
> // Static mutexes are leaked intentionally. It is not thread-safe to try
> // to clean them up.
> - // FIXME: Switch to Slim Reader/Writer (SRW) Locks, which requires
> - // nothing to clean it up but is available only on Vista and later.
> - //
> https://docs.microsoft.com/en-us/windows/desktop/Sync/slim-reader-writer--srw--locks
> if (type_ == kDynamic) {
> ::DeleteCriticalSection(critical_section_);
> delete critical_section_;
> - critical_section_ = NULL;
> + critical_section_ = nullptr;
> }
> }
>
> @@ -296,6 +380,7 @@ void Mutex::AssertHeld() {
>
> namespace {
>
> +#ifdef _MSC_VER
> // Use the RAII idiom to flag mem allocs that are intentionally never
> // deallocated. The motivation is to silence the false positive mem leaks
> // that are reported by the debug version of MS's CRT which can only
> detect
> @@ -308,19 +393,15 @@ class MemoryIsNotDeallocated
> {
> public:
> MemoryIsNotDeallocated() : old_crtdbg_flag_(0) {
> -#ifdef _MSC_VER
> old_crtdbg_flag_ = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);
> // Set heap allocation block type to _IGNORE_BLOCK so that MS debug
> CRT
> // doesn't report mem leak if there's no matching deallocation.
> _CrtSetDbgFlag(old_crtdbg_flag_ & ~_CRTDBG_ALLOC_MEM_DF);
> -#endif // _MSC_VER
> }
>
> ~MemoryIsNotDeallocated() {
> -#ifdef _MSC_VER
> // Restore the original _CRTDBG_ALLOC_MEM_DF flag
> _CrtSetDbgFlag(old_crtdbg_flag_);
> -#endif // _MSC_VER
> }
>
> private:
> @@ -328,6 +409,7 @@ class MemoryIsNotDeallocated
>
> GTEST_DISALLOW_COPY_AND_ASSIGN_(MemoryIsNotDeallocated);
> };
> +#endif // _MSC_VER
>
> } // namespace
>
> @@ -343,7 +425,9 @@ void Mutex::ThreadSafeLazyInit() {
> owner_thread_id_ = 0;
> {
> // Use RAII to flag that following mem alloc is never
> deallocated.
> +#ifdef _MSC_VER
> MemoryIsNotDeallocated memory_is_not_deallocated;
> +#endif // _MSC_VER
> critical_section_ = new CRITICAL_SECTION;
> }
> ::InitializeCriticalSection(critical_section_);
> @@ -384,17 +468,16 @@ class ThreadWithParamSupport : public
> ThreadWithParamBase {
> Notification* thread_can_start) {
> ThreadMainParam* param = new ThreadMainParam(runnable,
> thread_can_start);
> DWORD thread_id;
> - // FIXME: Consider to use _beginthreadex instead.
> HANDLE thread_handle = ::CreateThread(
> - NULL, // Default security.
> - 0, // Default stack size.
> + nullptr, // Default security.
> + 0, // Default stack size.
> &ThreadWithParamSupport::ThreadMain,
> - param, // Parameter to ThreadMainStatic
> - 0x0, // Default creation flags.
> + param, // Parameter to ThreadMainStatic
> + 0x0, // Default creation flags.
> &thread_id); // Need a valid pointer for the call to work under
> Win98.
> - GTEST_CHECK_(thread_handle != NULL) << "CreateThread failed with
> error "
> - << ::GetLastError() << ".";
> - if (thread_handle == NULL) {
> + GTEST_CHECK_(thread_handle != nullptr)
> + << "CreateThread failed with error " << ::GetLastError() << ".";
> + if (thread_handle == nullptr) {
> delete param;
> }
> return thread_handle;
> @@ -406,15 +489,15 @@ class ThreadWithParamSupport : public
> ThreadWithParamBase {
> : runnable_(runnable),
> thread_can_start_(thread_can_start) {
> }
> - scoped_ptr<Runnable> runnable_;
> + std::unique_ptr<Runnable> runnable_;
> // Does not own.
> Notification* thread_can_start_;
> };
>
> static DWORD WINAPI ThreadMain(void* ptr) {
> // Transfers ownership.
> - scoped_ptr<ThreadMainParam> param(static_cast<ThreadMainParam*>(ptr));
> - if (param->thread_can_start_ != NULL)
> + std::unique_ptr<ThreadMainParam>
> param(static_cast<ThreadMainParam*>(ptr));
> + if (param->thread_can_start_ != nullptr)
> param->thread_can_start_->WaitForNotification();
> param->runnable_->Run();
> return 0;
> @@ -472,7 +555,7 @@ class ThreadLocalRegistryImpl {
> thread_local_values
> .insert(std::make_pair(
> thread_local_instance,
> - linked_ptr<ThreadLocalValueHolderBase>(
> + std::shared_ptr<ThreadLocalValueHolderBase>(
> thread_local_instance->NewValueForCurrentThread())))
> .first;
> }
> @@ -481,7 +564,7 @@ class ThreadLocalRegistryImpl {
>
> static void OnThreadLocalDestroyed(
> const ThreadLocalBase* thread_local_instance) {
> - std::vector<linked_ptr<ThreadLocalValueHolderBase> > value_holders;
> + std::vector<std::shared_ptr<ThreadLocalValueHolderBase> >
> value_holders;
> // Clean up the ThreadLocalValues data structure while holding the
> lock, but
> // defer the destruction of the ThreadLocalValueHolderBases.
> {
> @@ -509,7 +592,7 @@ class ThreadLocalRegistryImpl {
>
> static void OnThreadExit(DWORD thread_id) {
> GTEST_CHECK_(thread_id != 0) << ::GetLastError();
> - std::vector<linked_ptr<ThreadLocalValueHolderBase> > value_holders;
> + std::vector<std::shared_ptr<ThreadLocalValueHolderBase> >
> value_holders;
> // Clean up the ThreadIdToThreadLocals data structure while holding
> the
> // lock, but defer the destruction of the ThreadLocalValueHolderBases.
> {
> @@ -536,7 +619,8 @@ class ThreadLocalRegistryImpl {
> private:
> // In a particular thread, maps a ThreadLocal object to its value.
> typedef std::map<const ThreadLocalBase*,
> - linked_ptr<ThreadLocalValueHolderBase> >
> ThreadLocalValues;
> + std::shared_ptr<ThreadLocalValueHolderBase> >
> + ThreadLocalValues;
> // Stores all ThreadIdToThreadLocals having values in a thread, indexed
> by
> // thread's ID.
> typedef std::map<DWORD, ThreadLocalValues> ThreadIdToThreadLocals;
> @@ -551,18 +635,17 @@ class ThreadLocalRegistryImpl {
> HANDLE thread = ::OpenThread(SYNCHRONIZE | THREAD_QUERY_INFORMATION,
> FALSE,
> thread_id);
> - GTEST_CHECK_(thread != NULL);
> + GTEST_CHECK_(thread != nullptr);
> // We need to pass a valid thread ID pointer into CreateThread for it
> // to work correctly under Win98.
> DWORD watcher_thread_id;
> HANDLE watcher_thread = ::CreateThread(
> - NULL, // Default security.
> - 0, // Default stack size
> + nullptr, // Default security.
> + 0, // Default stack size
> &ThreadLocalRegistryImpl::WatcherThreadFunc,
> reinterpret_cast<LPVOID>(new ThreadIdAndHandle(thread_id,
> thread)),
> - CREATE_SUSPENDED,
> - &watcher_thread_id);
> - GTEST_CHECK_(watcher_thread != NULL);
> + CREATE_SUSPENDED, &watcher_thread_id);
> + GTEST_CHECK_(watcher_thread != nullptr);
> // Give the watcher thread the same priority as ours to avoid being
> // blocked by it.
> ::SetThreadPriority(watcher_thread,
> @@ -587,7 +670,9 @@ class ThreadLocalRegistryImpl {
> // Returns map of thread local instances.
> static ThreadIdToThreadLocals* GetThreadLocalsMapLocked() {
> mutex_.AssertHeld();
> +#ifdef _MSC_VER
> MemoryIsNotDeallocated memory_is_not_deallocated;
> +#endif // _MSC_VER
> static ThreadIdToThreadLocals* map = new ThreadIdToThreadLocals();
> return map;
> }
> @@ -630,7 +715,7 @@ RE::~RE() {
> free(const_cast<char*>(pattern_));
> }
>
> -// Returns true iff regular expression re matches the entire str.
> +// Returns true if and only if regular expression re matches the entire
> str.
> bool RE::FullMatch(const char* str, const RE& re) {
> if (!re.is_valid_) return false;
>
> @@ -638,8 +723,8 @@ bool RE::FullMatch(const char* str, const RE& re) {
> return regexec(&re.full_regex_, str, 1, &match, 0) == 0;
> }
>
> -// Returns true iff regular expression re matches a substring of str
> -// (including str itself).
> +// Returns true if and only if regular expression re matches a substring
> of
> +// str (including str itself).
> bool RE::PartialMatch(const char* str, const RE& re) {
> if (!re.is_valid_) return false;
>
> @@ -679,14 +764,14 @@ void RE::Init(const char* regex) {
>
> #elif GTEST_USES_SIMPLE_RE
>
> -// Returns true iff ch appears anywhere in str (excluding the
> +// Returns true if and only if ch appears anywhere in str (excluding the
> // terminating '\0' character).
> bool IsInSet(char ch, const char* str) {
> - return ch != '\0' && strchr(str, ch) != NULL;
> + return ch != '\0' && strchr(str, ch) != nullptr;
> }
>
> -// Returns true iff ch belongs to the given classification. Unlike
> -// similar functions in <ctype.h>, these aren't affected by the
> +// Returns true if and only if ch belongs to the given classification.
> +// Unlike similar functions in <ctype.h>, these aren't affected by the
> // current locale.
> bool IsAsciiDigit(char ch) { return '0' <= ch && ch <= '9'; }
> bool IsAsciiPunct(char ch) {
> @@ -699,13 +784,13 @@ bool IsAsciiWordChar(char ch) {
> ('0' <= ch && ch <= '9') || ch == '_';
> }
>
> -// Returns true iff "\\c" is a supported escape sequence.
> +// Returns true if and only if "\\c" is a supported escape sequence.
> bool IsValidEscape(char c) {
> return (IsAsciiPunct(c) || IsInSet(c, "dDfnrsStvwW"));
> }
>
> -// Returns true iff the given atom (specified by escaped and pattern)
> -// matches ch. The result is undefined if the atom is invalid.
> +// Returns true if and only if the given atom (specified by escaped and
> +// pattern) matches ch. The result is undefined if the atom is invalid.
> bool AtomMatchesChar(bool escaped, char pattern_char, char ch) {
> if (escaped) { // "\\p" where p is pattern_char.
> switch (pattern_char) {
> @@ -736,17 +821,14 @@ static std::string FormatRegexSyntaxError(const
> char* regex, int index) {
> // Generates non-fatal failures and returns false if regex is invalid;
> // otherwise returns true.
> bool ValidateRegex(const char* regex) {
> - if (regex == NULL) {
> - // FIXME: fix the source file location in the
> - // assertion failures to match where the regex is used in user
> - // code.
> + if (regex == nullptr) {
> ADD_FAILURE() << "NULL is not a valid simple regular expression.";
> return false;
> }
>
> bool is_valid = true;
>
> - // True iff ?, *, or + can follow the previous atom.
> + // True if and only if ?, *, or + can follow the previous atom.
> bool prev_repeatable = false;
> for (int i = 0; regex[i]; i++) {
> if (regex[i] == '\\') { // An escape sequence
> @@ -822,8 +904,8 @@ bool MatchRepetitionAndRegexAtHead(
> return false;
> }
>
> -// Returns true iff regex matches a prefix of str. regex must be a
> -// valid simple regular expression and not start with "^", or the
> +// Returns true if and only if regex matches a prefix of str. regex must
> +// be a valid simple regular expression and not start with "^", or the
> // result is undefined.
> bool MatchRegexAtHead(const char* regex, const char* str) {
> if (*regex == '\0') // An empty regex matches a prefix of anything.
> @@ -853,8 +935,8 @@ bool MatchRegexAtHead(const char* regex, const char*
> str) {
> }
> }
>
> -// Returns true iff regex matches any substring of str. regex must be
> -// a valid simple regular expression, or the result is undefined.
> +// Returns true if and only if regex matches any substring of str. regex
> must
> +// be a valid simple regular expression, or the result is undefined.
> //
> // The algorithm is recursive, but the recursion depth doesn't exceed
> // the regex length, so we won't need to worry about running out of
> @@ -862,8 +944,7 @@ bool MatchRegexAtHead(const char* regex, const char*
> str) {
> // exponential with respect to the regex length + the string length,
> // but usually it's must faster (often close to linear).
> bool MatchRegexAnywhere(const char* regex, const char* str) {
> - if (regex == NULL || str == NULL)
> - return false;
> + if (regex == nullptr || str == nullptr) return false;
>
> if (*regex == '^')
> return MatchRegexAtHead(regex + 1, str);
> @@ -883,21 +964,21 @@ RE::~RE() {
> free(const_cast<char*>(full_pattern_));
> }
>
> -// Returns true iff regular expression re matches the entire str.
> +// Returns true if and only if regular expression re matches the entire
> str.
> bool RE::FullMatch(const char* str, const RE& re) {
> return re.is_valid_ && MatchRegexAnywhere(re.full_pattern_, str);
> }
>
> -// Returns true iff regular expression re matches a substring of str
> -// (including str itself).
> +// Returns true if and only if regular expression re matches a substring
> of
> +// str (including str itself).
> bool RE::PartialMatch(const char* str, const RE& re) {
> return re.is_valid_ && MatchRegexAnywhere(re.pattern_, str);
> }
>
> // Initializes an RE from its string representation.
> void RE::Init(const char* regex) {
> - pattern_ = full_pattern_ = NULL;
> - if (regex != NULL) {
> + pattern_ = full_pattern_ = nullptr;
> + if (regex != nullptr) {
> pattern_ = posix::StrDup(regex);
> }
>
> @@ -935,7 +1016,7 @@ const char kUnknownFile[] = "unknown file";
> // Formats a source file path and a line number as they would appear
> // in an error message from the compiler used to compile this code.
> GTEST_API_ ::std::string FormatFileLocation(const char* file, int line) {
> - const std::string file_name(file == NULL ? kUnknownFile : file);
> + const std::string file_name(file == nullptr ? kUnknownFile : file);
>
> if (line < 0) {
> return file_name + ":";
> @@ -954,7 +1035,7 @@ GTEST_API_ ::std::string FormatFileLocation(const
> char* file, int line) {
> // to the file location it produces, unlike FormatFileLocation().
> GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(
> const char* file, int line) {
> - const std::string file_name(file == NULL ? kUnknownFile : file);
> + const std::string file_name(file == nullptr ? kUnknownFile : file);
>
> if (line < 0)
> return file_name;
> @@ -1021,20 +1102,22 @@ class CapturedStream {
> // code as part of a regular standalone executable, which doesn't
> // run in a Dalvik process (e.g. when running it through 'adb shell').
> //
> - // The location /sdcard is directly accessible from native code
> - // and is the only location (unofficially) supported by the Android
> - // team. It's generally a symlink to the real SD Card mount point
> - // which can be /mnt/sdcard, /mnt/sdcard0, /system/media/sdcard, or
> - // other OEM-customized locations. Never rely on these, and always
> - // use /sdcard.
> - char name_template[] = "/sdcard/gtest_captured_stream.XXXXXX";
> + // The location /data/local/tmp is directly accessible from native
> code.
> + // '/sdcard' and other variants cannot be relied on, as they are not
> + // guaranteed to be mounted, or may have a delay in mounting.
> + char name_template[] = "/data/local/tmp/gtest_captured_stream.XXXXXX";
> # else
> char name_template[] = "/tmp/captured_stream.XXXXXX";
> # endif // GTEST_OS_LINUX_ANDROID
> const int captured_fd = mkstemp(name_template);
> + if (captured_fd == -1) {
> + GTEST_LOG_(WARNING)
> + << "Failed to create tmp file " << name_template
> + << " for test; does the test have access to the /tmp
> directory?";
> + }
> filename_ = name_template;
> # endif // GTEST_OS_WINDOWS
> - fflush(NULL);
> + fflush(nullptr);
> dup2(captured_fd, fd_);
> close(captured_fd);
> }
> @@ -1046,13 +1129,17 @@ class CapturedStream {
> std::string GetCapturedString() {
> if (uncaptured_fd_ != -1) {
> // Restores the original stream.
> - fflush(NULL);
> + fflush(nullptr);
> dup2(uncaptured_fd_, fd_);
> close(uncaptured_fd_);
> uncaptured_fd_ = -1;
> }
>
> FILE* const file = posix::FOpen(filename_.c_str(), "r");
> + if (file == nullptr) {
> + GTEST_LOG_(FATAL) << "Failed to open tmp file " << filename_
> + << " for capturing stream.";
> + }
> const std::string content = ReadEntireFile(file);
> posix::FClose(file);
> return content;
> @@ -1069,13 +1156,13 @@ class CapturedStream {
>
> GTEST_DISABLE_MSC_DEPRECATED_POP_()
>
> -static CapturedStream* g_captured_stderr = NULL;
> -static CapturedStream* g_captured_stdout = NULL;
> +static CapturedStream* g_captured_stderr = nullptr;
> +static CapturedStream* g_captured_stdout = nullptr;
>
> // Starts capturing an output stream (stdout/stderr).
> static void CaptureStream(int fd, const char* stream_name,
> CapturedStream** stream) {
> - if (*stream != NULL) {
> + if (*stream != nullptr) {
> GTEST_LOG_(FATAL) << "Only one " << stream_name
> << " capturer can exist at a time.";
> }
> @@ -1087,7 +1174,7 @@ static std::string
> GetCapturedStream(CapturedStream** captured_stream) {
> const std::string content = (*captured_stream)->GetCapturedString();
>
> delete *captured_stream;
> - *captured_stream = NULL;
> + *captured_stream = nullptr;
>
> return content;
> }
> @@ -1146,10 +1233,11 @@ std::string ReadEntireFile(FILE* file) {
> }
>
> #if GTEST_HAS_DEATH_TEST
> -static const std::vector<std::string>* g_injected_test_argvs = NULL; //
> Owned.
> +static const std::vector<std::string>* g_injected_test_argvs =
> + nullptr; // Owned.
>
> std::vector<std::string> GetInjectableArgvs() {
> - if (g_injected_test_argvs != NULL) {
> + if (g_injected_test_argvs != nullptr) {
> return *g_injected_test_argvs;
> }
> return GetArgvs();
> @@ -1165,16 +1253,9 @@ void SetInjectableArgvs(const
> std::vector<std::string>& new_argvs) {
> new std::vector<std::string>(new_argvs.begin(), new_argvs.end()));
> }
>
> -#if GTEST_HAS_GLOBAL_STRING
> -void SetInjectableArgvs(const std::vector< ::string>& new_argvs) {
> - SetInjectableArgvs(
> - new std::vector<std::string>(new_argvs.begin(), new_argvs.end()));
> -}
> -#endif // GTEST_HAS_GLOBAL_STRING
> -
> void ClearInjectableArgvs() {
> delete g_injected_test_argvs;
> - g_injected_test_argvs = NULL;
> + g_injected_test_argvs = nullptr;
> }
> #endif // GTEST_HAS_DEATH_TEST
>
> @@ -1207,7 +1288,7 @@ static std::string FlagToEnvVar(const char* flag) {
> // unchanged and returns false.
> bool ParseInt32(const Message& src_text, const char* str, Int32* value) {
> // Parses the environment variable as a decimal integer.
> - char* end = NULL;
> + char* end = nullptr;
> const long long_value = strtol(str, &end, 10); // NOLINT
>
> // Has strtol() consumed all characters in the string?
> @@ -1246,15 +1327,15 @@ bool ParseInt32(const Message& src_text, const
> char* str, Int32* value) {
> // Reads and returns the Boolean environment variable corresponding to
> // the given flag; if it's not set, returns default_value.
> //
> -// The value is considered true iff it's not "0".
> +// The value is considered true if and only if it's not "0".
> bool BoolFromGTestEnv(const char* flag, bool default_value) {
> #if defined(GTEST_GET_BOOL_FROM_ENV_)
> return GTEST_GET_BOOL_FROM_ENV_(flag, default_value);
> #else
> const std::string env_var = FlagToEnvVar(flag);
> const char* const string_value = posix::GetEnv(env_var.c_str());
> - return string_value == NULL ?
> - default_value : strcmp(string_value, "0") != 0;
> + return string_value == nullptr ? default_value
> + : strcmp(string_value, "0") != 0;
> #endif // defined(GTEST_GET_BOOL_FROM_ENV_)
> }
>
> @@ -1267,7 +1348,7 @@ Int32 Int32FromGTestEnv(const char* flag, Int32
> default_value) {
> #else
> const std::string env_var = FlagToEnvVar(flag);
> const char* const string_value = posix::GetEnv(env_var.c_str());
> - if (string_value == NULL) {
> + if (string_value == nullptr) {
> // The environment variable is not set.
> return default_value;
> }
> @@ -1296,7 +1377,7 @@ Int32 Int32FromGTestEnv(const char* flag, Int32
> default_value) {
> std::string OutputFlagAlsoCheckEnvVar(){
> std::string default_value_for_output_flag = "";
> const char* xml_output_file_env = posix::GetEnv("XML_OUTPUT_FILE");
> - if (NULL != xml_output_file_env) {
> + if (nullptr != xml_output_file_env) {
> default_value_for_output_flag = std::string("xml:") +
> xml_output_file_env;
> }
> return default_value_for_output_flag;
> @@ -1310,7 +1391,7 @@ const char* StringFromGTestEnv(const char* flag,
> const char* default_value) {
> #else
> const std::string env_var = FlagToEnvVar(flag);
> const char* const value = posix::GetEnv(env_var.c_str());
> - return value == NULL ? default_value : value;
> + return value == nullptr ? default_value : value;
> #endif // defined(GTEST_GET_STRING_FROM_ENV_)
> }
>
>
> diff --git a/llvm/utils/unittest/googletest/src/gtest-printers.cc
> b/llvm/utils/unittest/googletest/src/gtest-printers.cc
> index de4d245e9fc88..3337be312ea40 100644
> --- a/llvm/utils/unittest/googletest/src/gtest-printers.cc
> +++ b/llvm/utils/unittest/googletest/src/gtest-printers.cc
> @@ -59,6 +59,7 @@ using ::std::ostream;
> // Prints a segment of bytes in the given object.
> GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_
> GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
> +GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_
> GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_
> void PrintByteSegmentInObjectTo(const unsigned char* obj_bytes, size_t
> start,
> size_t count, ostream* os) {
> @@ -89,7 +90,6 @@ void PrintBytesInObjectToImpl(const unsigned char*
> obj_bytes, size_t count,
> // If the object size is bigger than kThreshold, we'll have to omit
> // some details by printing only the first and the last kChunkSize
> // bytes.
> - // FIXME: let the user control the threshold using a flag.
> if (count < kThreshold) {
> PrintByteSegmentInObjectTo(obj_bytes, 0, count, os);
> } else {
> @@ -144,7 +144,8 @@ inline bool IsPrintableAscii(wchar_t c) {
> // which is the type of c.
> template <typename UnsignedChar, typename Char>
> static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) {
> - switch (static_cast<wchar_t>(c)) {
> + wchar_t w_c = static_cast<wchar_t>(c);
> + switch (w_c) {
> case L'\0':
> *os << "\\0";
> break;
> @@ -176,7 +177,7 @@ static CharFormat PrintAsCharLiteralTo(Char c,
> ostream* os) {
> *os << "\\v";
> break;
> default:
> - if (IsPrintableAscii(c)) {
> + if (IsPrintableAscii(w_c)) {
> *os << static_cast<char>(c);
> return kAsIs;
> } else {
> @@ -236,7 +237,7 @@ void PrintCharAndCodeTo(Char c, ostream* os) {
> if (format == kHexEscape || (1 <= c && c <= 9)) {
> // Do nothing.
> } else {
> - *os << ", 0x" << String::FormatHexInt(static_cast<UnsignedChar>(c));
> + *os << ", 0x" << String::FormatHexInt(static_cast<int>(c));
> }
> *os << ")";
> }
> @@ -261,6 +262,7 @@ void PrintTo(wchar_t wc, ostream* os) {
> template <typename CharType>
> GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_
> GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
> +GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_
> GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_
> static CharFormat PrintCharsAsStringTo(
> const CharType* begin, size_t len, ostream* os) {
> @@ -291,6 +293,7 @@ static CharFormat PrintCharsAsStringTo(
> template <typename CharType>
> GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_
> GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
> +GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_
> GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_
> static void UniversalPrintCharArray(
> const CharType* begin, size_t len, ostream* os) {
> @@ -327,7 +330,7 @@ void UniversalPrintArray(const wchar_t* begin, size_t
> len, ostream* os) {
>
> // Prints the given C string to the ostream.
> void PrintTo(const char* s, ostream* os) {
> - if (s == NULL) {
> + if (s == nullptr) {
> *os << "NULL";
> } else {
> *os << ImplicitCast_<const void*>(s) << " pointing to ";
> @@ -344,11 +347,11 @@ void PrintTo(const char* s, ostream* os) {
> #if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED)
> // Prints the given wide C string to the ostream.
> void PrintTo(const wchar_t* s, ostream* os) {
> - if (s == NULL) {
> + if (s == nullptr) {
> *os << "NULL";
> } else {
> *os << ImplicitCast_<const void*>(s) << " pointing to ";
> - PrintCharsAsStringTo(s, std::wcslen(s), os);
> + PrintCharsAsStringTo(s, wcslen(s), os);
> }
> }
> #endif // wchar_t is native
> @@ -420,17 +423,6 @@ void ConditionalPrintAsText(const char* str, size_t
> length, ostream* os) {
>
> } // anonymous namespace
>
> -// Prints a ::string object.
> -#if GTEST_HAS_GLOBAL_STRING
> -void PrintStringTo(const ::string& s, ostream* os) {
> - if (PrintCharsAsStringTo(s.data(), s.size(), os) == kHexEscape) {
> - if (GTEST_FLAG(print_utf8)) {
> - ConditionalPrintAsText(s.data(), s.size(), os);
> - }
> - }
> -}
> -#endif // GTEST_HAS_GLOBAL_STRING
> -
> void PrintStringTo(const ::std::string& s, ostream* os) {
> if (PrintCharsAsStringTo(s.data(), s.size(), os) == kHexEscape) {
> if (GTEST_FLAG(print_utf8)) {
> @@ -439,13 +431,6 @@ void PrintStringTo(const ::std::string& s, ostream*
> os) {
> }
> }
>
> -// Prints a ::wstring object.
> -#if GTEST_HAS_GLOBAL_WSTRING
> -void PrintWideStringTo(const ::wstring& s, ostream* os) {
> - PrintCharsAsStringTo(s.data(), s.size(), os);
> -}
> -#endif // GTEST_HAS_GLOBAL_WSTRING
> -
> #if GTEST_HAS_STD_WSTRING
> void PrintWideStringTo(const ::std::wstring& s, ostream* os) {
> PrintCharsAsStringTo(s.data(), s.size(), os);
>
> diff --git a/llvm/utils/unittest/googletest/src/gtest-test-part.cc
> b/llvm/utils/unittest/googletest/src/gtest-test-part.cc
> index c88860d923856..178317a6bcdbd 100644
> --- a/llvm/utils/unittest/googletest/src/gtest-test-part.cc
> +++ b/llvm/utils/unittest/googletest/src/gtest-test-part.cc
> @@ -41,18 +41,21 @@ using internal::GetUnitTestImpl;
> // in it.
> std::string TestPartResult::ExtractSummary(const char* message) {
> const char* const stack_trace = strstr(message,
> internal::kStackTraceMarker);
> - return stack_trace == NULL ? message :
> - std::string(message, stack_trace);
> + return stack_trace == nullptr ? message : std::string(message,
> stack_trace);
> }
>
> // Prints a TestPartResult object.
> std::ostream& operator<<(std::ostream& os, const TestPartResult& result) {
> - return os
> - << result.file_name() << ":" << result.line_number() << ": "
> - << (result.type() == TestPartResult::kSuccess ? "Success" :
> - result.type() == TestPartResult::kFatalFailure ? "Fatal
> failure" :
> - "Non-fatal failure") << ":\n"
> - << result.message() << std::endl;
> + return os << result.file_name() << ":" << result.line_number() << ": "
> + << (result.type() == TestPartResult::kSuccess
> + ? "Success"
> + : result.type() == TestPartResult::kSkip
> + ? "Skipped"
> + : result.type() == TestPartResult::kFatalFailure
> + ? "Fatal failure"
> + : "Non-fatal failure")
> + << ":\n"
> + << result.message() << std::endl;
> }
>
> // Appends a TestPartResult to the array.
> @@ -67,7 +70,7 @@ const TestPartResult&
> TestPartResultArray::GetTestPartResult(int index) const {
> internal::posix::Abort();
> }
>
> - return array_[index];
> + return array_[static_cast<size_t>(index)];
> }
>
> // Returns the number of TestPartResult objects in the array.
>
> diff --git a/llvm/utils/unittest/googletest/src/gtest-typed-test.cc
> b/llvm/utils/unittest/googletest/src/gtest-typed-test.cc
> index 1dc2ad38bab98..8677caf732b42 100644
> --- a/llvm/utils/unittest/googletest/src/gtest-typed-test.cc
> +++ b/llvm/utils/unittest/googletest/src/gtest-typed-test.cc
> @@ -48,7 +48,7 @@ static const char* SkipSpaces(const char* str) {
> static std::vector<std::string> SplitIntoTestNames(const char* src) {
> std::vector<std::string> name_vec;
> src = SkipSpaces(src);
> - for (; src != NULL; src = SkipComma(src)) {
> + for (; src != nullptr; src = SkipComma(src)) {
> name_vec.push_back(StripTrailingSpaces(GetPrefixUntilComma(src)));
> }
> return name_vec;
> @@ -57,7 +57,7 @@ static std::vector<std::string> SplitIntoTestNames(const
> char* src) {
> // Verifies that registered_tests match the test names in
> // registered_tests_; returns registered_tests if successful, or
> // aborts the program otherwise.
> -const char* TypedTestCasePState::VerifyRegisteredTestNames(
> +const char* TypedTestSuitePState::VerifyRegisteredTestNames(
> const char* file, int line, const char* registered_tests) {
> typedef RegisteredTestsMap::const_iterator RegisteredTestIter;
> registered_ = true;
> @@ -89,7 +89,7 @@ const char*
> TypedTestCasePState::VerifyRegisteredTestNames(
> tests.insert(name);
> } else {
> errors << "No test named " << name
> - << " can be found in this test case.\n";
> + << " can be found in this test suite.\n";
> }
> }
>
>
> diff --git a/llvm/utils/unittest/googletest/src/gtest.cc
> b/llvm/utils/unittest/googletest/src/gtest.cc
> index 96b07c68abb05..a5b4e5ac78ca1 100644
> --- a/llvm/utils/unittest/googletest/src/gtest.cc
> +++ b/llvm/utils/unittest/googletest/src/gtest.cc
> @@ -54,8 +54,6 @@
>
> #if GTEST_OS_LINUX
>
> -// FIXME: Use autoconf to detect availability of
> -// gettimeofday().
> # define GTEST_HAS_GETTIMEOFDAY_ 1
>
> # include <fcntl.h> // NOLINT
> @@ -68,10 +66,6 @@
> # include <unistd.h> // NOLINT
> # include <string>
>
> -#elif GTEST_OS_SYMBIAN
> -# define GTEST_HAS_GETTIMEOFDAY_ 1
> -# include <sys/time.h> // NOLINT
> -
> #elif GTEST_OS_ZOS
> # define GTEST_HAS_GETTIMEOFDAY_ 1
> # include <sys/time.h> // NOLINT
> @@ -86,6 +80,11 @@
>
> #elif GTEST_OS_WINDOWS // We are on Windows proper.
>
> +# include <windows.h> // NOLINT
> +# undef min
> +
> +# include <crtdbg.h> // NOLINT
> +# include <debugapi.h> // NOLINT
> # include <io.h> // NOLINT
> # include <sys/timeb.h> // NOLINT
> # include <sys/types.h> // NOLINT
> @@ -93,25 +92,13 @@
>
> # if GTEST_OS_WINDOWS_MINGW
> // MinGW has gettimeofday() but not _ftime64().
> -// FIXME: Use autoconf to detect availability of
> -// gettimeofday().
> -// FIXME: There are other ways to get the time on
> -// Windows, like GetTickCount() or GetSystemTimeAsFileTime(). MinGW
> -// supports these. consider using them instead.
> # define GTEST_HAS_GETTIMEOFDAY_ 1
> # include <sys/time.h> // NOLINT
> # endif // GTEST_OS_WINDOWS_MINGW
>
> -// cpplint thinks that the header is already included, so we want to
> -// silence it.
> -# include <windows.h> // NOLINT
> -# undef min
> -
> #else
>
> // Assume other platforms have gettimeofday().
> -// FIXME: Use autoconf to detect availability of
> -// gettimeofday().
> # define GTEST_HAS_GETTIMEOFDAY_ 1
>
> // cpplint thinks that the header is already included, so we want to
> @@ -160,14 +147,14 @@ using internal::Shuffle;
>
> // Constants.
>
> -// A test whose test case name or test name matches this filter is
> +// A test whose test suite name or test name matches this filter is
> // disabled and not run.
> static const char kDisableTestFilter[] = "DISABLED_*:*/DISABLED_*";
>
> -// A test case whose name matches this filter is considered a death
> -// test case and will be run before test cases whose name doesn't
> +// A test suite whose name matches this filter is considered a death
> +// test suite and will be run before test suites whose name doesn't
> // match this filter.
> -static const char kDeathTestCaseFilter[] = "*DeathTest:*DeathTest/*";
> +static const char kDeathTestSuiteFilter[] = "*DeathTest:*DeathTest/*";
>
> // A test filter that matches everything.
> static const char kUniversalFilter[] = "*";
> @@ -190,20 +177,20 @@ namespace internal {
> // stack trace.
> const char kStackTraceMarker[] = "\nStack trace:\n";
>
> -// g_help_flag is true iff the --help flag or an equivalent form is
> -// specified on the command line.
> +// g_help_flag is true if and only if the --help flag or an equivalent
> form
> +// is specified on the command line.
> bool g_help_flag = false;
>
> // Utilty function to Open File for Writing
> static FILE* OpenFileForWriting(const std::string& output_file) {
> - FILE* fileout = NULL;
> + FILE* fileout = nullptr;
> FilePath output_file_path(output_file);
> FilePath output_dir(output_file_path.RemoveFileName());
>
> if (output_dir.CreateDirectoriesRecursively()) {
> fileout = posix::FOpen(output_file.c_str(), "w");
> }
> - if (fileout == NULL) {
> + if (fileout == nullptr) {
> GTEST_LOG_(FATAL) << "Unable to open file \"" << output_file << "\"";
> }
> return fileout;
> @@ -216,7 +203,7 @@ static FILE* OpenFileForWriting(const std::string&
> output_file) {
> static const char* GetDefaultFilter() {
> const char* const testbridge_test_only =
> internal::posix::GetEnv("TESTBRIDGE_TEST_ONLY");
> - if (testbridge_test_only != NULL) {
> + if (testbridge_test_only != nullptr) {
> return testbridge_test_only;
> }
> return kUniversalFilter;
> @@ -228,15 +215,14 @@ GTEST_DEFINE_bool_(
> "Run disabled tests too, in addition to the tests normally being
> run.");
>
> GTEST_DEFINE_bool_(
> - break_on_failure,
> - internal::BoolFromGTestEnv("break_on_failure", false),
> - "True iff a failed assertion should be a debugger break-point.");
> + break_on_failure, internal::BoolFromGTestEnv("break_on_failure",
> false),
> + "True if and only if a failed assertion should be a debugger "
> + "break-point.");
>
> -GTEST_DEFINE_bool_(
> - catch_exceptions,
> - internal::BoolFromGTestEnv("catch_exceptions", true),
> - "True iff " GTEST_NAME_
> - " should catch exceptions and treat them as test failures.");
> +GTEST_DEFINE_bool_(catch_exceptions,
> + internal::BoolFromGTestEnv("catch_exceptions", true),
> + "True if and only if " GTEST_NAME_
> + " should catch exceptions and treat them as test
> failures.");
>
> GTEST_DEFINE_string_(
> color,
> @@ -283,17 +269,13 @@ GTEST_DEFINE_string_(
> "executable's name and, if necessary, made unique by adding "
> "digits.");
>
> -GTEST_DEFINE_bool_(
> - print_time,
> - internal::BoolFromGTestEnv("print_time", true),
> - "True iff " GTEST_NAME_
> - " should display elapsed time in text output.");
> +GTEST_DEFINE_bool_(print_time, internal::BoolFromGTestEnv("print_time",
> true),
> + "True if and only if " GTEST_NAME_
> + " should display elapsed time in text output.");
>
> -GTEST_DEFINE_bool_(
> - print_utf8,
> - internal::BoolFromGTestEnv("print_utf8", true),
> - "True iff " GTEST_NAME_
> - " prints UTF8 characters as text.");
> +GTEST_DEFINE_bool_(print_utf8, internal::BoolFromGTestEnv("print_utf8",
> true),
> + "True if and only if " GTEST_NAME_
> + " prints UTF8 characters as text.");
>
> GTEST_DEFINE_int32_(
> random_seed,
> @@ -307,16 +289,14 @@ GTEST_DEFINE_int32_(
> "How many times to repeat each test. Specify a negative number "
> "for repeating forever. Useful for shaking out flaky tests.");
>
> -GTEST_DEFINE_bool_(
> - show_internal_stack_frames, false,
> - "True iff " GTEST_NAME_ " should include internal stack frames when "
> - "printing test failure stack traces.");
> +GTEST_DEFINE_bool_(show_internal_stack_frames, false,
> + "True if and only if " GTEST_NAME_
> + " should include internal stack frames when "
> + "printing test failure stack traces.");
>
> -GTEST_DEFINE_bool_(
> - shuffle,
> - internal::BoolFromGTestEnv("shuffle", false),
> - "True iff " GTEST_NAME_
> - " should randomize tests' order on every run.");
> +GTEST_DEFINE_bool_(shuffle, internal::BoolFromGTestEnv("shuffle", false),
> + "True if and only if " GTEST_NAME_
> + " should randomize tests' order on every run.");
>
> GTEST_DEFINE_int32_(
> stack_trace_depth,
> @@ -367,16 +347,16 @@ UInt32 Random::Generate(UInt32 range) {
> return state_ % range;
> }
>
> -// GTestIsInitialized() returns true iff the user has initialized
> +// GTestIsInitialized() returns true if and only if the user has
> initialized
> // Google Test. Useful for catching the user mistake of not initializing
> // Google Test before calling RUN_ALL_TESTS().
> static bool GTestIsInitialized() { return GetArgvs().size() > 0; }
>
> -// Iterates over a vector of TestCases, keeping a running sum of the
> +// Iterates over a vector of TestSuites, keeping a running sum of the
> // results of calling a given int-returning method on each.
> // Returns the sum.
> -static int SumOverTestCaseList(const std::vector<TestCase*>& case_list,
> - int (TestCase::*method)() const) {
> +static int SumOverTestSuiteList(const std::vector<TestSuite*>& case_list,
> + int (TestSuite::*method)() const) {
> int sum = 0;
> for (size_t i = 0; i < case_list.size(); i++) {
> sum += (case_list[i]->*method)();
> @@ -384,20 +364,20 @@ static int SumOverTestCaseList(const
> std::vector<TestCase*>& case_list,
> return sum;
> }
>
> -// Returns true iff the test case passed.
> -static bool TestCasePassed(const TestCase* test_case) {
> - return test_case->should_run() && test_case->Passed();
> +// Returns true if and only if the test suite passed.
> +static bool TestSuitePassed(const TestSuite* test_suite) {
> + return test_suite->should_run() && test_suite->Passed();
> }
>
> -// Returns true iff the test case failed.
> -static bool TestCaseFailed(const TestCase* test_case) {
> - return test_case->should_run() && test_case->Failed();
> +// Returns true if and only if the test suite failed.
> +static bool TestSuiteFailed(const TestSuite* test_suite) {
> + return test_suite->should_run() && test_suite->Failed();
> }
>
> -// Returns true iff test_case contains at least one test that should
> -// run.
> -static bool ShouldRunTestCase(const TestCase* test_case) {
> - return test_case->should_run();
> +// Returns true if and only if test_suite contains at least one test that
> +// should run.
> +static bool ShouldRunTestSuite(const TestSuite* test_suite) {
> + return test_suite->should_run();
> }
>
> // AssertHelper constructor.
> @@ -423,9 +403,6 @@ void AssertHelper::operator=(const Message& message)
> const {
> ); // NOLINT
> }
>
> -// Mutex for linked pointers.
> -GTEST_API_ GTEST_DEFINE_STATIC_MUTEX_(g_linked_ptr_mutex);
> -
> // A copy of all command line arguments. Set by InitGoogleTest().
> static ::std::vector<std::string> g_argvs;
>
> @@ -445,7 +422,7 @@ ::std::vector<std::string> GetArgvs() {
> FilePath GetCurrentExecutableName() {
> FilePath result;
>
> -#if GTEST_OS_WINDOWS
> +#if GTEST_OS_WINDOWS || GTEST_OS_OS2
> result.Set(FilePath(GetArgvs()[0]).RemoveExtension("exe"));
> #else
> result.Set(FilePath(GetArgvs()[0]));
> @@ -460,9 +437,10 @@ FilePath GetCurrentExecutableName() {
> std::string UnitTestOptions::GetOutputFormat() {
> const char* const gtest_output_flag = GTEST_FLAG(output).c_str();
> const char* const colon = strchr(gtest_output_flag, ':');
> - return (colon == NULL) ?
> - std::string(gtest_output_flag) :
> - std::string(gtest_output_flag, colon - gtest_output_flag);
> + return (colon == nullptr)
> + ? std::string(gtest_output_flag)
> + : std::string(gtest_output_flag,
> + static_cast<size_t>(colon -
> gtest_output_flag));
> }
>
> // Returns the name of the requested output file, or the default if none
> @@ -475,7 +453,7 @@ std::string
> UnitTestOptions::GetAbsolutePathToOutputFile() {
> format = std::string(kDefaultOutputFormat);
>
> const char* const colon = strchr(gtest_output_flag, ':');
> - if (colon == NULL)
> + if (colon == nullptr)
> return internal::FilePath::MakeFileName(
> internal::FilePath(
> UnitTest::GetInstance()->original_working_dir()),
> @@ -484,10 +462,6 @@ std::string
> UnitTestOptions::GetAbsolutePathToOutputFile() {
>
> internal::FilePath output_name(colon + 1);
> if (!output_name.IsAbsolutePath())
> - // FIXME: on Windows \some\path is not an absolute
> - // path (as its meaning depends on the current drive), yet the
> - // following logic for turning it into an absolute path is wrong.
> - // Fix it.
> output_name = internal::FilePath::ConcatPaths(
>
> internal::FilePath(UnitTest::GetInstance()->original_working_dir()),
> internal::FilePath(colon + 1));
> @@ -501,8 +475,8 @@ std::string
> UnitTestOptions::GetAbsolutePathToOutputFile() {
> return result.string();
> }
>
> -// Returns true iff the wildcard pattern matches the string. The
> -// first ':' or '\0' character in pattern marks the end of it.
> +// Returns true if and only if the wildcard pattern matches the string.
> +// The first ':' or '\0' character in pattern marks the end of it.
> //
> // This recursive algorithm isn't very efficient, but is clear and
> // works well enough for matching test names, which are short.
> @@ -535,7 +509,7 @@ bool UnitTestOptions::MatchesFilter(
> cur_pattern = strchr(cur_pattern, ':');
>
> // Returns if no more pattern can be found.
> - if (cur_pattern == NULL) {
> + if (cur_pattern == nullptr) {
> return false;
> }
>
> @@ -544,11 +518,11 @@ bool UnitTestOptions::MatchesFilter(
> }
> }
>
> -// Returns true iff the user-specified filter matches the test case
> -// name and the test name.
> -bool UnitTestOptions::FilterMatchesTest(const std::string &test_case_name,
> - const std::string &test_name) {
> - const std::string& full_name = test_case_name + "." + test_name.c_str();
> +// Returns true if and only if the user-specified filter matches the test
> +// suite name and the test name.
> +bool UnitTestOptions::FilterMatchesTest(const std::string&
> test_suite_name,
> + const std::string& test_name) {
> + const std::string& full_name = test_suite_name + "." +
> test_name.c_str();
>
> // Split --gtest_filter at '-', if there is one, to separate into
> // positive filter and negative filter portions
> @@ -556,7 +530,7 @@ bool UnitTestOptions::FilterMatchesTest(const
> std::string &test_case_name,
> const char* const dash = strchr(p, '-');
> std::string positive;
> std::string negative;
> - if (dash == NULL) {
> + if (dash == nullptr) {
> positive = GTEST_FLAG(filter).c_str(); // Whole string is a positive
> filter
> negative = "";
> } else {
> @@ -701,7 +675,7 @@ static AssertionResult HasOneFailure(const char* /*
> results_expr */,
> << r;
> }
>
> - if (strstr(r.message(), substr.c_str()) == NULL) {
> + if (strstr(r.message(), substr.c_str()) == nullptr) {
> return AssertionFailure() << "Expected: " << expected << " containing
> \""
> << substr << "\"\n"
> << " Actual:\n"
> @@ -770,61 +744,66 @@ void
> UnitTestImpl::SetTestPartResultReporterForCurrentThread(
> per_thread_test_part_result_reporter_.set(reporter);
> }
>
> -// Gets the number of successful test cases.
> -int UnitTestImpl::successful_test_case_count() const {
> - return CountIf(test_cases_, TestCasePassed);
> +// Gets the number of successful test suites.
> +int UnitTestImpl::successful_test_suite_count() const {
> + return CountIf(test_suites_, TestSuitePassed);
> }
>
> -// Gets the number of failed test cases.
> -int UnitTestImpl::failed_test_case_count() const {
> - return CountIf(test_cases_, TestCaseFailed);
> +// Gets the number of failed test suites.
> +int UnitTestImpl::failed_test_suite_count() const {
> + return CountIf(test_suites_, TestSuiteFailed);
> }
>
> -// Gets the number of all test cases.
> -int UnitTestImpl::total_test_case_count() const {
> - return static_cast<int>(test_cases_.size());
> +// Gets the number of all test suites.
> +int UnitTestImpl::total_test_suite_count() const {
> + return static_cast<int>(test_suites_.size());
> }
>
> -// Gets the number of all test cases that contain at least one test
> +// Gets the number of all test suites that contain at least one test
> // that should run.
> -int UnitTestImpl::test_case_to_run_count() const {
> - return CountIf(test_cases_, ShouldRunTestCase);
> +int UnitTestImpl::test_suite_to_run_count() const {
> + return CountIf(test_suites_, ShouldRunTestSuite);
> }
>
> // Gets the number of successful tests.
> int UnitTestImpl::successful_test_count() const {
> - return SumOverTestCaseList(test_cases_,
> &TestCase::successful_test_count);
> + return SumOverTestSuiteList(test_suites_,
> &TestSuite::successful_test_count);
> +}
> +
> +// Gets the number of skipped tests.
> +int UnitTestImpl::skipped_test_count() const {
> + return SumOverTestSuiteList(test_suites_,
> &TestSuite::skipped_test_count);
> }
>
> // Gets the number of failed tests.
> int UnitTestImpl::failed_test_count() const {
> - return SumOverTestCaseList(test_cases_, &TestCase::failed_test_count);
> + return SumOverTestSuiteList(test_suites_,
> &TestSuite::failed_test_count);
> }
>
> // Gets the number of disabled tests that will be reported in the XML
> report.
> int UnitTestImpl::reportable_disabled_test_count() const {
> - return SumOverTestCaseList(test_cases_,
> - &TestCase::reportable_disabled_test_count);
> + return SumOverTestSuiteList(test_suites_,
> + &TestSuite::reportable_disabled_test_count);
> }
>
> // Gets the number of disabled tests.
> int UnitTestImpl::disabled_test_count() const {
> - return SumOverTestCaseList(test_cases_, &TestCase::disabled_test_count);
> + return SumOverTestSuiteList(test_suites_,
> &TestSuite::disabled_test_count);
> }
>
> // Gets the number of tests to be printed in the XML report.
> int UnitTestImpl::reportable_test_count() const {
> - return SumOverTestCaseList(test_cases_,
> &TestCase::reportable_test_count);
> + return SumOverTestSuiteList(test_suites_,
> &TestSuite::reportable_test_count);
> }
>
> // Gets the number of all tests.
> int UnitTestImpl::total_test_count() const {
> - return SumOverTestCaseList(test_cases_, &TestCase::total_test_count);
> + return SumOverTestSuiteList(test_suites_, &TestSuite::total_test_count);
> }
>
> // Gets the number of tests that should run.
> int UnitTestImpl::test_to_run_count() const {
> - return SumOverTestCaseList(test_cases_, &TestCase::test_to_run_count);
> + return SumOverTestSuiteList(test_suites_,
> &TestSuite::test_to_run_count);
> }
>
> // Returns the current OS stack trace as an std::string.
> @@ -858,8 +837,6 @@ TimeInMillis GetTimeInMillis() {
> SYSTEMTIME now_systime;
> FILETIME now_filetime;
> ULARGE_INTEGER now_int64;
> - // FIXME: Shouldn't this just use
> - // GetSystemTimeAsFileTime()?
> GetSystemTime(&now_systime);
> if (SystemTimeToFileTime(&now_systime, &now_filetime)) {
> now_int64.LowPart = now_filetime.dwLowDateTime;
> @@ -874,8 +851,6 @@ TimeInMillis GetTimeInMillis() {
>
> // MSVC 8 deprecates _ftime64(), so we want to suppress warning 4996
> // (deprecated function) there.
> - // FIXME: Use GetTickCount()? Or use
> - // SystemTimeToFileTime()
> GTEST_DISABLE_MSC_DEPRECATED_PUSH_()
> _ftime64(&now);
> GTEST_DISABLE_MSC_DEPRECATED_POP_()
> @@ -883,7 +858,7 @@ TimeInMillis GetTimeInMillis() {
> return static_cast<TimeInMillis>(now.time) * 1000 + now.millitm;
> #elif GTEST_HAS_GETTIMEOFDAY_
> struct timeval now;
> - gettimeofday(&now, NULL);
> + gettimeofday(&now, nullptr);
> return static_cast<TimeInMillis>(now.tv_sec) * 1000 + now.tv_usec /
> 1000;
> #else
> # error "Don't know how to get the current time on your system."
> @@ -900,11 +875,10 @@ TimeInMillis GetTimeInMillis() {
> // value using delete[]. Returns the wide string, or NULL if the
> // input is NULL.
> LPCWSTR String::AnsiToUtf16(const char* ansi) {
> - if (!ansi) return NULL;
> + if (!ansi) return nullptr;
> const int length = strlen(ansi);
> const int unicode_length =
> - MultiByteToWideChar(CP_ACP, 0, ansi, length,
> - NULL, 0);
> + MultiByteToWideChar(CP_ACP, 0, ansi, length, nullptr, 0);
> WCHAR* unicode = new WCHAR[unicode_length + 1];
> MultiByteToWideChar(CP_ACP, 0, ansi, length,
> unicode, unicode_length);
> @@ -917,33 +891,33 @@ LPCWSTR String::AnsiToUtf16(const char* ansi) {
> // value using delete[]. Returns the ANSI string, or NULL if the
> // input is NULL.
> const char* String::Utf16ToAnsi(LPCWSTR utf16_str) {
> - if (!utf16_str) return NULL;
> - const int ansi_length =
> - WideCharToMultiByte(CP_ACP, 0, utf16_str, -1,
> - NULL, 0, NULL, NULL);
> + if (!utf16_str) return nullptr;
> + const int ansi_length = WideCharToMultiByte(CP_ACP, 0, utf16_str, -1,
> nullptr,
> + 0, nullptr, nullptr);
> char* ansi = new char[ansi_length + 1];
> - WideCharToMultiByte(CP_ACP, 0, utf16_str, -1,
> - ansi, ansi_length, NULL, NULL);
> + WideCharToMultiByte(CP_ACP, 0, utf16_str, -1, ansi, ansi_length,
> nullptr,
> + nullptr);
> ansi[ansi_length] = 0;
> return ansi;
> }
>
> #endif // GTEST_OS_WINDOWS_MOBILE
>
> -// Compares two C strings. Returns true iff they have the same content.
> +// Compares two C strings. Returns true if and only if they have the same
> +// content.
> //
> // Unlike strcmp(), this function can handle NULL argument(s). A NULL
> // C string is considered
> diff erent to any non-NULL C string,
> // including the empty string.
> bool String::CStringEquals(const char * lhs, const char * rhs) {
> - if ( lhs == NULL ) return rhs == NULL;
> + if (lhs == nullptr) return rhs == nullptr;
>
> - if ( rhs == NULL ) return false;
> + if (rhs == nullptr) return false;
>
> return strcmp(lhs, rhs) == 0;
> }
>
> -#if GTEST_HAS_STD_WSTRING || GTEST_HAS_GLOBAL_WSTRING
> +#if GTEST_HAS_STD_WSTRING
>
> // Converts an array of wide chars to a narrow string using the UTF-8
> // encoding, and streams the result to the given Message object.
> @@ -961,7 +935,7 @@ static void StreamWideCharsToMessage(const wchar_t*
> wstr, size_t length,
> }
> }
>
> -#endif // GTEST_HAS_STD_WSTRING || GTEST_HAS_GLOBAL_WSTRING
> +#endif // GTEST_HAS_STD_WSTRING
>
> void SplitString(const ::std::string& str, char delimiter,
> ::std::vector< ::std::string>* dest) {
> @@ -1011,15 +985,6 @@ Message& Message::operator <<(const ::std::wstring&
> wstr) {
> }
> #endif // GTEST_HAS_STD_WSTRING
>
> -#if GTEST_HAS_GLOBAL_WSTRING
> -// Converts the given wide string to a narrow string using the UTF-8
> -// encoding, and streams the result to this Message object.
> -Message& Message::operator <<(const ::wstring& wstr) {
> - internal::StreamWideCharsToMessage(wstr.c_str(), wstr.length(), this);
> - return *this;
> -}
> -#endif // GTEST_HAS_GLOBAL_WSTRING
> -
> // Gets the text streamed to this object so far as an std::string.
> // Each '\0' character in the buffer is replaced with "\\0".
> std::string Message::GetString() const {
> @@ -1030,10 +995,9 @@ std::string Message::GetString() const {
> // Used in EXPECT_TRUE/FALSE(assertion_result).
> AssertionResult::AssertionResult(const AssertionResult& other)
> : success_(other.success_),
> - message_(other.message_.get() != NULL ?
> - new ::std::string(*other.message_) :
> - static_cast< ::std::string*>(NULL)) {
> -}
> + message_(other.message_.get() != nullptr
> + ? new ::std::string(*other.message_)
> + : static_cast< ::std::string*>(nullptr)) {}
>
> // Swaps two AssertionResults.
> void AssertionResult::swap(AssertionResult& other) {
> @@ -1045,8 +1009,7 @@ void AssertionResult::swap(AssertionResult& other) {
> // Returns the assertion's negation. Used with EXPECT/ASSERT_FALSE.
> AssertionResult AssertionResult::operator!() const {
> AssertionResult negation(!success_);
> - if (message_.get() != NULL)
> - negation << *message_;
> + if (message_.get() != nullptr) negation << *message_;
> return negation;
> }
>
> @@ -1272,9 +1235,10 @@ std::string CreateUnifiedDiff(const
> std::vector<std::string>& left,
> for (; edit_i < edits.size(); ++edit_i) {
> if (n_suffix >= context) {
> // Continue only if the next hunk is very close.
> - std::vector<EditType>::const_iterator it = edits.begin() + edit_i;
> + auto it = edits.begin() + static_cast<int>(edit_i);
> while (it != edits.end() && *it == kMatch) ++it;
> - if (it == edits.end() || (it - edits.begin()) - edit_i >=
> context) {
> + if (it == edits.end() ||
> + static_cast<size_t>(it - edits.begin()) - edit_i >= context) {
> // There is no next edit or it is too far away.
> break;
> }
> @@ -1350,7 +1314,7 @@ std::vector<std::string> SplitEscapedString(const
> std::string& str) {
> // lhs_value: "5"
> // rhs_value: "6"
> //
> -// The ignoring_case parameter is true iff the assertion is a
> +// The ignoring_case parameter is true if and only if the assertion is a
> // *_STRCASEEQ*. When it's true, the string "Ignoring case" will
> // be inserted into the message.
> AssertionResult EqFailure(const char* lhs_expression,
> @@ -1413,8 +1377,6 @@ AssertionResult DoubleNearPredFormat(const char*
> expr1,
> const double
> diff = fabs(val1 - val2);
> if (
> diff <= abs_error) return AssertionSuccess();
>
> - // FIXME: do not print the value of an expression if it's
> - // already a literal.
> return AssertionFailure()
> << "The
> diff erence between " << expr1 << " and " << expr2
> << " is " <<
> diff << ", which exceeds " << abs_error_expr << ", where\n"
> @@ -1595,22 +1557,20 @@ namespace {
>
> // Helper functions for implementing IsSubString() and IsNotSubstring().
>
> -// This group of overloaded functions return true iff needle is a
> -// substring of haystack. NULL is considered a substring of itself
> -// only.
> +// This group of overloaded functions return true if and only if needle
> +// is a substring of haystack. NULL is considered a substring of
> +// itself only.
>
> bool IsSubstringPred(const char* needle, const char* haystack) {
> - if (needle == NULL || haystack == NULL)
> - return needle == haystack;
> + if (needle == nullptr || haystack == nullptr) return needle == haystack;
>
> - return strstr(haystack, needle) != NULL;
> + return strstr(haystack, needle) != nullptr;
> }
>
> bool IsSubstringPred(const wchar_t* needle, const wchar_t* haystack) {
> - if (needle == NULL || haystack == NULL)
> - return needle == haystack;
> + if (needle == nullptr || haystack == nullptr) return needle == haystack;
>
> - return wcsstr(haystack, needle) != NULL;
> + return wcsstr(haystack, needle) != nullptr;
> }
>
> // StringType here can be either ::std::string or ::std::wstring.
> @@ -1724,12 +1684,12 @@ AssertionResult HRESULTFailureHelper(const char*
> expr,
> // Gets the system's human readable message string for this HRESULT.
> char error_text[kBufSize] = { '\0' };
> DWORD message_length = ::FormatMessageA(kFlags,
> - 0, // no source, we're asking
> system
> - hr, // the error
> - 0, // no line width
> restrictions
> + 0, // no source, we're asking
> system
> + static_cast<DWORD>(hr), // the
> error
> + 0, // no line width
> restrictions
> error_text, // output buffer
> - kBufSize, // buf size
> - NULL); // no arguments for
> inserts
> + kBufSize, // buf size
> + nullptr); // no arguments for
> inserts
> // Trims tailing white space (FormatMessage leaves a trailing CR-LF)
> for (; message_length && IsSpace(error_text[message_length - 1]);
> --message_length) {
> @@ -1803,7 +1763,7 @@ inline UInt32 ChopLowBits(UInt32* bits, int n) {
> // to "(Invalid Unicode 0xXXXXXXXX)".
> std::string CodePointToUtf8(UInt32 code_point) {
> if (code_point > kMaxCodePoint4) {
> - return "(Invalid Unicode 0x" + String::FormatHexInt(code_point) + ")";
> + return "(Invalid Unicode 0x" + String::FormatHexUInt32(code_point) +
> ")";
> }
>
> char str[5]; // Big enough for the largest valid code point.
> @@ -1831,7 +1791,7 @@ std::string CodePointToUtf8(UInt32 code_point) {
>
> // The following two functions only make sense if the system
> // uses UTF-16 for wide string encoding. All supported systems
> -// with 16 bit wchar_t (Windows, Cygwin, Symbian OS) do use UTF-16.
> +// with 16 bit wchar_t (Windows, Cygwin) do use UTF-16.
>
> // Determines if the arguments constitute UTF-16 surrogate pair
> // and thus should be combined into a single Unicode code point
> @@ -1844,17 +1804,20 @@ inline bool IsUtf16SurrogatePair(wchar_t first,
> wchar_t second) {
> // Creates a Unicode code point from UTF16 surrogate pair.
> inline UInt32 CreateCodePointFromUtf16SurrogatePair(wchar_t first,
> wchar_t second) {
> + const auto first_u = static_cast<UInt32>(first);
> + const auto second_u = static_cast<UInt32>(second);
> const UInt32 mask = (1 << 10) - 1;
> - return (sizeof(wchar_t) == 2) ?
> - (((first & mask) << 10) | (second & mask)) + 0x10000 :
> - // This function should not be called when the condition is
> - // false, but we provide a sensible default in case it is.
> - static_cast<UInt32>(first);
> + return (sizeof(wchar_t) == 2)
> + ? (((first_u & mask) << 10) | (second_u & mask)) + 0x10000
> + :
> + // This function should not be called when the condition is
> + // false, but we provide a sensible default in case it is.
> + first_u;
> }
>
> // Converts a wide string to a narrow string in UTF-8 encoding.
> // The wide string is assumed to have the following encoding:
> -// UTF-16 if sizeof(wchar_t) == 2 (on Windows, Cygwin, Symbian OS)
> +// UTF-16 if sizeof(wchar_t) == 2 (on Windows, Cygwin)
> // UTF-32 if sizeof(wchar_t) == 4 (on Linux)
> // Parameter str points to a null-terminated wide string.
> // Parameter num_chars may additionally limit the number
> @@ -1891,21 +1854,21 @@ std::string WideStringToUtf8(const wchar_t* str,
> int num_chars) {
> // Converts a wide C string to an std::string using the UTF-8 encoding.
> // NULL will be converted to "(null)".
> std::string String::ShowWideCString(const wchar_t * wide_c_str) {
> - if (wide_c_str == NULL) return "(null)";
> + if (wide_c_str == nullptr) return "(null)";
>
> return internal::WideStringToUtf8(wide_c_str, -1);
> }
>
> -// Compares two wide C strings. Returns true iff they have the same
> -// content.
> +// Compares two wide C strings. Returns true if and only if they have the
> +// same content.
> //
> // Unlike wcscmp(), this function can handle NULL argument(s). A NULL
> // C string is considered
> diff erent to any non-NULL C string,
> // including the empty string.
> bool String::WideCStringEquals(const wchar_t * lhs, const wchar_t * rhs) {
> - if (lhs == NULL) return rhs == NULL;
> + if (lhs == nullptr) return rhs == nullptr;
>
> - if (rhs == NULL) return false;
> + if (rhs == nullptr) return false;
>
> return wcscmp(lhs, rhs) == 0;
> }
> @@ -1941,37 +1904,35 @@ AssertionResult CmpHelperSTRNE(const char*
> s1_expression,
> << " vs " << PrintToString(s2);
> }
>
> -// Compares two C strings, ignoring case. Returns true iff they have
> +// Compares two C strings, ignoring case. Returns true if and only if
> they have
> // the same content.
> //
> // Unlike strcasecmp(), this function can handle NULL argument(s). A
> // NULL C string is considered
> diff erent to any non-NULL C string,
> // including the empty string.
> bool String::CaseInsensitiveCStringEquals(const char * lhs, const char *
> rhs) {
> - if (lhs == NULL)
> - return rhs == NULL;
> - if (rhs == NULL)
> - return false;
> + if (lhs == nullptr) return rhs == nullptr;
> + if (rhs == nullptr) return false;
> return posix::StrCaseCmp(lhs, rhs) == 0;
> }
>
> - // Compares two wide C strings, ignoring case. Returns true iff they
> - // have the same content.
> - //
> - // Unlike wcscasecmp(), this function can handle NULL argument(s).
> - // A NULL C string is considered
> diff erent to any non-NULL wide C string,
> - // including the empty string.
> - // NB: The implementations on
> diff erent platforms slightly
> diff er.
> - // On windows, this method uses _wcsicmp which compares according to
> LC_CTYPE
> - // environment variable. On GNU platform this method uses wcscasecmp
> - // which compares according to LC_CTYPE category of the current locale.
> - // On MacOS X, it uses towlower, which also uses LC_CTYPE category of
> the
> - // current locale.
> +// Compares two wide C strings, ignoring case. Returns true if and only
> if they
> +// have the same content.
> +//
> +// Unlike wcscasecmp(), this function can handle NULL argument(s).
> +// A NULL C string is considered
> diff erent to any non-NULL wide C string,
> +// including the empty string.
> +// NB: The implementations on
> diff erent platforms slightly
> diff er.
> +// On windows, this method uses _wcsicmp which compares according to
> LC_CTYPE
> +// environment variable. On GNU platform this method uses wcscasecmp
> +// which compares according to LC_CTYPE category of the current locale.
> +// On MacOS X, it uses towlower, which also uses LC_CTYPE category of the
> +// current locale.
> bool String::CaseInsensitiveWideCStringEquals(const wchar_t* lhs,
> const wchar_t* rhs) {
> - if (lhs == NULL) return rhs == NULL;
> + if (lhs == nullptr) return rhs == nullptr;
>
> - if (rhs == NULL) return false;
> + if (rhs == nullptr) return false;
>
> #if GTEST_OS_WINDOWS
> return _wcsicmp(lhs, rhs) == 0;
> @@ -1982,14 +1943,14 @@ bool
> String::CaseInsensitiveWideCStringEquals(const wchar_t* lhs,
> // Other unknown OSes may not define it either.
> wint_t left, right;
> do {
> - left = towlower(*lhs++);
> - right = towlower(*rhs++);
> + left = towlower(static_cast<wint_t>(*lhs++));
> + right = towlower(static_cast<wint_t>(*rhs++));
> } while (left && left == right);
> return left == right;
> #endif // OS selector
> }
>
> -// Returns true iff str ends with the given suffix, ignoring case.
> +// Returns true if and only if str ends with the given suffix, ignoring
> case.
> // Any string is considered to end with an empty suffix.
> bool String::EndsWithCaseInsensitive(
> const std::string& str, const std::string& suffix) {
> @@ -2008,12 +1969,17 @@ std::string String::FormatIntWidth2(int value) {
> }
>
> // Formats an int value as "%X".
> -std::string String::FormatHexInt(int value) {
> +std::string String::FormatHexUInt32(UInt32 value) {
> std::stringstream ss;
> ss << std::hex << std::uppercase << value;
> return ss.str();
> }
>
> +// Formats an int value as "%X".
> +std::string String::FormatHexInt(int value) {
> + return FormatHexUInt32(static_cast<UInt32>(value));
> +}
> +
> // Formats a byte as "%02X".
> std::string String::FormatByte(unsigned char value) {
> std::stringstream ss;
> @@ -2030,7 +1996,7 @@ std::string
> StringStreamToString(::std::stringstream* ss) {
> const char* const end = start + str.length();
>
> std::string result;
> - result.reserve(2 * (end - start));
> + result.reserve(static_cast<size_t>(2 * (end - start)));
> for (const char* ch = start; ch != end; ++ch) {
> if (*ch == '\0') {
> result += "\\0"; // Replaces NUL with "\\0";
> @@ -2060,9 +2026,7 @@ std::string AppendUserMessage(const std::string&
> gtest_msg,
>
> // Creates an empty TestResult.
> TestResult::TestResult()
> - : death_test_count_(0),
> - elapsed_time_(0) {
> -}
> + : death_test_count_(0), start_timestamp_(0), elapsed_time_(0) {}
>
> // D'tor.
> TestResult::~TestResult() {
> @@ -2074,7 +2038,7 @@ TestResult::~TestResult() {
> const TestPartResult& TestResult::GetTestPartResult(int i) const {
> if (i < 0 || i >= total_part_count())
> internal::posix::Abort();
> - return test_part_results_.at(i);
> + return test_part_results_.at(static_cast<size_t>(i));
> }
>
> // Returns the i-th test property. i can range from 0 to
> @@ -2083,7 +2047,7 @@ const TestPartResult&
> TestResult::GetTestPartResult(int i) const {
> const TestProperty& TestResult::GetTestProperty(int i) const {
> if (i < 0 || i >= test_property_count())
> internal::posix::Abort();
> - return test_properties_.at(i);
> + return test_properties_.at(static_cast<size_t>(i));
> }
>
> // Clears the test part results.
> @@ -2131,18 +2095,18 @@ static const char* const
> kReservedTestSuitesAttributes[] = {
> // The list of reserved attributes used in the <testsuite> element of XML
> // output.
> static const char* const kReservedTestSuiteAttributes[] = {
> - "disabled",
> - "errors",
> - "failures",
> - "name",
> - "tests",
> - "time"
> -};
> + "disabled", "errors", "failures", "name", "tests", "time",
> "timestamp"};
>
> // The list of reserved attributes used in the <testcase> element of XML
> output.
> static const char* const kReservedTestCaseAttributes[] = {
> - "classname", "name", "status", "time",
> - "type_param", "value_param", "file", "line"};
> + "classname", "name", "status", "time", "type_param",
> + "value_param", "file", "line"};
> +
> +// Use a slightly
> diff erent set for allowed output to ensure existing tests can
> +// still RecordProperty("result") or "RecordProperty(timestamp")
> +static const char* const kReservedOutputTestCaseAttributes[] = {
> + "classname", "name", "status", "time", "type_param",
> + "value_param", "file", "line", "result", "timestamp"};
>
> template <int kSize>
> std::vector<std::string> ArrayAsVector(const char* const (&array)[kSize])
> {
> @@ -2164,6 +2128,22 @@ static std::vector<std::string>
> GetReservedAttributesForElement(
> return std::vector<std::string>();
> }
>
> +// TODO(jdesprez): Merge the two getReserved attributes once skip is
> improved
> +static std::vector<std::string> GetReservedOutputAttributesForElement(
> + const std::string& xml_element) {
> + if (xml_element == "testsuites") {
> + return ArrayAsVector(kReservedTestSuitesAttributes);
> + } else if (xml_element == "testsuite") {
> + return ArrayAsVector(kReservedTestSuiteAttributes);
> + } else if (xml_element == "testcase") {
> + return ArrayAsVector(kReservedOutputTestCaseAttributes);
> + } else {
> + GTEST_CHECK_(false) << "Unrecognized xml_element provided: " <<
> xml_element;
> + }
> + // This code is unreachable but some compilers may not realizes that.
> + return std::vector<std::string>();
> +}
> +
> static std::string FormatWordList(const std::vector<std::string>& words) {
> Message word_list;
> for (size_t i = 0; i < words.size(); ++i) {
> @@ -2207,7 +2187,17 @@ void TestResult::Clear() {
> elapsed_time_ = 0;
> }
>
> -// Returns true iff the test failed.
> +// Returns true off the test part was skipped.
> +static bool TestPartSkipped(const TestPartResult& result) {
> + return result.skipped();
> +}
> +
> +// Returns true if and only if the test was skipped.
> +bool TestResult::Skipped() const {
> + return !Failed() && CountIf(test_part_results_, TestPartSkipped) > 0;
> +}
> +
> +// Returns true if and only if the test failed.
> bool TestResult::Failed() const {
> for (int i = 0; i < total_part_count(); ++i) {
> if (GetTestPartResult(i).failed())
> @@ -2216,22 +2206,22 @@ bool TestResult::Failed() const {
> return false;
> }
>
> -// Returns true iff the test part fatally failed.
> +// Returns true if and only if the test part fatally failed.
> static bool TestPartFatallyFailed(const TestPartResult& result) {
> return result.fatally_failed();
> }
>
> -// Returns true iff the test fatally failed.
> +// Returns true if and only if the test fatally failed.
> bool TestResult::HasFatalFailure() const {
> return CountIf(test_part_results_, TestPartFatallyFailed) > 0;
> }
>
> -// Returns true iff the test part non-fatally failed.
> +// Returns true if and only if the test part non-fatally failed.
> static bool TestPartNonfatallyFailed(const TestPartResult& result) {
> return result.nonfatally_failed();
> }
>
> -// Returns true iff the test has a non-fatal failure.
> +// Returns true if and only if the test has a non-fatal failure.
> bool TestResult::HasNonfatalFailure() const {
> return CountIf(test_part_results_, TestPartNonfatallyFailed) > 0;
> }
> @@ -2294,25 +2284,25 @@ void
> ReportFailureInUnknownLocation(TestPartResult::Type result_type,
> // AddTestPartResult.
> UnitTest::GetInstance()->AddTestPartResult(
> result_type,
> - NULL, // No info about the source file where the exception
> occurred.
> - -1, // We have no info on which line caused the exception.
> + nullptr, // No info about the source file where the exception
> occurred.
> + -1, // We have no info on which line caused the exception.
> message,
> - ""); // No stack trace, either.
> + ""); // No stack trace, either.
> }
>
> } // namespace internal
>
> -// Google Test requires all tests in the same test case to use the same
> test
> +// Google Test requires all tests in the same test suite to use the same
> test
> // fixture class. This function checks if the current test has the
> -// same fixture class as the first test in the current test case. If
> +// same fixture class as the first test in the current test suite. If
> // yes, it returns true; otherwise it generates a Google Test failure and
> // returns false.
> bool Test::HasSameFixtureClass() {
> internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
> - const TestCase* const test_case = impl->current_test_case();
> + const TestSuite* const test_suite = impl->current_test_suite();
>
> - // Info about the first test in the current test case.
> - const TestInfo* const first_test_info = test_case->test_info_list()[0];
> + // Info about the first test in the current test suite.
> + const TestInfo* const first_test_info = test_suite->test_info_list()[0];
> const internal::TypeId first_fixture_id =
> first_test_info->fixture_class_id_;
> const char* const first_test_name = first_test_info->name();
>
> @@ -2328,7 +2318,7 @@ bool Test::HasSameFixtureClass() {
> const bool this_is_TEST = this_fixture_id ==
> internal::GetTestTypeId();
>
> if (first_is_TEST || this_is_TEST) {
> - // Both TEST and TEST_F appear in same test case, which is
> incorrect.
> + // Both TEST and TEST_F appear in same test suite, which is
> incorrect.
> // Tell the user how to fix this.
>
> // Gets the name of the TEST and the name of the TEST_F. Note
> @@ -2340,9 +2330,9 @@ bool Test::HasSameFixtureClass() {
> first_is_TEST ? this_test_name : first_test_name;
>
> ADD_FAILURE()
> - << "All tests in the same test case must use the same test
> fixture\n"
> - << "class, so mixing TEST_F and TEST in the same test case is\n"
> - << "illegal. In test case " << this_test_info->test_case_name()
> + << "All tests in the same test suite must use the same test
> fixture\n"
> + << "class, so mixing TEST_F and TEST in the same test suite
> is\n"
> + << "illegal. In test suite " <<
> this_test_info->test_suite_name()
> << ",\n"
> << "test " << TEST_F_name << " is defined using TEST_F but\n"
> << "test " << TEST_name << " is defined using TEST. You
> probably\n"
> @@ -2352,15 +2342,15 @@ bool Test::HasSameFixtureClass() {
> // Two fixture classes with the same name appear in two
> diff erent
> // namespaces, which is not allowed. Tell the user how to fix this.
> ADD_FAILURE()
> - << "All tests in the same test case must use the same test
> fixture\n"
> - << "class. However, in test case "
> - << this_test_info->test_case_name() << ",\n"
> - << "you defined test " << first_test_name
> - << " and test " << this_test_name << "\n"
> + << "All tests in the same test suite must use the same test
> fixture\n"
> + << "class. However, in test suite "
> + << this_test_info->test_suite_name() << ",\n"
> + << "you defined test " << first_test_name << " and test "
> + << this_test_name << "\n"
> << "using two
> diff erent test fixture classes. This can happen if\n"
> << "the two classes are from
> diff erent namespaces or translation\n"
> << "units and have the same name. You should probably rename
> one\n"
> - << "of the classes to put the tests into
> diff erent test cases.";
> + << "of the classes to put the tests into
> diff erent test suites.";
> }
> return false;
> }
> @@ -2393,7 +2383,7 @@ namespace internal {
> static std::string FormatCxxExceptionMessage(const char* description,
> const char* location) {
> Message message;
> - if (description != NULL) {
> + if (description != nullptr) {
> message << "C++ exception with description \"" << description << "\"";
> } else {
> message << "Unknown C++ exception";
> @@ -2491,7 +2481,7 @@ Result HandleExceptionsInMethodIfSupported(
> } catch (...) { // NOLINT
> internal::ReportFailureInUnknownLocation(
> TestPartResult::kFatalFailure,
> - FormatCxxExceptionMessage(NULL, location));
> + FormatCxxExceptionMessage(nullptr, location));
> }
> return static_cast<Result>(0);
> #else
> @@ -2511,8 +2501,9 @@ void Test::Run() {
> internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
> impl->os_stack_trace_getter()->UponLeavingGTest();
> internal::HandleExceptionsInMethodIfSupported(this, &Test::SetUp,
> "SetUp()");
> - // We will run the test only if SetUp() was successful.
> - if (!HasFatalFailure()) {
> + // We will run the test only if SetUp() was successful and didn't call
> + // GTEST_SKIP().
> + if (!HasFatalFailure() && !IsSkipped()) {
> impl->os_stack_trace_getter()->UponLeavingGTest();
> internal::HandleExceptionsInMethodIfSupported(
> this, &Test::TestBody, "the test body");
> @@ -2526,32 +2517,36 @@ void Test::Run() {
> this, &Test::TearDown, "TearDown()");
> }
>
> -// Returns true iff the current test has a fatal failure.
> +// Returns true if and only if the current test has a fatal failure.
> bool Test::HasFatalFailure() {
> return
> internal::GetUnitTestImpl()->current_test_result()->HasFatalFailure();
> }
>
> -// Returns true iff the current test has a non-fatal failure.
> +// Returns true if and only if the current test has a non-fatal failure.
> bool Test::HasNonfatalFailure() {
> return internal::GetUnitTestImpl()->current_test_result()->
> HasNonfatalFailure();
> }
>
> +// Returns true if and only if the current test was skipped.
> +bool Test::IsSkipped() {
> + return internal::GetUnitTestImpl()->current_test_result()->Skipped();
> +}
> +
> // class TestInfo
>
> // Constructs a TestInfo object. It assumes ownership of the test factory
> // object.
> -TestInfo::TestInfo(const std::string& a_test_case_name,
> - const std::string& a_name,
> - const char* a_type_param,
> +TestInfo::TestInfo(const std::string& a_test_suite_name,
> + const std::string& a_name, const char* a_type_param,
> const char* a_value_param,
> internal::CodeLocation a_code_location,
> internal::TypeId fixture_class_id,
> internal::TestFactoryBase* factory)
> - : test_case_name_(a_test_case_name),
> + : test_suite_name_(a_test_suite_name),
> name_(a_name),
> - type_param_(a_type_param ? new std::string(a_type_param) : NULL),
> - value_param_(a_value_param ? new std::string(a_value_param) : NULL),
> + type_param_(a_type_param ? new std::string(a_type_param) : nullptr),
> + value_param_(a_value_param ? new std::string(a_value_param) :
> nullptr),
> location_(a_code_location),
> fixture_class_id_(fixture_class_id),
> should_run_(false),
> @@ -2570,7 +2565,7 @@ namespace internal {
> //
> // Arguments:
> //
> -// test_case_name: name of the test case
> +// test_suite_name: name of the test suite
> // name: name of the test
> // type_param: the name of the test's type parameter, or NULL if
> // this is not a typed or a type-parameterized test.
> @@ -2578,40 +2573,35 @@ namespace internal {
> // or NULL if this is not a value-parameterized test.
> // code_location: code location where the test is defined
> // fixture_class_id: ID of the test fixture class
> -// set_up_tc: pointer to the function that sets up the test case
> -// tear_down_tc: pointer to the function that tears down the test
> case
> +// set_up_tc: pointer to the function that sets up the test suite
> +// tear_down_tc: pointer to the function that tears down the test
> suite
> // factory: pointer to the factory that creates a test object.
> // The newly created TestInfo instance will assume
> // ownership of the factory object.
> TestInfo* MakeAndRegisterTestInfo(
> - const char* test_case_name,
> - const char* name,
> - const char* type_param,
> - const char* value_param,
> - CodeLocation code_location,
> - TypeId fixture_class_id,
> - SetUpTestCaseFunc set_up_tc,
> - TearDownTestCaseFunc tear_down_tc,
> - TestFactoryBase* factory) {
> + const char* test_suite_name, const char* name, const char* type_param,
> + const char* value_param, CodeLocation code_location,
> + TypeId fixture_class_id, SetUpTestSuiteFunc set_up_tc,
> + TearDownTestSuiteFunc tear_down_tc, TestFactoryBase* factory) {
> TestInfo* const test_info =
> - new TestInfo(test_case_name, name, type_param, value_param,
> + new TestInfo(test_suite_name, name, type_param, value_param,
> code_location, fixture_class_id, factory);
> GetUnitTestImpl()->AddTestInfo(set_up_tc, tear_down_tc, test_info);
> return test_info;
> }
>
> -void ReportInvalidTestCaseType(const char* test_case_name,
> - CodeLocation code_location) {
> +void ReportInvalidTestSuiteType(const char* test_suite_name,
> + CodeLocation code_location) {
> Message errors;
> errors
> - << "Attempted redefinition of test case " << test_case_name << ".\n"
> - << "All tests in the same test case must use the same test
> fixture\n"
> - << "class. However, in test case " << test_case_name << ", you
> tried\n"
> + << "Attempted redefinition of test suite " << test_suite_name <<
> ".\n"
> + << "All tests in the same test suite must use the same test
> fixture\n"
> + << "class. However, in test suite " << test_suite_name << ", you
> tried\n"
> << "to define a test using a fixture class
> diff erent from the one\n"
> << "used earlier. This can happen if the two fixture classes are\n"
> << "from
> diff erent namespaces and have the same name. You should\n"
> << "probably rename one of the classes to put the tests into
> diff erent\n"
> - << "test cases.";
> + << "test suites.";
>
> GTEST_LOG_(ERROR) << FormatFileLocation(code_location.file.c_str(),
> code_location.line)
> @@ -2624,7 +2614,7 @@ namespace {
> // A predicate that checks the test name of a TestInfo against a known
> // value.
> //
> -// This is used for implementation of the TestCase class only. We put
> +// This is used for implementation of the TestSuite class only. We put
> // it in the anonymous namespace to prevent polluting the outer
> // namespace.
> //
> @@ -2637,7 +2627,7 @@ class TestNameIs {
> explicit TestNameIs(const char* name)
> : name_(name) {}
>
> - // Returns true iff the test name of test_info matches name_.
> + // Returns true if and only if the test name of test_info matches name_.
> bool operator()(const TestInfo * test_info) const {
> return test_info && test_info->name() == name_;
> }
> @@ -2651,7 +2641,7 @@ class TestNameIs {
> namespace internal {
>
> // This method expands all parameterized tests registered with macros
> TEST_P
> -// and INSTANTIATE_TEST_CASE_P into regular tests and registers those.
> +// and INSTANTIATE_TEST_SUITE_P into regular tests and registers those.
> // This will be done just once during the program runtime.
> void UnitTestImpl::RegisterParameterizedTests() {
> if (!parameterized_tests_registered_) {
> @@ -2685,19 +2675,23 @@ void TestInfo::Run() {
> factory_, &internal::TestFactoryBase::CreateTest,
> "the test fixture's constructor");
>
> - // Runs the test if the constructor didn't generate a fatal failure.
> + // Runs the test if the constructor didn't generate a fatal failure or
> invoke
> + // GTEST_SKIP().
> // Note that the object will not be null
> - if (!Test::HasFatalFailure()) {
> + if (!Test::HasFatalFailure() && !Test::IsSkipped()) {
> // This doesn't throw as all user code that can throw are wrapped into
> // exception handling code.
> test->Run();
> }
>
> + if (test != nullptr) {
> // Deletes the test object.
> impl->os_stack_trace_getter()->UponLeavingGTest();
> internal::HandleExceptionsInMethodIfSupported(
> test, &Test::DeleteSelf_, "the test fixture's destructor");
> + }
>
> + result_.set_start_timestamp(start);
> result_.set_elapsed_time(internal::GetTimeInMillis() - start);
>
> // Notifies the unit test event listener that a test has just finished.
> @@ -2705,134 +2699,151 @@ void TestInfo::Run() {
>
> // Tells UnitTest to stop associating assertion results to this
> // test.
> - impl->set_current_test_info(NULL);
> + impl->set_current_test_info(nullptr);
> }
>
> -// class TestCase
> +// class TestSuite
>
> -// Gets the number of successful tests in this test case.
> -int TestCase::successful_test_count() const {
> +// Gets the number of successful tests in this test suite.
> +int TestSuite::successful_test_count() const {
> return CountIf(test_info_list_, TestPassed);
> }
>
> -// Gets the number of failed tests in this test case.
> -int TestCase::failed_test_count() const {
> +// Gets the number of successful tests in this test suite.
> +int TestSuite::skipped_test_count() const {
> + return CountIf(test_info_list_, TestSkipped);
> +}
> +
> +// Gets the number of failed tests in this test suite.
> +int TestSuite::failed_test_count() const {
> return CountIf(test_info_list_, TestFailed);
> }
>
> // Gets the number of disabled tests that will be reported in the XML
> report.
> -int TestCase::reportable_disabled_test_count() const {
> +int TestSuite::reportable_disabled_test_count() const {
> return CountIf(test_info_list_, TestReportableDisabled);
> }
>
> -// Gets the number of disabled tests in this test case.
> -int TestCase::disabled_test_count() const {
> +// Gets the number of disabled tests in this test suite.
> +int TestSuite::disabled_test_count() const {
> return CountIf(test_info_list_, TestDisabled);
> }
>
> // Gets the number of tests to be printed in the XML report.
> -int TestCase::reportable_test_count() const {
> +int TestSuite::reportable_test_count() const {
> return CountIf(test_info_list_, TestReportable);
> }
>
> -// Get the number of tests in this test case that should run.
> -int TestCase::test_to_run_count() const {
> +// Get the number of tests in this test suite that should run.
> +int TestSuite::test_to_run_count() const {
> return CountIf(test_info_list_, ShouldRunTest);
> }
>
> // Gets the number of all tests.
> -int TestCase::total_test_count() const {
> +int TestSuite::total_test_count() const {
> return static_cast<int>(test_info_list_.size());
> }
>
> -// Creates a TestCase with the given name.
> +// Creates a TestSuite with the given name.
> //
> // Arguments:
> //
> -// name: name of the test case
> -// a_type_param: the name of the test case's type parameter, or NULL if
> -// this is not a typed or a type-parameterized test case.
> -// set_up_tc: pointer to the function that sets up the test case
> -// tear_down_tc: pointer to the function that tears down the test case
> -TestCase::TestCase(const char* a_name, const char* a_type_param,
> - Test::SetUpTestCaseFunc set_up_tc,
> - Test::TearDownTestCaseFunc tear_down_tc)
> +// name: name of the test suite
> +// a_type_param: the name of the test suite's type parameter, or NULL if
> +// this is not a typed or a type-parameterized test suite.
> +// set_up_tc: pointer to the function that sets up the test suite
> +// tear_down_tc: pointer to the function that tears down the test suite
> +TestSuite::TestSuite(const char* a_name, const char* a_type_param,
> + internal::SetUpTestSuiteFunc set_up_tc,
> + internal::TearDownTestSuiteFunc tear_down_tc)
> : name_(a_name),
> - type_param_(a_type_param ? new std::string(a_type_param) : NULL),
> + type_param_(a_type_param ? new std::string(a_type_param) : nullptr),
> set_up_tc_(set_up_tc),
> tear_down_tc_(tear_down_tc),
> should_run_(false),
> - elapsed_time_(0) {
> -}
> + start_timestamp_(0),
> + elapsed_time_(0) {}
>
> -// Destructor of TestCase.
> -TestCase::~TestCase() {
> +// Destructor of TestSuite.
> +TestSuite::~TestSuite() {
> // Deletes every Test in the collection.
> ForEach(test_info_list_, internal::Delete<TestInfo>);
> }
>
> // Returns the i-th test among all the tests. i can range from 0 to
> // total_test_count() - 1. If i is not in that range, returns NULL.
> -const TestInfo* TestCase::GetTestInfo(int i) const {
> +const TestInfo* TestSuite::GetTestInfo(int i) const {
> const int index = GetElementOr(test_indices_, i, -1);
> - return index < 0 ? NULL : test_info_list_[index];
> + return index < 0 ? nullptr :
> test_info_list_[static_cast<size_t>(index)];
> }
>
> // Returns the i-th test among all the tests. i can range from 0 to
> // total_test_count() - 1. If i is not in that range, returns NULL.
> -TestInfo* TestCase::GetMutableTestInfo(int i) {
> +TestInfo* TestSuite::GetMutableTestInfo(int i) {
> const int index = GetElementOr(test_indices_, i, -1);
> - return index < 0 ? NULL : test_info_list_[index];
> + return index < 0 ? nullptr :
> test_info_list_[static_cast<size_t>(index)];
> }
>
> -// Adds a test to this test case. Will delete the test upon
> -// destruction of the TestCase object.
> -void TestCase::AddTestInfo(TestInfo * test_info) {
> +// Adds a test to this test suite. Will delete the test upon
> +// destruction of the TestSuite object.
> +void TestSuite::AddTestInfo(TestInfo* test_info) {
> test_info_list_.push_back(test_info);
> test_indices_.push_back(static_cast<int>(test_indices_.size()));
> }
>
> -// Runs every test in this TestCase.
> -void TestCase::Run() {
> +// Runs every test in this TestSuite.
> +void TestSuite::Run() {
> if (!should_run_) return;
>
> internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
> - impl->set_current_test_case(this);
> + impl->set_current_test_suite(this);
>
> TestEventListener* repeater =
> UnitTest::GetInstance()->listeners().repeater();
>
> + // Call both legacy and the new API
> + repeater->OnTestSuiteStart(*this);
> +// Legacy API is deprecated but still available
> +#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI
> repeater->OnTestCaseStart(*this);
> +#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI
> +
> impl->os_stack_trace_getter()->UponLeavingGTest();
> internal::HandleExceptionsInMethodIfSupported(
> - this, &TestCase::RunSetUpTestCase, "SetUpTestCase()");
> + this, &TestSuite::RunSetUpTestSuite, "SetUpTestSuite()");
>
> - const internal::TimeInMillis start = internal::GetTimeInMillis();
> + start_timestamp_ = internal::GetTimeInMillis();
> for (int i = 0; i < total_test_count(); i++) {
> GetMutableTestInfo(i)->Run();
> }
> - elapsed_time_ = internal::GetTimeInMillis() - start;
> + elapsed_time_ = internal::GetTimeInMillis() - start_timestamp_;
>
> impl->os_stack_trace_getter()->UponLeavingGTest();
> internal::HandleExceptionsInMethodIfSupported(
> - this, &TestCase::RunTearDownTestCase, "TearDownTestCase()");
> + this, &TestSuite::RunTearDownTestSuite, "TearDownTestSuite()");
>
> + // Call both legacy and the new API
> + repeater->OnTestSuiteEnd(*this);
> +// Legacy API is deprecated but still available
> +#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI
> repeater->OnTestCaseEnd(*this);
> - impl->set_current_test_case(NULL);
> +#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI
> +
> + impl->set_current_test_suite(nullptr);
> }
>
> -// Clears the results of all tests in this test case.
> -void TestCase::ClearResult() {
> +// Clears the results of all tests in this test suite.
> +void TestSuite::ClearResult() {
> ad_hoc_test_result_.Clear();
> ForEach(test_info_list_, TestInfo::ClearTestResult);
> }
>
> -// Shuffles the tests in this test case.
> -void TestCase::ShuffleTests(internal::Random* random) {
> +// Shuffles the tests in this test suite.
> +void TestSuite::ShuffleTests(internal::Random* random) {
> Shuffle(random, &test_indices_);
> }
>
> // Restores the test order to before the first shuffle.
> -void TestCase::UnshuffleTests() {
> +void TestSuite::UnshuffleTests() {
> for (size_t i = 0; i < test_indices_.size(); i++) {
> test_indices_[i] = static_cast<int>(i);
> }
> @@ -2855,9 +2866,9 @@ static std::string FormatTestCount(int test_count) {
> return FormatCountableNoun(test_count, "test", "tests");
> }
>
> -// Formats the count of test cases.
> -static std::string FormatTestCaseCount(int test_case_count) {
> - return FormatCountableNoun(test_case_count, "test case", "test cases");
> +// Formats the count of test suites.
> +static std::string FormatTestSuiteCount(int test_suite_count) {
> + return FormatCountableNoun(test_suite_count, "test suite", "test
> suites");
> }
>
> // Converts a TestPartResult::Type enum to human-friendly string
> @@ -2866,6 +2877,8 @@ static std::string FormatTestCaseCount(int
> test_case_count) {
> // between the two when viewing the test result.
> static const char * TestPartResultTypeToString(TestPartResult::Type type)
> {
> switch (type) {
> + case TestPartResult::kSkip:
> + return "Skipped";
> case TestPartResult::kSuccess:
> return "Success";
>
> @@ -2913,14 +2926,6 @@ static void PrintTestPartResult(const
> TestPartResult& test_part_result) {
> }
>
> // class PrettyUnitTestResultPrinter
> -
> -enum GTestColor {
> - COLOR_DEFAULT,
> - COLOR_RED,
> - COLOR_GREEN,
> - COLOR_YELLOW
> -};
> -
> #if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE && \
> !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT &&
> !GTEST_OS_WINDOWS_MINGW
>
> @@ -2974,13 +2979,14 @@ static const char* GetAnsiColorCode(GTestColor
> color) {
> case COLOR_RED: return "1";
> case COLOR_GREEN: return "2";
> case COLOR_YELLOW: return "3";
> - default: return NULL;
> - };
> + default:
> + return nullptr;
> + }
> }
>
> #endif // GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE
>
> -// Returns true iff Google Test should use colors in the output.
> +// Returns true if and only if Google Test should use colors in the
> output.
> bool ShouldUseColor(bool stdout_is_tty) {
> const char* const gtest_color = GTEST_FLAG(color).c_str();
>
> @@ -3021,19 +3027,18 @@ bool ShouldUseColor(bool stdout_is_tty) {
> // cannot simply emit special characters and have the terminal change
> colors.
> // This routine must actually emit the characters rather than return a
> string
> // that would be colored when printed, as can be done on Linux.
> -static void ColoredPrintf(GTestColor color, const char* fmt, ...) {
> +void ColoredPrintf(GTestColor color, const char* fmt, ...) {
> va_list args;
> va_start(args, fmt);
>
> -#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_SYMBIAN || GTEST_OS_ZOS || \
> - GTEST_OS_IOS || GTEST_OS_WINDOWS_PHONE || GTEST_OS_WINDOWS_RT
> +#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_ZOS || GTEST_OS_IOS || \
> + GTEST_OS_WINDOWS_PHONE || GTEST_OS_WINDOWS_RT || defined(ESP_PLATFORM)
> const bool use_color = AlwaysFalse();
> #else
> static const bool in_color_mode =
> ShouldUseColor(posix::IsATTY(posix::FileNo(stdout)) != 0);
> const bool use_color = in_color_mode && (color != COLOR_DEFAULT);
> -#endif // GTEST_OS_WINDOWS_MOBILE || GTEST_OS_SYMBIAN || GTEST_OS_ZOS
> - // The '!= 0' comparison is necessary to satisfy MSVC 7.1.
> +#endif // GTEST_OS_WINDOWS_MOBILE || GTEST_OS_ZOS
>
> if (!use_color) {
> vprintf(fmt, args);
> @@ -3079,14 +3084,13 @@ static void PrintFullTestCommentIfPresent(const
> TestInfo& test_info) {
> const char* const type_param = test_info.type_param();
> const char* const value_param = test_info.value_param();
>
> - if (type_param != NULL || value_param != NULL) {
> + if (type_param != nullptr || value_param != nullptr) {
> printf(", where ");
> - if (type_param != NULL) {
> + if (type_param != nullptr) {
> printf("%s = %s", kTypeParamLabel, type_param);
> - if (value_param != NULL)
> - printf(" and ");
> + if (value_param != nullptr) printf(" and ");
> }
> - if (value_param != NULL) {
> + if (value_param != nullptr) {
> printf("%s = %s", kValueParamLabel, value_param);
> }
> }
> @@ -3098,27 +3102,39 @@ static void PrintFullTestCommentIfPresent(const
> TestInfo& test_info) {
> class PrettyUnitTestResultPrinter : public TestEventListener {
> public:
> PrettyUnitTestResultPrinter() {}
> - static void PrintTestName(const char * test_case, const char * test) {
> - printf("%s.%s", test_case, test);
> + static void PrintTestName(const char* test_suite, const char* test) {
> + printf("%s.%s", test_suite, test);
> }
>
> // The following methods override what's in the TestEventListener class.
> - virtual void OnTestProgramStart(const UnitTest& /*unit_test*/) {}
> - virtual void OnTestIterationStart(const UnitTest& unit_test, int
> iteration);
> - virtual void OnEnvironmentsSetUpStart(const UnitTest& unit_test);
> - virtual void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) {}
> - virtual void OnTestCaseStart(const TestCase& test_case);
> - virtual void OnTestStart(const TestInfo& test_info);
> - virtual void OnTestPartResult(const TestPartResult& result);
> - virtual void OnTestEnd(const TestInfo& test_info);
> - virtual void OnTestCaseEnd(const TestCase& test_case);
> - virtual void OnEnvironmentsTearDownStart(const UnitTest& unit_test);
> - virtual void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) {}
> - virtual void OnTestIterationEnd(const UnitTest& unit_test, int
> iteration);
> - virtual void OnTestProgramEnd(const UnitTest& /*unit_test*/) {}
> + void OnTestProgramStart(const UnitTest& /*unit_test*/) override {}
> + void OnTestIterationStart(const UnitTest& unit_test, int iteration)
> override;
> + void OnEnvironmentsSetUpStart(const UnitTest& unit_test) override;
> + void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) override {}
> +#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
> + void OnTestCaseStart(const TestCase& test_case) override;
> +#else
> + void OnTestSuiteStart(const TestSuite& test_suite) override;
> +#endif // OnTestCaseStart
> +
> + void OnTestStart(const TestInfo& test_info) override;
> +
> + void OnTestPartResult(const TestPartResult& result) override;
> + void OnTestEnd(const TestInfo& test_info) override;
> +#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
> + void OnTestCaseEnd(const TestCase& test_case) override;
> +#else
> + void OnTestSuiteEnd(const TestSuite& test_suite) override;
> +#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
> +
> + void OnEnvironmentsTearDownStart(const UnitTest& unit_test) override;
> + void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) override
> {}
> + void OnTestIterationEnd(const UnitTest& unit_test, int iteration)
> override;
> + void OnTestProgramEnd(const UnitTest& /*unit_test*/) override {}
>
> private:
> static void PrintFailedTests(const UnitTest& unit_test);
> + static void PrintSkippedTests(const UnitTest& unit_test);
> };
>
> // Fired before each iteration of tests starts.
> @@ -3153,7 +3169,7 @@ void
> PrettyUnitTestResultPrinter::OnTestIterationStart(
> ColoredPrintf(COLOR_GREEN, "[==========] ");
> printf("Running %s from %s.\n",
> FormatTestCount(unit_test.test_to_run_count()).c_str(),
> - FormatTestCaseCount(unit_test.test_case_to_run_count()).c_str());
> +
> FormatTestSuiteCount(unit_test.test_suite_to_run_count()).c_str());
> fflush(stdout);
> }
>
> @@ -3164,22 +3180,38 @@ void
> PrettyUnitTestResultPrinter::OnEnvironmentsSetUpStart(
> fflush(stdout);
> }
>
> +#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
> void PrettyUnitTestResultPrinter::OnTestCaseStart(const TestCase&
> test_case) {
> const std::string counts =
> FormatCountableNoun(test_case.test_to_run_count(), "test", "tests");
> ColoredPrintf(COLOR_GREEN, "[----------] ");
> printf("%s from %s", counts.c_str(), test_case.name());
> - if (test_case.type_param() == NULL) {
> + if (test_case.type_param() == nullptr) {
> printf("\n");
> } else {
> printf(", where %s = %s\n", kTypeParamLabel, test_case.type_param());
> }
> fflush(stdout);
> }
> +#else
> +void PrettyUnitTestResultPrinter::OnTestSuiteStart(
> + const TestSuite& test_suite) {
> + const std::string counts =
> + FormatCountableNoun(test_suite.test_to_run_count(), "test",
> "tests");
> + ColoredPrintf(COLOR_GREEN, "[----------] ");
> + printf("%s from %s", counts.c_str(), test_suite.name());
> + if (test_suite.type_param() == nullptr) {
> + printf("\n");
> + } else {
> + printf(", where %s = %s\n", kTypeParamLabel, test_suite.type_param());
> + }
> + fflush(stdout);
> +}
> +#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
>
> void PrettyUnitTestResultPrinter::OnTestStart(const TestInfo& test_info) {
> ColoredPrintf(COLOR_GREEN, "[ RUN ] ");
> - PrintTestName(test_info.test_case_name(), test_info.name());
> + PrintTestName(test_info.test_suite_name(), test_info.name());
> printf("\n");
> fflush(stdout);
> }
> @@ -3187,22 +3219,29 @@ void
> PrettyUnitTestResultPrinter::OnTestStart(const TestInfo& test_info) {
> // Called after an assertion failure.
> void PrettyUnitTestResultPrinter::OnTestPartResult(
> const TestPartResult& result) {
> - // If the test part succeeded, we don't need to do anything.
> - if (result.type() == TestPartResult::kSuccess)
> - return;
> -
> - // Print failure message from the assertion (e.g. expected this and got
> that).
> - PrintTestPartResult(result);
> - fflush(stdout);
> + switch (result.type()) {
> + // If the test part succeeded, or was skipped,
> + // we don't need to do anything.
> + case TestPartResult::kSkip:
> + case TestPartResult::kSuccess:
> + return;
> + default:
> + // Print failure message from the assertion
> + // (e.g. expected this and got that).
> + PrintTestPartResult(result);
> + fflush(stdout);
> + }
> }
>
> void PrettyUnitTestResultPrinter::OnTestEnd(const TestInfo& test_info) {
> if (test_info.result()->Passed()) {
> ColoredPrintf(COLOR_GREEN, "[ OK ] ");
> + } else if (test_info.result()->Skipped()) {
> + ColoredPrintf(COLOR_GREEN, "[ SKIPPED ] ");
> } else {
> ColoredPrintf(COLOR_RED, "[ FAILED ] ");
> }
> - PrintTestName(test_info.test_case_name(), test_info.name());
> + PrintTestName(test_info.test_suite_name(), test_info.name());
> if (test_info.result()->Failed())
> PrintFullTestCommentIfPresent(test_info);
>
> @@ -3215,17 +3254,29 @@ void PrettyUnitTestResultPrinter::OnTestEnd(const
> TestInfo& test_info) {
> fflush(stdout);
> }
>
> +#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
> void PrettyUnitTestResultPrinter::OnTestCaseEnd(const TestCase&
> test_case) {
> if (!GTEST_FLAG(print_time)) return;
>
> const std::string counts =
> FormatCountableNoun(test_case.test_to_run_count(), "test", "tests");
> ColoredPrintf(COLOR_GREEN, "[----------] ");
> - printf("%s from %s (%s ms total)\n\n",
> - counts.c_str(), test_case.name(),
> + printf("%s from %s (%s ms total)\n\n", counts.c_str(), test_case.name
> (),
> internal::StreamableToString(test_case.elapsed_time()).c_str());
> fflush(stdout);
> }
> +#else
> +void PrettyUnitTestResultPrinter::OnTestSuiteEnd(const TestSuite&
> test_suite) {
> + if (!GTEST_FLAG(print_time)) return;
> +
> + const std::string counts =
> + FormatCountableNoun(test_suite.test_to_run_count(), "test",
> "tests");
> + ColoredPrintf(COLOR_GREEN, "[----------] ");
> + printf("%s from %s (%s ms total)\n\n", counts.c_str(), test_suite.name
> (),
> + internal::StreamableToString(test_suite.elapsed_time()).c_str());
> + fflush(stdout);
> +}
> +#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
>
> void PrettyUnitTestResultPrinter::OnEnvironmentsTearDownStart(
> const UnitTest& /*unit_test*/) {
> @@ -3241,30 +3292,54 @@ void
> PrettyUnitTestResultPrinter::PrintFailedTests(const UnitTest& unit_test) {
> return;
> }
>
> - for (int i = 0; i < unit_test.total_test_case_count(); ++i) {
> - const TestCase& test_case = *unit_test.GetTestCase(i);
> - if (!test_case.should_run() || (test_case.failed_test_count() == 0)) {
> + for (int i = 0; i < unit_test.total_test_suite_count(); ++i) {
> + const TestSuite& test_suite = *unit_test.GetTestSuite(i);
> + if (!test_suite.should_run() || (test_suite.failed_test_count() ==
> 0)) {
> continue;
> }
> - for (int j = 0; j < test_case.total_test_count(); ++j) {
> - const TestInfo& test_info = *test_case.GetTestInfo(j);
> - if (!test_info.should_run() || test_info.result()->Passed()) {
> + for (int j = 0; j < test_suite.total_test_count(); ++j) {
> + const TestInfo& test_info = *test_suite.GetTestInfo(j);
> + if (!test_info.should_run() || !test_info.result()->Failed()) {
> continue;
> }
> ColoredPrintf(COLOR_RED, "[ FAILED ] ");
> - printf("%s.%s", test_case.name(), test_info.name());
> + printf("%s.%s", test_suite.name(), test_info.name());
> PrintFullTestCommentIfPresent(test_info);
> printf("\n");
> }
> }
> }
>
> +// Internal helper for printing the list of skipped tests.
> +void PrettyUnitTestResultPrinter::PrintSkippedTests(const UnitTest&
> unit_test) {
> + const int skipped_test_count = unit_test.skipped_test_count();
> + if (skipped_test_count == 0) {
> + return;
> + }
> +
> + for (int i = 0; i < unit_test.total_test_suite_count(); ++i) {
> + const TestSuite& test_suite = *unit_test.GetTestSuite(i);
> + if (!test_suite.should_run() || (test_suite.skipped_test_count() ==
> 0)) {
> + continue;
> + }
> + for (int j = 0; j < test_suite.total_test_count(); ++j) {
> + const TestInfo& test_info = *test_suite.GetTestInfo(j);
> + if (!test_info.should_run() || !test_info.result()->Skipped()) {
> + continue;
> + }
> + ColoredPrintf(COLOR_GREEN, "[ SKIPPED ] ");
> + printf("%s.%s", test_suite.name(), test_info.name());
> + printf("\n");
> + }
> + }
> +}
> +
> void PrettyUnitTestResultPrinter::OnTestIterationEnd(const UnitTest&
> unit_test,
> int /*iteration*/) {
> ColoredPrintf(COLOR_GREEN, "[==========] ");
> printf("%s from %s ran.",
> FormatTestCount(unit_test.test_to_run_count()).c_str(),
> - FormatTestCaseCount(unit_test.test_case_to_run_count()).c_str());
> +
> FormatTestSuiteCount(unit_test.test_suite_to_run_count()).c_str());
> if (GTEST_FLAG(print_time)) {
> printf(" (%s ms total)",
>
> internal::StreamableToString(unit_test.elapsed_time()).c_str());
> @@ -3273,6 +3348,13 @@ void
> PrettyUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
> ColoredPrintf(COLOR_GREEN, "[ PASSED ] ");
> printf("%s.\n",
> FormatTestCount(unit_test.successful_test_count()).c_str());
>
> + const int skipped_test_count = unit_test.skipped_test_count();
> + if (skipped_test_count > 0) {
> + ColoredPrintf(COLOR_GREEN, "[ SKIPPED ] ");
> + printf("%s, listed below:\n",
> FormatTestCount(skipped_test_count).c_str());
> + PrintSkippedTests(unit_test);
> + }
> +
> int num_failures = unit_test.failed_test_count();
> if (!unit_test.Passed()) {
> const int failed_test_count = unit_test.failed_test_count();
> @@ -3305,7 +3387,7 @@ void
> PrettyUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
> class TestEventRepeater : public TestEventListener {
> public:
> TestEventRepeater() : forwarding_enabled_(true) {}
> - virtual ~TestEventRepeater();
> + ~TestEventRepeater() override;
> void Append(TestEventListener *listener);
> TestEventListener* Release(TestEventListener* listener);
>
> @@ -3314,19 +3396,27 @@ class TestEventRepeater : public TestEventListener
> {
> bool forwarding_enabled() const { return forwarding_enabled_; }
> void set_forwarding_enabled(bool enable) { forwarding_enabled_ =
> enable; }
>
> - virtual void OnTestProgramStart(const UnitTest& unit_test);
> - virtual void OnTestIterationStart(const UnitTest& unit_test, int
> iteration);
> - virtual void OnEnvironmentsSetUpStart(const UnitTest& unit_test);
> - virtual void OnEnvironmentsSetUpEnd(const UnitTest& unit_test);
> - virtual void OnTestCaseStart(const TestCase& test_case);
> - virtual void OnTestStart(const TestInfo& test_info);
> - virtual void OnTestPartResult(const TestPartResult& result);
> - virtual void OnTestEnd(const TestInfo& test_info);
> - virtual void OnTestCaseEnd(const TestCase& test_case);
> - virtual void OnEnvironmentsTearDownStart(const UnitTest& unit_test);
> - virtual void OnEnvironmentsTearDownEnd(const UnitTest& unit_test);
> - virtual void OnTestIterationEnd(const UnitTest& unit_test, int
> iteration);
> - virtual void OnTestProgramEnd(const UnitTest& unit_test);
> + void OnTestProgramStart(const UnitTest& unit_test) override;
> + void OnTestIterationStart(const UnitTest& unit_test, int iteration)
> override;
> + void OnEnvironmentsSetUpStart(const UnitTest& unit_test) override;
> + void OnEnvironmentsSetUpEnd(const UnitTest& unit_test) override;
> +// Legacy API is deprecated but still available
> +#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
> + void OnTestCaseStart(const TestSuite& parameter) override;
> +#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
> + void OnTestSuiteStart(const TestSuite& parameter) override;
> + void OnTestStart(const TestInfo& test_info) override;
> + void OnTestPartResult(const TestPartResult& result) override;
> + void OnTestEnd(const TestInfo& test_info) override;
> +// Legacy API is deprecated but still available
> +#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
> + void OnTestCaseEnd(const TestCase& parameter) override;
> +#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
> + void OnTestSuiteEnd(const TestSuite& parameter) override;
> + void OnEnvironmentsTearDownStart(const UnitTest& unit_test) override;
> + void OnEnvironmentsTearDownEnd(const UnitTest& unit_test) override;
> + void OnTestIterationEnd(const UnitTest& unit_test, int iteration)
> override;
> + void OnTestProgramEnd(const UnitTest& unit_test) override;
>
> private:
> // Controls whether events will be forwarded to listeners_. Set to false
> @@ -3346,16 +3436,15 @@ void TestEventRepeater::Append(TestEventListener
> *listener) {
> listeners_.push_back(listener);
> }
>
> -// FIXME: Factor the search functionality into Vector::Find.
> TestEventListener* TestEventRepeater::Release(TestEventListener
> *listener) {
> for (size_t i = 0; i < listeners_.size(); ++i) {
> if (listeners_[i] == listener) {
> - listeners_.erase(listeners_.begin() + i);
> + listeners_.erase(listeners_.begin() + static_cast<int>(i));
> return listener;
> }
> }
>
> - return NULL;
> + return nullptr;
> }
>
> // Since most methods are very similar, use macros to reduce boilerplate.
> @@ -3370,25 +3459,33 @@ void TestEventRepeater::Name(const Type&
> parameter) { \
> }
> // This defines a member that forwards the call to all listeners in
> reverse
> // order.
> -#define GTEST_REVERSE_REPEATER_METHOD_(Name, Type) \
> -void TestEventRepeater::Name(const Type& parameter) { \
> - if (forwarding_enabled_) { \
> - for (int i = static_cast<int>(listeners_.size()) - 1; i >= 0; i--) { \
> - listeners_[i]->Name(parameter); \
> - } \
> - } \
> -}
> +#define GTEST_REVERSE_REPEATER_METHOD_(Name, Type) \
> + void TestEventRepeater::Name(const Type& parameter) { \
> + if (forwarding_enabled_) { \
> + for (size_t i = listeners_.size(); i != 0; i--) { \
> + listeners_[i - 1]->Name(parameter); \
> + } \
> + } \
> + }
>
> GTEST_REPEATER_METHOD_(OnTestProgramStart, UnitTest)
> GTEST_REPEATER_METHOD_(OnEnvironmentsSetUpStart, UnitTest)
> -GTEST_REPEATER_METHOD_(OnTestCaseStart, TestCase)
> +// Legacy API is deprecated but still available
> +#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
> +GTEST_REPEATER_METHOD_(OnTestCaseStart, TestSuite)
> +#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
> +GTEST_REPEATER_METHOD_(OnTestSuiteStart, TestSuite)
> GTEST_REPEATER_METHOD_(OnTestStart, TestInfo)
> GTEST_REPEATER_METHOD_(OnTestPartResult, TestPartResult)
> GTEST_REPEATER_METHOD_(OnEnvironmentsTearDownStart, UnitTest)
> GTEST_REVERSE_REPEATER_METHOD_(OnEnvironmentsSetUpEnd, UnitTest)
> GTEST_REVERSE_REPEATER_METHOD_(OnEnvironmentsTearDownEnd, UnitTest)
> GTEST_REVERSE_REPEATER_METHOD_(OnTestEnd, TestInfo)
> -GTEST_REVERSE_REPEATER_METHOD_(OnTestCaseEnd, TestCase)
> +// Legacy API is deprecated but still available
> +#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
> +GTEST_REVERSE_REPEATER_METHOD_(OnTestCaseEnd, TestSuite)
> +#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
> +GTEST_REVERSE_REPEATER_METHOD_(OnTestSuiteEnd, TestSuite)
> GTEST_REVERSE_REPEATER_METHOD_(OnTestProgramEnd, UnitTest)
>
> #undef GTEST_REPEATER_METHOD_
> @@ -3406,8 +3503,8 @@ void TestEventRepeater::OnTestIterationStart(const
> UnitTest& unit_test,
> void TestEventRepeater::OnTestIterationEnd(const UnitTest& unit_test,
> int iteration) {
> if (forwarding_enabled_) {
> - for (int i = static_cast<int>(listeners_.size()) - 1; i >= 0; i--) {
> - listeners_[i]->OnTestIterationEnd(unit_test, iteration);
> + for (size_t i = listeners_.size(); i > 0; i--) {
> + listeners_[i - 1]->OnTestIterationEnd(unit_test, iteration);
> }
> }
> }
> @@ -3419,12 +3516,12 @@ class XmlUnitTestResultPrinter : public
> EmptyTestEventListener {
> public:
> explicit XmlUnitTestResultPrinter(const char* output_file);
>
> - virtual void OnTestIterationEnd(const UnitTest& unit_test, int
> iteration);
> - void ListTestsMatchingFilter(const std::vector<TestCase*>& test_cases);
> + void OnTestIterationEnd(const UnitTest& unit_test, int iteration)
> override;
> + void ListTestsMatchingFilter(const std::vector<TestSuite*>&
> test_suites);
>
> // Prints an XML summary of all unit tests.
> static void PrintXmlTestsList(std::ostream* stream,
> - const std::vector<TestCase*>& test_cases);
> + const std::vector<TestSuite*>&
> test_suites);
>
> private:
> // Is c a whitespace character that is normalized to a space character
> @@ -3469,12 +3566,12 @@ class XmlUnitTestResultPrinter : public
> EmptyTestEventListener {
>
> // Streams an XML representation of a TestInfo object.
> static void OutputXmlTestInfo(::std::ostream* stream,
> - const char* test_case_name,
> + const char* test_suite_name,
> const TestInfo& test_info);
>
> - // Prints an XML representation of a TestCase object
> - static void PrintXmlTestCase(::std::ostream* stream,
> - const TestCase& test_case);
> + // Prints an XML representation of a TestSuite object
> + static void PrintXmlTestSuite(::std::ostream* stream,
> + const TestSuite& test_suite);
>
> // Prints an XML summary of unit_test to output stream out.
> static void PrintXmlUnitTest(::std::ostream* stream,
> @@ -3516,10 +3613,10 @@ void
> XmlUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
> }
>
> void XmlUnitTestResultPrinter::ListTestsMatchingFilter(
> - const std::vector<TestCase*>& test_cases) {
> + const std::vector<TestSuite*>& test_suites) {
> FILE* xmlout = OpenFileForWriting(output_file_);
> std::stringstream stream;
> - PrintXmlTestsList(&stream, test_cases);
> + PrintXmlTestsList(&stream, test_suites);
> fprintf(xmlout, "%s", StringStreamToString(&stream).c_str());
> fclose(xmlout);
> }
> @@ -3534,8 +3631,6 @@ void
> XmlUnitTestResultPrinter::ListTestsMatchingFilter(
> // module will consist of ordinary English text.
> // If this module is ever modified to produce version 1.1 XML output,
> // most invalid characters can be retained using character references.
> -// FIXME: It might be nice to have a minimally invasive, human-readable
> -// escaping scheme for invalid characters, rather than dropping them.
> std::string XmlUnitTestResultPrinter::EscapeXml(
> const std::string& str, bool is_attribute) {
> Message m;
> @@ -3600,7 +3695,7 @@ std::string
> XmlUnitTestResultPrinter::RemoveInvalidXmlCharacters(
> // This is how Google Test concepts map to the DTD:
> //
> // <testsuites name="AllTests"> <-- corresponds to a UnitTest
> object
> -// <testsuite name="testcase-name"> <-- corresponds to a TestCase
> object
> +// <testsuite name="testcase-name"> <-- corresponds to a TestSuite
> object
> // <testcase name="test-name"> <-- corresponds to a TestInfo
> object
> // <failure message="...">...</failure>
> // <failure message="...">...</failure>
> @@ -3624,12 +3719,11 @@ static bool PortableLocaltime(time_t seconds,
> struct tm* out) {
> // MINGW <time.h> provides neither localtime_r nor localtime_s, but uses
> // Windows' localtime(), which has a thread-local tm buffer.
> struct tm* tm_ptr = localtime(&seconds); // NOLINT
> - if (tm_ptr == NULL)
> - return false;
> + if (tm_ptr == nullptr) return false;
> *out = *tm_ptr;
> return true;
> #else
> - return localtime_r(&seconds, out) != NULL;
> + return localtime_r(&seconds, out) != nullptr;
> #endif
> }
>
> @@ -3655,7 +3749,7 @@ void
> XmlUnitTestResultPrinter::OutputXmlCDataSection(::std::ostream* stream,
> *stream << "<![CDATA[";
> for (;;) {
> const char* const next_segment = strstr(segment, "]]>");
> - if (next_segment != NULL) {
> + if (next_segment != nullptr) {
> stream->write(
> segment, static_cast<std::streamsize>(next_segment - segment));
> *stream << "]]>]]><![CDATA[";
> @@ -3674,7 +3768,7 @@ void XmlUnitTestResultPrinter::OutputXmlAttribute(
> const std::string& name,
> const std::string& value) {
> const std::vector<std::string>& allowed_names =
> - GetReservedAttributesForElement(element_name);
> + GetReservedOutputAttributesForElement(element_name);
>
> GTEST_CHECK_(std::find(allowed_names.begin(), allowed_names.end(),
> name) !=
> allowed_names.end())
> @@ -3685,40 +3779,47 @@ void XmlUnitTestResultPrinter::OutputXmlAttribute(
> }
>
> // Prints an XML representation of a TestInfo object.
> -// FIXME: There is also value in printing properties with the plain
> printer.
> void XmlUnitTestResultPrinter::OutputXmlTestInfo(::std::ostream* stream,
> - const char*
> test_case_name,
> + const char*
> test_suite_name,
> const TestInfo&
> test_info) {
> const TestResult& result = *test_info.result();
> - const std::string kTestcase = "testcase";
> + const std::string kTestsuite = "testcase";
>
> if (test_info.is_in_another_shard()) {
> return;
> }
>
> *stream << " <testcase";
> - OutputXmlAttribute(stream, kTestcase, "name", test_info.name());
> + OutputXmlAttribute(stream, kTestsuite, "name", test_info.name());
>
> - if (test_info.value_param() != NULL) {
> - OutputXmlAttribute(stream, kTestcase, "value_param",
> + if (test_info.value_param() != nullptr) {
> + OutputXmlAttribute(stream, kTestsuite, "value_param",
> test_info.value_param());
> }
> - if (test_info.type_param() != NULL) {
> - OutputXmlAttribute(stream, kTestcase, "type_param",
> test_info.type_param());
> + if (test_info.type_param() != nullptr) {
> + OutputXmlAttribute(stream, kTestsuite, "type_param",
> + test_info.type_param());
> }
> if (GTEST_FLAG(list_tests)) {
> - OutputXmlAttribute(stream, kTestcase, "file", test_info.file());
> - OutputXmlAttribute(stream, kTestcase, "line",
> + OutputXmlAttribute(stream, kTestsuite, "file", test_info.file());
> + OutputXmlAttribute(stream, kTestsuite, "line",
> StreamableToString(test_info.line()));
> *stream << " />\n";
> return;
> }
>
> - OutputXmlAttribute(stream, kTestcase, "status",
> + OutputXmlAttribute(stream, kTestsuite, "status",
> test_info.should_run() ? "run" : "notrun");
> - OutputXmlAttribute(stream, kTestcase, "time",
> + OutputXmlAttribute(stream, kTestsuite, "result",
> + test_info.should_run()
> + ? (result.Skipped() ? "skipped" : "completed")
> + : "suppressed");
> + OutputXmlAttribute(stream, kTestsuite, "time",
> FormatTimeInMillisAsSeconds(result.elapsed_time()));
> - OutputXmlAttribute(stream, kTestcase, "classname", test_case_name);
> + OutputXmlAttribute(
> + stream, kTestsuite, "timestamp",
> + FormatEpochTimeInMillisAsIso8601(result.start_timestamp()));
> + OutputXmlAttribute(stream, kTestsuite, "classname", test_suite_name);
>
> int failures = 0;
> for (int i = 0; i < result.total_part_count(); ++i) {
> @@ -3751,29 +3852,32 @@ void
> XmlUnitTestResultPrinter::OutputXmlTestInfo(::std::ostream* stream,
> }
> }
>
> -// Prints an XML representation of a TestCase object
> -void XmlUnitTestResultPrinter::PrintXmlTestCase(std::ostream* stream,
> - const TestCase&
> test_case) {
> +// Prints an XML representation of a TestSuite object
> +void XmlUnitTestResultPrinter::PrintXmlTestSuite(std::ostream* stream,
> + const TestSuite&
> test_suite) {
> const std::string kTestsuite = "testsuite";
> *stream << " <" << kTestsuite;
> - OutputXmlAttribute(stream, kTestsuite, "name", test_case.name());
> + OutputXmlAttribute(stream, kTestsuite, "name", test_suite.name());
> OutputXmlAttribute(stream, kTestsuite, "tests",
> -
> StreamableToString(test_case.reportable_test_count()));
> +
> StreamableToString(test_suite.reportable_test_count()));
> if (!GTEST_FLAG(list_tests)) {
> OutputXmlAttribute(stream, kTestsuite, "failures",
> - StreamableToString(test_case.failed_test_count()));
> +
> StreamableToString(test_suite.failed_test_count()));
> OutputXmlAttribute(
> stream, kTestsuite, "disabled",
> - StreamableToString(test_case.reportable_disabled_test_count()));
> + StreamableToString(test_suite.reportable_disabled_test_count()));
> OutputXmlAttribute(stream, kTestsuite, "errors", "0");
> OutputXmlAttribute(stream, kTestsuite, "time",
> -
> FormatTimeInMillisAsSeconds(test_case.elapsed_time()));
> - *stream <<
> TestPropertiesAsXmlAttributes(test_case.ad_hoc_test_result());
> +
> FormatTimeInMillisAsSeconds(test_suite.elapsed_time()));
> + OutputXmlAttribute(
> + stream, kTestsuite, "timestamp",
> + FormatEpochTimeInMillisAsIso8601(test_suite.start_timestamp()));
> + *stream <<
> TestPropertiesAsXmlAttributes(test_suite.ad_hoc_test_result());
> }
> *stream << ">\n";
> - for (int i = 0; i < test_case.total_test_count(); ++i) {
> - if (test_case.GetTestInfo(i)->is_reportable())
> - OutputXmlTestInfo(stream, test_case.name(),
> *test_case.GetTestInfo(i));
> + for (int i = 0; i < test_suite.total_test_count(); ++i) {
> + if (test_suite.GetTestInfo(i)->is_reportable())
> + OutputXmlTestInfo(stream, test_suite.name(),
> *test_suite.GetTestInfo(i));
> }
> *stream << " </" << kTestsuite << ">\n";
> }
> @@ -3794,11 +3898,11 @@ void
> XmlUnitTestResultPrinter::PrintXmlUnitTest(std::ostream* stream,
> stream, kTestsuites, "disabled",
> StreamableToString(unit_test.reportable_disabled_test_count()));
> OutputXmlAttribute(stream, kTestsuites, "errors", "0");
> + OutputXmlAttribute(stream, kTestsuites, "time",
> +
> FormatTimeInMillisAsSeconds(unit_test.elapsed_time()));
> OutputXmlAttribute(
> stream, kTestsuites, "timestamp",
> FormatEpochTimeInMillisAsIso8601(unit_test.start_timestamp()));
> - OutputXmlAttribute(stream, kTestsuites, "time",
> -
> FormatTimeInMillisAsSeconds(unit_test.elapsed_time()));
>
> if (GTEST_FLAG(shuffle)) {
> OutputXmlAttribute(stream, kTestsuites, "random_seed",
> @@ -3809,31 +3913,31 @@ void
> XmlUnitTestResultPrinter::PrintXmlUnitTest(std::ostream* stream,
> OutputXmlAttribute(stream, kTestsuites, "name", "AllTests");
> *stream << ">\n";
>
> - for (int i = 0; i < unit_test.total_test_case_count(); ++i) {
> - if (unit_test.GetTestCase(i)->reportable_test_count() > 0)
> - PrintXmlTestCase(stream, *unit_test.GetTestCase(i));
> + for (int i = 0; i < unit_test.total_test_suite_count(); ++i) {
> + if (unit_test.GetTestSuite(i)->reportable_test_count() > 0)
> + PrintXmlTestSuite(stream, *unit_test.GetTestSuite(i));
> }
> *stream << "</" << kTestsuites << ">\n";
> }
>
> void XmlUnitTestResultPrinter::PrintXmlTestsList(
> - std::ostream* stream, const std::vector<TestCase*>& test_cases) {
> + std::ostream* stream, const std::vector<TestSuite*>& test_suites) {
> const std::string kTestsuites = "testsuites";
>
> *stream << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
> *stream << "<" << kTestsuites;
>
> int total_tests = 0;
> - for (size_t i = 0; i < test_cases.size(); ++i) {
> - total_tests += test_cases[i]->total_test_count();
> + for (auto test_suite : test_suites) {
> + total_tests += test_suite->total_test_count();
> }
> OutputXmlAttribute(stream, kTestsuites, "tests",
> StreamableToString(total_tests));
> OutputXmlAttribute(stream, kTestsuites, "name", "AllTests");
> *stream << ">\n";
>
> - for (size_t i = 0; i < test_cases.size(); ++i) {
> - PrintXmlTestCase(stream, *test_cases[i]);
> + for (auto test_suite : test_suites) {
> + PrintXmlTestSuite(stream, *test_suite);
> }
> *stream << "</" << kTestsuites << ">\n";
> }
> @@ -3878,11 +3982,11 @@ class JsonUnitTestResultPrinter : public
> EmptyTestEventListener {
> public:
> explicit JsonUnitTestResultPrinter(const char* output_file);
>
> - virtual void OnTestIterationEnd(const UnitTest& unit_test, int
> iteration);
> + void OnTestIterationEnd(const UnitTest& unit_test, int iteration)
> override;
>
> // Prints an JSON summary of all unit tests.
> static void PrintJsonTestList(::std::ostream* stream,
> - const std::vector<TestCase*>& test_cases);
> + const std::vector<TestSuite*>&
> test_suites);
>
> private:
> // Returns an JSON-escaped copy of the input string str.
> @@ -3905,12 +4009,12 @@ class JsonUnitTestResultPrinter : public
> EmptyTestEventListener {
>
> // Streams a JSON representation of a TestInfo object.
> static void OutputJsonTestInfo(::std::ostream* stream,
> - const char* test_case_name,
> + const char* test_suite_name,
> const TestInfo& test_info);
>
> - // Prints a JSON representation of a TestCase object
> - static void PrintJsonTestCase(::std::ostream* stream,
> - const TestCase& test_case);
> + // Prints a JSON representation of a TestSuite object
> + static void PrintJsonTestSuite(::std::ostream* stream,
> + const TestSuite& test_suite);
>
> // Prints a JSON summary of unit_test to output stream out.
> static void PrintJsonUnitTest(::std::ostream* stream,
> @@ -4009,7 +4113,7 @@ static std::string
> FormatEpochTimeInMillisAsRFC3339(TimeInMillis ms) {
> String::FormatIntWidth2(time_struct.tm_sec) + "Z";
> }
>
> -static inline std::string Indent(int width) {
> +static inline std::string Indent(size_t width) {
> return std::string(width, ' ');
> }
>
> @@ -4021,7 +4125,7 @@ void JsonUnitTestResultPrinter::OutputJsonKey(
> const std::string& indent,
> bool comma) {
> const std::vector<std::string>& allowed_names =
> - GetReservedAttributesForElement(element_name);
> + GetReservedOutputAttributesForElement(element_name);
>
> GTEST_CHECK_(std::find(allowed_names.begin(), allowed_names.end(),
> name) !=
> allowed_names.end())
> @@ -4041,7 +4145,7 @@ void JsonUnitTestResultPrinter::OutputJsonKey(
> const std::string& indent,
> bool comma) {
> const std::vector<std::string>& allowed_names =
> - GetReservedAttributesForElement(element_name);
> + GetReservedOutputAttributesForElement(element_name);
>
> GTEST_CHECK_(std::find(allowed_names.begin(), allowed_names.end(),
> name) !=
> allowed_names.end())
> @@ -4055,35 +4159,44 @@ void JsonUnitTestResultPrinter::OutputJsonKey(
>
> // Prints a JSON representation of a TestInfo object.
> void JsonUnitTestResultPrinter::OutputJsonTestInfo(::std::ostream* stream,
> - const char*
> test_case_name,
> + const char*
> test_suite_name,
> const TestInfo&
> test_info) {
> const TestResult& result = *test_info.result();
> - const std::string kTestcase = "testcase";
> + const std::string kTestsuite = "testcase";
> const std::string kIndent = Indent(10);
>
> *stream << Indent(8) << "{\n";
> - OutputJsonKey(stream, kTestcase, "name", test_info.name(), kIndent);
> + OutputJsonKey(stream, kTestsuite, "name", test_info.name(), kIndent);
>
> - if (test_info.value_param() != NULL) {
> - OutputJsonKey(stream, kTestcase, "value_param",
> - test_info.value_param(), kIndent);
> + if (test_info.value_param() != nullptr) {
> + OutputJsonKey(stream, kTestsuite, "value_param",
> test_info.value_param(),
> + kIndent);
> }
> - if (test_info.type_param() != NULL) {
> - OutputJsonKey(stream, kTestcase, "type_param", test_info.type_param(),
> + if (test_info.type_param() != nullptr) {
> + OutputJsonKey(stream, kTestsuite, "type_param",
> test_info.type_param(),
> kIndent);
> }
> if (GTEST_FLAG(list_tests)) {
> - OutputJsonKey(stream, kTestcase, "file", test_info.file(), kIndent);
> - OutputJsonKey(stream, kTestcase, "line", test_info.line(), kIndent,
> false);
> + OutputJsonKey(stream, kTestsuite, "file", test_info.file(), kIndent);
> + OutputJsonKey(stream, kTestsuite, "line", test_info.line(), kIndent,
> false);
> *stream << "\n" << Indent(8) << "}";
> return;
> }
>
> - OutputJsonKey(stream, kTestcase, "status",
> + OutputJsonKey(stream, kTestsuite, "status",
> test_info.should_run() ? "RUN" : "NOTRUN", kIndent);
> - OutputJsonKey(stream, kTestcase, "time",
> + OutputJsonKey(stream, kTestsuite, "result",
> + test_info.should_run()
> + ? (result.Skipped() ? "SKIPPED" : "COMPLETED")
> + : "SUPPRESSED",
> + kIndent);
> + OutputJsonKey(stream, kTestsuite, "timestamp",
> +
> FormatEpochTimeInMillisAsRFC3339(result.start_timestamp()),
> + kIndent);
> + OutputJsonKey(stream, kTestsuite, "time",
> FormatTimeInMillisAsDuration(result.elapsed_time()),
> kIndent);
> - OutputJsonKey(stream, kTestcase, "classname", test_case_name, kIndent,
> false);
> + OutputJsonKey(stream, kTestsuite, "classname", test_suite_name, kIndent,
> + false);
> *stream << TestPropertiesAsJson(result, kIndent);
>
> int failures = 0;
> @@ -4110,40 +4223,44 @@ void
> JsonUnitTestResultPrinter::OutputJsonTestInfo(::std::ostream* stream,
> *stream << "\n" << Indent(8) << "}";
> }
>
> -// Prints an JSON representation of a TestCase object
> -void JsonUnitTestResultPrinter::PrintJsonTestCase(std::ostream* stream,
> - const TestCase&
> test_case) {
> +// Prints an JSON representation of a TestSuite object
> +void JsonUnitTestResultPrinter::PrintJsonTestSuite(
> + std::ostream* stream, const TestSuite& test_suite) {
> const std::string kTestsuite = "testsuite";
> const std::string kIndent = Indent(6);
>
> *stream << Indent(4) << "{\n";
> - OutputJsonKey(stream, kTestsuite, "name", test_case.name(), kIndent);
> - OutputJsonKey(stream, kTestsuite, "tests",
> test_case.reportable_test_count(),
> + OutputJsonKey(stream, kTestsuite, "name", test_suite.name(), kIndent);
> + OutputJsonKey(stream, kTestsuite, "tests",
> test_suite.reportable_test_count(),
> kIndent);
> if (!GTEST_FLAG(list_tests)) {
> - OutputJsonKey(stream, kTestsuite, "failures",
> test_case.failed_test_count(),
> - kIndent);
> + OutputJsonKey(stream, kTestsuite, "failures",
> + test_suite.failed_test_count(), kIndent);
> OutputJsonKey(stream, kTestsuite, "disabled",
> - test_case.reportable_disabled_test_count(), kIndent);
> + test_suite.reportable_disabled_test_count(), kIndent);
> OutputJsonKey(stream, kTestsuite, "errors", 0, kIndent);
> + OutputJsonKey(
> + stream, kTestsuite, "timestamp",
> + FormatEpochTimeInMillisAsRFC3339(test_suite.start_timestamp()),
> + kIndent);
> OutputJsonKey(stream, kTestsuite, "time",
> - FormatTimeInMillisAsDuration(test_case.elapsed_time()),
> + FormatTimeInMillisAsDuration(test_suite.elapsed_time()),
> kIndent, false);
> - *stream << TestPropertiesAsJson(test_case.ad_hoc_test_result(),
> kIndent)
> + *stream << TestPropertiesAsJson(test_suite.ad_hoc_test_result(),
> kIndent)
> << ",\n";
> }
>
> *stream << kIndent << "\"" << kTestsuite << "\": [\n";
>
> bool comma = false;
> - for (int i = 0; i < test_case.total_test_count(); ++i) {
> - if (test_case.GetTestInfo(i)->is_reportable()) {
> + for (int i = 0; i < test_suite.total_test_count(); ++i) {
> + if (test_suite.GetTestInfo(i)->is_reportable()) {
> if (comma) {
> *stream << ",\n";
> } else {
> comma = true;
> }
> - OutputJsonTestInfo(stream, test_case.name(),
> *test_case.GetTestInfo(i));
> + OutputJsonTestInfo(stream, test_suite.name(),
> *test_suite.GetTestInfo(i));
> }
> }
> *stream << "\n" << kIndent << "]\n" << Indent(4) << "}";
> @@ -4181,14 +4298,14 @@ void
> JsonUnitTestResultPrinter::PrintJsonUnitTest(std::ostream* stream,
> *stream << kIndent << "\"" << kTestsuites << "\": [\n";
>
> bool comma = false;
> - for (int i = 0; i < unit_test.total_test_case_count(); ++i) {
> - if (unit_test.GetTestCase(i)->reportable_test_count() > 0) {
> + for (int i = 0; i < unit_test.total_test_suite_count(); ++i) {
> + if (unit_test.GetTestSuite(i)->reportable_test_count() > 0) {
> if (comma) {
> *stream << ",\n";
> } else {
> comma = true;
> }
> - PrintJsonTestCase(stream, *unit_test.GetTestCase(i));
> + PrintJsonTestSuite(stream, *unit_test.GetTestSuite(i));
> }
> }
>
> @@ -4196,24 +4313,24 @@ void
> JsonUnitTestResultPrinter::PrintJsonUnitTest(std::ostream* stream,
> }
>
> void JsonUnitTestResultPrinter::PrintJsonTestList(
> - std::ostream* stream, const std::vector<TestCase*>& test_cases) {
> + std::ostream* stream, const std::vector<TestSuite*>& test_suites) {
> const std::string kTestsuites = "testsuites";
> const std::string kIndent = Indent(2);
> *stream << "{\n";
> int total_tests = 0;
> - for (size_t i = 0; i < test_cases.size(); ++i) {
> - total_tests += test_cases[i]->total_test_count();
> + for (auto test_suite : test_suites) {
> + total_tests += test_suite->total_test_count();
> }
> OutputJsonKey(stream, kTestsuites, "tests", total_tests, kIndent);
>
> OutputJsonKey(stream, kTestsuites, "name", "AllTests", kIndent);
> *stream << kIndent << "\"" << kTestsuites << "\": [\n";
>
> - for (size_t i = 0; i < test_cases.size(); ++i) {
> + for (size_t i = 0; i < test_suites.size(); ++i) {
> if (i != 0) {
> *stream << ",\n";
> }
> - PrintJsonTestCase(stream, *test_cases[i]);
> + PrintJsonTestSuite(stream, *test_suites[i]);
> }
>
> *stream << "\n"
> @@ -4269,7 +4386,7 @@ void
> StreamingListener::SocketWriter::MakeConnection() {
> memset(&hints, 0, sizeof(hints));
> hints.ai_family = AF_UNSPEC; // To allow both IPv4 and IPv6
> addresses.
> hints.ai_socktype = SOCK_STREAM;
> - addrinfo* servinfo = NULL;
> + addrinfo* servinfo = nullptr;
>
> // Use the getaddrinfo() to get a linked list of IP addresses for
> // the given host name.
> @@ -4281,7 +4398,7 @@ void
> StreamingListener::SocketWriter::MakeConnection() {
> }
>
> // Loop through all the results and connect to the first we can.
> - for (addrinfo* cur_addr = servinfo; sockfd_ == -1 && cur_addr != NULL;
> + for (addrinfo* cur_addr = servinfo; sockfd_ == -1 && cur_addr !=
> nullptr;
> cur_addr = cur_addr->ai_next) {
> sockfd_ = socket(
> cur_addr->ai_family, cur_addr->ai_socktype,
> cur_addr->ai_protocol);
> @@ -4413,9 +4530,8 @@ class ScopedPrematureExitFile {
>
> TestEventListeners::TestEventListeners()
> : repeater_(new internal::TestEventRepeater()),
> - default_result_printer_(NULL),
> - default_xml_generator_(NULL) {
> -}
> + default_result_printer_(nullptr),
> + default_xml_generator_(nullptr) {}
>
> TestEventListeners::~TestEventListeners() { delete repeater_; }
>
> @@ -4432,9 +4548,9 @@ void TestEventListeners::Append(TestEventListener*
> listener) {
> // NULL if the listener is not found in the list.
> TestEventListener* TestEventListeners::Release(TestEventListener*
> listener) {
> if (listener == default_result_printer_)
> - default_result_printer_ = NULL;
> + default_result_printer_ = nullptr;
> else if (listener == default_xml_generator_)
> - default_xml_generator_ = NULL;
> + default_xml_generator_ = nullptr;
> return repeater_->Release(listener);
> }
>
> @@ -4453,8 +4569,7 @@ void
> TestEventListeners::SetDefaultResultPrinter(TestEventListener* listener) {
> // list.
> delete Release(default_result_printer_);
> default_result_printer_ = listener;
> - if (listener != NULL)
> - Append(listener);
> + if (listener != nullptr) Append(listener);
> }
> }
>
> @@ -4469,8 +4584,7 @@ void
> TestEventListeners::SetDefaultXmlGenerator(TestEventListener* listener) {
> // list.
> delete Release(default_xml_generator_);
> default_xml_generator_ = listener;
> - if (listener != NULL)
> - Append(listener);
> + if (listener != nullptr) Append(listener);
> }
> }
>
> @@ -4494,52 +4608,66 @@ void TestEventListeners::SuppressEventForwarding()
> {
> // call this before main() starts, from which point on the return
> // value will never change.
> UnitTest* UnitTest::GetInstance() {
> - // When compiled with MSVC 7.1 in optimized mode, destroying the
> - // UnitTest object upon exiting the program messes up the exit code,
> - // causing successful tests to appear failed. We have to use a
> - //
> diff erent implementation in this case to bypass the compiler bug.
> - // This implementation makes the compiler happy, at the cost of
> - // leaking the UnitTest object.
> -
> // CodeGear C++Builder insists on a public destructor for the
> // default implementation. Use this implementation to keep good OO
> // design with private destructor.
>
> -#if (_MSC_VER == 1310 && !defined(_DEBUG)) || defined(__BORLANDC__)
> +#if defined(__BORLANDC__)
> static UnitTest* const instance = new UnitTest;
> return instance;
> #else
> static UnitTest instance;
> return &instance;
> -#endif // (_MSC_VER == 1310 && !defined(_DEBUG)) || defined(__BORLANDC__)
> +#endif // defined(__BORLANDC__)
> }
>
> -// Gets the number of successful test cases.
> -int UnitTest::successful_test_case_count() const {
> - return impl()->successful_test_case_count();
> +// Gets the number of successful test suites.
> +int UnitTest::successful_test_suite_count() const {
> + return impl()->successful_test_suite_count();
> }
>
> -// Gets the number of failed test cases.
> -int UnitTest::failed_test_case_count() const {
> - return impl()->failed_test_case_count();
> +// Gets the number of failed test suites.
> +int UnitTest::failed_test_suite_count() const {
> + return impl()->failed_test_suite_count();
> }
>
> -// Gets the number of all test cases.
> -int UnitTest::total_test_case_count() const {
> - return impl()->total_test_case_count();
> +// Gets the number of all test suites.
> +int UnitTest::total_test_suite_count() const {
> + return impl()->total_test_suite_count();
> }
>
> -// Gets the number of all test cases that contain at least one test
> +// Gets the number of all test suites that contain at least one test
> // that should run.
> +int UnitTest::test_suite_to_run_count() const {
> + return impl()->test_suite_to_run_count();
> +}
> +
> +// Legacy API is deprecated but still available
> +#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
> +int UnitTest::successful_test_case_count() const {
> + return impl()->successful_test_suite_count();
> +}
> +int UnitTest::failed_test_case_count() const {
> + return impl()->failed_test_suite_count();
> +}
> +int UnitTest::total_test_case_count() const {
> + return impl()->total_test_suite_count();
> +}
> int UnitTest::test_case_to_run_count() const {
> - return impl()->test_case_to_run_count();
> + return impl()->test_suite_to_run_count();
> }
> +#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
>
> // Gets the number of successful tests.
> int UnitTest::successful_test_count() const {
> return impl()->successful_test_count();
> }
>
> +// Gets the number of skipped tests.
> +int UnitTest::skipped_test_count() const {
> + return impl()->skipped_test_count();
> +}
> +
> // Gets the number of failed tests.
> int UnitTest::failed_test_count() const { return
> impl()->failed_test_count(); }
>
> @@ -4575,29 +4703,37 @@ internal::TimeInMillis UnitTest::elapsed_time()
> const {
> return impl()->elapsed_time();
> }
>
> -// Returns true iff the unit test passed (i.e. all test cases passed).
> +// Returns true if and only if the unit test passed (i.e. all test suites
> +// passed).
> bool UnitTest::Passed() const { return impl()->Passed(); }
>
> -// Returns true iff the unit test failed (i.e. some test case failed
> -// or something outside of all tests failed).
> +// Returns true if and only if the unit test failed (i.e. some test suite
> +// failed or something outside of all tests failed).
> bool UnitTest::Failed() const { return impl()->Failed(); }
>
> -// Gets the i-th test case among all the test cases. i can range from 0 to
> -// total_test_case_count() - 1. If i is not in that range, returns NULL.
> +// Gets the i-th test suite among all the test suites. i can range from 0
> to
> +// total_test_suite_count() - 1. If i is not in that range, returns NULL.
> +const TestSuite* UnitTest::GetTestSuite(int i) const {
> + return impl()->GetTestSuite(i);
> +}
> +
> +// Legacy API is deprecated but still available
> +#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
> const TestCase* UnitTest::GetTestCase(int i) const {
> return impl()->GetTestCase(i);
> }
> +#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
>
> // Returns the TestResult containing information on test failures and
> -// properties logged outside of individual test cases.
> +// properties logged outside of individual test suites.
> const TestResult& UnitTest::ad_hoc_test_result() const {
> return *impl()->ad_hoc_test_result();
> }
>
> -// Gets the i-th test case among all the test cases. i can range from 0 to
> -// total_test_case_count() - 1. If i is not in that range, returns NULL.
> -TestCase* UnitTest::GetMutableTestCase(int i) {
> - return impl()->GetMutableTestCase(i);
> +// Gets the i-th test suite among all the test suites. i can range from 0
> to
> +// total_test_suite_count() - 1. If i is not in that range, returns NULL.
> +TestSuite* UnitTest::GetMutableTestSuite(int i) {
> + return impl()->GetMutableSuiteCase(i);
> }
>
> // Returns the list of event listeners that can be used to track events
> @@ -4617,8 +4753,8 @@ TestEventListeners& UnitTest::listeners() {
> // We don't protect this under mutex_, as we only support calling it
> // from the main thread.
> Environment* UnitTest::AddEnvironment(Environment* env) {
> - if (env == NULL) {
> - return NULL;
> + if (env == nullptr) {
> + return nullptr;
> }
>
> impl_->environments().push_back(env);
> @@ -4642,25 +4778,24 @@ void UnitTest::AddTestPartResult(
> if (impl_->gtest_trace_stack().size() > 0) {
> msg << "\n" << GTEST_NAME_ << " trace:";
>
> - for (int i = static_cast<int>(impl_->gtest_trace_stack().size());
> - i > 0; --i) {
> + for (size_t i = impl_->gtest_trace_stack().size(); i > 0; --i) {
> const internal::TraceInfo& trace = impl_->gtest_trace_stack()[i -
> 1];
> msg << "\n" << internal::FormatFileLocation(trace.file, trace.line)
> << " " << trace.message;
> }
> }
>
> - if (os_stack_trace.c_str() != NULL && !os_stack_trace.empty()) {
> + if (os_stack_trace.c_str() != nullptr && !os_stack_trace.empty()) {
> msg << internal::kStackTraceMarker << os_stack_trace;
> }
>
> - const TestPartResult result =
> - TestPartResult(result_type, file_name, line_number,
> - msg.GetString().c_str());
> + const TestPartResult result = TestPartResult(
> + result_type, file_name, line_number, msg.GetString().c_str());
> impl_->GetTestPartResultReporterForCurrentThread()->
> ReportTestPartResult(result);
>
> - if (result_type != TestPartResult::kSuccess) {
> + if (result_type != TestPartResult::kSuccess &&
> + result_type != TestPartResult::kSkip) {
> // gtest_break_on_failure takes precedence over
> // gtest_throw_on_failure. This allows a user to set the latter
> // in the code (perhaps in order to use Google Test assertions
> @@ -4678,11 +4813,10 @@ void UnitTest::AddTestPartResult(
> // with clang/gcc we can achieve the same effect on x86 by invoking
> int3
> asm("int3");
> #else
> - // Dereference NULL through a volatile pointer to prevent the
> compiler
> + // Dereference nullptr through a volatile pointer to prevent the
> compiler
> // from removing. We use this rather than abort() or
> __builtin_trap() for
> - // portability: Symbian doesn't implement abort() well, and some
> debuggers
> - // don't correctly trap abort().
> - *static_cast<volatile int*>(NULL) = 1;
> + // portability: some debuggers don't correctly trap abort().
> + *static_cast<volatile int*>(nullptr) = 1;
> #endif // GTEST_OS_WINDOWS
> } else if (GTEST_FLAG(throw_on_failure)) {
> #if GTEST_HAS_EXCEPTIONS
> @@ -4697,8 +4831,8 @@ void UnitTest::AddTestPartResult(
> }
>
> // Adds a TestProperty to the current TestResult object when invoked from
> -// inside a test, to current TestCase's ad_hoc_test_result_ when invoked
> -// from SetUpTestCase or TearDownTestCase, or to the global property set
> +// inside a test, to current TestSuite's ad_hoc_test_result_ when invoked
> +// from SetUpTestSuite or TearDownTestSuite, or to the global property set
> // when invoked elsewhere. If the result already contains a property with
> // the same key, the value will be updated.
> void UnitTest::RecordProperty(const std::string& key,
> @@ -4737,8 +4871,9 @@ int UnitTest::Run() {
> // that understands the premature-exit-file protocol to report the
> // test as having failed.
> const internal::ScopedPrematureExitFile premature_exit_file(
> - in_death_test_child_process ?
> - NULL : internal::posix::GetEnv("TEST_PREMATURE_EXIT_FILE"));
> + in_death_test_child_process
> + ? nullptr
> + : internal::posix::GetEnv("TEST_PREMATURE_EXIT_FILE"));
>
> // Captures the value of GTEST_FLAG(catch_exceptions). This value will
> be
> // used for the duration of the program.
> @@ -4763,23 +4898,27 @@ int UnitTest::Run() {
> _set_error_mode(_OUT_TO_STDERR);
> # endif
>
> -# if _MSC_VER >= 1400 && !GTEST_OS_WINDOWS_MOBILE
> +# if defined(_MSC_VER) && !GTEST_OS_WINDOWS_MOBILE
> // In the debug version, Visual Studio pops up a separate dialog
> // offering a choice to debug the aborted program. We need to suppress
> // this dialog or it will pop up for every EXPECT/ASSERT_DEATH
> statement
> // executed. Google Test will notify the user of any unexpected
> // failure via stderr.
> - //
> - // VC++ doesn't define _set_abort_behavior() prior to the version 8.0.
> - // Users of prior VC versions shall suffer the agony and pain of
> - // clicking through the countless debug dialogs.
> - // FIXME: find a way to suppress the abort dialog() in the
> - // debug mode when compiled with VC 7.1 or lower.
> if (!GTEST_FLAG(break_on_failure))
> _set_abort_behavior(
> 0x0, // Clear the following
> flags:
> _WRITE_ABORT_MSG | _CALL_REPORTFAULT); // pop-up window, core
> dump.
> # endif
> +
> + // In debug mode, the Windows CRT can crash with an assertion over
> invalid
> + // input (e.g. passing an invalid file descriptor). The default
> handling
> + // for these assertions is to pop up a dialog and wait for user input.
> + // Instead ask the CRT to dump such assertions to stderr
> non-interactively.
> + if (!IsDebuggerPresent()) {
> + (void)_CrtSetReportMode(_CRT_ASSERT,
> + _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG);
> + (void)_CrtSetReportFile(_CRT_ASSERT, _CRTDBG_FILE_STDERR);
> + }
> }
> #endif // GTEST_OS_WINDOWS
>
> @@ -4795,13 +4934,22 @@ const char* UnitTest::original_working_dir() const
> {
> return impl_->original_working_dir_.c_str();
> }
>
> -// Returns the TestCase object for the test that's currently running,
> +// Returns the TestSuite object for the test that's currently running,
> // or NULL if no test is running.
> +const TestSuite* UnitTest::current_test_suite() const
> + GTEST_LOCK_EXCLUDED_(mutex_) {
> + internal::MutexLock lock(&mutex_);
> + return impl_->current_test_suite();
> +}
> +
> +// Legacy API is still available but deprecated
> +#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
> const TestCase* UnitTest::current_test_case() const
> GTEST_LOCK_EXCLUDED_(mutex_) {
> internal::MutexLock lock(&mutex_);
> - return impl_->current_test_case();
> + return impl_->current_test_suite();
> }
> +#endif
>
> // Returns the TestInfo object for the test that's currently running,
> // or NULL if no test is running.
> @@ -4814,11 +4962,10 @@ const TestInfo* UnitTest::current_test_info() const
> // Returns the random seed used at the start of the current test run.
> int UnitTest::random_seed() const { return impl_->random_seed(); }
>
> -// Returns ParameterizedTestCaseRegistry object used to keep track of
> +// Returns ParameterizedTestSuiteRegistry object used to keep track of
> // value-parameterized tests and instantiate and register them.
> -internal::ParameterizedTestCaseRegistry&
> - UnitTest::parameterized_test_registry()
> - GTEST_LOCK_EXCLUDED_(mutex_) {
> +internal::ParameterizedTestSuiteRegistry&
> +UnitTest::parameterized_test_registry() GTEST_LOCK_EXCLUDED_(mutex_) {
> return impl_->parameterized_test_registry();
> }
>
> @@ -4852,23 +4999,22 @@ namespace internal {
> UnitTestImpl::UnitTestImpl(UnitTest* parent)
> : parent_(parent),
> GTEST_DISABLE_MSC_WARNINGS_PUSH_(4355 /* using this in initializer
> */)
> - default_global_test_part_result_reporter_(this),
> + default_global_test_part_result_reporter_(this),
> default_per_thread_test_part_result_reporter_(this),
> - GTEST_DISABLE_MSC_WARNINGS_POP_()
> - global_test_part_result_repoter_(
> + GTEST_DISABLE_MSC_WARNINGS_POP_() global_test_part_result_repoter_(
> &default_global_test_part_result_reporter_),
> per_thread_test_part_result_reporter_(
> &default_per_thread_test_part_result_reporter_),
> parameterized_test_registry_(),
> parameterized_tests_registered_(false),
> - last_death_test_case_(-1),
> - current_test_case_(NULL),
> - current_test_info_(NULL),
> + last_death_test_suite_(-1),
> + current_test_suite_(nullptr),
> + current_test_info_(nullptr),
> ad_hoc_test_result_(),
> - os_stack_trace_getter_(NULL),
> + os_stack_trace_getter_(nullptr),
> post_flag_parse_init_performed_(false),
> random_seed_(0), // Will be overridden by the flag before first
> use.
> - random_(0), // Will be reseeded before first use.
> + random_(0), // Will be reseeded before first use.
> start_timestamp_(0),
> elapsed_time_(0),
> #if GTEST_HAS_DEATH_TEST
> @@ -4880,8 +5026,8 @@ UnitTestImpl::UnitTestImpl(UnitTest* parent)
> }
>
> UnitTestImpl::~UnitTestImpl() {
> - // Deletes every TestCase.
> - ForEach(test_cases_, internal::Delete<TestCase>);
> + // Deletes every TestSuite.
> + ForEach(test_suites_, internal::Delete<TestSuite>);
>
> // Deletes every Environment.
> ForEach(environments_, internal::Delete<Environment>);
> @@ -4890,20 +5036,20 @@ UnitTestImpl::~UnitTestImpl() {
> }
>
> // Adds a TestProperty to the current TestResult object when invoked in a
> -// context of a test, to current test case's ad_hoc_test_result when
> invoke
> -// from SetUpTestCase/TearDownTestCase, or to the global property set
> +// context of a test, to current test suite's ad_hoc_test_result when
> invoke
> +// from SetUpTestSuite/TearDownTestSuite, or to the global property set
> // otherwise. If the result already contains a property with the same
> key,
> // the value will be updated.
> void UnitTestImpl::RecordProperty(const TestProperty& test_property) {
> std::string xml_element;
> TestResult* test_result; // TestResult appropriate for property
> recording.
>
> - if (current_test_info_ != NULL) {
> + if (current_test_info_ != nullptr) {
> xml_element = "testcase";
> test_result = &(current_test_info_->result_);
> - } else if (current_test_case_ != NULL) {
> + } else if (current_test_suite_ != nullptr) {
> xml_element = "testsuite";
> - test_result = &(current_test_case_->ad_hoc_test_result_);
> + test_result = &(current_test_suite_->ad_hoc_test_result_);
> } else {
> xml_element = "testsuites";
> test_result = &ad_hoc_test_result_;
> @@ -4915,7 +5061,7 @@ void UnitTestImpl::RecordProperty(const
> TestProperty& test_property) {
> // Disables event forwarding if the control is currently in a death test
> // subprocess. Must not be called before InitGoogleTest.
> void UnitTestImpl::SuppressTestEventsIfInSubprocess() {
> - if (internal_run_death_test_flag_.get() != NULL)
> + if (internal_run_death_test_flag_.get() != nullptr)
> listeners()->SuppressEventForwarding();
> }
> #endif // GTEST_HAS_DEATH_TEST
> @@ -4997,74 +5143,73 @@ void UnitTestImpl::PostFlagParsingInit() {
> }
> }
>
> -// A predicate that checks the name of a TestCase against a known
> +// A predicate that checks the name of a TestSuite against a known
> // value.
> //
> // This is used for implementation of the UnitTest class only. We put
> // it in the anonymous namespace to prevent polluting the outer
> // namespace.
> //
> -// TestCaseNameIs is copyable.
> -class TestCaseNameIs {
> +// TestSuiteNameIs is copyable.
> +class TestSuiteNameIs {
> public:
> // Constructor.
> - explicit TestCaseNameIs(const std::string& name)
> - : name_(name) {}
> + explicit TestSuiteNameIs(const std::string& name) : name_(name) {}
>
> - // Returns true iff the name of test_case matches name_.
> - bool operator()(const TestCase* test_case) const {
> - return test_case != NULL && strcmp(test_case->name(), name_.c_str())
> == 0;
> + // Returns true if and only if the name of test_suite matches name_.
> + bool operator()(const TestSuite* test_suite) const {
> + return test_suite != nullptr &&
> + strcmp(test_suite->name(), name_.c_str()) == 0;
> }
>
> private:
> std::string name_;
> };
>
> -// Finds and returns a TestCase with the given name. If one doesn't
> +// Finds and returns a TestSuite with the given name. If one doesn't
> // exist, creates one and returns it. It's the CALLER'S
> // RESPONSIBILITY to ensure that this function is only called WHEN THE
> // TESTS ARE NOT SHUFFLED.
> //
> // Arguments:
> //
> -// test_case_name: name of the test case
> -// type_param: the name of the test case's type parameter, or NULL
> if
> -// this is not a typed or a type-parameterized test
> case.
> -// set_up_tc: pointer to the function that sets up the test case
> -// tear_down_tc: pointer to the function that tears down the test case
> -TestCase* UnitTestImpl::GetTestCase(const char* test_case_name,
> - const char* type_param,
> - Test::SetUpTestCaseFunc set_up_tc,
> - Test::TearDownTestCaseFunc
> tear_down_tc) {
> - // Can we find a TestCase with the given name?
> - const std::vector<TestCase*>::const_reverse_iterator test_case =
> - std::find_if(test_cases_.rbegin(), test_cases_.rend(),
> - TestCaseNameIs(test_case_name));
> -
> - if (test_case != test_cases_.rend())
> - return *test_case;
> +// test_suite_name: name of the test suite
> +// type_param: the name of the test suite's type parameter, or NULL
> if
> +// this is not a typed or a type-parameterized test
> suite.
> +// set_up_tc: pointer to the function that sets up the test suite
> +// tear_down_tc: pointer to the function that tears down the test
> suite
> +TestSuite* UnitTestImpl::GetTestSuite(
> + const char* test_suite_name, const char* type_param,
> + internal::SetUpTestSuiteFunc set_up_tc,
> + internal::TearDownTestSuiteFunc tear_down_tc) {
> + // Can we find a TestSuite with the given name?
> + const auto test_suite =
> + std::find_if(test_suites_.rbegin(), test_suites_.rend(),
> + TestSuiteNameIs(test_suite_name));
> +
> + if (test_suite != test_suites_.rend()) return *test_suite;
>
> // No. Let's create one.
> - TestCase* const new_test_case =
> - new TestCase(test_case_name, type_param, set_up_tc, tear_down_tc);
> -
> - // Is this a death test case?
> - if (internal::UnitTestOptions::MatchesFilter(test_case_name,
> - kDeathTestCaseFilter)) {
> - // Yes. Inserts the test case after the last death test case
> - // defined so far. This only works when the test cases haven't
> + auto* const new_test_suite =
> + new TestSuite(test_suite_name, type_param, set_up_tc, tear_down_tc);
> +
> + // Is this a death test suite?
> + if (internal::UnitTestOptions::MatchesFilter(test_suite_name,
> + kDeathTestSuiteFilter)) {
> + // Yes. Inserts the test suite after the last death test suite
> + // defined so far. This only works when the test suites haven't
> // been shuffled. Otherwise we may end up running a death test
> // after a non-death test.
> - ++last_death_test_case_;
> - test_cases_.insert(test_cases_.begin() + last_death_test_case_,
> - new_test_case);
> + ++last_death_test_suite_;
> + test_suites_.insert(test_suites_.begin() + last_death_test_suite_,
> + new_test_suite);
> } else {
> // No. Appends to the end of the list.
> - test_cases_.push_back(new_test_case);
> + test_suites_.push_back(new_test_suite);
> }
>
> -
> test_case_indices_.push_back(static_cast<int>(test_case_indices_.size()));
> - return new_test_case;
> +
> test_suite_indices_.push_back(static_cast<int>(test_suite_indices_.size()));
> + return new_test_suite;
> }
>
> // Helpers for setting up / tearing down the given environment. They
> @@ -5082,7 +5227,8 @@ static void TearDownEnvironment(Environment* env) {
> env->TearDown(); }
> // All other functions called from RunAllTests() may safely assume that
> // parameterized tests are ready to be counted and run.
> bool UnitTestImpl::RunAllTests() {
> - // True iff Google Test is initialized before RUN_ALL_TESTS() is called.
> + // True if and only if Google Test is initialized before
> RUN_ALL_TESTS() is
> + // called.
> const bool gtest_is_initialized_before_run_all_tests =
> GTestIsInitialized();
>
> // Do not run any test if the --help flag was specified.
> @@ -5098,12 +5244,13 @@ bool UnitTestImpl::RunAllTests() {
> // protocol.
> internal::WriteToShardStatusFileIfNeeded();
>
> - // True iff we are in a subprocess for running a thread-safe-style
> + // True if and only if we are in a subprocess for running a
> thread-safe-style
> // death test.
> bool in_subprocess_for_death_test = false;
>
> #if GTEST_HAS_DEATH_TEST
> - in_subprocess_for_death_test = (internal_run_death_test_flag_.get() !=
> NULL);
> + in_subprocess_for_death_test =
> + (internal_run_death_test_flag_.get() != nullptr);
> # if defined(GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_)
> if (in_subprocess_for_death_test) {
> GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_();
> @@ -5130,7 +5277,7 @@ bool UnitTestImpl::RunAllTests() {
> random_seed_ = GTEST_FLAG(shuffle) ?
> GetRandomSeedFromFlag(GTEST_FLAG(random_seed)) : 0;
>
> - // True iff at least one test has failed.
> + // True if and only if at least one test has failed.
> bool failed = false;
>
> TestEventListener* repeater = listeners()->repeater();
> @@ -5142,17 +5289,17 @@ bool UnitTestImpl::RunAllTests() {
> // when we are inside the subprocess of a death test.
> const int repeat = in_subprocess_for_death_test ? 1 :
> GTEST_FLAG(repeat);
> // Repeats forever if the repeat count is negative.
> - const bool forever = repeat < 0;
> - for (int i = 0; forever || i != repeat; i++) {
> + const bool gtest_repeat_forever = repeat < 0;
> + for (int i = 0; gtest_repeat_forever || i != repeat; i++) {
> // We want to preserve failures generated by ad-hoc test
> // assertions executed before RUN_ALL_TESTS().
> ClearNonAdHocTestResult();
>
> const TimeInMillis start = GetTimeInMillis();
>
> - // Shuffles test cases and tests if requested.
> + // Shuffles test suites and tests if requested.
> if (has_tests_to_run && GTEST_FLAG(shuffle)) {
> - random()->Reseed(random_seed_);
> + random()->Reseed(static_cast<UInt32>(random_seed_));
> // This should be done before calling OnTestIterationStart(),
> // such that a test event listener can see the actual test order
> // in the event.
> @@ -5162,19 +5309,33 @@ bool UnitTestImpl::RunAllTests() {
> // Tells the unit test event listeners that the tests are about to
> start.
> repeater->OnTestIterationStart(*parent_, i);
>
> - // Runs each test case if there is at least one test to run.
> + // Runs each test suite if there is at least one test to run.
> if (has_tests_to_run) {
> // Sets up all environments beforehand.
> repeater->OnEnvironmentsSetUpStart(*parent_);
> ForEach(environments_, SetUpEnvironment);
> repeater->OnEnvironmentsSetUpEnd(*parent_);
>
> - // Runs the tests only if there was no fatal failure during global
> - // set-up.
> - if (!Test::HasFatalFailure()) {
> - for (int test_index = 0; test_index < total_test_case_count();
> + // Runs the tests only if there was no fatal failure or skip
> triggered
> + // during global set-up.
> + if (Test::IsSkipped()) {
> + // Emit diagnostics when global set-up calls skip, as it will not
> be
> + // emitted by default.
> + TestResult& test_result =
> + *internal::GetUnitTestImpl()->current_test_result();
> + for (int j = 0; j < test_result.total_part_count(); ++j) {
> + const TestPartResult& test_part_result =
> + test_result.GetTestPartResult(j);
> + if (test_part_result.type() == TestPartResult::kSkip) {
> + const std::string& result = test_part_result.message();
> + printf("%s\n", result.c_str());
> + }
> + }
> + fflush(stdout);
> + } else if (!Test::HasFatalFailure()) {
> + for (int test_index = 0; test_index < total_test_suite_count();
> test_index++) {
> - GetMutableTestCase(test_index)->Run();
> + GetMutableSuiteCase(test_index)->Run();
> }
> }
>
> @@ -5234,9 +5395,9 @@ bool UnitTestImpl::RunAllTests() {
> // be created, prints an error and exits.
> void WriteToShardStatusFileIfNeeded() {
> const char* const test_shard_file = posix::GetEnv(kTestShardStatusFile);
> - if (test_shard_file != NULL) {
> + if (test_shard_file != nullptr) {
> FILE* const file = posix::FOpen(test_shard_file, "w");
> - if (file == NULL) {
> + if (file == nullptr) {
> ColoredPrintf(COLOR_RED,
> "Could not write to the test shard status file \"%s\"
> "
> "specified by the %s environment variable.\n",
> @@ -5271,7 +5432,7 @@ bool ShouldShard(const char* total_shards_env,
> << "Invalid environment variables: you have "
> << kTestShardIndex << " = " << shard_index
> << ", but have left " << kTestTotalShards << " unset.\n";
> - ColoredPrintf(COLOR_RED, msg.GetString().c_str());
> + ColoredPrintf(COLOR_RED, "%s", msg.GetString().c_str());
> fflush(stdout);
> exit(EXIT_FAILURE);
> } else if (total_shards != -1 && shard_index == -1) {
> @@ -5279,7 +5440,7 @@ bool ShouldShard(const char* total_shards_env,
> << "Invalid environment variables: you have "
> << kTestTotalShards << " = " << total_shards
> << ", but have left " << kTestShardIndex << " unset.\n";
> - ColoredPrintf(COLOR_RED, msg.GetString().c_str());
> + ColoredPrintf(COLOR_RED, "%s", msg.GetString().c_str());
> fflush(stdout);
> exit(EXIT_FAILURE);
> } else if (shard_index < 0 || shard_index >= total_shards) {
> @@ -5288,7 +5449,7 @@ bool ShouldShard(const char* total_shards_env,
> << kTestShardIndex << " < " << kTestTotalShards
> << ", but you have " << kTestShardIndex << "=" << shard_index
> << ", " << kTestTotalShards << "=" << total_shards << ".\n";
> - ColoredPrintf(COLOR_RED, msg.GetString().c_str());
> + ColoredPrintf(COLOR_RED, "%s", msg.GetString().c_str());
> fflush(stdout);
> exit(EXIT_FAILURE);
> }
> @@ -5301,7 +5462,7 @@ bool ShouldShard(const char* total_shards_env,
> // and aborts.
> Int32 Int32FromEnvOrDie(const char* var, Int32 default_val) {
> const char* str_val = posix::GetEnv(var);
> - if (str_val == NULL) {
> + if (str_val == nullptr) {
> return default_val;
> }
>
> @@ -5314,8 +5475,8 @@ Int32 Int32FromEnvOrDie(const char* var, Int32
> default_val) {
> }
>
> // Given the total number of shards, the shard index, and the test id,
> -// returns true iff the test should be run on this shard. The test id is
> -// some arbitrary but unique non-negative integer assigned to each test
> +// returns true if and only if the test should be run on this shard. The
> test id
> +// is some arbitrary but unique non-negative integer assigned to each test
> // method. Assumes that 0 <= shard_index < total_shards.
> bool ShouldRunTestOnShard(int total_shards, int shard_index, int test_id)
> {
> return (test_id % total_shards) == shard_index;
> @@ -5323,7 +5484,7 @@ bool ShouldRunTestOnShard(int total_shards, int
> shard_index, int test_id) {
>
> // Compares the name of each test with the user-specified filter to
> // decide whether the test should be run, then records the result in
> -// each TestCase and TestInfo object.
> +// each TestSuite and TestInfo object.
> // If shard_tests == true, further filters tests based on sharding
> // variables in the environment - see
> //
> https://github.com/google/googletest/blob/master/googletest/docs/advanced.md
> @@ -5340,26 +5501,23 @@ int UnitTestImpl::FilterTests(ReactionToSharding
> shard_tests) {
> // this shard.
> int num_runnable_tests = 0;
> int num_selected_tests = 0;
> - for (size_t i = 0; i < test_cases_.size(); i++) {
> - TestCase* const test_case = test_cases_[i];
> - const std::string &test_case_name = test_case->name();
> - test_case->set_should_run(false);
> + for (auto* test_suite : test_suites_) {
> + const std::string& test_suite_name = test_suite->name();
> + test_suite->set_should_run(false);
>
> - for (size_t j = 0; j < test_case->test_info_list().size(); j++) {
> - TestInfo* const test_info = test_case->test_info_list()[j];
> + for (size_t j = 0; j < test_suite->test_info_list().size(); j++) {
> + TestInfo* const test_info = test_suite->test_info_list()[j];
> const std::string test_name(test_info->name());
> - // A test is disabled if test case name or test name matches
> + // A test is disabled if test suite name or test name matches
> // kDisableTestFilter.
> - const bool is_disabled =
> - internal::UnitTestOptions::MatchesFilter(test_case_name,
> - kDisableTestFilter) ||
> - internal::UnitTestOptions::MatchesFilter(test_name,
> - kDisableTestFilter);
> + const bool is_disabled = internal::UnitTestOptions::MatchesFilter(
> + test_suite_name, kDisableTestFilter) ||
> + internal::UnitTestOptions::MatchesFilter(
> + test_name, kDisableTestFilter);
> test_info->is_disabled_ = is_disabled;
>
> - const bool matches_filter =
> - internal::UnitTestOptions::FilterMatchesTest(test_case_name,
> - test_name);
> + const bool matches_filter =
> internal::UnitTestOptions::FilterMatchesTest(
> + test_suite_name, test_name);
> test_info->matches_filter_ = matches_filter;
>
> const bool is_runnable =
> @@ -5376,7 +5534,7 @@ int UnitTestImpl::FilterTests(ReactionToSharding
> shard_tests) {
> num_selected_tests += is_selected;
>
> test_info->should_run_ = is_selected;
> - test_case->set_should_run(test_case->should_run() || is_selected);
> + test_suite->set_should_run(test_suite->should_run() || is_selected);
> }
> }
> return num_selected_tests;
> @@ -5387,7 +5545,7 @@ int UnitTestImpl::FilterTests(ReactionToSharding
> shard_tests) {
> // max_length characters, only prints the first max_length characters
> // and "...".
> static void PrintOnOneLine(const char* str, int max_length) {
> - if (str != NULL) {
> + if (str != nullptr) {
> for (int i = 0; *str != '\0'; ++str) {
> if (i >= max_length) {
> printf("...");
> @@ -5409,27 +5567,25 @@ void UnitTestImpl::ListTestsMatchingFilter() {
> // Print at most this many characters for each type/value parameter.
> const int kMaxParamLength = 250;
>
> - for (size_t i = 0; i < test_cases_.size(); i++) {
> - const TestCase* const test_case = test_cases_[i];
> - bool printed_test_case_name = false;
> + for (auto* test_suite : test_suites_) {
> + bool printed_test_suite_name = false;
>
> - for (size_t j = 0; j < test_case->test_info_list().size(); j++) {
> - const TestInfo* const test_info =
> - test_case->test_info_list()[j];
> + for (size_t j = 0; j < test_suite->test_info_list().size(); j++) {
> + const TestInfo* const test_info = test_suite->test_info_list()[j];
> if (test_info->matches_filter_) {
> - if (!printed_test_case_name) {
> - printed_test_case_name = true;
> - printf("%s.", test_case->name());
> - if (test_case->type_param() != NULL) {
> + if (!printed_test_suite_name) {
> + printed_test_suite_name = true;
> + printf("%s.", test_suite->name());
> + if (test_suite->type_param() != nullptr) {
> printf(" # %s = ", kTypeParamLabel);
> // We print the type parameter on a single line to make
> // the output easy to parse by a program.
> - PrintOnOneLine(test_case->type_param(), kMaxParamLength);
> + PrintOnOneLine(test_suite->type_param(), kMaxParamLength);
> }
> printf("\n");
> }
> printf(" %s", test_info->name());
> - if (test_info->value_param() != NULL) {
> + if (test_info->value_param() != nullptr) {
> printf(" # %s = ", kValueParamLabel);
> // We print the value parameter on a single line to make the
> // output easy to parse by a program.
> @@ -5448,11 +5604,11 @@ void UnitTestImpl::ListTestsMatchingFilter() {
> if (output_format == "xml") {
> XmlUnitTestResultPrinter(
> UnitTestOptions::GetAbsolutePathToOutputFile().c_str())
> - .PrintXmlTestsList(&stream, test_cases_);
> + .PrintXmlTestsList(&stream, test_suites_);
> } else if (output_format == "json") {
> JsonUnitTestResultPrinter(
> UnitTestOptions::GetAbsolutePathToOutputFile().c_str())
> - .PrintJsonTestList(&stream, test_cases_);
> + .PrintJsonTestList(&stream, test_suites_);
> }
> fprintf(fileout, "%s", StringStreamToString(&stream).c_str());
> fclose(fileout);
> @@ -5476,7 +5632,7 @@ void UnitTestImpl::set_os_stack_trace_getter(
> // otherwise, creates an OsStackTraceGetter, makes it the current
> // getter, and returns it.
> OsStackTraceGetterInterface* UnitTestImpl::os_stack_trace_getter() {
> - if (os_stack_trace_getter_ == NULL) {
> + if (os_stack_trace_getter_ == nullptr) {
> #ifdef GTEST_OS_STACK_TRACE_GETTER_
> os_stack_trace_getter_ = new GTEST_OS_STACK_TRACE_GETTER_;
> #else
> @@ -5489,38 +5645,38 @@ OsStackTraceGetterInterface*
> UnitTestImpl::os_stack_trace_getter() {
>
> // Returns the most specific TestResult currently running.
> TestResult* UnitTestImpl::current_test_result() {
> - if (current_test_info_ != NULL) {
> + if (current_test_info_ != nullptr) {
> return ¤t_test_info_->result_;
> }
> - if (current_test_case_ != NULL) {
> - return ¤t_test_case_->ad_hoc_test_result_;
> + if (current_test_suite_ != nullptr) {
> + return ¤t_test_suite_->ad_hoc_test_result_;
> }
> return &ad_hoc_test_result_;
> }
>
> -// Shuffles all test cases, and the tests within each test case,
> +// Shuffles all test suites, and the tests within each test suite,
> // making sure that death tests are still run first.
> void UnitTestImpl::ShuffleTests() {
> - // Shuffles the death test cases.
> - ShuffleRange(random(), 0, last_death_test_case_ + 1,
> &test_case_indices_);
> + // Shuffles the death test suites.
> + ShuffleRange(random(), 0, last_death_test_suite_ + 1,
> &test_suite_indices_);
>
> - // Shuffles the non-death test cases.
> - ShuffleRange(random(), last_death_test_case_ + 1,
> - static_cast<int>(test_cases_.size()), &test_case_indices_);
> + // Shuffles the non-death test suites.
> + ShuffleRange(random(), last_death_test_suite_ + 1,
> + static_cast<int>(test_suites_.size()),
> &test_suite_indices_);
>
> - // Shuffles the tests inside each test case.
> - for (size_t i = 0; i < test_cases_.size(); i++) {
> - test_cases_[i]->ShuffleTests(random());
> + // Shuffles the tests inside each test suite.
> + for (auto& test_suite : test_suites_) {
> + test_suite->ShuffleTests(random());
> }
> }
>
> -// Restores the test cases and tests to their order before the first
> shuffle.
> +// Restores the test suites and tests to their order before the first
> shuffle.
> void UnitTestImpl::UnshuffleTests() {
> - for (size_t i = 0; i < test_cases_.size(); i++) {
> - // Unshuffles the tests in each test case.
> - test_cases_[i]->UnshuffleTests();
> - // Resets the index of each test case.
> - test_case_indices_[i] = static_cast<int>(i);
> + for (size_t i = 0; i < test_suites_.size(); i++) {
> + // Unshuffles the tests in each test suite.
> + test_suites_[i]->UnshuffleTests();
> + // Resets the index of each test suite.
> + test_suite_indices_[i] = static_cast<int>(i);
> }
> }
>
> @@ -5579,12 +5735,12 @@ bool SkipPrefix(const char* prefix, const char**
> pstr) {
> static const char* ParseFlagValue(const char* str, const char* flag,
> bool def_optional) {
> // str and flag must not be NULL.
> - if (str == NULL || flag == NULL) return NULL;
> + if (str == nullptr || flag == nullptr) return nullptr;
>
> // The flag must start with "--" followed by GTEST_FLAG_PREFIX_.
> const std::string flag_str = std::string("--") + GTEST_FLAG_PREFIX_ +
> flag;
> const size_t flag_len = flag_str.length();
> - if (strncmp(str, flag_str.c_str(), flag_len) != 0) return NULL;
> + if (strncmp(str, flag_str.c_str(), flag_len) != 0) return nullptr;
>
> // Skips the flag name.
> const char* flag_end = str + flag_len;
> @@ -5597,7 +5753,7 @@ static const char* ParseFlagValue(const char* str,
> const char* flag,
> // If def_optional is true and there are more characters after the
> // flag name, or if def_optional is false, there must be a '=' after
> // the flag name.
> - if (flag_end[0] != '=') return NULL;
> + if (flag_end[0] != '=') return nullptr;
>
> // Returns the string after "=".
> return flag_end + 1;
> @@ -5618,7 +5774,7 @@ static bool ParseBoolFlag(const char* str, const
> char* flag, bool* value) {
> const char* const value_str = ParseFlagValue(str, flag, true);
>
> // Aborts if the parsing failed.
> - if (value_str == NULL) return false;
> + if (value_str == nullptr) return false;
>
> // Converts the string value to a bool.
> *value = !(*value_str == '0' || *value_str == 'f' || *value_str == 'F');
> @@ -5635,7 +5791,7 @@ bool ParseInt32Flag(const char* str, const char*
> flag, Int32* value) {
> const char* const value_str = ParseFlagValue(str, flag, false);
>
> // Aborts if the parsing failed.
> - if (value_str == NULL) return false;
> + if (value_str == nullptr) return false;
>
> // Sets *value to the value of the flag.
> return ParseInt32(Message() << "The value of flag --" << flag,
> @@ -5653,7 +5809,7 @@ static bool ParseStringFlag(const char* str, const
> char* flag, String* value) {
> const char* const value_str = ParseFlagValue(str, flag, false);
>
> // Aborts if the parsing failed.
> - if (value_str == NULL) return false;
> + if (value_str == nullptr) return false;
>
> // Sets *value to the value of the flag.
> *value = value_str;
> @@ -5684,8 +5840,6 @@ static bool HasGoogleTestFlagPrefix(const char* str)
> {
> // @Y changes the color to yellow.
> // @D changes to the default terminal text color.
> //
> -// FIXME: Write tests for this once we add stdout
> -// capturing to Google Test.
> static void PrintColorEncoded(const char* str) {
> GTestColor color = COLOR_DEFAULT; // The current color.
>
> @@ -5695,7 +5849,7 @@ static void PrintColorEncoded(const char* str) {
> // next segment.
> for (;;) {
> const char* p = strchr(str, '@');
> - if (p == NULL) {
> + if (p == nullptr) {
> ColoredPrintf(color, "%s", str);
> return;
> }
> @@ -5753,7 +5907,7 @@ static const char kColorEncodedHelpMessage[] =
> " @G--" GTEST_FLAG_PREFIX_ "output=@Y(@Gjson at Y|@Gxml at Y
> )[@G:@YDIRECTORY_PATH at G"
> GTEST_PATH_SEP_ "@Y|@G:@YFILE_PATH]@D\n"
> " Generate a JSON or XML report in the given directory or with the
> given\n"
> -" file name. @YFILE_PATH at D defaults to @Gtest_details.xml at D.\n"
> +" file name. @YFILE_PATH at D defaults to @Gtest_detail.xml at D.\n"
> # if GTEST_CAN_STREAM_RESULTS_
> " @G--" GTEST_FLAG_PREFIX_ "stream_result_to=@YHOST at G:@YPORT at D\n"
> " Stream test results to the given server.\n"
> @@ -5895,7 +6049,7 @@ void ParseGoogleTestFlagsOnlyImpl(int* argc,
> CharType** argv) {
> void ParseGoogleTestFlagsOnly(int* argc, char** argv) {
> ParseGoogleTestFlagsOnlyImpl(argc, argv);
>
> - // Fix the value of *_NSGetArgc() on macOS, but iff
> + // Fix the value of *_NSGetArgc() on macOS, but if and only if
> // *_NSGetArgv() == argv
> // Only applicable to char** version of argv
> #if GTEST_OS_MAC
> @@ -5963,6 +6117,22 @@ void InitGoogleTest(int* argc, wchar_t** argv) {
> #endif // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
> }
>
> +// This overloaded version can be used on Arduino/embedded platforms where
> +// there is no argc/argv.
> +void InitGoogleTest() {
> + // Since Arduino doesn't have a command line, fake out the argc/argv
> arguments
> + int argc = 1;
> + const auto arg0 = "dummy";
> + char* argv0 = const_cast<char*>(arg0);
> + char** argv = &argv0;
> +
> +#if defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
> + GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_(&argc, argv);
> +#else // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
> + internal::InitGoogleTestImpl(&argc, argv);
> +#endif // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
> +}
> +
> std::string TempDir() {
> #if defined(GTEST_CUSTOM_TEMPDIR_FUNCTION_)
> return GTEST_CUSTOM_TEMPDIR_FUNCTION_();
> @@ -5972,7 +6142,7 @@ std::string TempDir() {
> return "\\temp\\";
> #elif GTEST_OS_WINDOWS
> const char* temp_dir = internal::posix::GetEnv("TEMP");
> - if (temp_dir == NULL || temp_dir[0] == '\0')
> + if (temp_dir == nullptr || temp_dir[0] == '\0')
> return "\\temp\\";
> else if (temp_dir[strlen(temp_dir) - 1] == '\\')
> return temp_dir;
>
>
>
> _______________________________________________
> llvm-commits mailing list
> llvm-commits at lists.llvm.org
> https://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-commits
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/llvm-commits/attachments/20210515/e0e909bd/attachment-0001.html>
More information about the llvm-commits
mailing list