diff --git a/generator/integration_tests/golden/v1/mocks/mock_golden_thing_admin_connection.h b/generator/integration_tests/golden/v1/mocks/mock_golden_thing_admin_connection.h index 126c571ed0cd7..09f51b1f92c0b 100644 --- a/generator/integration_tests/golden/v1/mocks/mock_golden_thing_admin_connection.h +++ b/generator/integration_tests/golden/v1/mocks/mock_golden_thing_admin_connection.h @@ -50,17 +50,36 @@ class MockGoldenThingAdminConnection : public golden_v1::GoldenThingAdminConnect ListDatabases, (google::test::admin::database::v1::ListDatabasesRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateDatabase)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateDatabase(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateDatabase(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateDatabase, (google::test::admin::database::v1::CreateDatabaseRequest const& request), (override)); + + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateDatabase(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateDatabase, (NoAwaitTag, google::test::admin::database::v1::CreateDatabaseRequest const& request), (override)); + + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateDatabase(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateDatabase, ( google::longrunning::Operation const& operation), (override)); @@ -69,17 +88,36 @@ class MockGoldenThingAdminConnection : public golden_v1::GoldenThingAdminConnect GetDatabase, (google::test::admin::database::v1::GetDatabaseRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateDatabaseDdl)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateDatabaseDdl(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateDatabaseDdl(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateDatabaseDdl, (google::test::admin::database::v1::UpdateDatabaseDdlRequest const& request), (override)); + + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateDatabaseDdl(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateDatabaseDdl, (NoAwaitTag, google::test::admin::database::v1::UpdateDatabaseDdlRequest const& request), (override)); + + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateDatabaseDdl(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateDatabaseDdl, ( google::longrunning::Operation const& operation), (override)); @@ -104,17 +142,36 @@ class MockGoldenThingAdminConnection : public golden_v1::GoldenThingAdminConnect TestIamPermissions, (google::iam::v1::TestIamPermissionsRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateBackup)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateBackup(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateBackup(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateBackup, (google::test::admin::database::v1::CreateBackupRequest const& request), (override)); + + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateBackup(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateBackup, (NoAwaitTag, google::test::admin::database::v1::CreateBackupRequest const& request), (override)); + + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateBackup(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateBackup, ( google::longrunning::Operation const& operation), (override)); @@ -135,17 +192,36 @@ class MockGoldenThingAdminConnection : public golden_v1::GoldenThingAdminConnect ListBackups, (google::test::admin::database::v1::ListBackupsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, RestoreDatabase)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, RestoreDatabase(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, RestoreDatabase(Matcher(_))) + /// @endcode MOCK_METHOD(future>, RestoreDatabase, (google::test::admin::database::v1::RestoreDatabaseRequest const& request), (override)); + + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, RestoreDatabase(_, _)) + /// @endcode MOCK_METHOD(StatusOr, RestoreDatabase, (NoAwaitTag, google::test::admin::database::v1::RestoreDatabaseRequest const& request), (override)); + + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, RestoreDatabase(Matcher(_))) + /// @endcode MOCK_METHOD(future>, RestoreDatabase, ( google::longrunning::Operation const& operation), (override)); @@ -158,17 +234,36 @@ class MockGoldenThingAdminConnection : public golden_v1::GoldenThingAdminConnect ListBackupOperations, (google::test::admin::database::v1::ListBackupOperationsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, LongRunningWithoutRouting)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, LongRunningWithoutRouting(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, LongRunningWithoutRouting(Matcher(_))) + /// @endcode MOCK_METHOD(future>, LongRunningWithoutRouting, (google::test::admin::database::v1::RestoreDatabaseRequest const& request), (override)); + + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, LongRunningWithoutRouting(_, _)) + /// @endcode MOCK_METHOD(StatusOr, LongRunningWithoutRouting, (NoAwaitTag, google::test::admin::database::v1::RestoreDatabaseRequest const& request), (override)); + + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, LongRunningWithoutRouting(Matcher(_))) + /// @endcode MOCK_METHOD(future>, LongRunningWithoutRouting, ( google::longrunning::Operation const& operation), (override)); diff --git a/generator/integration_tests/golden/v1/mocks/mock_request_id_connection.h b/generator/integration_tests/golden/v1/mocks/mock_request_id_connection.h index 7c5a0d36184ab..6aae17b45199d 100644 --- a/generator/integration_tests/golden/v1/mocks/mock_request_id_connection.h +++ b/generator/integration_tests/golden/v1/mocks/mock_request_id_connection.h @@ -50,17 +50,36 @@ class MockRequestIdServiceConnection : public golden_v1::RequestIdServiceConnect CreateFoo, (google::test::requestid::v1::CreateFooRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, RenameFoo)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, RenameFoo(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, RenameFoo(Matcher(_))) + /// @endcode MOCK_METHOD(future>, RenameFoo, (google::test::requestid::v1::RenameFooRequest const& request), (override)); + + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, RenameFoo(_, _)) + /// @endcode MOCK_METHOD(StatusOr, RenameFoo, (NoAwaitTag, google::test::requestid::v1::RenameFooRequest const& request), (override)); + + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, RenameFoo(Matcher(_))) + /// @endcode MOCK_METHOD(future>, RenameFoo, ( google::longrunning::Operation const& operation), (override)); diff --git a/generator/internal/mock_connection_generator.cc b/generator/internal/mock_connection_generator.cc index 684f1bc10f263..c52306a9bef4b 100644 --- a/generator/internal/mock_connection_generator.cc +++ b/generator/internal/mock_connection_generator.cc @@ -103,11 +103,16 @@ class $mock_connection_class_name$ : public $product_namespace$::$connection_cla Not(IsPaginated))), MethodPattern( { - {// clang-format off - "\n /// Due to additional overloads for this method\n" - " /// `EXPECT_CALL(*mock, $method_name$)` is now ambiguous. Use\n" - " /// `EXPECT_CALL(*mock, $method_name$(::testing::_))` instead.\n"}, - // clang-format on + { + R"""( + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, $method_name$(Matcher<$request_type$ const&>(_))) + /// @endcode +)"""}, {IsResponseTypeEmpty, // clang-format off " MOCK_METHOD(future,\n", @@ -115,6 +120,14 @@ class $mock_connection_class_name$ : public $product_namespace$::$connection_cla {" $method_name$,\n" " ($request_type$ const& request), (override));\n\n",}, // clang-format on + {R"""( + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, $method_name$(_, _)) + /// @endcode +)"""}, {IsResponseTypeEmpty, // clang-format off " MOCK_METHOD(Status,\n", @@ -122,6 +135,15 @@ class $mock_connection_class_name$ : public $product_namespace$::$connection_cla {" $method_name$, (NoAwaitTag,\n" " $request_type$ const& request), (override));\n\n"}, // clang-format on + {R"""( + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, $method_name$(Matcher<$longrunning_operation_type$ const&>(_))) + /// @endcode +)"""}, {IsResponseTypeEmpty, // clang-format off " MOCK_METHOD(future,\n", diff --git a/google/cloud/accesscontextmanager/v1/mocks/mock_access_context_manager_connection.h b/google/cloud/accesscontextmanager/v1/mocks/mock_access_context_manager_connection.h index b26cdafbdc6a3..9a6226da6fa5c 100644 --- a/google/cloud/accesscontextmanager/v1/mocks/mock_access_context_manager_connection.h +++ b/google/cloud/accesscontextmanager/v1/mocks/mock_access_context_manager_connection.h @@ -61,9 +61,15 @@ class MockAccessContextManagerConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateAccessPolicy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateAccessPolicy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateAccessPolicy(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, @@ -71,21 +77,41 @@ class MockAccessContextManagerConnection (google::identity::accesscontextmanager::v1::AccessPolicy const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateAccessPolicy(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateAccessPolicy, (NoAwaitTag, google::identity::accesscontextmanager::v1::AccessPolicy const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateAccessPolicy(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, CreateAccessPolicy, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateAccessPolicy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateAccessPolicy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateAccessPolicy(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, @@ -94,20 +120,40 @@ class MockAccessContextManagerConnection UpdateAccessPolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateAccessPolicy(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateAccessPolicy, (NoAwaitTag, google::identity::accesscontextmanager::v1:: UpdateAccessPolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateAccessPolicy(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, UpdateAccessPolicy, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteAccessPolicy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteAccessPolicy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteAccessPolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteAccessPolicy, @@ -115,11 +161,25 @@ class MockAccessContextManagerConnection DeleteAccessPolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteAccessPolicy(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteAccessPolicy, (NoAwaitTag, google::identity::accesscontextmanager::v1:: DeleteAccessPolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteAccessPolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteAccessPolicy, @@ -139,9 +199,15 @@ class MockAccessContextManagerConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateAccessLevel)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateAccessLevel(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateAccessLevel(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateAccessLevel, @@ -149,19 +215,39 @@ class MockAccessContextManagerConnection CreateAccessLevelRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateAccessLevel(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateAccessLevel, (NoAwaitTag, google::identity::accesscontextmanager::v1:: CreateAccessLevelRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateAccessLevel(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateAccessLevel, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateAccessLevel)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateAccessLevel(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateAccessLevel(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateAccessLevel, @@ -169,19 +255,39 @@ class MockAccessContextManagerConnection UpdateAccessLevelRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateAccessLevel(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateAccessLevel, (NoAwaitTag, google::identity::accesscontextmanager::v1:: UpdateAccessLevelRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateAccessLevel(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateAccessLevel, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteAccessLevel)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteAccessLevel(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteAccessLevel(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteAccessLevel, @@ -189,19 +295,39 @@ class MockAccessContextManagerConnection DeleteAccessLevelRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteAccessLevel(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteAccessLevel, (NoAwaitTag, google::identity::accesscontextmanager::v1:: DeleteAccessLevelRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteAccessLevel(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteAccessLevel, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ReplaceAccessLevels)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ReplaceAccessLevels(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ReplaceAccessLevels(Matcher(_))) + /// @endcode MOCK_METHOD(future>, ReplaceAccessLevels, @@ -209,11 +335,25 @@ class MockAccessContextManagerConnection ReplaceAccessLevelsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ReplaceAccessLevels(_, _)) + /// @endcode MOCK_METHOD(StatusOr, ReplaceAccessLevels, (NoAwaitTag, google::identity::accesscontextmanager::v1:: ReplaceAccessLevelsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ReplaceAccessLevels(Matcher(_))) + /// @endcode MOCK_METHOD(future>, ReplaceAccessLevels, @@ -234,9 +374,15 @@ class MockAccessContextManagerConnection GetServicePerimeterRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateServicePerimeter)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateServicePerimeter(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateServicePerimeter(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -245,20 +391,40 @@ class MockAccessContextManagerConnection CreateServicePerimeterRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateServicePerimeter(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateServicePerimeter, (NoAwaitTag, google::identity::accesscontextmanager::v1:: CreateServicePerimeterRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateServicePerimeter(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateServicePerimeter, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateServicePerimeter)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateServicePerimeter(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateServicePerimeter(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -267,20 +433,40 @@ class MockAccessContextManagerConnection UpdateServicePerimeterRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateServicePerimeter(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateServicePerimeter, (NoAwaitTag, google::identity::accesscontextmanager::v1:: UpdateServicePerimeterRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateServicePerimeter(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateServicePerimeter, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteServicePerimeter)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteServicePerimeter(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteServicePerimeter(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteServicePerimeter, @@ -288,19 +474,39 @@ class MockAccessContextManagerConnection DeleteServicePerimeterRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteServicePerimeter(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteServicePerimeter, (NoAwaitTag, google::identity::accesscontextmanager::v1:: DeleteServicePerimeterRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteServicePerimeter(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteServicePerimeter, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ReplaceServicePerimeters)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ReplaceServicePerimeters(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ReplaceServicePerimeters(Matcher(_))) + /// @endcode MOCK_METHOD(future>, ReplaceServicePerimeters, @@ -308,20 +514,41 @@ class MockAccessContextManagerConnection ReplaceServicePerimetersRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ReplaceServicePerimeters(_, _)) + /// @endcode MOCK_METHOD(StatusOr, ReplaceServicePerimeters, (NoAwaitTag, google::identity::accesscontextmanager::v1:: ReplaceServicePerimetersRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ReplaceServicePerimeters(Matcher(_))) + /// @endcode MOCK_METHOD(future>, ReplaceServicePerimeters, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CommitServicePerimeters)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CommitServicePerimeters(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CommitServicePerimeters(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CommitServicePerimeters, @@ -329,11 +556,26 @@ class MockAccessContextManagerConnection CommitServicePerimetersRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CommitServicePerimeters(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CommitServicePerimeters, (NoAwaitTag, google::identity::accesscontextmanager::v1:: CommitServicePerimetersRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CommitServicePerimeters(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CommitServicePerimeters, @@ -355,9 +597,15 @@ class MockAccessContextManagerConnection GetGcpUserAccessBindingRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateGcpUserAccessBinding)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateGcpUserAccessBinding(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateGcpUserAccessBinding(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -366,6 +614,12 @@ class MockAccessContextManagerConnection CreateGcpUserAccessBindingRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateGcpUserAccessBinding(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateGcpUserAccessBinding, (NoAwaitTag, @@ -373,15 +627,30 @@ class MockAccessContextManagerConnection CreateGcpUserAccessBindingRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateGcpUserAccessBinding(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateGcpUserAccessBinding, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateGcpUserAccessBinding)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateGcpUserAccessBinding(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateGcpUserAccessBinding(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -390,6 +659,12 @@ class MockAccessContextManagerConnection UpdateGcpUserAccessBindingRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateGcpUserAccessBinding(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateGcpUserAccessBinding, (NoAwaitTag, @@ -397,15 +672,30 @@ class MockAccessContextManagerConnection UpdateGcpUserAccessBindingRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateGcpUserAccessBinding(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateGcpUserAccessBinding, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteGcpUserAccessBinding)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteGcpUserAccessBinding(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteGcpUserAccessBinding(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteGcpUserAccessBinding, @@ -413,6 +703,12 @@ class MockAccessContextManagerConnection DeleteGcpUserAccessBindingRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteGcpUserAccessBinding(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteGcpUserAccessBinding, (NoAwaitTag, @@ -420,6 +716,15 @@ class MockAccessContextManagerConnection DeleteGcpUserAccessBindingRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteGcpUserAccessBinding(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteGcpUserAccessBinding, diff --git a/google/cloud/aiplatform/v1/mocks/mock_dataset_connection.h b/google/cloud/aiplatform/v1/mocks/mock_dataset_connection.h index 38daeea6c12fa..8190d778364c5 100644 --- a/google/cloud/aiplatform/v1/mocks/mock_dataset_connection.h +++ b/google/cloud/aiplatform/v1/mocks/mock_dataset_connection.h @@ -47,20 +47,40 @@ class MockDatasetServiceConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateDataset)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateDataset(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateDataset(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateDataset, (google::cloud::aiplatform::v1::CreateDatasetRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateDataset(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateDataset, (NoAwaitTag, google::cloud::aiplatform::v1::CreateDatasetRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateDataset(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateDataset, (google::longrunning::Operation const& operation), (override)); @@ -79,79 +99,159 @@ class MockDatasetServiceConnection (google::cloud::aiplatform::v1::ListDatasetsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteDataset)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteDataset(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteDataset(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteDataset, (google::cloud::aiplatform::v1::DeleteDatasetRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteDataset(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteDataset, (NoAwaitTag, google::cloud::aiplatform::v1::DeleteDatasetRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteDataset(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteDataset, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ImportData)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ImportData(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ImportData(Matcher(_))) + /// @endcode MOCK_METHOD( future>, ImportData, (google::cloud::aiplatform::v1::ImportDataRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ImportData(_, _)) + /// @endcode MOCK_METHOD(StatusOr, ImportData, (NoAwaitTag, google::cloud::aiplatform::v1::ImportDataRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, ImportData(Matcher(_))) + /// @endcode MOCK_METHOD( future>, ImportData, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ExportData)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ExportData(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ExportData(Matcher(_))) + /// @endcode MOCK_METHOD( future>, ExportData, (google::cloud::aiplatform::v1::ExportDataRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ExportData(_, _)) + /// @endcode MOCK_METHOD(StatusOr, ExportData, (NoAwaitTag, google::cloud::aiplatform::v1::ExportDataRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, ExportData(Matcher(_))) + /// @endcode MOCK_METHOD( future>, ExportData, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateDatasetVersion)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateDatasetVersion(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateDatasetVersion(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateDatasetVersion, (google::cloud::aiplatform::v1::CreateDatasetVersionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateDatasetVersion(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateDatasetVersion, (NoAwaitTag, google::cloud::aiplatform::v1::CreateDatasetVersionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateDatasetVersion(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateDatasetVersion, (google::longrunning::Operation const& operation), (override)); @@ -162,9 +262,15 @@ class MockDatasetServiceConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteDatasetVersion)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteDatasetVersion(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteDatasetVersion(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteDatasetVersion, @@ -172,12 +278,26 @@ class MockDatasetServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteDatasetVersion(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteDatasetVersion, (NoAwaitTag, google::cloud::aiplatform::v1::DeleteDatasetVersionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteDatasetVersion(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteDatasetVersion, (google::longrunning::Operation const& operation), @@ -195,9 +315,15 @@ class MockDatasetServiceConnection (google::cloud::aiplatform::v1::ListDatasetVersionsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, RestoreDatasetVersion)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, RestoreDatasetVersion(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RestoreDatasetVersion(Matcher(_))) + /// @endcode MOCK_METHOD( future>, RestoreDatasetVersion, @@ -205,6 +331,12 @@ class MockDatasetServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, RestoreDatasetVersion(_, _)) + /// @endcode MOCK_METHOD( StatusOr, RestoreDatasetVersion, (NoAwaitTag, @@ -212,6 +344,14 @@ class MockDatasetServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RestoreDatasetVersion(Matcher(_))) + /// @endcode MOCK_METHOD(future>, RestoreDatasetVersion, (google::longrunning::Operation const& operation), (override)); @@ -231,21 +371,41 @@ class MockDatasetServiceConnection (google::cloud::aiplatform::v1::ListSavedQueriesRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteSavedQuery)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteSavedQuery(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteSavedQuery(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteSavedQuery, (google::cloud::aiplatform::v1::DeleteSavedQueryRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteSavedQuery(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteSavedQuery, (NoAwaitTag, google::cloud::aiplatform::v1::DeleteSavedQueryRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteSavedQuery(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteSavedQuery, (google::longrunning::Operation const& operation), diff --git a/google/cloud/aiplatform/v1/mocks/mock_deployment_resource_pool_connection.h b/google/cloud/aiplatform/v1/mocks/mock_deployment_resource_pool_connection.h index caf4f6ea6ca53..671a5d4630371 100644 --- a/google/cloud/aiplatform/v1/mocks/mock_deployment_resource_pool_connection.h +++ b/google/cloud/aiplatform/v1/mocks/mock_deployment_resource_pool_connection.h @@ -47,9 +47,15 @@ class MockDeploymentResourcePoolServiceConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateDeploymentResourcePool)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateDeploymentResourcePool(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateDeploymentResourcePool(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateDeploymentResourcePool, @@ -57,6 +63,12 @@ class MockDeploymentResourcePoolServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateDeploymentResourcePool(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateDeploymentResourcePool, (NoAwaitTag, @@ -64,6 +76,15 @@ class MockDeploymentResourcePoolServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateDeploymentResourcePool(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateDeploymentResourcePool, @@ -83,9 +104,15 @@ class MockDeploymentResourcePoolServiceConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateDeploymentResourcePool)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateDeploymentResourcePool(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateDeploymentResourcePool(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateDeploymentResourcePool, @@ -93,6 +120,12 @@ class MockDeploymentResourcePoolServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateDeploymentResourcePool(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateDeploymentResourcePool, (NoAwaitTag, @@ -100,14 +133,29 @@ class MockDeploymentResourcePoolServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateDeploymentResourcePool(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateDeploymentResourcePool, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteDeploymentResourcePool)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteDeploymentResourcePool(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteDeploymentResourcePool(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteDeploymentResourcePool, @@ -115,6 +163,12 @@ class MockDeploymentResourcePoolServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteDeploymentResourcePool(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteDeploymentResourcePool, (NoAwaitTag, @@ -122,6 +176,15 @@ class MockDeploymentResourcePoolServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteDeploymentResourcePool(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteDeploymentResourcePool, diff --git a/google/cloud/aiplatform/v1/mocks/mock_endpoint_connection.h b/google/cloud/aiplatform/v1/mocks/mock_endpoint_connection.h index 5694eb68b8084..9d37d637e807c 100644 --- a/google/cloud/aiplatform/v1/mocks/mock_endpoint_connection.h +++ b/google/cloud/aiplatform/v1/mocks/mock_endpoint_connection.h @@ -47,20 +47,40 @@ class MockEndpointServiceConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateEndpoint)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateEndpoint(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateEndpoint(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateEndpoint, (google::cloud::aiplatform::v1::CreateEndpointRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateEndpoint(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateEndpoint, (NoAwaitTag, google::cloud::aiplatform::v1::CreateEndpointRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateEndpoint(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateEndpoint, (google::longrunning::Operation const& operation), (override)); @@ -80,69 +100,135 @@ class MockEndpointServiceConnection (google::cloud::aiplatform::v1::UpdateEndpointRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteEndpoint)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteEndpoint(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteEndpoint(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteEndpoint, (google::cloud::aiplatform::v1::DeleteEndpointRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteEndpoint(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteEndpoint, (NoAwaitTag, google::cloud::aiplatform::v1::DeleteEndpointRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteEndpoint(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteEndpoint, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeployModel)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeployModel(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeployModel(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeployModel, (google::cloud::aiplatform::v1::DeployModelRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeployModel(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeployModel, (NoAwaitTag, google::cloud::aiplatform::v1::DeployModelRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeployModel(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeployModel, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UndeployModel)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UndeployModel(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UndeployModel(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UndeployModel, (google::cloud::aiplatform::v1::UndeployModelRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UndeployModel(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UndeployModel, (NoAwaitTag, google::cloud::aiplatform::v1::UndeployModelRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UndeployModel(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UndeployModel, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, MutateDeployedModel)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, MutateDeployedModel(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// MutateDeployedModel(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, @@ -151,12 +237,26 @@ class MockEndpointServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, MutateDeployedModel(_, _)) + /// @endcode MOCK_METHOD(StatusOr, MutateDeployedModel, (NoAwaitTag, google::cloud::aiplatform::v1::MutateDeployedModelRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// MutateDeployedModel(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, diff --git a/google/cloud/aiplatform/v1/mocks/mock_feature_online_store_admin_connection.h b/google/cloud/aiplatform/v1/mocks/mock_feature_online_store_admin_connection.h index a89aecc738b7c..0c951ab958968 100644 --- a/google/cloud/aiplatform/v1/mocks/mock_feature_online_store_admin_connection.h +++ b/google/cloud/aiplatform/v1/mocks/mock_feature_online_store_admin_connection.h @@ -47,9 +47,15 @@ class MockFeatureOnlineStoreAdminServiceConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateFeatureOnlineStore)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateFeatureOnlineStore(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateFeatureOnlineStore(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateFeatureOnlineStore, @@ -57,6 +63,12 @@ class MockFeatureOnlineStoreAdminServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateFeatureOnlineStore(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateFeatureOnlineStore, (NoAwaitTag, @@ -64,6 +76,15 @@ class MockFeatureOnlineStoreAdminServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateFeatureOnlineStore(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateFeatureOnlineStore, @@ -82,9 +103,15 @@ class MockFeatureOnlineStoreAdminServiceConnection (google::cloud::aiplatform::v1::ListFeatureOnlineStoresRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateFeatureOnlineStore)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateFeatureOnlineStore(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateFeatureOnlineStore(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateFeatureOnlineStore, @@ -92,6 +119,12 @@ class MockFeatureOnlineStoreAdminServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateFeatureOnlineStore(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateFeatureOnlineStore, (NoAwaitTag, @@ -99,14 +132,29 @@ class MockFeatureOnlineStoreAdminServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateFeatureOnlineStore(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateFeatureOnlineStore, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteFeatureOnlineStore)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteFeatureOnlineStore(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteFeatureOnlineStore(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteFeatureOnlineStore, @@ -114,6 +162,12 @@ class MockFeatureOnlineStoreAdminServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteFeatureOnlineStore(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteFeatureOnlineStore, (NoAwaitTag, @@ -121,26 +175,55 @@ class MockFeatureOnlineStoreAdminServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteFeatureOnlineStore(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteFeatureOnlineStore, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateFeatureView)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateFeatureView(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateFeatureView(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateFeatureView, (google::cloud::aiplatform::v1::CreateFeatureViewRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateFeatureView(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateFeatureView, (NoAwaitTag, google::cloud::aiplatform::v1::CreateFeatureViewRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateFeatureView(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateFeatureView, (google::longrunning::Operation const& operation), (override)); @@ -155,40 +238,80 @@ class MockFeatureOnlineStoreAdminServiceConnection (google::cloud::aiplatform::v1::ListFeatureViewsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateFeatureView)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateFeatureView(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateFeatureView(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateFeatureView, (google::cloud::aiplatform::v1::UpdateFeatureViewRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateFeatureView(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateFeatureView, (NoAwaitTag, google::cloud::aiplatform::v1::UpdateFeatureViewRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateFeatureView(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateFeatureView, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteFeatureView)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteFeatureView(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteFeatureView(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteFeatureView, (google::cloud::aiplatform::v1::DeleteFeatureViewRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteFeatureView(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteFeatureView, (NoAwaitTag, google::cloud::aiplatform::v1::DeleteFeatureViewRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteFeatureView(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteFeatureView, (google::longrunning::Operation const& operation), diff --git a/google/cloud/aiplatform/v1/mocks/mock_feature_registry_connection.h b/google/cloud/aiplatform/v1/mocks/mock_feature_registry_connection.h index fd9b4863af210..278afd37ed095 100644 --- a/google/cloud/aiplatform/v1/mocks/mock_feature_registry_connection.h +++ b/google/cloud/aiplatform/v1/mocks/mock_feature_registry_connection.h @@ -47,21 +47,41 @@ class MockFeatureRegistryServiceConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateFeatureGroup)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateFeatureGroup(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateFeatureGroup(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateFeatureGroup, (google::cloud::aiplatform::v1::CreateFeatureGroupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateFeatureGroup(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateFeatureGroup, (NoAwaitTag, google::cloud::aiplatform::v1::CreateFeatureGroupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateFeatureGroup(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateFeatureGroup, (google::longrunning::Operation const& operation), (override)); @@ -76,59 +96,119 @@ class MockFeatureRegistryServiceConnection (google::cloud::aiplatform::v1::ListFeatureGroupsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateFeatureGroup)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateFeatureGroup(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateFeatureGroup(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateFeatureGroup, (google::cloud::aiplatform::v1::UpdateFeatureGroupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateFeatureGroup(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateFeatureGroup, (NoAwaitTag, google::cloud::aiplatform::v1::UpdateFeatureGroupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateFeatureGroup(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateFeatureGroup, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteFeatureGroup)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteFeatureGroup(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteFeatureGroup(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteFeatureGroup, (google::cloud::aiplatform::v1::DeleteFeatureGroupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteFeatureGroup(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteFeatureGroup, (NoAwaitTag, google::cloud::aiplatform::v1::DeleteFeatureGroupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteFeatureGroup(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteFeatureGroup, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateFeature)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateFeature(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateFeature(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateFeature, (google::cloud::aiplatform::v1::CreateFeatureRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateFeature(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateFeature, (NoAwaitTag, google::cloud::aiplatform::v1::CreateFeatureRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateFeature(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateFeature, (google::longrunning::Operation const& operation), (override)); @@ -142,39 +222,79 @@ class MockFeatureRegistryServiceConnection (google::cloud::aiplatform::v1::ListFeaturesRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateFeature)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateFeature(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateFeature(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateFeature, (google::cloud::aiplatform::v1::UpdateFeatureRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateFeature(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateFeature, (NoAwaitTag, google::cloud::aiplatform::v1::UpdateFeatureRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateFeature(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateFeature, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteFeature)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteFeature(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteFeature(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteFeature, (google::cloud::aiplatform::v1::DeleteFeatureRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteFeature(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteFeature, (NoAwaitTag, google::cloud::aiplatform::v1::DeleteFeatureRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteFeature(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteFeature, (google::longrunning::Operation const& operation), diff --git a/google/cloud/aiplatform/v1/mocks/mock_featurestore_connection.h b/google/cloud/aiplatform/v1/mocks/mock_featurestore_connection.h index b68539a658674..38e073f9d2c62 100644 --- a/google/cloud/aiplatform/v1/mocks/mock_featurestore_connection.h +++ b/google/cloud/aiplatform/v1/mocks/mock_featurestore_connection.h @@ -47,21 +47,41 @@ class MockFeaturestoreServiceConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateFeaturestore)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateFeaturestore(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateFeaturestore(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateFeaturestore, (google::cloud::aiplatform::v1::CreateFeaturestoreRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateFeaturestore(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateFeaturestore, (NoAwaitTag, google::cloud::aiplatform::v1::CreateFeaturestoreRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateFeaturestore(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateFeaturestore, (google::longrunning::Operation const& operation), (override)); @@ -76,60 +96,120 @@ class MockFeaturestoreServiceConnection (google::cloud::aiplatform::v1::ListFeaturestoresRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateFeaturestore)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateFeaturestore(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateFeaturestore(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateFeaturestore, (google::cloud::aiplatform::v1::UpdateFeaturestoreRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateFeaturestore(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateFeaturestore, (NoAwaitTag, google::cloud::aiplatform::v1::UpdateFeaturestoreRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateFeaturestore(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateFeaturestore, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteFeaturestore)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteFeaturestore(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteFeaturestore(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteFeaturestore, (google::cloud::aiplatform::v1::DeleteFeaturestoreRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteFeaturestore(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteFeaturestore, (NoAwaitTag, google::cloud::aiplatform::v1::DeleteFeaturestoreRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteFeaturestore(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteFeaturestore, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateEntityType)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateEntityType(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateEntityType(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateEntityType, (google::cloud::aiplatform::v1::CreateEntityTypeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateEntityType(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateEntityType, (NoAwaitTag, google::cloud::aiplatform::v1::CreateEntityTypeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateEntityType(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateEntityType, (google::longrunning::Operation const& operation), (override)); @@ -149,47 +229,93 @@ class MockFeaturestoreServiceConnection (google::cloud::aiplatform::v1::UpdateEntityTypeRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteEntityType)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteEntityType(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteEntityType(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteEntityType, (google::cloud::aiplatform::v1::DeleteEntityTypeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteEntityType(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteEntityType, (NoAwaitTag, google::cloud::aiplatform::v1::DeleteEntityTypeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteEntityType(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteEntityType, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateFeature)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateFeature(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateFeature(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateFeature, (google::cloud::aiplatform::v1::CreateFeatureRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateFeature(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateFeature, (NoAwaitTag, google::cloud::aiplatform::v1::CreateFeatureRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateFeature(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateFeature, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, BatchCreateFeatures)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, BatchCreateFeatures(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// BatchCreateFeatures(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, @@ -198,12 +324,26 @@ class MockFeaturestoreServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, BatchCreateFeatures(_, _)) + /// @endcode MOCK_METHOD(StatusOr, BatchCreateFeatures, (NoAwaitTag, google::cloud::aiplatform::v1::BatchCreateFeaturesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// BatchCreateFeatures(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, @@ -224,29 +364,55 @@ class MockFeaturestoreServiceConnection (google::cloud::aiplatform::v1::UpdateFeatureRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteFeature)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteFeature(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteFeature(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteFeature, (google::cloud::aiplatform::v1::DeleteFeatureRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteFeature(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteFeature, (NoAwaitTag, google::cloud::aiplatform::v1::DeleteFeatureRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteFeature(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteFeature, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ImportFeatureValues)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ImportFeatureValues(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ImportFeatureValues(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, @@ -255,21 +421,41 @@ class MockFeaturestoreServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ImportFeatureValues(_, _)) + /// @endcode MOCK_METHOD(StatusOr, ImportFeatureValues, (NoAwaitTag, google::cloud::aiplatform::v1::ImportFeatureValuesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ImportFeatureValues(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, ImportFeatureValues, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, BatchReadFeatureValues)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, BatchReadFeatureValues(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// BatchReadFeatureValues(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -278,6 +464,12 @@ class MockFeaturestoreServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, BatchReadFeatureValues(_, _)) + /// @endcode MOCK_METHOD( StatusOr, BatchReadFeatureValues, (NoAwaitTag, @@ -285,15 +477,29 @@ class MockFeaturestoreServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// BatchReadFeatureValues(Matcher(_))) + /// @endcode MOCK_METHOD( future>, BatchReadFeatureValues, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ExportFeatureValues)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ExportFeatureValues(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ExportFeatureValues(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, @@ -302,21 +508,41 @@ class MockFeaturestoreServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ExportFeatureValues(_, _)) + /// @endcode MOCK_METHOD(StatusOr, ExportFeatureValues, (NoAwaitTag, google::cloud::aiplatform::v1::ExportFeatureValuesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ExportFeatureValues(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, ExportFeatureValues, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteFeatureValues)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteFeatureValues(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteFeatureValues(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, @@ -325,12 +551,26 @@ class MockFeaturestoreServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteFeatureValues(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteFeatureValues, (NoAwaitTag, google::cloud::aiplatform::v1::DeleteFeatureValuesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteFeatureValues(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, diff --git a/google/cloud/aiplatform/v1/mocks/mock_index_connection.h b/google/cloud/aiplatform/v1/mocks/mock_index_connection.h index 815fede6dc2ac..a8938f5538b81 100644 --- a/google/cloud/aiplatform/v1/mocks/mock_index_connection.h +++ b/google/cloud/aiplatform/v1/mocks/mock_index_connection.h @@ -47,20 +47,40 @@ class MockIndexServiceConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateIndex)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateIndex(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateIndex(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateIndex, (google::cloud::aiplatform::v1::CreateIndexRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateIndex(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateIndex, (NoAwaitTag, google::cloud::aiplatform::v1::CreateIndexRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateIndex(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateIndex, (google::longrunning::Operation const& operation), (override)); @@ -73,39 +93,79 @@ class MockIndexServiceConnection (google::cloud::aiplatform::v1::ListIndexesRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateIndex)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateIndex(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateIndex(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateIndex, (google::cloud::aiplatform::v1::UpdateIndexRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateIndex(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateIndex, (NoAwaitTag, google::cloud::aiplatform::v1::UpdateIndexRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateIndex(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateIndex, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteIndex)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteIndex(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteIndex(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteIndex, (google::cloud::aiplatform::v1::DeleteIndexRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteIndex(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteIndex, (NoAwaitTag, google::cloud::aiplatform::v1::DeleteIndexRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteIndex(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteIndex, (google::longrunning::Operation const& operation), diff --git a/google/cloud/aiplatform/v1/mocks/mock_index_endpoint_connection.h b/google/cloud/aiplatform/v1/mocks/mock_index_endpoint_connection.h index 20ebe2ea03dba..76695621e9b2c 100644 --- a/google/cloud/aiplatform/v1/mocks/mock_index_endpoint_connection.h +++ b/google/cloud/aiplatform/v1/mocks/mock_index_endpoint_connection.h @@ -47,21 +47,41 @@ class MockIndexEndpointServiceConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateIndexEndpoint)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateIndexEndpoint(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateIndexEndpoint(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateIndexEndpoint, (google::cloud::aiplatform::v1::CreateIndexEndpointRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateIndexEndpoint(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateIndexEndpoint, (NoAwaitTag, google::cloud::aiplatform::v1::CreateIndexEndpointRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateIndexEndpoint(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateIndexEndpoint, (google::longrunning::Operation const& operation), (override)); @@ -83,9 +103,15 @@ class MockIndexEndpointServiceConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteIndexEndpoint)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteIndexEndpoint(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteIndexEndpoint(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteIndexEndpoint, @@ -93,60 +119,120 @@ class MockIndexEndpointServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteIndexEndpoint(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteIndexEndpoint, (NoAwaitTag, google::cloud::aiplatform::v1::DeleteIndexEndpointRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteIndexEndpoint(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteIndexEndpoint, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeployIndex)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeployIndex(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeployIndex(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeployIndex, (google::cloud::aiplatform::v1::DeployIndexRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeployIndex(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeployIndex, (NoAwaitTag, google::cloud::aiplatform::v1::DeployIndexRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeployIndex(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeployIndex, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UndeployIndex)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UndeployIndex(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UndeployIndex(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UndeployIndex, (google::cloud::aiplatform::v1::UndeployIndexRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UndeployIndex(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UndeployIndex, (NoAwaitTag, google::cloud::aiplatform::v1::UndeployIndexRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UndeployIndex(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UndeployIndex, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, MutateDeployedIndex)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, MutateDeployedIndex(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// MutateDeployedIndex(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, @@ -155,12 +241,26 @@ class MockIndexEndpointServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, MutateDeployedIndex(_, _)) + /// @endcode MOCK_METHOD(StatusOr, MutateDeployedIndex, (NoAwaitTag, google::cloud::aiplatform::v1::MutateDeployedIndexRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// MutateDeployedIndex(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, diff --git a/google/cloud/aiplatform/v1/mocks/mock_job_connection.h b/google/cloud/aiplatform/v1/mocks/mock_job_connection.h index b29fef9d32071..0ad4698001361 100644 --- a/google/cloud/aiplatform/v1/mocks/mock_job_connection.h +++ b/google/cloud/aiplatform/v1/mocks/mock_job_connection.h @@ -61,21 +61,41 @@ class MockJobServiceConnection : public aiplatform_v1::JobServiceConnection { (google::cloud::aiplatform::v1::ListCustomJobsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteCustomJob)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteCustomJob(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteCustomJob(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteCustomJob, (google::cloud::aiplatform::v1::DeleteCustomJobRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteCustomJob(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteCustomJob, (NoAwaitTag, google::cloud::aiplatform::v1::DeleteCustomJobRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteCustomJob(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteCustomJob, (google::longrunning::Operation const& operation), @@ -105,9 +125,15 @@ class MockJobServiceConnection : public aiplatform_v1::JobServiceConnection { (google::cloud::aiplatform::v1::ListDataLabelingJobsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteDataLabelingJob)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteDataLabelingJob(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteDataLabelingJob(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteDataLabelingJob, @@ -115,6 +141,12 @@ class MockJobServiceConnection : public aiplatform_v1::JobServiceConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteDataLabelingJob(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteDataLabelingJob, (NoAwaitTag, @@ -122,6 +154,14 @@ class MockJobServiceConnection : public aiplatform_v1::JobServiceConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteDataLabelingJob(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteDataLabelingJob, (google::longrunning::Operation const& operation), @@ -153,9 +193,15 @@ class MockJobServiceConnection : public aiplatform_v1::JobServiceConnection { request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteHyperparameterTuningJob)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteHyperparameterTuningJob(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteHyperparameterTuningJob(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteHyperparameterTuningJob, @@ -163,6 +209,12 @@ class MockJobServiceConnection : public aiplatform_v1::JobServiceConnection { DeleteHyperparameterTuningJobRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteHyperparameterTuningJob(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteHyperparameterTuningJob, (NoAwaitTag, @@ -170,6 +222,15 @@ class MockJobServiceConnection : public aiplatform_v1::JobServiceConnection { DeleteHyperparameterTuningJobRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteHyperparameterTuningJob(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteHyperparameterTuningJob, @@ -193,21 +254,41 @@ class MockJobServiceConnection : public aiplatform_v1::JobServiceConnection { (google::cloud::aiplatform::v1::ListNasJobsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteNasJob)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteNasJob(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteNasJob(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteNasJob, (google::cloud::aiplatform::v1::DeleteNasJobRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteNasJob(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteNasJob, (NoAwaitTag, google::cloud::aiplatform::v1::DeleteNasJobRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteNasJob(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteNasJob, (google::longrunning::Operation const& operation), @@ -250,9 +331,15 @@ class MockJobServiceConnection : public aiplatform_v1::JobServiceConnection { (google::cloud::aiplatform::v1::ListBatchPredictionJobsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteBatchPredictionJob)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteBatchPredictionJob(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteBatchPredictionJob(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteBatchPredictionJob, @@ -260,6 +347,12 @@ class MockJobServiceConnection : public aiplatform_v1::JobServiceConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteBatchPredictionJob(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteBatchPredictionJob, (NoAwaitTag, @@ -267,6 +360,15 @@ class MockJobServiceConnection : public aiplatform_v1::JobServiceConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteBatchPredictionJob(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteBatchPredictionJob, @@ -308,10 +410,15 @@ class MockJobServiceConnection : public aiplatform_v1::JobServiceConnection { request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateModelDeploymentMonitoringJob)` is now ambiguous. - /// Use `EXPECT_CALL(*mock, UpdateModelDeploymentMonitoringJob(::testing::_))` - /// instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateModelDeploymentMonitoringJob(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateModelDeploymentMonitoringJob, @@ -319,6 +426,12 @@ class MockJobServiceConnection : public aiplatform_v1::JobServiceConnection { UpdateModelDeploymentMonitoringJobRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateModelDeploymentMonitoringJob(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateModelDeploymentMonitoringJob, (NoAwaitTag, @@ -326,15 +439,29 @@ class MockJobServiceConnection : public aiplatform_v1::JobServiceConnection { UpdateModelDeploymentMonitoringJobRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateModelDeploymentMonitoringJob(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateModelDeploymentMonitoringJob, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteModelDeploymentMonitoringJob)` is now ambiguous. - /// Use `EXPECT_CALL(*mock, DeleteModelDeploymentMonitoringJob(::testing::_))` - /// instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteModelDeploymentMonitoringJob(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteModelDeploymentMonitoringJob, @@ -342,6 +469,12 @@ class MockJobServiceConnection : public aiplatform_v1::JobServiceConnection { DeleteModelDeploymentMonitoringJobRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteModelDeploymentMonitoringJob(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteModelDeploymentMonitoringJob, (NoAwaitTag, @@ -349,6 +482,15 @@ class MockJobServiceConnection : public aiplatform_v1::JobServiceConnection { DeleteModelDeploymentMonitoringJobRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteModelDeploymentMonitoringJob(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteModelDeploymentMonitoringJob, diff --git a/google/cloud/aiplatform/v1/mocks/mock_metadata_connection.h b/google/cloud/aiplatform/v1/mocks/mock_metadata_connection.h index 8102cbe051c42..5fd2dc70b3993 100644 --- a/google/cloud/aiplatform/v1/mocks/mock_metadata_connection.h +++ b/google/cloud/aiplatform/v1/mocks/mock_metadata_connection.h @@ -47,21 +47,41 @@ class MockMetadataServiceConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateMetadataStore)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateMetadataStore(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateMetadataStore(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateMetadataStore, (google::cloud::aiplatform::v1::CreateMetadataStoreRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateMetadataStore(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateMetadataStore, (NoAwaitTag, google::cloud::aiplatform::v1::CreateMetadataStoreRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateMetadataStore(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateMetadataStore, (google::longrunning::Operation const& operation), (override)); @@ -77,9 +97,15 @@ class MockMetadataServiceConnection (google::cloud::aiplatform::v1::ListMetadataStoresRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteMetadataStore)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteMetadataStore(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteMetadataStore(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -88,12 +114,26 @@ class MockMetadataServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteMetadataStore(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteMetadataStore, (NoAwaitTag, google::cloud::aiplatform::v1::DeleteMetadataStoreRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteMetadataStore(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -120,41 +160,81 @@ class MockMetadataServiceConnection (google::cloud::aiplatform::v1::UpdateArtifactRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteArtifact)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteArtifact(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteArtifact(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteArtifact, (google::cloud::aiplatform::v1::DeleteArtifactRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteArtifact(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteArtifact, (NoAwaitTag, google::cloud::aiplatform::v1::DeleteArtifactRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteArtifact(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteArtifact, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, PurgeArtifacts)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, PurgeArtifacts(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PurgeArtifacts(Matcher(_))) + /// @endcode MOCK_METHOD( future>, PurgeArtifacts, (google::cloud::aiplatform::v1::PurgeArtifactsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, PurgeArtifacts(_, _)) + /// @endcode MOCK_METHOD( StatusOr, PurgeArtifacts, (NoAwaitTag, google::cloud::aiplatform::v1::PurgeArtifactsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, PurgeArtifacts(Matcher(_))) + /// @endcode MOCK_METHOD( future>, PurgeArtifacts, (google::longrunning::Operation const& operation), @@ -179,41 +259,81 @@ class MockMetadataServiceConnection (google::cloud::aiplatform::v1::UpdateContextRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteContext)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteContext(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteContext(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteContext, (google::cloud::aiplatform::v1::DeleteContextRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteContext(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteContext, (NoAwaitTag, google::cloud::aiplatform::v1::DeleteContextRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteContext(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteContext, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, PurgeContexts)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, PurgeContexts(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PurgeContexts(Matcher(_))) + /// @endcode MOCK_METHOD( future>, PurgeContexts, (google::cloud::aiplatform::v1::PurgeContextsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, PurgeContexts(_, _)) + /// @endcode MOCK_METHOD( StatusOr, PurgeContexts, (NoAwaitTag, google::cloud::aiplatform::v1::PurgeContextsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, PurgeContexts(Matcher(_))) + /// @endcode MOCK_METHOD( future>, PurgeContexts, (google::longrunning::Operation const& operation), @@ -266,41 +386,81 @@ class MockMetadataServiceConnection (google::cloud::aiplatform::v1::UpdateExecutionRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteExecution)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteExecution(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteExecution(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteExecution, (google::cloud::aiplatform::v1::DeleteExecutionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteExecution(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteExecution, (NoAwaitTag, google::cloud::aiplatform::v1::DeleteExecutionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteExecution(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteExecution, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, PurgeExecutions)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, PurgeExecutions(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PurgeExecutions(Matcher(_))) + /// @endcode MOCK_METHOD( future>, PurgeExecutions, (google::cloud::aiplatform::v1::PurgeExecutionsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, PurgeExecutions(_, _)) + /// @endcode MOCK_METHOD( StatusOr, PurgeExecutions, (NoAwaitTag, google::cloud::aiplatform::v1::PurgeExecutionsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, PurgeExecutions(Matcher(_))) + /// @endcode MOCK_METHOD( future>, PurgeExecutions, (google::longrunning::Operation const& operation), diff --git a/google/cloud/aiplatform/v1/mocks/mock_migration_connection.h b/google/cloud/aiplatform/v1/mocks/mock_migration_connection.h index 32dd64e343742..2e167f1c9f24a 100644 --- a/google/cloud/aiplatform/v1/mocks/mock_migration_connection.h +++ b/google/cloud/aiplatform/v1/mocks/mock_migration_connection.h @@ -53,9 +53,15 @@ class MockMigrationServiceConnection (google::cloud::aiplatform::v1::SearchMigratableResourcesRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, BatchMigrateResources)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, BatchMigrateResources(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// BatchMigrateResources(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -64,6 +70,12 @@ class MockMigrationServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, BatchMigrateResources(_, _)) + /// @endcode MOCK_METHOD( StatusOr, BatchMigrateResources, (NoAwaitTag, @@ -71,6 +83,14 @@ class MockMigrationServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// BatchMigrateResources(Matcher(_))) + /// @endcode MOCK_METHOD( future>, diff --git a/google/cloud/aiplatform/v1/mocks/mock_model_connection.h b/google/cloud/aiplatform/v1/mocks/mock_model_connection.h index d46230120ff5d..27012300c3ad3 100644 --- a/google/cloud/aiplatform/v1/mocks/mock_model_connection.h +++ b/google/cloud/aiplatform/v1/mocks/mock_model_connection.h @@ -47,21 +47,41 @@ class MockModelServiceConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UploadModel)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UploadModel(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UploadModel(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UploadModel, (google::cloud::aiplatform::v1::UploadModelRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UploadModel(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UploadModel, (NoAwaitTag, google::cloud::aiplatform::v1::UploadModelRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UploadModel(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UploadModel, (google::longrunning::Operation const& operation), @@ -85,9 +105,15 @@ class MockModelServiceConnection (google::cloud::aiplatform::v1::UpdateModelRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateExplanationDataset)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateExplanationDataset(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateExplanationDataset(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -96,6 +122,12 @@ class MockModelServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateExplanationDataset(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateExplanationDataset, (NoAwaitTag, @@ -103,47 +135,96 @@ class MockModelServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateExplanationDataset(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateExplanationDataset, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteModel)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteModel(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteModel(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteModel, (google::cloud::aiplatform::v1::DeleteModelRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteModel(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteModel, (NoAwaitTag, google::cloud::aiplatform::v1::DeleteModelRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteModel(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteModel, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteModelVersion)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteModelVersion(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteModelVersion(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteModelVersion, (google::cloud::aiplatform::v1::DeleteModelVersionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteModelVersion(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteModelVersion, (NoAwaitTag, google::cloud::aiplatform::v1::DeleteModelVersionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteModelVersion(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteModelVersion, (google::longrunning::Operation const& operation), @@ -155,40 +236,80 @@ class MockModelServiceConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ExportModel)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ExportModel(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ExportModel(Matcher(_))) + /// @endcode MOCK_METHOD( future>, ExportModel, (google::cloud::aiplatform::v1::ExportModelRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ExportModel(_, _)) + /// @endcode MOCK_METHOD( StatusOr, ExportModel, (NoAwaitTag, google::cloud::aiplatform::v1::ExportModelRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, ExportModel(Matcher(_))) + /// @endcode MOCK_METHOD( future>, ExportModel, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CopyModel)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CopyModel(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CopyModel(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CopyModel, (google::cloud::aiplatform::v1::CopyModelRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CopyModel(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CopyModel, (NoAwaitTag, google::cloud::aiplatform::v1::CopyModelRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CopyModel(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CopyModel, (google::longrunning::Operation const& operation), (override)); diff --git a/google/cloud/aiplatform/v1/mocks/mock_notebook_connection.h b/google/cloud/aiplatform/v1/mocks/mock_notebook_connection.h index e181f6b71b2ae..524b109668202 100644 --- a/google/cloud/aiplatform/v1/mocks/mock_notebook_connection.h +++ b/google/cloud/aiplatform/v1/mocks/mock_notebook_connection.h @@ -47,9 +47,15 @@ class MockNotebookServiceConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateNotebookRuntimeTemplate)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateNotebookRuntimeTemplate(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateNotebookRuntimeTemplate(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateNotebookRuntimeTemplate, @@ -57,6 +63,12 @@ class MockNotebookServiceConnection CreateNotebookRuntimeTemplateRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateNotebookRuntimeTemplate(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateNotebookRuntimeTemplate, (NoAwaitTag, @@ -64,6 +76,15 @@ class MockNotebookServiceConnection CreateNotebookRuntimeTemplateRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateNotebookRuntimeTemplate(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateNotebookRuntimeTemplate, @@ -83,9 +104,15 @@ class MockNotebookServiceConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteNotebookRuntimeTemplate)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteNotebookRuntimeTemplate(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteNotebookRuntimeTemplate(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteNotebookRuntimeTemplate, @@ -93,6 +120,12 @@ class MockNotebookServiceConnection DeleteNotebookRuntimeTemplateRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteNotebookRuntimeTemplate(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteNotebookRuntimeTemplate, (NoAwaitTag, @@ -100,6 +133,15 @@ class MockNotebookServiceConnection DeleteNotebookRuntimeTemplateRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteNotebookRuntimeTemplate(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteNotebookRuntimeTemplate, @@ -111,9 +153,15 @@ class MockNotebookServiceConnection UpdateNotebookRuntimeTemplateRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, AssignNotebookRuntime)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, AssignNotebookRuntime(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// AssignNotebookRuntime(Matcher(_))) + /// @endcode MOCK_METHOD( future>, AssignNotebookRuntime, @@ -121,6 +169,12 @@ class MockNotebookServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, AssignNotebookRuntime(_, _)) + /// @endcode MOCK_METHOD( StatusOr, AssignNotebookRuntime, (NoAwaitTag, @@ -128,6 +182,14 @@ class MockNotebookServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// AssignNotebookRuntime(Matcher(_))) + /// @endcode MOCK_METHOD(future>, AssignNotebookRuntime, (google::longrunning::Operation const& operation), (override)); @@ -144,9 +206,15 @@ class MockNotebookServiceConnection (google::cloud::aiplatform::v1::ListNotebookRuntimesRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteNotebookRuntime)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteNotebookRuntime(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteNotebookRuntime(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteNotebookRuntime, @@ -154,6 +222,12 @@ class MockNotebookServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteNotebookRuntime(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteNotebookRuntime, (NoAwaitTag, @@ -161,14 +235,28 @@ class MockNotebookServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteNotebookRuntime(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteNotebookRuntime, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpgradeNotebookRuntime)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpgradeNotebookRuntime(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpgradeNotebookRuntime(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -177,6 +265,12 @@ class MockNotebookServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpgradeNotebookRuntime(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpgradeNotebookRuntime, (NoAwaitTag, @@ -184,15 +278,29 @@ class MockNotebookServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpgradeNotebookRuntime(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpgradeNotebookRuntime, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, StartNotebookRuntime)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, StartNotebookRuntime(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// StartNotebookRuntime(Matcher(_))) + /// @endcode MOCK_METHOD(future>, StartNotebookRuntime, @@ -200,12 +308,26 @@ class MockNotebookServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, StartNotebookRuntime(_, _)) + /// @endcode MOCK_METHOD(StatusOr, StartNotebookRuntime, (NoAwaitTag, google::cloud::aiplatform::v1::StartNotebookRuntimeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// StartNotebookRuntime(Matcher(_))) + /// @endcode MOCK_METHOD(future>, StartNotebookRuntime, diff --git a/google/cloud/aiplatform/v1/mocks/mock_persistent_resource_connection.h b/google/cloud/aiplatform/v1/mocks/mock_persistent_resource_connection.h index 890e71292599a..0ef6a39464dbe 100644 --- a/google/cloud/aiplatform/v1/mocks/mock_persistent_resource_connection.h +++ b/google/cloud/aiplatform/v1/mocks/mock_persistent_resource_connection.h @@ -47,9 +47,15 @@ class MockPersistentResourceServiceConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreatePersistentResource)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreatePersistentResource(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreatePersistentResource(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreatePersistentResource, @@ -57,6 +63,12 @@ class MockPersistentResourceServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreatePersistentResource(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreatePersistentResource, (NoAwaitTag, @@ -64,6 +76,15 @@ class MockPersistentResourceServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreatePersistentResource(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreatePersistentResource, @@ -82,9 +103,15 @@ class MockPersistentResourceServiceConnection (google::cloud::aiplatform::v1::ListPersistentResourcesRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeletePersistentResource)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeletePersistentResource(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeletePersistentResource(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeletePersistentResource, @@ -92,6 +119,12 @@ class MockPersistentResourceServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeletePersistentResource(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeletePersistentResource, (NoAwaitTag, @@ -99,14 +132,29 @@ class MockPersistentResourceServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeletePersistentResource(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeletePersistentResource, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdatePersistentResource)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdatePersistentResource(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdatePersistentResource(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdatePersistentResource, @@ -114,6 +162,12 @@ class MockPersistentResourceServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdatePersistentResource(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdatePersistentResource, (NoAwaitTag, @@ -121,14 +175,29 @@ class MockPersistentResourceServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdatePersistentResource(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdatePersistentResource, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, RebootPersistentResource)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, RebootPersistentResource(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RebootPersistentResource(Matcher(_))) + /// @endcode MOCK_METHOD( future>, RebootPersistentResource, @@ -136,6 +205,12 @@ class MockPersistentResourceServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, RebootPersistentResource(_, _)) + /// @endcode MOCK_METHOD( StatusOr, RebootPersistentResource, (NoAwaitTag, @@ -143,6 +218,15 @@ class MockPersistentResourceServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RebootPersistentResource(Matcher(_))) + /// @endcode MOCK_METHOD( future>, RebootPersistentResource, diff --git a/google/cloud/aiplatform/v1/mocks/mock_pipeline_connection.h b/google/cloud/aiplatform/v1/mocks/mock_pipeline_connection.h index a8de486cbc8f2..de29a3a984bcb 100644 --- a/google/cloud/aiplatform/v1/mocks/mock_pipeline_connection.h +++ b/google/cloud/aiplatform/v1/mocks/mock_pipeline_connection.h @@ -66,9 +66,15 @@ class MockPipelineServiceConnection (google::cloud::aiplatform::v1::ListTrainingPipelinesRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteTrainingPipeline)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteTrainingPipeline(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteTrainingPipeline(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteTrainingPipeline, @@ -76,6 +82,12 @@ class MockPipelineServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteTrainingPipeline(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteTrainingPipeline, (NoAwaitTag, @@ -83,6 +95,14 @@ class MockPipelineServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteTrainingPipeline(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteTrainingPipeline, (google::longrunning::Operation const& operation), @@ -109,29 +129,55 @@ class MockPipelineServiceConnection (google::cloud::aiplatform::v1::ListPipelineJobsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeletePipelineJob)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeletePipelineJob(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeletePipelineJob(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeletePipelineJob, (google::cloud::aiplatform::v1::DeletePipelineJobRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeletePipelineJob(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeletePipelineJob, (NoAwaitTag, google::cloud::aiplatform::v1::DeletePipelineJobRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeletePipelineJob(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeletePipelineJob, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, BatchDeletePipelineJobs)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, BatchDeletePipelineJobs(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// BatchDeletePipelineJobs(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -140,6 +186,12 @@ class MockPipelineServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, BatchDeletePipelineJobs(_, _)) + /// @endcode MOCK_METHOD( StatusOr, BatchDeletePipelineJobs, (NoAwaitTag, @@ -147,6 +199,15 @@ class MockPipelineServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// BatchDeletePipelineJobs(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -158,9 +219,15 @@ class MockPipelineServiceConnection (google::cloud::aiplatform::v1::CancelPipelineJobRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, BatchCancelPipelineJobs)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, BatchCancelPipelineJobs(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// BatchCancelPipelineJobs(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -169,6 +236,12 @@ class MockPipelineServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, BatchCancelPipelineJobs(_, _)) + /// @endcode MOCK_METHOD( StatusOr, BatchCancelPipelineJobs, (NoAwaitTag, @@ -176,6 +249,15 @@ class MockPipelineServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// BatchCancelPipelineJobs(Matcher(_))) + /// @endcode MOCK_METHOD( future>, diff --git a/google/cloud/aiplatform/v1/mocks/mock_schedule_connection.h b/google/cloud/aiplatform/v1/mocks/mock_schedule_connection.h index 4da84c330d71b..5f0a27ae4c675 100644 --- a/google/cloud/aiplatform/v1/mocks/mock_schedule_connection.h +++ b/google/cloud/aiplatform/v1/mocks/mock_schedule_connection.h @@ -52,21 +52,41 @@ class MockScheduleServiceConnection (google::cloud::aiplatform::v1::CreateScheduleRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteSchedule)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteSchedule(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteSchedule(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteSchedule, (google::cloud::aiplatform::v1::DeleteScheduleRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteSchedule(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteSchedule, (NoAwaitTag, google::cloud::aiplatform::v1::DeleteScheduleRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteSchedule(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteSchedule, (google::longrunning::Operation const& operation), diff --git a/google/cloud/aiplatform/v1/mocks/mock_specialist_pool_connection.h b/google/cloud/aiplatform/v1/mocks/mock_specialist_pool_connection.h index 96c7f1e3c61e2..21801c761f3f3 100644 --- a/google/cloud/aiplatform/v1/mocks/mock_specialist_pool_connection.h +++ b/google/cloud/aiplatform/v1/mocks/mock_specialist_pool_connection.h @@ -47,21 +47,41 @@ class MockSpecialistPoolServiceConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateSpecialistPool)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateSpecialistPool(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateSpecialistPool(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateSpecialistPool, (google::cloud::aiplatform::v1::CreateSpecialistPoolRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateSpecialistPool(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateSpecialistPool, (NoAwaitTag, google::cloud::aiplatform::v1::CreateSpecialistPoolRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateSpecialistPool(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateSpecialistPool, (google::longrunning::Operation const& operation), (override)); @@ -78,9 +98,15 @@ class MockSpecialistPoolServiceConnection (google::cloud::aiplatform::v1::ListSpecialistPoolsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteSpecialistPool)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteSpecialistPool(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteSpecialistPool(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteSpecialistPool, @@ -88,32 +114,66 @@ class MockSpecialistPoolServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteSpecialistPool(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteSpecialistPool, (NoAwaitTag, google::cloud::aiplatform::v1::DeleteSpecialistPoolRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteSpecialistPool(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteSpecialistPool, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateSpecialistPool)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateSpecialistPool(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateSpecialistPool(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateSpecialistPool, (google::cloud::aiplatform::v1::UpdateSpecialistPoolRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateSpecialistPool(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateSpecialistPool, (NoAwaitTag, google::cloud::aiplatform::v1::UpdateSpecialistPoolRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateSpecialistPool(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateSpecialistPool, (google::longrunning::Operation const& operation), (override)); diff --git a/google/cloud/aiplatform/v1/mocks/mock_tensorboard_connection.h b/google/cloud/aiplatform/v1/mocks/mock_tensorboard_connection.h index e1ef1d51cba74..d21343927166b 100644 --- a/google/cloud/aiplatform/v1/mocks/mock_tensorboard_connection.h +++ b/google/cloud/aiplatform/v1/mocks/mock_tensorboard_connection.h @@ -47,21 +47,41 @@ class MockTensorboardServiceConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateTensorboard)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateTensorboard(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateTensorboard(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateTensorboard, (google::cloud::aiplatform::v1::CreateTensorboardRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateTensorboard(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateTensorboard, (NoAwaitTag, google::cloud::aiplatform::v1::CreateTensorboardRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateTensorboard(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateTensorboard, (google::longrunning::Operation const& operation), (override)); @@ -71,21 +91,41 @@ class MockTensorboardServiceConnection (google::cloud::aiplatform::v1::GetTensorboardRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateTensorboard)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateTensorboard(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateTensorboard(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateTensorboard, (google::cloud::aiplatform::v1::UpdateTensorboardRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateTensorboard(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateTensorboard, (NoAwaitTag, google::cloud::aiplatform::v1::UpdateTensorboardRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateTensorboard(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateTensorboard, (google::longrunning::Operation const& operation), (override)); @@ -95,21 +135,41 @@ class MockTensorboardServiceConnection (google::cloud::aiplatform::v1::ListTensorboardsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteTensorboard)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteTensorboard(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteTensorboard(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteTensorboard, (google::cloud::aiplatform::v1::DeleteTensorboardRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteTensorboard(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteTensorboard, (NoAwaitTag, google::cloud::aiplatform::v1::DeleteTensorboardRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteTensorboard(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteTensorboard, (google::longrunning::Operation const& operation), @@ -157,9 +217,15 @@ class MockTensorboardServiceConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteTensorboardExperiment)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteTensorboardExperiment(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteTensorboardExperiment(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteTensorboardExperiment, @@ -167,6 +233,12 @@ class MockTensorboardServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteTensorboardExperiment(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteTensorboardExperiment, (NoAwaitTag, @@ -174,6 +246,15 @@ class MockTensorboardServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteTensorboardExperiment(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteTensorboardExperiment, @@ -211,9 +292,15 @@ class MockTensorboardServiceConnection (google::cloud::aiplatform::v1::ListTensorboardRunsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteTensorboardRun)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteTensorboardRun(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteTensorboardRun(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteTensorboardRun, @@ -221,12 +308,26 @@ class MockTensorboardServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteTensorboardRun(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteTensorboardRun, (NoAwaitTag, google::cloud::aiplatform::v1::DeleteTensorboardRunRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteTensorboardRun(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteTensorboardRun, (google::longrunning::Operation const& operation), @@ -266,9 +367,15 @@ class MockTensorboardServiceConnection (google::cloud::aiplatform::v1::ListTensorboardTimeSeriesRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteTensorboardTimeSeries)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteTensorboardTimeSeries(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteTensorboardTimeSeries(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteTensorboardTimeSeries, @@ -276,6 +383,12 @@ class MockTensorboardServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteTensorboardTimeSeries(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteTensorboardTimeSeries, (NoAwaitTag, @@ -283,6 +396,15 @@ class MockTensorboardServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteTensorboardTimeSeries(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteTensorboardTimeSeries, diff --git a/google/cloud/aiplatform/v1/mocks/mock_vizier_connection.h b/google/cloud/aiplatform/v1/mocks/mock_vizier_connection.h index e9a72fe636ba4..33bc98c731c03 100644 --- a/google/cloud/aiplatform/v1/mocks/mock_vizier_connection.h +++ b/google/cloud/aiplatform/v1/mocks/mock_vizier_connection.h @@ -70,21 +70,41 @@ class MockVizierServiceConnection (google::cloud::aiplatform::v1::LookupStudyRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SuggestTrials)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SuggestTrials(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SuggestTrials(Matcher(_))) + /// @endcode MOCK_METHOD( future>, SuggestTrials, (google::cloud::aiplatform::v1::SuggestTrialsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SuggestTrials(_, _)) + /// @endcode MOCK_METHOD( StatusOr, SuggestTrials, (NoAwaitTag, google::cloud::aiplatform::v1::SuggestTrialsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, SuggestTrials(Matcher(_))) + /// @endcode MOCK_METHOD( future>, SuggestTrials, (google::longrunning::Operation const& operation), @@ -119,9 +139,15 @@ class MockVizierServiceConnection (google::cloud::aiplatform::v1::DeleteTrialRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CheckTrialEarlyStoppingState)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CheckTrialEarlyStoppingState(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CheckTrialEarlyStoppingState(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -130,6 +156,12 @@ class MockVizierServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CheckTrialEarlyStoppingState(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CheckTrialEarlyStoppingState, (NoAwaitTag, @@ -137,6 +169,15 @@ class MockVizierServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CheckTrialEarlyStoppingState(Matcher(_))) + /// @endcode MOCK_METHOD( future>, diff --git a/google/cloud/alloydb/v1/mocks/mock_alloy_db_admin_connection.h b/google/cloud/alloydb/v1/mocks/mock_alloy_db_admin_connection.h index ed81415267d6a..efd8f84665539 100644 --- a/google/cloud/alloydb/v1/mocks/mock_alloy_db_admin_connection.h +++ b/google/cloud/alloydb/v1/mocks/mock_alloy_db_admin_connection.h @@ -54,108 +54,228 @@ class MockAlloyDBAdminConnection : public alloydb_v1::AlloyDBAdminConnection { (google::cloud::alloydb::v1::GetClusterRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateCluster)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateCluster(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateCluster(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateCluster, (google::cloud::alloydb::v1::CreateClusterRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateCluster(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateCluster, (NoAwaitTag, google::cloud::alloydb::v1::CreateClusterRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateCluster(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateCluster, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateCluster)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateCluster(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateCluster(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateCluster, (google::cloud::alloydb::v1::UpdateClusterRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateCluster(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateCluster, (NoAwaitTag, google::cloud::alloydb::v1::UpdateClusterRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateCluster(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateCluster, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteCluster)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteCluster(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteCluster(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteCluster, (google::cloud::alloydb::v1::DeleteClusterRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteCluster(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteCluster, (NoAwaitTag, google::cloud::alloydb::v1::DeleteClusterRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteCluster(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteCluster, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, PromoteCluster)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, PromoteCluster(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PromoteCluster(Matcher(_))) + /// @endcode MOCK_METHOD( future>, PromoteCluster, (google::cloud::alloydb::v1::PromoteClusterRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, PromoteCluster(_, _)) + /// @endcode MOCK_METHOD( StatusOr, PromoteCluster, (NoAwaitTag, google::cloud::alloydb::v1::PromoteClusterRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, PromoteCluster(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PromoteCluster, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, RestoreCluster)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, RestoreCluster(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RestoreCluster(Matcher(_))) + /// @endcode MOCK_METHOD( future>, RestoreCluster, (google::cloud::alloydb::v1::RestoreClusterRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, RestoreCluster(_, _)) + /// @endcode MOCK_METHOD( StatusOr, RestoreCluster, (NoAwaitTag, google::cloud::alloydb::v1::RestoreClusterRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, RestoreCluster(Matcher(_))) + /// @endcode MOCK_METHOD(future>, RestoreCluster, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateSecondaryCluster)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateSecondaryCluster(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateSecondaryCluster(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateSecondaryCluster, (google::cloud::alloydb::v1::CreateSecondaryClusterRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateSecondaryCluster(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateSecondaryCluster, (NoAwaitTag, google::cloud::alloydb::v1::CreateSecondaryClusterRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateSecondaryCluster(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateSecondaryCluster, (google::longrunning::Operation const& operation), (override)); @@ -169,46 +289,93 @@ class MockAlloyDBAdminConnection : public alloydb_v1::AlloyDBAdminConnection { (google::cloud::alloydb::v1::GetInstanceRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateInstance)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateInstance(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateInstance(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateInstance, (google::cloud::alloydb::v1::CreateInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateInstance(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateInstance, (NoAwaitTag, google::cloud::alloydb::v1::CreateInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateInstance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateInstance, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateSecondaryInstance)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateSecondaryInstance(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateSecondaryInstance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateSecondaryInstance, (google::cloud::alloydb::v1::CreateSecondaryInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateSecondaryInstance(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateSecondaryInstance, (NoAwaitTag, google::cloud::alloydb::v1::CreateSecondaryInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateSecondaryInstance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateSecondaryInstance, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, BatchCreateInstances)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, BatchCreateInstances(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// BatchCreateInstances(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, @@ -216,104 +383,218 @@ class MockAlloyDBAdminConnection : public alloydb_v1::AlloyDBAdminConnection { (google::cloud::alloydb::v1::BatchCreateInstancesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, BatchCreateInstances(_, _)) + /// @endcode MOCK_METHOD( StatusOr, BatchCreateInstances, (NoAwaitTag, google::cloud::alloydb::v1::BatchCreateInstancesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// BatchCreateInstances(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, BatchCreateInstances, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateInstance)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateInstance(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateInstance(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateInstance, (google::cloud::alloydb::v1::UpdateInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateInstance(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateInstance, (NoAwaitTag, google::cloud::alloydb::v1::UpdateInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateInstance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateInstance, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteInstance)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteInstance(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteInstance(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteInstance, (google::cloud::alloydb::v1::DeleteInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteInstance(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteInstance, (NoAwaitTag, google::cloud::alloydb::v1::DeleteInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteInstance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteInstance, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, FailoverInstance)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, FailoverInstance(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// FailoverInstance(Matcher(_))) + /// @endcode MOCK_METHOD( future>, FailoverInstance, (google::cloud::alloydb::v1::FailoverInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, FailoverInstance(_, _)) + /// @endcode MOCK_METHOD( StatusOr, FailoverInstance, (NoAwaitTag, google::cloud::alloydb::v1::FailoverInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, FailoverInstance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, FailoverInstance, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InjectFault)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, InjectFault(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InjectFault(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InjectFault, (google::cloud::alloydb::v1::InjectFaultRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InjectFault(_, _)) + /// @endcode MOCK_METHOD(StatusOr, InjectFault, (NoAwaitTag, google::cloud::alloydb::v1::InjectFaultRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, InjectFault(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InjectFault, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, RestartInstance)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, RestartInstance(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RestartInstance(Matcher(_))) + /// @endcode MOCK_METHOD( future>, RestartInstance, (google::cloud::alloydb::v1::RestartInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, RestartInstance(_, _)) + /// @endcode MOCK_METHOD( StatusOr, RestartInstance, (NoAwaitTag, google::cloud::alloydb::v1::RestartInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, RestartInstance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, RestartInstance, (google::longrunning::Operation const& operation), (override)); @@ -326,53 +607,113 @@ class MockAlloyDBAdminConnection : public alloydb_v1::AlloyDBAdminConnection { (google::cloud::alloydb::v1::GetBackupRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateBackup)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateBackup(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateBackup(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateBackup, (google::cloud::alloydb::v1::CreateBackupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateBackup(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateBackup, (NoAwaitTag, google::cloud::alloydb::v1::CreateBackupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateBackup(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateBackup, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateBackup)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateBackup(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateBackup(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateBackup, (google::cloud::alloydb::v1::UpdateBackupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateBackup(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateBackup, (NoAwaitTag, google::cloud::alloydb::v1::UpdateBackupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateBackup(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateBackup, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteBackup)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteBackup(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteBackup(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteBackup, (google::cloud::alloydb::v1::DeleteBackupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteBackup(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteBackup, (NoAwaitTag, google::cloud::alloydb::v1::DeleteBackupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteBackup(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteBackup, (google::longrunning::Operation const& operation), (override)); diff --git a/google/cloud/apigateway/v1/mocks/mock_api_gateway_connection.h b/google/cloud/apigateway/v1/mocks/mock_api_gateway_connection.h index 9b186969c01f3..184e657fc8348 100644 --- a/google/cloud/apigateway/v1/mocks/mock_api_gateway_connection.h +++ b/google/cloud/apigateway/v1/mocks/mock_api_gateway_connection.h @@ -56,57 +56,117 @@ class MockApiGatewayServiceConnection (google::cloud::apigateway::v1::GetGatewayRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateGateway)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateGateway(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateGateway(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateGateway, (google::cloud::apigateway::v1::CreateGatewayRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateGateway(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateGateway, (NoAwaitTag, google::cloud::apigateway::v1::CreateGatewayRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateGateway(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateGateway, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateGateway)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateGateway(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateGateway(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateGateway, (google::cloud::apigateway::v1::UpdateGatewayRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateGateway(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateGateway, (NoAwaitTag, google::cloud::apigateway::v1::UpdateGatewayRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateGateway(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateGateway, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteGateway)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteGateway(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteGateway(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteGateway, (google::cloud::apigateway::v1::DeleteGatewayRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteGateway(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteGateway, (NoAwaitTag, google::cloud::apigateway::v1::DeleteGatewayRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteGateway(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteGateway, (google::longrunning::Operation const& operation), @@ -120,50 +180,110 @@ class MockApiGatewayServiceConnection (google::cloud::apigateway::v1::GetApiRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateApi)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateApi(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateApi(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateApi, (google::cloud::apigateway::v1::CreateApiRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateApi(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateApi, (NoAwaitTag, google::cloud::apigateway::v1::CreateApiRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateApi(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateApi, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateApi)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateApi(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateApi(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateApi, (google::cloud::apigateway::v1::UpdateApiRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateApi(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateApi, (NoAwaitTag, google::cloud::apigateway::v1::UpdateApiRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateApi(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateApi, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteApi)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteApi(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteApi(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteApi, (google::cloud::apigateway::v1::DeleteApiRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteApi(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteApi, (NoAwaitTag, google::cloud::apigateway::v1::DeleteApiRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteApi(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteApi, (google::longrunning::Operation const& operation), (override)); @@ -178,59 +298,119 @@ class MockApiGatewayServiceConnection (google::cloud::apigateway::v1::GetApiConfigRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateApiConfig)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateApiConfig(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateApiConfig(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateApiConfig, (google::cloud::apigateway::v1::CreateApiConfigRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateApiConfig(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateApiConfig, (NoAwaitTag, google::cloud::apigateway::v1::CreateApiConfigRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateApiConfig(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateApiConfig, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateApiConfig)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateApiConfig(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateApiConfig(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateApiConfig, (google::cloud::apigateway::v1::UpdateApiConfigRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateApiConfig(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateApiConfig, (NoAwaitTag, google::cloud::apigateway::v1::UpdateApiConfigRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateApiConfig(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateApiConfig, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteApiConfig)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteApiConfig(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteApiConfig(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteApiConfig, (google::cloud::apigateway::v1::DeleteApiConfigRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteApiConfig(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteApiConfig, (NoAwaitTag, google::cloud::apigateway::v1::DeleteApiConfigRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteApiConfig(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteApiConfig, (google::longrunning::Operation const& operation), diff --git a/google/cloud/apikeys/v2/mocks/mock_api_keys_connection.h b/google/cloud/apikeys/v2/mocks/mock_api_keys_connection.h index 69f7872b9dbd6..e12069b7eaf93 100644 --- a/google/cloud/apikeys/v2/mocks/mock_api_keys_connection.h +++ b/google/cloud/apikeys/v2/mocks/mock_api_keys_connection.h @@ -46,18 +46,37 @@ class MockApiKeysConnection : public apikeys_v2::ApiKeysConnection { public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateKey)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateKey(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateKey(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateKey, (google::api::apikeys::v2::CreateKeyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateKey(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateKey, (NoAwaitTag, google::api::apikeys::v2::CreateKeyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateKey(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateKey, (google::longrunning::Operation const& operation), (override)); @@ -73,48 +92,106 @@ class MockApiKeysConnection : public apikeys_v2::ApiKeysConnection { (google::api::apikeys::v2::GetKeyStringRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateKey)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateKey(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateKey(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateKey, (google::api::apikeys::v2::UpdateKeyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateKey(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateKey, (NoAwaitTag, google::api::apikeys::v2::UpdateKeyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateKey(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateKey, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteKey)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteKey(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteKey(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteKey, (google::api::apikeys::v2::DeleteKeyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteKey(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteKey, (NoAwaitTag, google::api::apikeys::v2::DeleteKeyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteKey(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteKey, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UndeleteKey)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UndeleteKey(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UndeleteKey(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UndeleteKey, (google::api::apikeys::v2::UndeleteKeyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UndeleteKey(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UndeleteKey, (NoAwaitTag, google::api::apikeys::v2::UndeleteKeyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UndeleteKey(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UndeleteKey, (google::longrunning::Operation const& operation), (override)); diff --git a/google/cloud/appengine/v1/mocks/mock_applications_connection.h b/google/cloud/appengine/v1/mocks/mock_applications_connection.h index 92d6f55c26bc1..8df782af2108b 100644 --- a/google/cloud/appengine/v1/mocks/mock_applications_connection.h +++ b/google/cloud/appengine/v1/mocks/mock_applications_connection.h @@ -50,53 +50,113 @@ class MockApplicationsConnection : public appengine_v1::ApplicationsConnection { (google::appengine::v1::GetApplicationRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateApplication)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateApplication(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateApplication(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateApplication, (google::appengine::v1::CreateApplicationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateApplication(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateApplication, (NoAwaitTag, google::appengine::v1::CreateApplicationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateApplication(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateApplication, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateApplication)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateApplication(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateApplication(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateApplication, (google::appengine::v1::UpdateApplicationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateApplication(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateApplication, (NoAwaitTag, google::appengine::v1::UpdateApplicationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateApplication(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateApplication, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, RepairApplication)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, RepairApplication(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RepairApplication(Matcher(_))) + /// @endcode MOCK_METHOD(future>, RepairApplication, (google::appengine::v1::RepairApplicationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, RepairApplication(_, _)) + /// @endcode MOCK_METHOD(StatusOr, RepairApplication, (NoAwaitTag, google::appengine::v1::RepairApplicationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RepairApplication(Matcher(_))) + /// @endcode MOCK_METHOD(future>, RepairApplication, (google::longrunning::Operation const& operation), (override)); diff --git a/google/cloud/appengine/v1/mocks/mock_domain_mappings_connection.h b/google/cloud/appengine/v1/mocks/mock_domain_mappings_connection.h index 4770a4e0d1899..70e128276a6a8 100644 --- a/google/cloud/appengine/v1/mocks/mock_domain_mappings_connection.h +++ b/google/cloud/appengine/v1/mocks/mock_domain_mappings_connection.h @@ -56,59 +56,119 @@ class MockDomainMappingsConnection (google::appengine::v1::GetDomainMappingRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateDomainMapping)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateDomainMapping(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateDomainMapping(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateDomainMapping, (google::appengine::v1::CreateDomainMappingRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateDomainMapping(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateDomainMapping, (NoAwaitTag, google::appengine::v1::CreateDomainMappingRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateDomainMapping(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateDomainMapping, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateDomainMapping)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateDomainMapping(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateDomainMapping(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateDomainMapping, (google::appengine::v1::UpdateDomainMappingRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateDomainMapping(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateDomainMapping, (NoAwaitTag, google::appengine::v1::UpdateDomainMappingRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateDomainMapping(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateDomainMapping, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteDomainMapping)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteDomainMapping(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteDomainMapping(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteDomainMapping, (google::appengine::v1::DeleteDomainMappingRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteDomainMapping(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteDomainMapping, (NoAwaitTag, google::appengine::v1::DeleteDomainMappingRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteDomainMapping(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteDomainMapping, (google::longrunning::Operation const& operation), (override)); diff --git a/google/cloud/appengine/v1/mocks/mock_instances_connection.h b/google/cloud/appengine/v1/mocks/mock_instances_connection.h index 3cbea482949df..f07952af6e4b4 100644 --- a/google/cloud/appengine/v1/mocks/mock_instances_connection.h +++ b/google/cloud/appengine/v1/mocks/mock_instances_connection.h @@ -54,35 +54,75 @@ class MockInstancesConnection : public appengine_v1::InstancesConnection { (google::appengine::v1::GetInstanceRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteInstance)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteInstance(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteInstance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteInstance, (google::appengine::v1::DeleteInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteInstance(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteInstance, (NoAwaitTag, google::appengine::v1::DeleteInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteInstance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteInstance, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DebugInstance)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DebugInstance(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DebugInstance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DebugInstance, (google::appengine::v1::DebugInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DebugInstance(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DebugInstance, (NoAwaitTag, google::appengine::v1::DebugInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DebugInstance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DebugInstance, (google::longrunning::Operation const& operation), (override)); }; diff --git a/google/cloud/appengine/v1/mocks/mock_services_connection.h b/google/cloud/appengine/v1/mocks/mock_services_connection.h index 43aab09e78888..70e50a8fbc4b5 100644 --- a/google/cloud/appengine/v1/mocks/mock_services_connection.h +++ b/google/cloud/appengine/v1/mocks/mock_services_connection.h @@ -53,34 +53,74 @@ class MockServicesConnection : public appengine_v1::ServicesConnection { (google::appengine::v1::GetServiceRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateService)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateService(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateService(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateService, (google::appengine::v1::UpdateServiceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateService(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateService, (NoAwaitTag, google::appengine::v1::UpdateServiceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateService(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateService, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteService)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteService(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteService(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteService, (google::appengine::v1::DeleteServiceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteService(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteService, (NoAwaitTag, google::appengine::v1::DeleteServiceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteService(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteService, (google::longrunning::Operation const& operation), (override)); diff --git a/google/cloud/appengine/v1/mocks/mock_versions_connection.h b/google/cloud/appengine/v1/mocks/mock_versions_connection.h index ede7e123d629c..cf366fa88f67a 100644 --- a/google/cloud/appengine/v1/mocks/mock_versions_connection.h +++ b/google/cloud/appengine/v1/mocks/mock_versions_connection.h @@ -53,49 +53,109 @@ class MockVersionsConnection : public appengine_v1::VersionsConnection { (google::appengine::v1::GetVersionRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateVersion)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateVersion(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateVersion(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateVersion, (google::appengine::v1::CreateVersionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateVersion(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateVersion, (NoAwaitTag, google::appengine::v1::CreateVersionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateVersion(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateVersion, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateVersion)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateVersion(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateVersion(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateVersion, (google::appengine::v1::UpdateVersionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateVersion(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateVersion, (NoAwaitTag, google::appengine::v1::UpdateVersionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateVersion(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateVersion, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteVersion)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteVersion(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteVersion(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteVersion, (google::appengine::v1::DeleteVersionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteVersion(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteVersion, (NoAwaitTag, google::appengine::v1::DeleteVersionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteVersion(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteVersion, (google::longrunning::Operation const& operation), (override)); diff --git a/google/cloud/apphub/v1/mocks/mock_app_hub_connection.h b/google/cloud/apphub/v1/mocks/mock_app_hub_connection.h index 63ea5e9dcf633..32192d8be8085 100644 --- a/google/cloud/apphub/v1/mocks/mock_app_hub_connection.h +++ b/google/cloud/apphub/v1/mocks/mock_app_hub_connection.h @@ -60,10 +60,15 @@ class MockAppHubConnection : public apphub_v1::AppHubConnection { (google::cloud::apphub::v1::ListServiceProjectAttachmentsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateServiceProjectAttachment)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateServiceProjectAttachment(::testing::_))` - /// instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateServiceProjectAttachment(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateServiceProjectAttachment, @@ -71,6 +76,12 @@ class MockAppHubConnection : public apphub_v1::AppHubConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateServiceProjectAttachment(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateServiceProjectAttachment, (NoAwaitTag, @@ -78,6 +89,15 @@ class MockAppHubConnection : public apphub_v1::AppHubConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateServiceProjectAttachment(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateServiceProjectAttachment, @@ -90,10 +110,15 @@ class MockAppHubConnection : public apphub_v1::AppHubConnection { request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteServiceProjectAttachment)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteServiceProjectAttachment(::testing::_))` - /// instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteServiceProjectAttachment(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteServiceProjectAttachment, @@ -101,6 +126,12 @@ class MockAppHubConnection : public apphub_v1::AppHubConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteServiceProjectAttachment(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteServiceProjectAttachment, (NoAwaitTag, @@ -108,6 +139,15 @@ class MockAppHubConnection : public apphub_v1::AppHubConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteServiceProjectAttachment(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteServiceProjectAttachment, (google::longrunning::Operation const& operation), (override)); @@ -143,19 +183,39 @@ class MockAppHubConnection : public apphub_v1::AppHubConnection { (google::cloud::apphub::v1::ListServicesRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateService)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateService(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateService(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateService, (google::cloud::apphub::v1::CreateServiceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateService(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateService, (NoAwaitTag, google::cloud::apphub::v1::CreateServiceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateService(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateService, (google::longrunning::Operation const& operation), (override)); @@ -164,36 +224,76 @@ class MockAppHubConnection : public apphub_v1::AppHubConnection { (google::cloud::apphub::v1::GetServiceRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateService)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateService(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateService(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateService, (google::cloud::apphub::v1::UpdateServiceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateService(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateService, (NoAwaitTag, google::cloud::apphub::v1::UpdateServiceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateService(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateService, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteService)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteService(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteService(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteService, (google::cloud::apphub::v1::DeleteServiceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteService(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteService, (NoAwaitTag, google::cloud::apphub::v1::DeleteServiceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteService(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteService, (google::longrunning::Operation const& operation), (override)); @@ -221,19 +321,39 @@ class MockAppHubConnection : public apphub_v1::AppHubConnection { (google::cloud::apphub::v1::ListWorkloadsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateWorkload)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateWorkload(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateWorkload(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateWorkload, (google::cloud::apphub::v1::CreateWorkloadRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateWorkload(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateWorkload, (NoAwaitTag, google::cloud::apphub::v1::CreateWorkloadRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateWorkload(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateWorkload, (google::longrunning::Operation const& operation), (override)); @@ -242,36 +362,76 @@ class MockAppHubConnection : public apphub_v1::AppHubConnection { (google::cloud::apphub::v1::GetWorkloadRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateWorkload)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateWorkload(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateWorkload(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateWorkload, (google::cloud::apphub::v1::UpdateWorkloadRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateWorkload(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateWorkload, (NoAwaitTag, google::cloud::apphub::v1::UpdateWorkloadRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateWorkload(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateWorkload, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteWorkload)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteWorkload(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteWorkload(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteWorkload, (google::cloud::apphub::v1::DeleteWorkloadRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteWorkload(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteWorkload, (NoAwaitTag, google::cloud::apphub::v1::DeleteWorkloadRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteWorkload(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteWorkload, (google::longrunning::Operation const& operation), (override)); @@ -281,21 +441,41 @@ class MockAppHubConnection : public apphub_v1::AppHubConnection { (google::cloud::apphub::v1::ListApplicationsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateApplication)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateApplication(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateApplication(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateApplication, (google::cloud::apphub::v1::CreateApplicationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateApplication(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateApplication, (NoAwaitTag, google::cloud::apphub::v1::CreateApplicationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateApplication(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateApplication, (google::longrunning::Operation const& operation), (override)); @@ -304,40 +484,80 @@ class MockAppHubConnection : public apphub_v1::AppHubConnection { (google::cloud::apphub::v1::GetApplicationRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateApplication)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateApplication(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateApplication(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateApplication, (google::cloud::apphub::v1::UpdateApplicationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateApplication(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateApplication, (NoAwaitTag, google::cloud::apphub::v1::UpdateApplicationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateApplication(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateApplication, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteApplication)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteApplication(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteApplication(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteApplication, (google::cloud::apphub::v1::DeleteApplicationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteApplication(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteApplication, (NoAwaitTag, google::cloud::apphub::v1::DeleteApplicationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteApplication(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteApplication, (google::longrunning::Operation const& operation), (override)); diff --git a/google/cloud/artifactregistry/v1/mocks/mock_artifact_registry_connection.h b/google/cloud/artifactregistry/v1/mocks/mock_artifact_registry_connection.h index 8bbe079f7d14d..584b7463119b2 100644 --- a/google/cloud/artifactregistry/v1/mocks/mock_artifact_registry_connection.h +++ b/google/cloud/artifactregistry/v1/mocks/mock_artifact_registry_connection.h @@ -101,9 +101,15 @@ class MockArtifactRegistryConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ImportAptArtifacts)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ImportAptArtifacts(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ImportAptArtifacts(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -112,6 +118,12 @@ class MockArtifactRegistryConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ImportAptArtifacts(_, _)) + /// @endcode MOCK_METHOD( StatusOr, ImportAptArtifacts, (NoAwaitTag, @@ -119,15 +131,29 @@ class MockArtifactRegistryConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ImportAptArtifacts(Matcher(_))) + /// @endcode MOCK_METHOD( future>, ImportAptArtifacts, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ImportYumArtifacts)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ImportYumArtifacts(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ImportYumArtifacts(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -136,6 +162,12 @@ class MockArtifactRegistryConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ImportYumArtifacts(_, _)) + /// @endcode MOCK_METHOD( StatusOr, ImportYumArtifacts, (NoAwaitTag, @@ -143,6 +175,14 @@ class MockArtifactRegistryConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ImportYumArtifacts(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -162,9 +202,15 @@ class MockArtifactRegistryConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateRepository)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateRepository(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateRepository(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateRepository, @@ -172,6 +218,12 @@ class MockArtifactRegistryConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateRepository(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateRepository, (NoAwaitTag, @@ -179,6 +231,14 @@ class MockArtifactRegistryConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateRepository(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateRepository, (google::longrunning::Operation const& operation), @@ -191,9 +251,15 @@ class MockArtifactRegistryConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteRepository)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteRepository(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteRepository(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, @@ -202,6 +268,12 @@ class MockArtifactRegistryConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteRepository(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteRepository, (NoAwaitTag, @@ -209,6 +281,14 @@ class MockArtifactRegistryConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteRepository(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, @@ -227,9 +307,15 @@ class MockArtifactRegistryConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeletePackage)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeletePackage(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeletePackage(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, @@ -238,6 +324,12 @@ class MockArtifactRegistryConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeletePackage(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeletePackage, (NoAwaitTag, @@ -245,6 +337,14 @@ class MockArtifactRegistryConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeletePackage(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, @@ -263,9 +363,15 @@ class MockArtifactRegistryConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteVersion)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteVersion(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteVersion(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, @@ -274,6 +380,12 @@ class MockArtifactRegistryConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteVersion(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteVersion, (NoAwaitTag, @@ -281,15 +393,29 @@ class MockArtifactRegistryConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteVersion(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, DeleteVersion, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, BatchDeleteVersions)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, BatchDeleteVersions(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// BatchDeleteVersions(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -298,6 +424,12 @@ class MockArtifactRegistryConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, BatchDeleteVersions(_, _)) + /// @endcode MOCK_METHOD( StatusOr, BatchDeleteVersions, (NoAwaitTag, @@ -305,6 +437,14 @@ class MockArtifactRegistryConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// BatchDeleteVersions(Matcher(_))) + /// @endcode MOCK_METHOD( future>, diff --git a/google/cloud/asset/v1/mocks/mock_asset_connection.h b/google/cloud/asset/v1/mocks/mock_asset_connection.h index 3aef4f0763960..3fb729e731338 100644 --- a/google/cloud/asset/v1/mocks/mock_asset_connection.h +++ b/google/cloud/asset/v1/mocks/mock_asset_connection.h @@ -46,19 +46,39 @@ class MockAssetServiceConnection : public asset_v1::AssetServiceConnection { public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ExportAssets)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ExportAssets(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ExportAssets(Matcher(_))) + /// @endcode MOCK_METHOD(future>, ExportAssets, (google::cloud::asset::v1::ExportAssetsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ExportAssets(_, _)) + /// @endcode MOCK_METHOD(StatusOr, ExportAssets, (NoAwaitTag, google::cloud::asset::v1::ExportAssetsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, ExportAssets(Matcher(_))) + /// @endcode MOCK_METHOD(future>, ExportAssets, (google::longrunning::Operation const& operation), (override)); @@ -109,9 +129,15 @@ class MockAssetServiceConnection : public asset_v1::AssetServiceConnection { (google::cloud::asset::v1::AnalyzeIamPolicyRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, AnalyzeIamPolicyLongrunning)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, AnalyzeIamPolicyLongrunning(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// AnalyzeIamPolicyLongrunning(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -120,6 +146,12 @@ class MockAssetServiceConnection : public asset_v1::AssetServiceConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, AnalyzeIamPolicyLongrunning(_, _)) + /// @endcode MOCK_METHOD( StatusOr, AnalyzeIamPolicyLongrunning, (NoAwaitTag, @@ -127,6 +159,15 @@ class MockAssetServiceConnection : public asset_v1::AssetServiceConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// AnalyzeIamPolicyLongrunning(Matcher(_))) + /// @endcode MOCK_METHOD( future>, diff --git a/google/cloud/assuredworkloads/v1/mocks/mock_assured_workloads_connection.h b/google/cloud/assuredworkloads/v1/mocks/mock_assured_workloads_connection.h index a13d17d31fee6..e2934bc06161f 100644 --- a/google/cloud/assuredworkloads/v1/mocks/mock_assured_workloads_connection.h +++ b/google/cloud/assuredworkloads/v1/mocks/mock_assured_workloads_connection.h @@ -47,21 +47,41 @@ class MockAssuredWorkloadsServiceConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateWorkload)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateWorkload(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateWorkload(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateWorkload, (google::cloud::assuredworkloads::v1::CreateWorkloadRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateWorkload(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateWorkload, (NoAwaitTag, google::cloud::assuredworkloads::v1::CreateWorkloadRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateWorkload(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateWorkload, (google::longrunning::Operation const& operation), (override)); diff --git a/google/cloud/automl/v1/mocks/mock_auto_ml_connection.h b/google/cloud/automl/v1/mocks/mock_auto_ml_connection.h index 71543d80c27aa..1936ed9866e38 100644 --- a/google/cloud/automl/v1/mocks/mock_auto_ml_connection.h +++ b/google/cloud/automl/v1/mocks/mock_auto_ml_connection.h @@ -46,19 +46,39 @@ class MockAutoMlConnection : public automl_v1::AutoMlConnection { public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateDataset)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateDataset(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateDataset(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateDataset, (google::cloud::automl::v1::CreateDatasetRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateDataset(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateDataset, (NoAwaitTag, google::cloud::automl::v1::CreateDatasetRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateDataset(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateDataset, (google::longrunning::Operation const& operation), (override)); @@ -75,53 +95,113 @@ class MockAutoMlConnection : public automl_v1::AutoMlConnection { (google::cloud::automl::v1::UpdateDatasetRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteDataset)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteDataset(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteDataset(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteDataset, (google::cloud::automl::v1::DeleteDatasetRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteDataset(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteDataset, (NoAwaitTag, google::cloud::automl::v1::DeleteDatasetRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteDataset(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteDataset, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ImportData)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ImportData(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ImportData(Matcher(_))) + /// @endcode MOCK_METHOD(future>, ImportData, (google::cloud::automl::v1::ImportDataRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ImportData(_, _)) + /// @endcode MOCK_METHOD(StatusOr, ImportData, (NoAwaitTag, google::cloud::automl::v1::ImportDataRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, ImportData(Matcher(_))) + /// @endcode MOCK_METHOD(future>, ImportData, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ExportData)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ExportData(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ExportData(Matcher(_))) + /// @endcode MOCK_METHOD(future>, ExportData, (google::cloud::automl::v1::ExportDataRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ExportData(_, _)) + /// @endcode MOCK_METHOD(StatusOr, ExportData, (NoAwaitTag, google::cloud::automl::v1::ExportDataRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, ExportData(Matcher(_))) + /// @endcode MOCK_METHOD(future>, ExportData, (google::longrunning::Operation const& operation), (override)); @@ -131,18 +211,38 @@ class MockAutoMlConnection : public automl_v1::AutoMlConnection { (google::cloud::automl::v1::GetAnnotationSpecRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateModel)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateModel(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateModel(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateModel, (google::cloud::automl::v1::CreateModelRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateModel(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateModel, (NoAwaitTag, google::cloud::automl::v1::CreateModelRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateModel(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateModel, (google::longrunning::Operation const& operation), (override)); @@ -154,19 +254,39 @@ class MockAutoMlConnection : public automl_v1::AutoMlConnection { (google::cloud::automl::v1::ListModelsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteModel)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteModel(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteModel(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteModel, (google::cloud::automl::v1::DeleteModelRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteModel(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteModel, (NoAwaitTag, google::cloud::automl::v1::DeleteModelRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteModel(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteModel, (google::longrunning::Operation const& operation), (override)); @@ -175,53 +295,113 @@ class MockAutoMlConnection : public automl_v1::AutoMlConnection { (google::cloud::automl::v1::UpdateModelRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeployModel)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeployModel(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeployModel(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeployModel, (google::cloud::automl::v1::DeployModelRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeployModel(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeployModel, (NoAwaitTag, google::cloud::automl::v1::DeployModelRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeployModel(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeployModel, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UndeployModel)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UndeployModel(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UndeployModel(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UndeployModel, (google::cloud::automl::v1::UndeployModelRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UndeployModel(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UndeployModel, (NoAwaitTag, google::cloud::automl::v1::UndeployModelRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UndeployModel(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UndeployModel, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ExportModel)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ExportModel(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ExportModel(Matcher(_))) + /// @endcode MOCK_METHOD(future>, ExportModel, (google::cloud::automl::v1::ExportModelRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ExportModel(_, _)) + /// @endcode MOCK_METHOD(StatusOr, ExportModel, (NoAwaitTag, google::cloud::automl::v1::ExportModelRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, ExportModel(Matcher(_))) + /// @endcode MOCK_METHOD(future>, ExportModel, (google::longrunning::Operation const& operation), (override)); diff --git a/google/cloud/automl/v1/mocks/mock_prediction_connection.h b/google/cloud/automl/v1/mocks/mock_prediction_connection.h index 6bbad455d648d..2cf8e23746044 100644 --- a/google/cloud/automl/v1/mocks/mock_prediction_connection.h +++ b/google/cloud/automl/v1/mocks/mock_prediction_connection.h @@ -51,19 +51,39 @@ class MockPredictionServiceConnection (google::cloud::automl::v1::PredictRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, BatchPredict)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, BatchPredict(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// BatchPredict(Matcher(_))) + /// @endcode MOCK_METHOD(future>, BatchPredict, (google::cloud::automl::v1::BatchPredictRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, BatchPredict(_, _)) + /// @endcode MOCK_METHOD(StatusOr, BatchPredict, (NoAwaitTag, google::cloud::automl::v1::BatchPredictRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, BatchPredict(Matcher(_))) + /// @endcode MOCK_METHOD(future>, BatchPredict, (google::longrunning::Operation const& operation), (override)); diff --git a/google/cloud/backupdr/v1/mocks/mock_backup_dr_connection.h b/google/cloud/backupdr/v1/mocks/mock_backup_dr_connection.h index fd28c1b69d56e..6530e2c245d01 100644 --- a/google/cloud/backupdr/v1/mocks/mock_backup_dr_connection.h +++ b/google/cloud/backupdr/v1/mocks/mock_backup_dr_connection.h @@ -58,40 +58,80 @@ class MockBackupDRConnection : public backupdr_v1::BackupDRConnection { (google::cloud::backupdr::v1::GetManagementServerRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateManagementServer)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateManagementServer(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateManagementServer(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateManagementServer, (google::cloud::backupdr::v1::CreateManagementServerRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateManagementServer(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateManagementServer, (NoAwaitTag, google::cloud::backupdr::v1::CreateManagementServerRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateManagementServer(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateManagementServer, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteManagementServer)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteManagementServer(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteManagementServer(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteManagementServer, (google::cloud::backupdr::v1::DeleteManagementServerRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteManagementServer(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteManagementServer, (NoAwaitTag, google::cloud::backupdr::v1::DeleteManagementServerRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteManagementServer(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteManagementServer, (google::longrunning::Operation const& operation), (override)); diff --git a/google/cloud/baremetalsolution/v2/mocks/mock_bare_metal_solution_connection.h b/google/cloud/baremetalsolution/v2/mocks/mock_bare_metal_solution_connection.h index d69e74c4e266e..a23ebea8da8c6 100644 --- a/google/cloud/baremetalsolution/v2/mocks/mock_bare_metal_solution_connection.h +++ b/google/cloud/baremetalsolution/v2/mocks/mock_bare_metal_solution_connection.h @@ -58,9 +58,15 @@ class MockBareMetalSolutionConnection (google::cloud::baremetalsolution::v2::GetInstanceRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateInstance)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateInstance(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateInstance(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateInstance, @@ -68,6 +74,12 @@ class MockBareMetalSolutionConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateInstance(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateInstance, (NoAwaitTag, @@ -75,6 +87,14 @@ class MockBareMetalSolutionConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateInstance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateInstance, (google::longrunning::Operation const& operation), (override)); @@ -85,9 +105,15 @@ class MockBareMetalSolutionConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ResetInstance)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ResetInstance(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ResetInstance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, ResetInstance, @@ -95,20 +121,40 @@ class MockBareMetalSolutionConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ResetInstance(_, _)) + /// @endcode MOCK_METHOD(StatusOr, ResetInstance, (NoAwaitTag, google::cloud::baremetalsolution::v2::ResetInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, ResetInstance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, ResetInstance, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, StartInstance)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, StartInstance(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// StartInstance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, StartInstance, @@ -116,20 +162,40 @@ class MockBareMetalSolutionConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, StartInstance(_, _)) + /// @endcode MOCK_METHOD(StatusOr, StartInstance, (NoAwaitTag, google::cloud::baremetalsolution::v2::StartInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, StartInstance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, StartInstance, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, StopInstance)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, StopInstance(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// StopInstance(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, @@ -138,22 +204,41 @@ class MockBareMetalSolutionConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, StopInstance(_, _)) + /// @endcode MOCK_METHOD(StatusOr, StopInstance, (NoAwaitTag, google::cloud::baremetalsolution::v2::StopInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, StopInstance(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, StopInstance, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, EnableInteractiveSerialConsole)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, EnableInteractiveSerialConsole(::testing::_))` - /// instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// EnableInteractiveSerialConsole(Matcher(_))) + /// @endcode MOCK_METHOD(future>, EnableInteractiveSerialConsole, @@ -161,6 +246,12 @@ class MockBareMetalSolutionConnection EnableInteractiveSerialConsoleRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, EnableInteractiveSerialConsole(_, _)) + /// @endcode MOCK_METHOD(StatusOr, EnableInteractiveSerialConsole, (NoAwaitTag, @@ -168,15 +259,29 @@ class MockBareMetalSolutionConnection EnableInteractiveSerialConsoleRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// EnableInteractiveSerialConsole(Matcher(_))) + /// @endcode MOCK_METHOD(future>, EnableInteractiveSerialConsole, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DisableInteractiveSerialConsole)` is now ambiguous. - /// Use `EXPECT_CALL(*mock, DisableInteractiveSerialConsole(::testing::_))` - /// instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DisableInteractiveSerialConsole(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DisableInteractiveSerialConsole, @@ -184,6 +289,12 @@ class MockBareMetalSolutionConnection DisableInteractiveSerialConsoleRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DisableInteractiveSerialConsole(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DisableInteractiveSerialConsole, (NoAwaitTag, @@ -191,26 +302,55 @@ class MockBareMetalSolutionConnection DisableInteractiveSerialConsoleRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DisableInteractiveSerialConsole(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DisableInteractiveSerialConsole, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DetachLun)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DetachLun(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DetachLun(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DetachLun, (google::cloud::baremetalsolution::v2::DetachLunRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DetachLun(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DetachLun, (NoAwaitTag, google::cloud::baremetalsolution::v2::DetachLunRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DetachLun(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DetachLun, (google::longrunning::Operation const& operation), (override)); @@ -241,21 +381,41 @@ class MockBareMetalSolutionConnection (google::cloud::baremetalsolution::v2::GetVolumeRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateVolume)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateVolume(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateVolume(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateVolume, (google::cloud::baremetalsolution::v2::UpdateVolumeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateVolume(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateVolume, (NoAwaitTag, google::cloud::baremetalsolution::v2::UpdateVolumeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateVolume(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateVolume, (google::longrunning::Operation const& operation), (override)); @@ -266,41 +426,81 @@ class MockBareMetalSolutionConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, EvictVolume)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, EvictVolume(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// EvictVolume(Matcher(_))) + /// @endcode MOCK_METHOD( future>, EvictVolume, (google::cloud::baremetalsolution::v2::EvictVolumeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, EvictVolume(_, _)) + /// @endcode MOCK_METHOD( StatusOr, EvictVolume, (NoAwaitTag, google::cloud::baremetalsolution::v2::EvictVolumeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, EvictVolume(Matcher(_))) + /// @endcode MOCK_METHOD( future>, EvictVolume, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ResizeVolume)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ResizeVolume(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ResizeVolume(Matcher(_))) + /// @endcode MOCK_METHOD(future>, ResizeVolume, (google::cloud::baremetalsolution::v2::ResizeVolumeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ResizeVolume(_, _)) + /// @endcode MOCK_METHOD(StatusOr, ResizeVolume, (NoAwaitTag, google::cloud::baremetalsolution::v2::ResizeVolumeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, ResizeVolume(Matcher(_))) + /// @endcode MOCK_METHOD(future>, ResizeVolume, (google::longrunning::Operation const& operation), (override)); @@ -323,21 +523,41 @@ class MockBareMetalSolutionConnection (google::cloud::baremetalsolution::v2::GetNetworkRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateNetwork)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateNetwork(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateNetwork(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateNetwork, (google::cloud::baremetalsolution::v2::UpdateNetworkRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateNetwork(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateNetwork, (NoAwaitTag, google::cloud::baremetalsolution::v2::UpdateNetworkRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateNetwork(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateNetwork, (google::longrunning::Operation const& operation), (override)); @@ -349,9 +569,15 @@ class MockBareMetalSolutionConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, RestoreVolumeSnapshot)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, RestoreVolumeSnapshot(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RestoreVolumeSnapshot(Matcher(_))) + /// @endcode MOCK_METHOD( future>, RestoreVolumeSnapshot, @@ -359,6 +585,12 @@ class MockBareMetalSolutionConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, RestoreVolumeSnapshot(_, _)) + /// @endcode MOCK_METHOD( StatusOr, RestoreVolumeSnapshot, (NoAwaitTag, @@ -366,6 +598,14 @@ class MockBareMetalSolutionConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RestoreVolumeSnapshot(Matcher(_))) + /// @endcode MOCK_METHOD( future>, RestoreVolumeSnapshot, (google::longrunning::Operation const& operation), @@ -401,21 +641,41 @@ class MockBareMetalSolutionConnection (google::cloud::baremetalsolution::v2::ListLunsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, EvictLun)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, EvictLun(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// EvictLun(Matcher(_))) + /// @endcode MOCK_METHOD( future>, EvictLun, (google::cloud::baremetalsolution::v2::EvictLunRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, EvictLun(_, _)) + /// @endcode MOCK_METHOD( StatusOr, EvictLun, (NoAwaitTag, google::cloud::baremetalsolution::v2::EvictLunRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, EvictLun(Matcher(_))) + /// @endcode MOCK_METHOD( future>, EvictLun, (google::longrunning::Operation const& operation), (override)); @@ -431,9 +691,15 @@ class MockBareMetalSolutionConnection (google::cloud::baremetalsolution::v2::ListNfsSharesRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateNfsShare)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateNfsShare(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateNfsShare(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateNfsShare, @@ -441,6 +707,12 @@ class MockBareMetalSolutionConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateNfsShare(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateNfsShare, (NoAwaitTag, @@ -448,13 +720,27 @@ class MockBareMetalSolutionConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateNfsShare(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateNfsShare, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateNfsShare)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateNfsShare(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateNfsShare(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateNfsShare, @@ -462,6 +748,12 @@ class MockBareMetalSolutionConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateNfsShare(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateNfsShare, (NoAwaitTag, @@ -469,6 +761,14 @@ class MockBareMetalSolutionConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateNfsShare(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateNfsShare, (google::longrunning::Operation const& operation), (override)); @@ -479,9 +779,15 @@ class MockBareMetalSolutionConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteNfsShare)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteNfsShare(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteNfsShare(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteNfsShare, @@ -489,6 +795,12 @@ class MockBareMetalSolutionConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteNfsShare(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteNfsShare, (NoAwaitTag, @@ -496,6 +808,14 @@ class MockBareMetalSolutionConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteNfsShare(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteNfsShare, (google::longrunning::Operation const& operation), diff --git a/google/cloud/batch/v1/mocks/mock_batch_connection.h b/google/cloud/batch/v1/mocks/mock_batch_connection.h index 6b5af2b6f0154..a1322d1bcf677 100644 --- a/google/cloud/batch/v1/mocks/mock_batch_connection.h +++ b/google/cloud/batch/v1/mocks/mock_batch_connection.h @@ -54,19 +54,38 @@ class MockBatchServiceConnection : public batch_v1::BatchServiceConnection { (google::cloud::batch::v1::GetJobRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteJob)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteJob(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteJob(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteJob, (google::cloud::batch::v1::DeleteJobRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteJob(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteJob, (NoAwaitTag, google::cloud::batch::v1::DeleteJobRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteJob(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteJob, (google::longrunning::Operation const& operation), (override)); diff --git a/google/cloud/beyondcorp/appconnections/v1/mocks/mock_app_connections_connection.h b/google/cloud/beyondcorp/appconnections/v1/mocks/mock_app_connections_connection.h index 1dbeb6874a065..8052665d00db5 100644 --- a/google/cloud/beyondcorp/appconnections/v1/mocks/mock_app_connections_connection.h +++ b/google/cloud/beyondcorp/appconnections/v1/mocks/mock_app_connections_connection.h @@ -63,9 +63,15 @@ class MockAppConnectionsServiceConnection GetAppConnectionRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateAppConnection)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateAppConnection(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateAppConnection(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -74,20 +80,40 @@ class MockAppConnectionsServiceConnection CreateAppConnectionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateAppConnection(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateAppConnection, (NoAwaitTag, google::cloud::beyondcorp::appconnections::v1:: CreateAppConnectionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateAppConnection(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateAppConnection, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateAppConnection)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateAppConnection(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateAppConnection(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -96,20 +122,40 @@ class MockAppConnectionsServiceConnection UpdateAppConnectionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateAppConnection(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateAppConnection, (NoAwaitTag, google::cloud::beyondcorp::appconnections::v1:: UpdateAppConnectionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateAppConnection(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateAppConnection, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteAppConnection)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteAppConnection(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteAppConnection(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteAppConnection, @@ -117,11 +163,25 @@ class MockAppConnectionsServiceConnection DeleteAppConnectionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteAppConnection(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteAppConnection, (NoAwaitTag, google::cloud::beyondcorp::appconnections::v1:: DeleteAppConnectionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteAppConnection(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteAppConnection, diff --git a/google/cloud/beyondcorp/appconnectors/v1/mocks/mock_app_connectors_connection.h b/google/cloud/beyondcorp/appconnectors/v1/mocks/mock_app_connectors_connection.h index c4c44cc1b7369..a0f711d1b7268 100644 --- a/google/cloud/beyondcorp/appconnectors/v1/mocks/mock_app_connectors_connection.h +++ b/google/cloud/beyondcorp/appconnectors/v1/mocks/mock_app_connectors_connection.h @@ -61,9 +61,15 @@ class MockAppConnectorsServiceConnection GetAppConnectorRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateAppConnector)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateAppConnector(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateAppConnector(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, @@ -72,20 +78,40 @@ class MockAppConnectorsServiceConnection CreateAppConnectorRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateAppConnector(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateAppConnector, (NoAwaitTag, google::cloud::beyondcorp::appconnectors::v1:: CreateAppConnectorRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateAppConnector(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, CreateAppConnector, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateAppConnector)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateAppConnector(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateAppConnector(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, @@ -94,20 +120,40 @@ class MockAppConnectorsServiceConnection UpdateAppConnectorRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateAppConnector(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateAppConnector, (NoAwaitTag, google::cloud::beyondcorp::appconnectors::v1:: UpdateAppConnectorRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateAppConnector(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, UpdateAppConnector, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteAppConnector)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteAppConnector(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteAppConnector(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteAppConnector, @@ -115,19 +161,39 @@ class MockAppConnectorsServiceConnection DeleteAppConnectorRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteAppConnector(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteAppConnector, (NoAwaitTag, google::cloud::beyondcorp::appconnectors::v1:: DeleteAppConnectorRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteAppConnector(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteAppConnector, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ReportStatus)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ReportStatus(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ReportStatus(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, @@ -136,6 +202,12 @@ class MockAppConnectorsServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ReportStatus(_, _)) + /// @endcode MOCK_METHOD( StatusOr, ReportStatus, (NoAwaitTag, @@ -143,6 +215,14 @@ class MockAppConnectorsServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, ReportStatus(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, diff --git a/google/cloud/beyondcorp/appgateways/v1/mocks/mock_app_gateways_connection.h b/google/cloud/beyondcorp/appgateways/v1/mocks/mock_app_gateways_connection.h index 6eee28098d6d8..a63cf465366ae 100644 --- a/google/cloud/beyondcorp/appgateways/v1/mocks/mock_app_gateways_connection.h +++ b/google/cloud/beyondcorp/appgateways/v1/mocks/mock_app_gateways_connection.h @@ -61,9 +61,15 @@ class MockAppGatewaysServiceConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateAppGateway)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateAppGateway(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateAppGateway(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateAppGateway, @@ -71,19 +77,39 @@ class MockAppGatewaysServiceConnection CreateAppGatewayRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateAppGateway(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateAppGateway, (NoAwaitTag, google::cloud::beyondcorp::appgateways::v1:: CreateAppGatewayRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateAppGateway(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateAppGateway, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteAppGateway)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteAppGateway(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteAppGateway(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteAppGateway, @@ -91,11 +117,25 @@ class MockAppGatewaysServiceConnection DeleteAppGatewayRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteAppGateway(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteAppGateway, (NoAwaitTag, google::cloud::beyondcorp::appgateways::v1:: DeleteAppGatewayRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteAppGateway(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteAppGateway, diff --git a/google/cloud/bigquery/analyticshub/v1/mocks/mock_analytics_hub_connection.h b/google/cloud/bigquery/analyticshub/v1/mocks/mock_analytics_hub_connection.h index 12d665c97cf9b..1a04b90e1e5df 100644 --- a/google/cloud/bigquery/analyticshub/v1/mocks/mock_analytics_hub_connection.h +++ b/google/cloud/bigquery/analyticshub/v1/mocks/mock_analytics_hub_connection.h @@ -125,9 +125,15 @@ class MockAnalyticsHubServiceConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SubscribeDataExchange)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SubscribeDataExchange(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SubscribeDataExchange(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SubscribeDataExchange, @@ -135,19 +141,39 @@ class MockAnalyticsHubServiceConnection SubscribeDataExchangeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SubscribeDataExchange(_, _)) + /// @endcode MOCK_METHOD(StatusOr, SubscribeDataExchange, (NoAwaitTag, google::cloud::bigquery::analyticshub::v1:: SubscribeDataExchangeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SubscribeDataExchange(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SubscribeDataExchange, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, RefreshSubscription)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, RefreshSubscription(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RefreshSubscription(Matcher(_))) + /// @endcode MOCK_METHOD(future>, RefreshSubscription, @@ -155,11 +181,25 @@ class MockAnalyticsHubServiceConnection RefreshSubscriptionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, RefreshSubscription(_, _)) + /// @endcode MOCK_METHOD(StatusOr, RefreshSubscription, (NoAwaitTag, google::cloud::bigquery::analyticshub::v1:: RefreshSubscriptionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RefreshSubscription(Matcher(_))) + /// @endcode MOCK_METHOD(future>, RefreshSubscription, @@ -193,9 +233,15 @@ class MockAnalyticsHubServiceConnection RevokeSubscriptionRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteSubscription)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteSubscription(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteSubscription(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -204,11 +250,25 @@ class MockAnalyticsHubServiceConnection DeleteSubscriptionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteSubscription(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteSubscription, (NoAwaitTag, google::cloud::bigquery::analyticshub::v1:: DeleteSubscriptionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteSubscription(Matcher(_))) + /// @endcode MOCK_METHOD( future>, diff --git a/google/cloud/bigtable/admin/mocks/mock_bigtable_instance_admin_connection.h b/google/cloud/bigtable/admin/mocks/mock_bigtable_instance_admin_connection.h index b5b902fbd074b..6b0ce383c1a41 100644 --- a/google/cloud/bigtable/admin/mocks/mock_bigtable_instance_admin_connection.h +++ b/google/cloud/bigtable/admin/mocks/mock_bigtable_instance_admin_connection.h @@ -47,20 +47,40 @@ class MockBigtableInstanceAdminConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateInstance)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateInstance(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateInstance(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateInstance, (google::bigtable::admin::v2::CreateInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateInstance(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateInstance, (NoAwaitTag, google::bigtable::admin::v2::CreateInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateInstance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateInstance, (google::longrunning::Operation const& operation), (override)); @@ -79,21 +99,41 @@ class MockBigtableInstanceAdminConnection (google::bigtable::admin::v2::Instance const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, PartialUpdateInstance)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, PartialUpdateInstance(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PartialUpdateInstance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PartialUpdateInstance, (google::bigtable::admin::v2::PartialUpdateInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, PartialUpdateInstance(_, _)) + /// @endcode MOCK_METHOD(StatusOr, PartialUpdateInstance, (NoAwaitTag, google::bigtable::admin::v2::PartialUpdateInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PartialUpdateInstance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PartialUpdateInstance, (google::longrunning::Operation const& operation), (override)); @@ -103,20 +143,40 @@ class MockBigtableInstanceAdminConnection (google::bigtable::admin::v2::DeleteInstanceRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateCluster)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateCluster(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateCluster(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateCluster, (google::bigtable::admin::v2::CreateClusterRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateCluster(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateCluster, (NoAwaitTag, google::bigtable::admin::v2::CreateClusterRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateCluster(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateCluster, (google::longrunning::Operation const& operation), (override)); @@ -130,37 +190,76 @@ class MockBigtableInstanceAdminConnection (google::bigtable::admin::v2::ListClustersRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateCluster)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateCluster(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateCluster(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateCluster, (google::bigtable::admin::v2::Cluster const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateCluster(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateCluster, (NoAwaitTag, google::bigtable::admin::v2::Cluster const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateCluster(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateCluster, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, PartialUpdateCluster)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, PartialUpdateCluster(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PartialUpdateCluster(Matcher(_))) + /// @endcode MOCK_METHOD( future>, PartialUpdateCluster, (google::bigtable::admin::v2::PartialUpdateClusterRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, PartialUpdateCluster(_, _)) + /// @endcode MOCK_METHOD( StatusOr, PartialUpdateCluster, (NoAwaitTag, google::bigtable::admin::v2::PartialUpdateClusterRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PartialUpdateCluster(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PartialUpdateCluster, (google::longrunning::Operation const& operation), (override)); @@ -185,21 +284,41 @@ class MockBigtableInstanceAdminConnection (google::bigtable::admin::v2::ListAppProfilesRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateAppProfile)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateAppProfile(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateAppProfile(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateAppProfile, (google::bigtable::admin::v2::UpdateAppProfileRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateAppProfile(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateAppProfile, (NoAwaitTag, google::bigtable::admin::v2::UpdateAppProfileRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateAppProfile(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateAppProfile, (google::longrunning::Operation const& operation), (override)); diff --git a/google/cloud/bigtable/admin/mocks/mock_bigtable_table_admin_connection.h b/google/cloud/bigtable/admin/mocks/mock_bigtable_table_admin_connection.h index 5d08378161205..bc44c782bb2f8 100644 --- a/google/cloud/bigtable/admin/mocks/mock_bigtable_table_admin_connection.h +++ b/google/cloud/bigtable/admin/mocks/mock_bigtable_table_admin_connection.h @@ -59,18 +59,38 @@ class MockBigtableTableAdminConnection (google::bigtable::admin::v2::GetTableRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateTable)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateTable(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateTable(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateTable, (google::bigtable::admin::v2::UpdateTableRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateTable(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateTable, (NoAwaitTag, google::bigtable::admin::v2::UpdateTableRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateTable(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateTable, (google::longrunning::Operation const& operation), (override)); @@ -78,39 +98,79 @@ class MockBigtableTableAdminConnection (google::bigtable::admin::v2::DeleteTableRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UndeleteTable)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UndeleteTable(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UndeleteTable(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UndeleteTable, (google::bigtable::admin::v2::UndeleteTableRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UndeleteTable(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UndeleteTable, (NoAwaitTag, google::bigtable::admin::v2::UndeleteTableRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UndeleteTable(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UndeleteTable, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateAuthorizedView)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateAuthorizedView(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateAuthorizedView(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateAuthorizedView, (google::bigtable::admin::v2::CreateAuthorizedViewRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateAuthorizedView(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateAuthorizedView, (NoAwaitTag, google::bigtable::admin::v2::CreateAuthorizedViewRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateAuthorizedView(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateAuthorizedView, (google::longrunning::Operation const& operation), (override)); @@ -125,21 +185,41 @@ class MockBigtableTableAdminConnection (google::bigtable::admin::v2::GetAuthorizedViewRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateAuthorizedView)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateAuthorizedView(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateAuthorizedView(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateAuthorizedView, (google::bigtable::admin::v2::UpdateAuthorizedViewRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateAuthorizedView(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateAuthorizedView, (NoAwaitTag, google::bigtable::admin::v2::UpdateAuthorizedViewRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateAuthorizedView(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateAuthorizedView, (google::longrunning::Operation const& operation), (override)); @@ -171,19 +251,39 @@ class MockBigtableTableAdminConnection (google::bigtable::admin::v2::CheckConsistencyRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateBackup)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateBackup(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateBackup(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateBackup, (google::bigtable::admin::v2::CreateBackupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateBackup(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateBackup, (NoAwaitTag, google::bigtable::admin::v2::CreateBackupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateBackup(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateBackup, (google::longrunning::Operation const& operation), (override)); @@ -204,35 +304,75 @@ class MockBigtableTableAdminConnection (google::bigtable::admin::v2::ListBackupsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, RestoreTable)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, RestoreTable(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RestoreTable(Matcher(_))) + /// @endcode MOCK_METHOD(future>, RestoreTable, (google::bigtable::admin::v2::RestoreTableRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, RestoreTable(_, _)) + /// @endcode MOCK_METHOD(StatusOr, RestoreTable, (NoAwaitTag, google::bigtable::admin::v2::RestoreTableRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, RestoreTable(Matcher(_))) + /// @endcode MOCK_METHOD(future>, RestoreTable, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CopyBackup)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CopyBackup(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CopyBackup(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CopyBackup, (google::bigtable::admin::v2::CopyBackupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CopyBackup(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CopyBackup, (NoAwaitTag, google::bigtable::admin::v2::CopyBackupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CopyBackup(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CopyBackup, (google::longrunning::Operation const& operation), (override)); diff --git a/google/cloud/certificatemanager/v1/mocks/mock_certificate_manager_connection.h b/google/cloud/certificatemanager/v1/mocks/mock_certificate_manager_connection.h index 673a91c630037..151c0eecb3246 100644 --- a/google/cloud/certificatemanager/v1/mocks/mock_certificate_manager_connection.h +++ b/google/cloud/certificatemanager/v1/mocks/mock_certificate_manager_connection.h @@ -60,9 +60,15 @@ class MockCertificateManagerConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateCertificate)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateCertificate(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateCertificate(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateCertificate, @@ -70,6 +76,12 @@ class MockCertificateManagerConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateCertificate(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateCertificate, (NoAwaitTag, @@ -77,14 +89,28 @@ class MockCertificateManagerConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateCertificate(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateCertificate, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateCertificate)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateCertificate(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateCertificate(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateCertificate, @@ -92,6 +118,12 @@ class MockCertificateManagerConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateCertificate(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateCertificate, (NoAwaitTag, @@ -99,14 +131,28 @@ class MockCertificateManagerConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateCertificate(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateCertificate, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteCertificate)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteCertificate(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteCertificate(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, @@ -115,6 +161,12 @@ class MockCertificateManagerConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteCertificate(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteCertificate, (NoAwaitTag, @@ -122,6 +174,14 @@ class MockCertificateManagerConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteCertificate(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, @@ -142,9 +202,15 @@ class MockCertificateManagerConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateCertificateMap)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateCertificateMap(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateCertificateMap(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateCertificateMap, @@ -152,6 +218,12 @@ class MockCertificateManagerConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateCertificateMap(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateCertificateMap, (NoAwaitTag, @@ -159,14 +231,28 @@ class MockCertificateManagerConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateCertificateMap(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateCertificateMap, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateCertificateMap)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateCertificateMap(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateCertificateMap(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateCertificateMap, @@ -174,6 +260,12 @@ class MockCertificateManagerConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateCertificateMap(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateCertificateMap, (NoAwaitTag, @@ -181,14 +273,28 @@ class MockCertificateManagerConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateCertificateMap(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateCertificateMap, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteCertificateMap)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteCertificateMap(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteCertificateMap(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, @@ -197,6 +303,12 @@ class MockCertificateManagerConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteCertificateMap(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteCertificateMap, (NoAwaitTag, @@ -204,6 +316,14 @@ class MockCertificateManagerConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteCertificateMap(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, @@ -224,9 +344,15 @@ class MockCertificateManagerConnection GetCertificateMapEntryRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateCertificateMapEntry)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateCertificateMapEntry(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateCertificateMapEntry(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, @@ -235,21 +361,42 @@ class MockCertificateManagerConnection CreateCertificateMapEntryRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateCertificateMapEntry(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateCertificateMapEntry, (NoAwaitTag, google::cloud::certificatemanager::v1:: CreateCertificateMapEntryRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateCertificateMapEntry(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, CreateCertificateMapEntry, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateCertificateMapEntry)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateCertificateMapEntry(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateCertificateMapEntry(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, @@ -258,21 +405,42 @@ class MockCertificateManagerConnection UpdateCertificateMapEntryRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateCertificateMapEntry(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateCertificateMapEntry, (NoAwaitTag, google::cloud::certificatemanager::v1:: UpdateCertificateMapEntryRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateCertificateMapEntry(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, UpdateCertificateMapEntry, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteCertificateMapEntry)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteCertificateMapEntry(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteCertificateMapEntry(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, @@ -281,12 +449,27 @@ class MockCertificateManagerConnection DeleteCertificateMapEntryRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteCertificateMapEntry(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteCertificateMapEntry, (NoAwaitTag, google::cloud::certificatemanager::v1:: DeleteCertificateMapEntryRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteCertificateMapEntry(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, @@ -307,9 +490,15 @@ class MockCertificateManagerConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateDnsAuthorization)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateDnsAuthorization(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateDnsAuthorization(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateDnsAuthorization, @@ -317,19 +506,39 @@ class MockCertificateManagerConnection CreateDnsAuthorizationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateDnsAuthorization(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateDnsAuthorization, (NoAwaitTag, google::cloud::certificatemanager::v1:: CreateDnsAuthorizationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateDnsAuthorization(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateDnsAuthorization, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateDnsAuthorization)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateDnsAuthorization(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateDnsAuthorization(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateDnsAuthorization, @@ -337,19 +546,39 @@ class MockCertificateManagerConnection UpdateDnsAuthorizationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateDnsAuthorization(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateDnsAuthorization, (NoAwaitTag, google::cloud::certificatemanager::v1:: UpdateDnsAuthorizationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateDnsAuthorization(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateDnsAuthorization, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteDnsAuthorization)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteDnsAuthorization(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteDnsAuthorization(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, @@ -358,11 +587,25 @@ class MockCertificateManagerConnection DeleteDnsAuthorizationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteDnsAuthorization(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteDnsAuthorization, (NoAwaitTag, google::cloud::certificatemanager::v1:: DeleteDnsAuthorizationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteDnsAuthorization(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, @@ -385,10 +628,15 @@ class MockCertificateManagerConnection GetCertificateIssuanceConfigRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateCertificateIssuanceConfig)` is now ambiguous. - /// Use `EXPECT_CALL(*mock, CreateCertificateIssuanceConfig(::testing::_))` - /// instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateCertificateIssuanceConfig(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -397,6 +645,12 @@ class MockCertificateManagerConnection CreateCertificateIssuanceConfigRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateCertificateIssuanceConfig(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateCertificateIssuanceConfig, (NoAwaitTag, @@ -404,16 +658,30 @@ class MockCertificateManagerConnection CreateCertificateIssuanceConfigRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateCertificateIssuanceConfig(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateCertificateIssuanceConfig, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteCertificateIssuanceConfig)` is now ambiguous. - /// Use `EXPECT_CALL(*mock, DeleteCertificateIssuanceConfig(::testing::_))` - /// instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteCertificateIssuanceConfig(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, @@ -422,6 +690,12 @@ class MockCertificateManagerConnection DeleteCertificateIssuanceConfigRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteCertificateIssuanceConfig(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteCertificateIssuanceConfig, (NoAwaitTag, @@ -429,6 +703,15 @@ class MockCertificateManagerConnection DeleteCertificateIssuanceConfigRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteCertificateIssuanceConfig(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, @@ -448,9 +731,15 @@ class MockCertificateManagerConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateTrustConfig)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateTrustConfig(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateTrustConfig(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateTrustConfig, @@ -458,6 +747,12 @@ class MockCertificateManagerConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateTrustConfig(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateTrustConfig, (NoAwaitTag, @@ -465,14 +760,28 @@ class MockCertificateManagerConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateTrustConfig(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateTrustConfig, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateTrustConfig)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateTrustConfig(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateTrustConfig(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateTrustConfig, @@ -480,6 +789,12 @@ class MockCertificateManagerConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateTrustConfig(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateTrustConfig, (NoAwaitTag, @@ -487,14 +802,28 @@ class MockCertificateManagerConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateTrustConfig(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateTrustConfig, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteTrustConfig)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteTrustConfig(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteTrustConfig(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, @@ -503,6 +832,12 @@ class MockCertificateManagerConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteTrustConfig(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteTrustConfig, (NoAwaitTag, @@ -510,6 +845,14 @@ class MockCertificateManagerConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteTrustConfig(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, diff --git a/google/cloud/channel/v1/mocks/mock_cloud_channel_connection.h b/google/cloud/channel/v1/mocks/mock_cloud_channel_connection.h index 84cd269b5a663..c54c3592a350c 100644 --- a/google/cloud/channel/v1/mocks/mock_cloud_channel_connection.h +++ b/google/cloud/channel/v1/mocks/mock_cloud_channel_connection.h @@ -84,21 +84,41 @@ class MockCloudChannelServiceConnection (google::cloud::channel::v1::ImportCustomerRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ProvisionCloudIdentity)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ProvisionCloudIdentity(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ProvisionCloudIdentity(Matcher(_))) + /// @endcode MOCK_METHOD(future>, ProvisionCloudIdentity, (google::cloud::channel::v1::ProvisionCloudIdentityRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ProvisionCloudIdentity(_, _)) + /// @endcode MOCK_METHOD(StatusOr, ProvisionCloudIdentity, (NoAwaitTag, google::cloud::channel::v1::ProvisionCloudIdentityRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ProvisionCloudIdentity(Matcher(_))) + /// @endcode MOCK_METHOD(future>, ProvisionCloudIdentity, (google::longrunning::Operation const& operation), (override)); @@ -124,159 +144,325 @@ class MockCloudChannelServiceConnection (google::cloud::channel::v1::GetEntitlementRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateEntitlement)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateEntitlement(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateEntitlement(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateEntitlement, (google::cloud::channel::v1::CreateEntitlementRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateEntitlement(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateEntitlement, (NoAwaitTag, google::cloud::channel::v1::CreateEntitlementRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateEntitlement(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateEntitlement, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ChangeParameters)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ChangeParameters(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ChangeParameters(Matcher(_))) + /// @endcode MOCK_METHOD( future>, ChangeParameters, (google::cloud::channel::v1::ChangeParametersRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ChangeParameters(_, _)) + /// @endcode MOCK_METHOD( StatusOr, ChangeParameters, (NoAwaitTag, google::cloud::channel::v1::ChangeParametersRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, ChangeParameters(Matcher(_))) + /// @endcode MOCK_METHOD(future>, ChangeParameters, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ChangeRenewalSettings)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ChangeRenewalSettings(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ChangeRenewalSettings(Matcher(_))) + /// @endcode MOCK_METHOD( future>, ChangeRenewalSettings, (google::cloud::channel::v1::ChangeRenewalSettingsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ChangeRenewalSettings(_, _)) + /// @endcode MOCK_METHOD( StatusOr, ChangeRenewalSettings, (NoAwaitTag, google::cloud::channel::v1::ChangeRenewalSettingsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ChangeRenewalSettings(Matcher(_))) + /// @endcode MOCK_METHOD(future>, ChangeRenewalSettings, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ChangeOffer)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ChangeOffer(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ChangeOffer(Matcher(_))) + /// @endcode MOCK_METHOD(future>, ChangeOffer, (google::cloud::channel::v1::ChangeOfferRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ChangeOffer(_, _)) + /// @endcode MOCK_METHOD(StatusOr, ChangeOffer, (NoAwaitTag, google::cloud::channel::v1::ChangeOfferRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, ChangeOffer(Matcher(_))) + /// @endcode MOCK_METHOD(future>, ChangeOffer, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, StartPaidService)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, StartPaidService(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// StartPaidService(Matcher(_))) + /// @endcode MOCK_METHOD( future>, StartPaidService, (google::cloud::channel::v1::StartPaidServiceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, StartPaidService(_, _)) + /// @endcode MOCK_METHOD( StatusOr, StartPaidService, (NoAwaitTag, google::cloud::channel::v1::StartPaidServiceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, StartPaidService(Matcher(_))) + /// @endcode MOCK_METHOD(future>, StartPaidService, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SuspendEntitlement)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SuspendEntitlement(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SuspendEntitlement(Matcher(_))) + /// @endcode MOCK_METHOD( future>, SuspendEntitlement, (google::cloud::channel::v1::SuspendEntitlementRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SuspendEntitlement(_, _)) + /// @endcode MOCK_METHOD( StatusOr, SuspendEntitlement, (NoAwaitTag, google::cloud::channel::v1::SuspendEntitlementRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SuspendEntitlement(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SuspendEntitlement, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CancelEntitlement)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CancelEntitlement(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CancelEntitlement(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CancelEntitlement, (google::cloud::channel::v1::CancelEntitlementRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CancelEntitlement(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CancelEntitlement, (NoAwaitTag, google::cloud::channel::v1::CancelEntitlementRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CancelEntitlement(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CancelEntitlement, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ActivateEntitlement)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ActivateEntitlement(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ActivateEntitlement(Matcher(_))) + /// @endcode MOCK_METHOD( future>, ActivateEntitlement, (google::cloud::channel::v1::ActivateEntitlementRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ActivateEntitlement(_, _)) + /// @endcode MOCK_METHOD( StatusOr, ActivateEntitlement, (NoAwaitTag, google::cloud::channel::v1::ActivateEntitlementRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ActivateEntitlement(Matcher(_))) + /// @endcode MOCK_METHOD(future>, ActivateEntitlement, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, TransferEntitlements)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, TransferEntitlements(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// TransferEntitlements(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, @@ -284,21 +470,41 @@ class MockCloudChannelServiceConnection (google::cloud::channel::v1::TransferEntitlementsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, TransferEntitlements(_, _)) + /// @endcode MOCK_METHOD( StatusOr, TransferEntitlements, (NoAwaitTag, google::cloud::channel::v1::TransferEntitlementsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// TransferEntitlements(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, TransferEntitlements, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, TransferEntitlementsToGoogle)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, TransferEntitlementsToGoogle(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// TransferEntitlementsToGoogle(Matcher(_))) + /// @endcode MOCK_METHOD( future>, TransferEntitlementsToGoogle, @@ -306,6 +512,12 @@ class MockCloudChannelServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, TransferEntitlementsToGoogle(_, _)) + /// @endcode MOCK_METHOD( StatusOr, TransferEntitlementsToGoogle, (NoAwaitTag, @@ -313,6 +525,15 @@ class MockCloudChannelServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// TransferEntitlementsToGoogle(Matcher(_))) + /// @endcode MOCK_METHOD(future>, TransferEntitlementsToGoogle, (google::longrunning::Operation const& operation), (override)); diff --git a/google/cloud/channel/v1/mocks/mock_cloud_channel_reports_connection.h b/google/cloud/channel/v1/mocks/mock_cloud_channel_reports_connection.h index da1dbab5c6b32..63ff37f2c82b6 100644 --- a/google/cloud/channel/v1/mocks/mock_cloud_channel_reports_connection.h +++ b/google/cloud/channel/v1/mocks/mock_cloud_channel_reports_connection.h @@ -47,20 +47,40 @@ class MockCloudChannelReportsServiceConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, RunReportJob)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, RunReportJob(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RunReportJob(Matcher(_))) + /// @endcode MOCK_METHOD( future>, RunReportJob, (google::cloud::channel::v1::RunReportJobRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, RunReportJob(_, _)) + /// @endcode MOCK_METHOD(StatusOr, RunReportJob, (NoAwaitTag, google::cloud::channel::v1::RunReportJobRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, RunReportJob(Matcher(_))) + /// @endcode MOCK_METHOD( future>, RunReportJob, (google::longrunning::Operation const& operation), diff --git a/google/cloud/cloudbuild/v1/mocks/mock_cloud_build_connection.h b/google/cloud/cloudbuild/v1/mocks/mock_cloud_build_connection.h index 062bef8eb4ad4..78d1cf43f44a4 100644 --- a/google/cloud/cloudbuild/v1/mocks/mock_cloud_build_connection.h +++ b/google/cloud/cloudbuild/v1/mocks/mock_cloud_build_connection.h @@ -46,20 +46,40 @@ class MockCloudBuildConnection : public cloudbuild_v1::CloudBuildConnection { public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateBuild)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateBuild(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateBuild(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateBuild, (google::devtools::cloudbuild::v1::CreateBuildRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateBuild(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateBuild, (NoAwaitTag, google::devtools::cloudbuild::v1::CreateBuildRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateBuild(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateBuild, (google::longrunning::Operation const& operation), (override)); @@ -79,38 +99,78 @@ class MockCloudBuildConnection : public cloudbuild_v1::CloudBuildConnection { (google::devtools::cloudbuild::v1::CancelBuildRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, RetryBuild)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, RetryBuild(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RetryBuild(Matcher(_))) + /// @endcode MOCK_METHOD( future>, RetryBuild, (google::devtools::cloudbuild::v1::RetryBuildRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, RetryBuild(_, _)) + /// @endcode MOCK_METHOD( StatusOr, RetryBuild, (NoAwaitTag, google::devtools::cloudbuild::v1::RetryBuildRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, RetryBuild(Matcher(_))) + /// @endcode MOCK_METHOD(future>, RetryBuild, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ApproveBuild)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ApproveBuild(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ApproveBuild(Matcher(_))) + /// @endcode MOCK_METHOD( future>, ApproveBuild, (google::devtools::cloudbuild::v1::ApproveBuildRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ApproveBuild(_, _)) + /// @endcode MOCK_METHOD( StatusOr, ApproveBuild, (NoAwaitTag, google::devtools::cloudbuild::v1::ApproveBuildRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, ApproveBuild(Matcher(_))) + /// @endcode MOCK_METHOD(future>, ApproveBuild, (google::longrunning::Operation const& operation), (override)); @@ -146,21 +206,41 @@ class MockCloudBuildConnection : public cloudbuild_v1::CloudBuildConnection { request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, RunBuildTrigger)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, RunBuildTrigger(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RunBuildTrigger(Matcher(_))) + /// @endcode MOCK_METHOD( future>, RunBuildTrigger, (google::devtools::cloudbuild::v1::RunBuildTriggerRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, RunBuildTrigger(_, _)) + /// @endcode MOCK_METHOD( StatusOr, RunBuildTrigger, (NoAwaitTag, google::devtools::cloudbuild::v1::RunBuildTriggerRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, RunBuildTrigger(Matcher(_))) + /// @endcode MOCK_METHOD(future>, RunBuildTrigger, (google::longrunning::Operation const& operation), (override)); @@ -172,21 +252,41 @@ class MockCloudBuildConnection : public cloudbuild_v1::CloudBuildConnection { request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateWorkerPool)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateWorkerPool(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateWorkerPool(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateWorkerPool, (google::devtools::cloudbuild::v1::CreateWorkerPoolRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateWorkerPool(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateWorkerPool, (NoAwaitTag, google::devtools::cloudbuild::v1::CreateWorkerPoolRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateWorkerPool(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateWorkerPool, (google::longrunning::Operation const& operation), (override)); @@ -196,9 +296,15 @@ class MockCloudBuildConnection : public cloudbuild_v1::CloudBuildConnection { (google::devtools::cloudbuild::v1::GetWorkerPoolRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteWorkerPool)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteWorkerPool(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteWorkerPool(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -207,33 +313,67 @@ class MockCloudBuildConnection : public cloudbuild_v1::CloudBuildConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteWorkerPool(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteWorkerPool, (NoAwaitTag, google::devtools::cloudbuild::v1::DeleteWorkerPoolRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteWorkerPool(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteWorkerPool, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateWorkerPool)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateWorkerPool(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateWorkerPool(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateWorkerPool, (google::devtools::cloudbuild::v1::UpdateWorkerPoolRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateWorkerPool(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateWorkerPool, (NoAwaitTag, google::devtools::cloudbuild::v1::UpdateWorkerPoolRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateWorkerPool(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateWorkerPool, (google::longrunning::Operation const& operation), (override)); diff --git a/google/cloud/cloudbuild/v2/mocks/mock_repository_manager_connection.h b/google/cloud/cloudbuild/v2/mocks/mock_repository_manager_connection.h index 4425657a5679a..255b4d36231ea 100644 --- a/google/cloud/cloudbuild/v2/mocks/mock_repository_manager_connection.h +++ b/google/cloud/cloudbuild/v2/mocks/mock_repository_manager_connection.h @@ -47,21 +47,41 @@ class MockRepositoryManagerConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateConnection)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateConnection(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateConnection(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateConnection, (google::devtools::cloudbuild::v2::CreateConnectionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateConnection(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateConnection, (NoAwaitTag, google::devtools::cloudbuild::v2::CreateConnectionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateConnection(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateConnection, (google::longrunning::Operation const& operation), (override)); @@ -77,28 +97,54 @@ class MockRepositoryManagerConnection (google::devtools::cloudbuild::v2::ListConnectionsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateConnection)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateConnection(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateConnection(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateConnection, (google::devtools::cloudbuild::v2::UpdateConnectionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateConnection(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateConnection, (NoAwaitTag, google::devtools::cloudbuild::v2::UpdateConnectionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateConnection(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateConnection, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteConnection)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteConnection(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteConnection(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteConnection, @@ -106,39 +152,79 @@ class MockRepositoryManagerConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteConnection(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteConnection, (NoAwaitTag, google::devtools::cloudbuild::v2::DeleteConnectionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteConnection(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteConnection, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateRepository)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateRepository(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateRepository(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateRepository, (google::devtools::cloudbuild::v2::CreateRepositoryRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateRepository(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateRepository, (NoAwaitTag, google::devtools::cloudbuild::v2::CreateRepositoryRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateRepository(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateRepository, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, BatchCreateRepositories)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, BatchCreateRepositories(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// BatchCreateRepositories(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -147,6 +233,12 @@ class MockRepositoryManagerConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, BatchCreateRepositories(_, _)) + /// @endcode MOCK_METHOD( StatusOr, BatchCreateRepositories, (NoAwaitTag, @@ -154,6 +246,15 @@ class MockRepositoryManagerConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// BatchCreateRepositories(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -171,9 +272,15 @@ class MockRepositoryManagerConnection (google::devtools::cloudbuild::v2::ListRepositoriesRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteRepository)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteRepository(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteRepository(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteRepository, @@ -181,12 +288,26 @@ class MockRepositoryManagerConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteRepository(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteRepository, (NoAwaitTag, google::devtools::cloudbuild::v2::DeleteRepositoryRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteRepository(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteRepository, (google::longrunning::Operation const& operation), diff --git a/google/cloud/commerce/consumer/procurement/v1/mocks/mock_consumer_procurement_connection.h b/google/cloud/commerce/consumer/procurement/v1/mocks/mock_consumer_procurement_connection.h index e85628132a628..136c16dc9609b 100644 --- a/google/cloud/commerce/consumer/procurement/v1/mocks/mock_consumer_procurement_connection.h +++ b/google/cloud/commerce/consumer/procurement/v1/mocks/mock_consumer_procurement_connection.h @@ -49,9 +49,15 @@ class MockConsumerProcurementServiceConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, PlaceOrder)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, PlaceOrder(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PlaceOrder(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, @@ -60,11 +66,25 @@ class MockConsumerProcurementServiceConnection PlaceOrderRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, PlaceOrder(_, _)) + /// @endcode MOCK_METHOD(StatusOr, PlaceOrder, (NoAwaitTag, google::cloud::commerce::consumer::procurement::v1:: PlaceOrderRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, PlaceOrder(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, diff --git a/google/cloud/composer/v1/mocks/mock_environments_connection.h b/google/cloud/composer/v1/mocks/mock_environments_connection.h index 8b245c60e19e7..572718dab5ea7 100644 --- a/google/cloud/composer/v1/mocks/mock_environments_connection.h +++ b/google/cloud/composer/v1/mocks/mock_environments_connection.h @@ -46,9 +46,15 @@ class MockEnvironmentsConnection : public composer_v1::EnvironmentsConnection { public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateEnvironment)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateEnvironment(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateEnvironment(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -57,11 +63,25 @@ class MockEnvironmentsConnection : public composer_v1::EnvironmentsConnection { CreateEnvironmentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateEnvironment(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateEnvironment, (NoAwaitTag, google::cloud::orchestration::airflow::service::v1:: CreateEnvironmentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateEnvironment(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -83,9 +103,15 @@ class MockEnvironmentsConnection : public composer_v1::EnvironmentsConnection { ListEnvironmentsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateEnvironment)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateEnvironment(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateEnvironment(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -94,20 +120,40 @@ class MockEnvironmentsConnection : public composer_v1::EnvironmentsConnection { UpdateEnvironmentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateEnvironment(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateEnvironment, (NoAwaitTag, google::cloud::orchestration::airflow::service::v1:: UpdateEnvironmentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateEnvironment(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateEnvironment, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteEnvironment)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteEnvironment(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteEnvironment(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteEnvironment, @@ -115,11 +161,25 @@ class MockEnvironmentsConnection : public composer_v1::EnvironmentsConnection { DeleteEnvironmentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteEnvironment(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteEnvironment, (NoAwaitTag, google::cloud::orchestration::airflow::service::v1:: DeleteEnvironmentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteEnvironment(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteEnvironment, @@ -220,9 +280,15 @@ class MockEnvironmentsConnection : public composer_v1::EnvironmentsConnection { DeleteUserWorkloadsConfigMapRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SaveSnapshot)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SaveSnapshot(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SaveSnapshot(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SaveSnapshot, @@ -230,19 +296,39 @@ class MockEnvironmentsConnection : public composer_v1::EnvironmentsConnection { SaveSnapshotRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SaveSnapshot(_, _)) + /// @endcode MOCK_METHOD(StatusOr, SaveSnapshot, (NoAwaitTag, google::cloud::orchestration::airflow::service::v1:: SaveSnapshotRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, SaveSnapshot(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SaveSnapshot, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, LoadSnapshot)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, LoadSnapshot(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// LoadSnapshot(Matcher(_))) + /// @endcode MOCK_METHOD(future>, LoadSnapshot, @@ -250,19 +336,39 @@ class MockEnvironmentsConnection : public composer_v1::EnvironmentsConnection { LoadSnapshotRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, LoadSnapshot(_, _)) + /// @endcode MOCK_METHOD(StatusOr, LoadSnapshot, (NoAwaitTag, google::cloud::orchestration::airflow::service::v1:: LoadSnapshotRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, LoadSnapshot(Matcher(_))) + /// @endcode MOCK_METHOD(future>, LoadSnapshot, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DatabaseFailover)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DatabaseFailover(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DatabaseFailover(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DatabaseFailover, @@ -270,11 +376,25 @@ class MockEnvironmentsConnection : public composer_v1::EnvironmentsConnection { DatabaseFailoverRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DatabaseFailover(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DatabaseFailover, (NoAwaitTag, google::cloud::orchestration::airflow::service::v1:: DatabaseFailoverRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DatabaseFailover(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DatabaseFailover, diff --git a/google/cloud/compute/addresses/v1/mocks/mock_addresses_connection.h b/google/cloud/compute/addresses/v1/mocks/mock_addresses_connection.h index 938e4ef397906..c1a2a48b0fe37 100644 --- a/google/cloud/compute/addresses/v1/mocks/mock_addresses_connection.h +++ b/google/cloud/compute/addresses/v1/mocks/mock_addresses_connection.h @@ -55,9 +55,15 @@ class MockAddressesConnection AggregatedListAddressesRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteAddress)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteAddress(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteAddress(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteAddress, @@ -65,6 +71,12 @@ class MockAddressesConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteAddress(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteAddress, (NoAwaitTag, @@ -72,6 +84,15 @@ class MockAddressesConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteAddress(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteAddress, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -83,9 +104,15 @@ class MockAddressesConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InsertAddress)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, InsertAddress(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertAddress(Matcher(_))) + /// @endcode MOCK_METHOD( future>, InsertAddress, @@ -93,6 +120,12 @@ class MockAddressesConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InsertAddress(_, _)) + /// @endcode MOCK_METHOD( StatusOr, InsertAddress, (NoAwaitTag, @@ -100,6 +133,15 @@ class MockAddressesConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertAddress(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertAddress, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -111,34 +153,66 @@ class MockAddressesConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, Move)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, Move(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// Move(Matcher(_))) + /// @endcode MOCK_METHOD( future>, Move, (google::cloud::cpp::compute::addresses::v1::MoveRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, Move(_, _)) + /// @endcode MOCK_METHOD( StatusOr, Move, (NoAwaitTag, google::cloud::cpp::compute::addresses::v1::MoveRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, Move(Matcher(_))) + /// @endcode MOCK_METHOD(future>, Move, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SetLabels)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SetLabels(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetLabels(Matcher(_))) + /// @endcode MOCK_METHOD( future>, SetLabels, (google::cloud::cpp::compute::addresses::v1::SetLabelsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SetLabels(_, _)) + /// @endcode MOCK_METHOD( StatusOr, SetLabels, (NoAwaitTag, @@ -146,6 +220,14 @@ class MockAddressesConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetLabels(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetLabels, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/autoscalers/v1/mocks/mock_autoscalers_connection.h b/google/cloud/compute/autoscalers/v1/mocks/mock_autoscalers_connection.h index e2b506997c31d..fda7bdec4b24c 100644 --- a/google/cloud/compute/autoscalers/v1/mocks/mock_autoscalers_connection.h +++ b/google/cloud/compute/autoscalers/v1/mocks/mock_autoscalers_connection.h @@ -56,21 +56,42 @@ class MockAutoscalersConnection AggregatedListAutoscalersRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteAutoscaler)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteAutoscaler(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteAutoscaler(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteAutoscaler, (google::cloud::cpp::compute::autoscalers::v1:: DeleteAutoscalerRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteAutoscaler(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteAutoscaler, (NoAwaitTag, google::cloud::cpp::compute::autoscalers::v1:: DeleteAutoscalerRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteAutoscaler(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteAutoscaler, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -82,21 +103,42 @@ class MockAutoscalersConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InsertAutoscaler)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, InsertAutoscaler(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertAutoscaler(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertAutoscaler, (google::cloud::cpp::compute::autoscalers::v1:: InsertAutoscalerRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InsertAutoscaler(_, _)) + /// @endcode MOCK_METHOD(StatusOr, InsertAutoscaler, (NoAwaitTag, google::cloud::cpp::compute::autoscalers::v1:: InsertAutoscalerRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertAutoscaler(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertAutoscaler, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -109,41 +151,83 @@ class MockAutoscalersConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, PatchAutoscaler)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, PatchAutoscaler(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchAutoscaler(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchAutoscaler, (google::cloud::cpp::compute::autoscalers::v1:: PatchAutoscalerRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, PatchAutoscaler(_, _)) + /// @endcode MOCK_METHOD(StatusOr, PatchAutoscaler, (NoAwaitTag, google::cloud::cpp::compute::autoscalers::v1:: PatchAutoscalerRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchAutoscaler(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchAutoscaler, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateAutoscaler)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateAutoscaler(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateAutoscaler(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateAutoscaler, (google::cloud::cpp::compute::autoscalers::v1:: UpdateAutoscalerRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateAutoscaler(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateAutoscaler, (NoAwaitTag, google::cloud::cpp::compute::autoscalers::v1:: UpdateAutoscalerRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateAutoscaler(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateAutoscaler, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/backend_buckets/v1/mocks/mock_backend_buckets_connection.h b/google/cloud/compute/backend_buckets/v1/mocks/mock_backend_buckets_connection.h index ff52106e69026..d6886f787bb43 100644 --- a/google/cloud/compute/backend_buckets/v1/mocks/mock_backend_buckets_connection.h +++ b/google/cloud/compute/backend_buckets/v1/mocks/mock_backend_buckets_connection.h @@ -47,61 +47,124 @@ class MockBackendBucketsConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, AddSignedUrlKey)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, AddSignedUrlKey(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// AddSignedUrlKey(Matcher(_))) + /// @endcode MOCK_METHOD(future>, AddSignedUrlKey, (google::cloud::cpp::compute::backend_buckets::v1:: AddSignedUrlKeyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, AddSignedUrlKey(_, _)) + /// @endcode MOCK_METHOD(StatusOr, AddSignedUrlKey, (NoAwaitTag, google::cloud::cpp::compute::backend_buckets::v1:: AddSignedUrlKeyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// AddSignedUrlKey(Matcher(_))) + /// @endcode MOCK_METHOD(future>, AddSignedUrlKey, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteBackendBucket)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteBackendBucket(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteBackendBucket(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteBackendBucket, (google::cloud::cpp::compute::backend_buckets::v1:: DeleteBackendBucketRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteBackendBucket(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteBackendBucket, (NoAwaitTag, google::cloud::cpp::compute::backend_buckets::v1:: DeleteBackendBucketRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteBackendBucket(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteBackendBucket, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteSignedUrlKey)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteSignedUrlKey(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteSignedUrlKey(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteSignedUrlKey, (google::cloud::cpp::compute::backend_buckets::v1:: DeleteSignedUrlKeyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteSignedUrlKey(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteSignedUrlKey, (NoAwaitTag, google::cloud::cpp::compute::backend_buckets::v1:: DeleteSignedUrlKeyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteSignedUrlKey(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteSignedUrlKey, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -118,21 +181,42 @@ class MockBackendBucketsConnection GetIamPolicyRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InsertBackendBucket)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, InsertBackendBucket(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertBackendBucket(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertBackendBucket, (google::cloud::cpp::compute::backend_buckets::v1:: InsertBackendBucketRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InsertBackendBucket(_, _)) + /// @endcode MOCK_METHOD(StatusOr, InsertBackendBucket, (NoAwaitTag, google::cloud::cpp::compute::backend_buckets::v1:: InsertBackendBucketRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertBackendBucket(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertBackendBucket, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -144,41 +228,83 @@ class MockBackendBucketsConnection ListBackendBucketsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, PatchBackendBucket)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, PatchBackendBucket(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchBackendBucket(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchBackendBucket, (google::cloud::cpp::compute::backend_buckets::v1:: PatchBackendBucketRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, PatchBackendBucket(_, _)) + /// @endcode MOCK_METHOD(StatusOr, PatchBackendBucket, (NoAwaitTag, google::cloud::cpp::compute::backend_buckets::v1:: PatchBackendBucketRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchBackendBucket(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchBackendBucket, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SetEdgeSecurityPolicy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SetEdgeSecurityPolicy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetEdgeSecurityPolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetEdgeSecurityPolicy, (google::cloud::cpp::compute::backend_buckets::v1:: SetEdgeSecurityPolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SetEdgeSecurityPolicy(_, _)) + /// @endcode MOCK_METHOD(StatusOr, SetEdgeSecurityPolicy, (NoAwaitTag, google::cloud::cpp::compute::backend_buckets::v1:: SetEdgeSecurityPolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetEdgeSecurityPolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetEdgeSecurityPolicy, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -196,21 +322,42 @@ class MockBackendBucketsConnection TestIamPermissionsRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateBackendBucket)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateBackendBucket(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateBackendBucket(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateBackendBucket, (google::cloud::cpp::compute::backend_buckets::v1:: UpdateBackendBucketRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateBackendBucket(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateBackendBucket, (NoAwaitTag, google::cloud::cpp::compute::backend_buckets::v1:: UpdateBackendBucketRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateBackendBucket(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateBackendBucket, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/backend_services/v1/mocks/mock_backend_services_connection.h b/google/cloud/compute/backend_services/v1/mocks/mock_backend_services_connection.h index 702befbf8d24f..7b09990eafe59 100644 --- a/google/cloud/compute/backend_services/v1/mocks/mock_backend_services_connection.h +++ b/google/cloud/compute/backend_services/v1/mocks/mock_backend_services_connection.h @@ -47,21 +47,42 @@ class MockBackendServicesConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, AddSignedUrlKey)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, AddSignedUrlKey(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// AddSignedUrlKey(Matcher(_))) + /// @endcode MOCK_METHOD(future>, AddSignedUrlKey, (google::cloud::cpp::compute::backend_services::v1:: AddSignedUrlKeyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, AddSignedUrlKey(_, _)) + /// @endcode MOCK_METHOD(StatusOr, AddSignedUrlKey, (NoAwaitTag, google::cloud::cpp::compute::backend_services::v1:: AddSignedUrlKeyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// AddSignedUrlKey(Matcher(_))) + /// @endcode MOCK_METHOD(future>, AddSignedUrlKey, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -75,41 +96,83 @@ class MockBackendServicesConnection AggregatedListBackendServicesRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteBackendService)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteBackendService(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteBackendService(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteBackendService, (google::cloud::cpp::compute::backend_services::v1:: DeleteBackendServiceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteBackendService(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteBackendService, (NoAwaitTag, google::cloud::cpp::compute::backend_services::v1:: DeleteBackendServiceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteBackendService(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteBackendService, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteSignedUrlKey)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteSignedUrlKey(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteSignedUrlKey(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteSignedUrlKey, (google::cloud::cpp::compute::backend_services::v1:: DeleteSignedUrlKeyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteSignedUrlKey(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteSignedUrlKey, (NoAwaitTag, google::cloud::cpp::compute::backend_services::v1:: DeleteSignedUrlKeyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteSignedUrlKey(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteSignedUrlKey, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -133,21 +196,42 @@ class MockBackendServicesConnection GetIamPolicyRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InsertBackendService)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, InsertBackendService(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertBackendService(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertBackendService, (google::cloud::cpp::compute::backend_services::v1:: InsertBackendServiceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InsertBackendService(_, _)) + /// @endcode MOCK_METHOD(StatusOr, InsertBackendService, (NoAwaitTag, google::cloud::cpp::compute::backend_services::v1:: InsertBackendServiceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertBackendService(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertBackendService, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -166,41 +250,83 @@ class MockBackendServicesConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, PatchBackendService)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, PatchBackendService(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchBackendService(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchBackendService, (google::cloud::cpp::compute::backend_services::v1:: PatchBackendServiceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, PatchBackendService(_, _)) + /// @endcode MOCK_METHOD(StatusOr, PatchBackendService, (NoAwaitTag, google::cloud::cpp::compute::backend_services::v1:: PatchBackendServiceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchBackendService(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchBackendService, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SetEdgeSecurityPolicy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SetEdgeSecurityPolicy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetEdgeSecurityPolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetEdgeSecurityPolicy, (google::cloud::cpp::compute::backend_services::v1:: SetEdgeSecurityPolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SetEdgeSecurityPolicy(_, _)) + /// @endcode MOCK_METHOD(StatusOr, SetEdgeSecurityPolicy, (NoAwaitTag, google::cloud::cpp::compute::backend_services::v1:: SetEdgeSecurityPolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetEdgeSecurityPolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetEdgeSecurityPolicy, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -211,21 +337,42 @@ class MockBackendServicesConnection SetIamPolicyRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SetSecurityPolicy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SetSecurityPolicy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetSecurityPolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetSecurityPolicy, (google::cloud::cpp::compute::backend_services::v1:: SetSecurityPolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SetSecurityPolicy(_, _)) + /// @endcode MOCK_METHOD(StatusOr, SetSecurityPolicy, (NoAwaitTag, google::cloud::cpp::compute::backend_services::v1:: SetSecurityPolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetSecurityPolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetSecurityPolicy, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -238,21 +385,42 @@ class MockBackendServicesConnection TestIamPermissionsRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateBackendService)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateBackendService(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateBackendService(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateBackendService, (google::cloud::cpp::compute::backend_services::v1:: UpdateBackendServiceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateBackendService(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateBackendService, (NoAwaitTag, google::cloud::cpp::compute::backend_services::v1:: UpdateBackendServiceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateBackendService(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateBackendService, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/disks/v1/mocks/mock_disks_connection.h b/google/cloud/compute/disks/v1/mocks/mock_disks_connection.h index afa14ffae08ec..a4a5578e09905 100644 --- a/google/cloud/compute/disks/v1/mocks/mock_disks_connection.h +++ b/google/cloud/compute/disks/v1/mocks/mock_disks_connection.h @@ -46,9 +46,15 @@ class MockDisksConnection : public compute_disks_v1::DisksConnection { public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, AddResourcePolicies)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, AddResourcePolicies(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// AddResourcePolicies(Matcher(_))) + /// @endcode MOCK_METHOD( future>, AddResourcePolicies, @@ -56,6 +62,12 @@ class MockDisksConnection : public compute_disks_v1::DisksConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, AddResourcePolicies(_, _)) + /// @endcode MOCK_METHOD( StatusOr, AddResourcePolicies, (NoAwaitTag, @@ -63,6 +75,15 @@ class MockDisksConnection : public compute_disks_v1::DisksConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// AddResourcePolicies(Matcher(_))) + /// @endcode MOCK_METHOD(future>, AddResourcePolicies, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -76,29 +97,55 @@ class MockDisksConnection : public compute_disks_v1::DisksConnection { request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, BulkInsert)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, BulkInsert(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// BulkInsert(Matcher(_))) + /// @endcode MOCK_METHOD(future>, BulkInsert, (google::cloud::cpp::compute::disks::v1::BulkInsertRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, BulkInsert(_, _)) + /// @endcode MOCK_METHOD(StatusOr, BulkInsert, (NoAwaitTag, google::cloud::cpp::compute::disks::v1::BulkInsertRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// BulkInsert(Matcher(_))) + /// @endcode MOCK_METHOD(future>, BulkInsert, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateSnapshot)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateSnapshot(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateSnapshot(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateSnapshot, @@ -106,6 +153,12 @@ class MockDisksConnection : public compute_disks_v1::DisksConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateSnapshot(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateSnapshot, (NoAwaitTag, @@ -113,26 +166,55 @@ class MockDisksConnection : public compute_disks_v1::DisksConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateSnapshot(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateSnapshot, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteDisk)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteDisk(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteDisk(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteDisk, (google::cloud::cpp::compute::disks::v1::DeleteDiskRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteDisk(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteDisk, (NoAwaitTag, google::cloud::cpp::compute::disks::v1::DeleteDiskRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteDisk(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteDisk, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -149,21 +231,41 @@ class MockDisksConnection : public compute_disks_v1::DisksConnection { request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InsertDisk)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, InsertDisk(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertDisk(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertDisk, (google::cloud::cpp::compute::disks::v1::InsertDiskRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InsertDisk(_, _)) + /// @endcode MOCK_METHOD(StatusOr, InsertDisk, (NoAwaitTag, google::cloud::cpp::compute::disks::v1::InsertDiskRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertDisk(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertDisk, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -174,40 +276,81 @@ class MockDisksConnection : public compute_disks_v1::DisksConnection { (google::cloud::cpp::compute::disks::v1::ListDisksRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, RemoveResourcePolicies)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, RemoveResourcePolicies(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RemoveResourcePolicies(Matcher(_))) + /// @endcode MOCK_METHOD(future>, RemoveResourcePolicies, (google::cloud::cpp::compute::disks::v1:: RemoveResourcePoliciesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, RemoveResourcePolicies(_, _)) + /// @endcode MOCK_METHOD(StatusOr, RemoveResourcePolicies, (NoAwaitTag, google::cloud::cpp::compute::disks::v1:: RemoveResourcePoliciesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RemoveResourcePolicies(Matcher(_))) + /// @endcode MOCK_METHOD(future>, RemoveResourcePolicies, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, Resize)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, Resize(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// Resize(Matcher(_))) + /// @endcode MOCK_METHOD( future>, Resize, (google::cloud::cpp::compute::disks::v1::ResizeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, Resize(_, _)) + /// @endcode MOCK_METHOD( StatusOr, Resize, (NoAwaitTag, google::cloud::cpp::compute::disks::v1::ResizeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// Resize(Matcher(_))) + /// @endcode MOCK_METHOD(future>, Resize, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -219,80 +362,163 @@ class MockDisksConnection : public compute_disks_v1::DisksConnection { request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SetLabels)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SetLabels(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetLabels(Matcher(_))) + /// @endcode MOCK_METHOD( future>, SetLabels, (google::cloud::cpp::compute::disks::v1::SetLabelsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SetLabels(_, _)) + /// @endcode MOCK_METHOD( StatusOr, SetLabels, (NoAwaitTag, google::cloud::cpp::compute::disks::v1::SetLabelsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetLabels(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetLabels, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, StartAsyncReplication)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, StartAsyncReplication(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// StartAsyncReplication(Matcher(_))) + /// @endcode MOCK_METHOD(future>, StartAsyncReplication, (google::cloud::cpp::compute::disks::v1:: StartAsyncReplicationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, StartAsyncReplication(_, _)) + /// @endcode MOCK_METHOD(StatusOr, StartAsyncReplication, (NoAwaitTag, google::cloud::cpp::compute::disks::v1:: StartAsyncReplicationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// StartAsyncReplication(Matcher(_))) + /// @endcode MOCK_METHOD(future>, StartAsyncReplication, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, StopAsyncReplication)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, StopAsyncReplication(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// StopAsyncReplication(Matcher(_))) + /// @endcode MOCK_METHOD(future>, StopAsyncReplication, (google::cloud::cpp::compute::disks::v1:: StopAsyncReplicationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, StopAsyncReplication(_, _)) + /// @endcode MOCK_METHOD(StatusOr, StopAsyncReplication, (NoAwaitTag, google::cloud::cpp::compute::disks::v1:: StopAsyncReplicationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// StopAsyncReplication(Matcher(_))) + /// @endcode MOCK_METHOD(future>, StopAsyncReplication, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, StopGroupAsyncReplication)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, StopGroupAsyncReplication(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// StopGroupAsyncReplication(Matcher(_))) + /// @endcode MOCK_METHOD(future>, StopGroupAsyncReplication, (google::cloud::cpp::compute::disks::v1:: StopGroupAsyncReplicationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, StopGroupAsyncReplication(_, _)) + /// @endcode MOCK_METHOD(StatusOr, StopGroupAsyncReplication, (NoAwaitTag, google::cloud::cpp::compute::disks::v1:: StopGroupAsyncReplicationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// StopGroupAsyncReplication(Matcher(_))) + /// @endcode MOCK_METHOD(future>, StopGroupAsyncReplication, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -305,21 +531,41 @@ class MockDisksConnection : public compute_disks_v1::DisksConnection { request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateDisk)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateDisk(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateDisk(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateDisk, (google::cloud::cpp::compute::disks::v1::UpdateDiskRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateDisk(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateDisk, (NoAwaitTag, google::cloud::cpp::compute::disks::v1::UpdateDiskRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateDisk(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateDisk, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/external_vpn_gateways/v1/mocks/mock_external_vpn_gateways_connection.h b/google/cloud/compute/external_vpn_gateways/v1/mocks/mock_external_vpn_gateways_connection.h index 60927d8e70ad7..1d52d31e84b7f 100644 --- a/google/cloud/compute/external_vpn_gateways/v1/mocks/mock_external_vpn_gateways_connection.h +++ b/google/cloud/compute/external_vpn_gateways/v1/mocks/mock_external_vpn_gateways_connection.h @@ -48,15 +48,27 @@ class MockExternalVpnGatewaysConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteExternalVpnGateway)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteExternalVpnGateway(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteExternalVpnGateway(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteExternalVpnGateway, (google::cloud::cpp::compute::external_vpn_gateways::v1:: DeleteExternalVpnGatewayRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteExternalVpnGateway(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteExternalVpnGateway, (NoAwaitTag, @@ -64,6 +76,15 @@ class MockExternalVpnGatewaysConnection DeleteExternalVpnGatewayRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteExternalVpnGateway(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteExternalVpnGateway, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -75,15 +96,27 @@ class MockExternalVpnGatewaysConnection GetExternalVpnGatewayRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InsertExternalVpnGateway)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, InsertExternalVpnGateway(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertExternalVpnGateway(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertExternalVpnGateway, (google::cloud::cpp::compute::external_vpn_gateways::v1:: InsertExternalVpnGatewayRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InsertExternalVpnGateway(_, _)) + /// @endcode MOCK_METHOD(StatusOr, InsertExternalVpnGateway, (NoAwaitTag, @@ -91,6 +124,15 @@ class MockExternalVpnGatewaysConnection InsertExternalVpnGatewayRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertExternalVpnGateway(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertExternalVpnGateway, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -103,20 +145,40 @@ class MockExternalVpnGatewaysConnection ListExternalVpnGatewaysRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SetLabels)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SetLabels(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetLabels(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetLabels, (google::cloud::cpp::compute::external_vpn_gateways::v1:: SetLabelsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SetLabels(_, _)) + /// @endcode MOCK_METHOD(StatusOr, SetLabels, (NoAwaitTag, google::cloud::cpp::compute::external_vpn_gateways:: v1::SetLabelsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetLabels(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetLabels, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/firewall_policies/v1/mocks/mock_firewall_policies_connection.h b/google/cloud/compute/firewall_policies/v1/mocks/mock_firewall_policies_connection.h index 149fe7e381125..3ac5c2c2b84d7 100644 --- a/google/cloud/compute/firewall_policies/v1/mocks/mock_firewall_policies_connection.h +++ b/google/cloud/compute/firewall_policies/v1/mocks/mock_firewall_policies_connection.h @@ -47,35 +47,68 @@ class MockFirewallPoliciesConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, AddAssociation)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, AddAssociation(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// AddAssociation(Matcher(_))) + /// @endcode MOCK_METHOD(future>, AddAssociation, (google::cloud::cpp::compute::firewall_policies::v1:: AddAssociationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, AddAssociation(_, _)) + /// @endcode MOCK_METHOD(StatusOr, AddAssociation, (NoAwaitTag, google::cloud::cpp::compute::firewall_policies::v1:: AddAssociationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// AddAssociation(Matcher(_))) + /// @endcode MOCK_METHOD(future>, AddAssociation, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, AddRule)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, AddRule(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// AddRule(Matcher(_))) + /// @endcode MOCK_METHOD( future>, AddRule, (google::cloud::cpp::compute::firewall_policies::v1::AddRuleRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, AddRule(_, _)) + /// @endcode MOCK_METHOD( StatusOr, AddRule, (NoAwaitTag, @@ -83,45 +116,94 @@ class MockFirewallPoliciesConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// AddRule(Matcher(_))) + /// @endcode MOCK_METHOD(future>, AddRule, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CloneRules)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CloneRules(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CloneRules(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CloneRules, (google::cloud::cpp::compute::firewall_policies::v1:: CloneRulesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CloneRules(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CloneRules, (NoAwaitTag, google::cloud::cpp::compute::firewall_policies::v1:: CloneRulesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CloneRules(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CloneRules, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteFirewallPolicy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteFirewallPolicy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteFirewallPolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteFirewallPolicy, (google::cloud::cpp::compute::firewall_policies::v1:: DeleteFirewallPolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteFirewallPolicy(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteFirewallPolicy, (NoAwaitTag, google::cloud::cpp::compute::firewall_policies::v1:: DeleteFirewallPolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteFirewallPolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteFirewallPolicy, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -151,21 +233,42 @@ class MockFirewallPoliciesConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InsertFirewallPolicy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, InsertFirewallPolicy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertFirewallPolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertFirewallPolicy, (google::cloud::cpp::compute::firewall_policies::v1:: InsertFirewallPolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InsertFirewallPolicy(_, _)) + /// @endcode MOCK_METHOD(StatusOr, InsertFirewallPolicy, (NoAwaitTag, google::cloud::cpp::compute::firewall_policies::v1:: InsertFirewallPolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertFirewallPolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertFirewallPolicy, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -184,15 +287,27 @@ class MockFirewallPoliciesConnection ListAssociationsRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, Move)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, Move(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// Move(Matcher(_))) + /// @endcode MOCK_METHOD( future>, Move, (google::cloud::cpp::compute::firewall_policies::v1::MoveRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, Move(_, _)) + /// @endcode MOCK_METHOD( StatusOr, Move, (NoAwaitTag, @@ -200,84 +315,174 @@ class MockFirewallPoliciesConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, Move(Matcher(_))) + /// @endcode MOCK_METHOD(future>, Move, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, PatchFirewallPolicy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, PatchFirewallPolicy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchFirewallPolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchFirewallPolicy, (google::cloud::cpp::compute::firewall_policies::v1:: PatchFirewallPolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, PatchFirewallPolicy(_, _)) + /// @endcode MOCK_METHOD(StatusOr, PatchFirewallPolicy, (NoAwaitTag, google::cloud::cpp::compute::firewall_policies::v1:: PatchFirewallPolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchFirewallPolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchFirewallPolicy, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, PatchRule)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, PatchRule(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchRule(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchRule, (google::cloud::cpp::compute::firewall_policies::v1:: PatchRuleRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, PatchRule(_, _)) + /// @endcode MOCK_METHOD(StatusOr, PatchRule, (NoAwaitTag, google::cloud::cpp::compute::firewall_policies::v1:: PatchRuleRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchRule(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchRule, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, RemoveAssociation)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, RemoveAssociation(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RemoveAssociation(Matcher(_))) + /// @endcode MOCK_METHOD(future>, RemoveAssociation, (google::cloud::cpp::compute::firewall_policies::v1:: RemoveAssociationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, RemoveAssociation(_, _)) + /// @endcode MOCK_METHOD(StatusOr, RemoveAssociation, (NoAwaitTag, google::cloud::cpp::compute::firewall_policies::v1:: RemoveAssociationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RemoveAssociation(Matcher(_))) + /// @endcode MOCK_METHOD(future>, RemoveAssociation, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, RemoveRule)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, RemoveRule(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RemoveRule(Matcher(_))) + /// @endcode MOCK_METHOD(future>, RemoveRule, (google::cloud::cpp::compute::firewall_policies::v1:: RemoveRuleRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, RemoveRule(_, _)) + /// @endcode MOCK_METHOD(StatusOr, RemoveRule, (NoAwaitTag, google::cloud::cpp::compute::firewall_policies::v1:: RemoveRuleRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RemoveRule(Matcher(_))) + /// @endcode MOCK_METHOD(future>, RemoveRule, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/firewalls/v1/mocks/mock_firewalls_connection.h b/google/cloud/compute/firewalls/v1/mocks/mock_firewalls_connection.h index 370c0796ed90c..e3758a4871da2 100644 --- a/google/cloud/compute/firewalls/v1/mocks/mock_firewalls_connection.h +++ b/google/cloud/compute/firewalls/v1/mocks/mock_firewalls_connection.h @@ -47,9 +47,15 @@ class MockFirewallsConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteFirewall)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteFirewall(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteFirewall(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteFirewall, @@ -57,6 +63,12 @@ class MockFirewallsConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteFirewall(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteFirewall, (NoAwaitTag, @@ -64,6 +76,15 @@ class MockFirewallsConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteFirewall(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteFirewall, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -75,9 +96,15 @@ class MockFirewallsConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InsertFirewall)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, InsertFirewall(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertFirewall(Matcher(_))) + /// @endcode MOCK_METHOD( future>, InsertFirewall, @@ -85,6 +112,12 @@ class MockFirewallsConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InsertFirewall(_, _)) + /// @endcode MOCK_METHOD( StatusOr, InsertFirewall, (NoAwaitTag, @@ -92,6 +125,15 @@ class MockFirewallsConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertFirewall(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertFirewall, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -103,9 +145,15 @@ class MockFirewallsConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, PatchFirewall)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, PatchFirewall(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchFirewall(Matcher(_))) + /// @endcode MOCK_METHOD( future>, PatchFirewall, @@ -113,6 +161,12 @@ class MockFirewallsConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, PatchFirewall(_, _)) + /// @endcode MOCK_METHOD( StatusOr, PatchFirewall, (NoAwaitTag, @@ -120,14 +174,29 @@ class MockFirewallsConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchFirewall(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchFirewall, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateFirewall)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateFirewall(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateFirewall(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateFirewall, @@ -135,6 +204,12 @@ class MockFirewallsConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateFirewall(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateFirewall, (NoAwaitTag, @@ -142,6 +217,15 @@ class MockFirewallsConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateFirewall(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateFirewall, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/forwarding_rules/v1/mocks/mock_forwarding_rules_connection.h b/google/cloud/compute/forwarding_rules/v1/mocks/mock_forwarding_rules_connection.h index a2939c0dbe815..55cc55aa6f9e8 100644 --- a/google/cloud/compute/forwarding_rules/v1/mocks/mock_forwarding_rules_connection.h +++ b/google/cloud/compute/forwarding_rules/v1/mocks/mock_forwarding_rules_connection.h @@ -55,21 +55,42 @@ class MockForwardingRulesConnection AggregatedListForwardingRulesRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteForwardingRule)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteForwardingRule(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteForwardingRule(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteForwardingRule, (google::cloud::cpp::compute::forwarding_rules::v1:: DeleteForwardingRuleRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteForwardingRule(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteForwardingRule, (NoAwaitTag, google::cloud::cpp::compute::forwarding_rules::v1:: DeleteForwardingRuleRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteForwardingRule(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteForwardingRule, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -81,21 +102,42 @@ class MockForwardingRulesConnection GetForwardingRuleRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InsertForwardingRule)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, InsertForwardingRule(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertForwardingRule(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertForwardingRule, (google::cloud::cpp::compute::forwarding_rules::v1:: InsertForwardingRuleRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InsertForwardingRule(_, _)) + /// @endcode MOCK_METHOD(StatusOr, InsertForwardingRule, (NoAwaitTag, google::cloud::cpp::compute::forwarding_rules::v1:: InsertForwardingRuleRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertForwardingRule(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertForwardingRule, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -107,59 +149,120 @@ class MockForwardingRulesConnection ListForwardingRulesRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, PatchForwardingRule)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, PatchForwardingRule(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchForwardingRule(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchForwardingRule, (google::cloud::cpp::compute::forwarding_rules::v1:: PatchForwardingRuleRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, PatchForwardingRule(_, _)) + /// @endcode MOCK_METHOD(StatusOr, PatchForwardingRule, (NoAwaitTag, google::cloud::cpp::compute::forwarding_rules::v1:: PatchForwardingRuleRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchForwardingRule(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchForwardingRule, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SetLabels)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SetLabels(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetLabels(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetLabels, (google::cloud::cpp::compute::forwarding_rules::v1:: SetLabelsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SetLabels(_, _)) + /// @endcode MOCK_METHOD(StatusOr, SetLabels, (NoAwaitTag, google::cloud::cpp::compute::forwarding_rules::v1:: SetLabelsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetLabels(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetLabels, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SetTarget)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SetTarget(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetTarget(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetTarget, (google::cloud::cpp::compute::forwarding_rules::v1:: SetTargetRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SetTarget(_, _)) + /// @endcode MOCK_METHOD(StatusOr, SetTarget, (NoAwaitTag, google::cloud::cpp::compute::forwarding_rules::v1:: SetTargetRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetTarget(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetTarget, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/global_addresses/v1/mocks/mock_global_addresses_connection.h b/google/cloud/compute/global_addresses/v1/mocks/mock_global_addresses_connection.h index ed0f949a2106a..a24f3a8f8036c 100644 --- a/google/cloud/compute/global_addresses/v1/mocks/mock_global_addresses_connection.h +++ b/google/cloud/compute/global_addresses/v1/mocks/mock_global_addresses_connection.h @@ -47,21 +47,42 @@ class MockGlobalAddressesConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteAddress)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteAddress(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteAddress(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteAddress, (google::cloud::cpp::compute::global_addresses::v1:: DeleteAddressRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteAddress(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteAddress, (NoAwaitTag, google::cloud::cpp::compute::global_addresses::v1:: DeleteAddressRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteAddress(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteAddress, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -72,21 +93,42 @@ class MockGlobalAddressesConnection GetAddressRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InsertAddress)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, InsertAddress(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertAddress(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertAddress, (google::cloud::cpp::compute::global_addresses::v1:: InsertAddressRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InsertAddress(_, _)) + /// @endcode MOCK_METHOD(StatusOr, InsertAddress, (NoAwaitTag, google::cloud::cpp::compute::global_addresses::v1:: InsertAddressRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertAddress(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertAddress, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -98,15 +140,27 @@ class MockGlobalAddressesConnection ListGlobalAddressesRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, Move)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, Move(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// Move(Matcher(_))) + /// @endcode MOCK_METHOD( future>, Move, (google::cloud::cpp::compute::global_addresses::v1::MoveRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, Move(_, _)) + /// @endcode MOCK_METHOD( StatusOr, Move, (NoAwaitTag, @@ -114,25 +168,53 @@ class MockGlobalAddressesConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, Move(Matcher(_))) + /// @endcode MOCK_METHOD(future>, Move, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SetLabels)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SetLabels(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetLabels(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetLabels, (google::cloud::cpp::compute::global_addresses::v1:: SetLabelsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SetLabels(_, _)) + /// @endcode MOCK_METHOD(StatusOr, SetLabels, (NoAwaitTag, google::cloud::cpp::compute::global_addresses::v1:: SetLabelsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetLabels(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetLabels, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/global_forwarding_rules/v1/mocks/mock_global_forwarding_rules_connection.h b/google/cloud/compute/global_forwarding_rules/v1/mocks/mock_global_forwarding_rules_connection.h index fbb35f30f8c94..b9f744c53dfdb 100644 --- a/google/cloud/compute/global_forwarding_rules/v1/mocks/mock_global_forwarding_rules_connection.h +++ b/google/cloud/compute/global_forwarding_rules/v1/mocks/mock_global_forwarding_rules_connection.h @@ -49,15 +49,27 @@ class MockGlobalForwardingRulesConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteForwardingRule)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteForwardingRule(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteForwardingRule(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteForwardingRule, (google::cloud::cpp::compute::global_forwarding_rules::v1:: DeleteForwardingRuleRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteForwardingRule(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteForwardingRule, (NoAwaitTag, @@ -65,6 +77,15 @@ class MockGlobalForwardingRulesConnection DeleteForwardingRuleRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteForwardingRule(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteForwardingRule, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -76,15 +97,27 @@ class MockGlobalForwardingRulesConnection GetForwardingRuleRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InsertForwardingRule)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, InsertForwardingRule(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertForwardingRule(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertForwardingRule, (google::cloud::cpp::compute::global_forwarding_rules::v1:: InsertForwardingRuleRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InsertForwardingRule(_, _)) + /// @endcode MOCK_METHOD(StatusOr, InsertForwardingRule, (NoAwaitTag, @@ -92,6 +125,15 @@ class MockGlobalForwardingRulesConnection InsertForwardingRuleRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertForwardingRule(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertForwardingRule, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -103,15 +145,27 @@ class MockGlobalForwardingRulesConnection ListGlobalForwardingRulesRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, PatchForwardingRule)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, PatchForwardingRule(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchForwardingRule(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchForwardingRule, (google::cloud::cpp::compute::global_forwarding_rules::v1:: PatchForwardingRuleRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, PatchForwardingRule(_, _)) + /// @endcode MOCK_METHOD(StatusOr, PatchForwardingRule, (NoAwaitTag, @@ -119,46 +173,95 @@ class MockGlobalForwardingRulesConnection PatchForwardingRuleRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchForwardingRule(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchForwardingRule, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SetLabels)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SetLabels(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetLabels(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetLabels, (google::cloud::cpp::compute::global_forwarding_rules::v1:: SetLabelsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SetLabels(_, _)) + /// @endcode MOCK_METHOD(StatusOr, SetLabels, (NoAwaitTag, google::cloud::cpp::compute::global_forwarding_rules::v1:: SetLabelsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetLabels(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetLabels, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SetTarget)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SetTarget(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetTarget(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetTarget, (google::cloud::cpp::compute::global_forwarding_rules::v1:: SetTargetRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SetTarget(_, _)) + /// @endcode MOCK_METHOD(StatusOr, SetTarget, (NoAwaitTag, google::cloud::cpp::compute::global_forwarding_rules::v1:: SetTargetRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetTarget(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetTarget, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/global_network_endpoint_groups/v1/mocks/mock_global_network_endpoint_groups_connection.h b/google/cloud/compute/global_network_endpoint_groups/v1/mocks/mock_global_network_endpoint_groups_connection.h index 688ba7aa00a79..866d58f9d91f5 100644 --- a/google/cloud/compute/global_network_endpoint_groups/v1/mocks/mock_global_network_endpoint_groups_connection.h +++ b/google/cloud/compute/global_network_endpoint_groups/v1/mocks/mock_global_network_endpoint_groups_connection.h @@ -49,15 +49,27 @@ class MockGlobalNetworkEndpointGroupsConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, AttachNetworkEndpoints)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, AttachNetworkEndpoints(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// AttachNetworkEndpoints(Matcher(_))) + /// @endcode MOCK_METHOD(future>, AttachNetworkEndpoints, (google::cloud::cpp::compute::global_network_endpoint_groups::v1:: AttachNetworkEndpointsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, AttachNetworkEndpoints(_, _)) + /// @endcode MOCK_METHOD(StatusOr, AttachNetworkEndpoints, (NoAwaitTag, @@ -65,20 +77,41 @@ class MockGlobalNetworkEndpointGroupsConnection AttachNetworkEndpointsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// AttachNetworkEndpoints(Matcher(_))) + /// @endcode MOCK_METHOD(future>, AttachNetworkEndpoints, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteNetworkEndpointGroup)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteNetworkEndpointGroup(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteNetworkEndpointGroup(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteNetworkEndpointGroup, (google::cloud::cpp::compute::global_network_endpoint_groups::v1:: DeleteNetworkEndpointGroupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteNetworkEndpointGroup(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteNetworkEndpointGroup, (NoAwaitTag, @@ -86,20 +119,41 @@ class MockGlobalNetworkEndpointGroupsConnection DeleteNetworkEndpointGroupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteNetworkEndpointGroup(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteNetworkEndpointGroup, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DetachNetworkEndpoints)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DetachNetworkEndpoints(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DetachNetworkEndpoints(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DetachNetworkEndpoints, (google::cloud::cpp::compute::global_network_endpoint_groups::v1:: DetachNetworkEndpointsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DetachNetworkEndpoints(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DetachNetworkEndpoints, (NoAwaitTag, @@ -107,6 +161,15 @@ class MockGlobalNetworkEndpointGroupsConnection DetachNetworkEndpointsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DetachNetworkEndpoints(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DetachNetworkEndpoints, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -118,15 +181,27 @@ class MockGlobalNetworkEndpointGroupsConnection GetNetworkEndpointGroupRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InsertNetworkEndpointGroup)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, InsertNetworkEndpointGroup(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertNetworkEndpointGroup(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertNetworkEndpointGroup, (google::cloud::cpp::compute::global_network_endpoint_groups::v1:: InsertNetworkEndpointGroupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InsertNetworkEndpointGroup(_, _)) + /// @endcode MOCK_METHOD(StatusOr, InsertNetworkEndpointGroup, (NoAwaitTag, @@ -134,6 +209,15 @@ class MockGlobalNetworkEndpointGroupsConnection InsertNetworkEndpointGroupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertNetworkEndpointGroup(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertNetworkEndpointGroup, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/global_public_delegated_prefixes/v1/mocks/mock_global_public_delegated_prefixes_connection.h b/google/cloud/compute/global_public_delegated_prefixes/v1/mocks/mock_global_public_delegated_prefixes_connection.h index b24d07684d81a..75b8121687673 100644 --- a/google/cloud/compute/global_public_delegated_prefixes/v1/mocks/mock_global_public_delegated_prefixes_connection.h +++ b/google/cloud/compute/global_public_delegated_prefixes/v1/mocks/mock_global_public_delegated_prefixes_connection.h @@ -49,15 +49,27 @@ class MockGlobalPublicDelegatedPrefixesConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeletePublicDelegatedPrefix)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeletePublicDelegatedPrefix(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeletePublicDelegatedPrefix(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeletePublicDelegatedPrefix, (google::cloud::cpp::compute::global_public_delegated_prefixes:: v1::DeletePublicDelegatedPrefixRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeletePublicDelegatedPrefix(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeletePublicDelegatedPrefix, (NoAwaitTag, @@ -65,6 +77,15 @@ class MockGlobalPublicDelegatedPrefixesConnection v1::DeletePublicDelegatedPrefixRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeletePublicDelegatedPrefix(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeletePublicDelegatedPrefix, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -76,15 +97,27 @@ class MockGlobalPublicDelegatedPrefixesConnection v1::GetPublicDelegatedPrefixRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InsertPublicDelegatedPrefix)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, InsertPublicDelegatedPrefix(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertPublicDelegatedPrefix(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertPublicDelegatedPrefix, (google::cloud::cpp::compute::global_public_delegated_prefixes:: v1::InsertPublicDelegatedPrefixRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InsertPublicDelegatedPrefix(_, _)) + /// @endcode MOCK_METHOD(StatusOr, InsertPublicDelegatedPrefix, (NoAwaitTag, @@ -92,6 +125,15 @@ class MockGlobalPublicDelegatedPrefixesConnection v1::InsertPublicDelegatedPrefixRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertPublicDelegatedPrefix(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertPublicDelegatedPrefix, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -104,15 +146,27 @@ class MockGlobalPublicDelegatedPrefixesConnection ListGlobalPublicDelegatedPrefixesRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, PatchPublicDelegatedPrefix)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, PatchPublicDelegatedPrefix(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchPublicDelegatedPrefix(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchPublicDelegatedPrefix, (google::cloud::cpp::compute::global_public_delegated_prefixes:: v1::PatchPublicDelegatedPrefixRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, PatchPublicDelegatedPrefix(_, _)) + /// @endcode MOCK_METHOD(StatusOr, PatchPublicDelegatedPrefix, (NoAwaitTag, @@ -120,6 +174,15 @@ class MockGlobalPublicDelegatedPrefixesConnection v1::PatchPublicDelegatedPrefixRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchPublicDelegatedPrefix(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchPublicDelegatedPrefix, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/health_checks/v1/mocks/mock_health_checks_connection.h b/google/cloud/compute/health_checks/v1/mocks/mock_health_checks_connection.h index 46153809fddbc..0032e914f5db2 100644 --- a/google/cloud/compute/health_checks/v1/mocks/mock_health_checks_connection.h +++ b/google/cloud/compute/health_checks/v1/mocks/mock_health_checks_connection.h @@ -56,21 +56,42 @@ class MockHealthChecksConnection AggregatedListHealthChecksRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteHealthCheck)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteHealthCheck(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteHealthCheck(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteHealthCheck, (google::cloud::cpp::compute::health_checks::v1:: DeleteHealthCheckRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteHealthCheck(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteHealthCheck, (NoAwaitTag, google::cloud::cpp::compute::health_checks::v1:: DeleteHealthCheckRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteHealthCheck(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteHealthCheck, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -82,21 +103,42 @@ class MockHealthChecksConnection GetHealthCheckRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InsertHealthCheck)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, InsertHealthCheck(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertHealthCheck(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertHealthCheck, (google::cloud::cpp::compute::health_checks::v1:: InsertHealthCheckRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InsertHealthCheck(_, _)) + /// @endcode MOCK_METHOD(StatusOr, InsertHealthCheck, (NoAwaitTag, google::cloud::cpp::compute::health_checks::v1:: InsertHealthCheckRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertHealthCheck(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertHealthCheck, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -109,41 +151,83 @@ class MockHealthChecksConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, PatchHealthCheck)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, PatchHealthCheck(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchHealthCheck(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchHealthCheck, (google::cloud::cpp::compute::health_checks::v1:: PatchHealthCheckRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, PatchHealthCheck(_, _)) + /// @endcode MOCK_METHOD(StatusOr, PatchHealthCheck, (NoAwaitTag, google::cloud::cpp::compute::health_checks::v1:: PatchHealthCheckRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchHealthCheck(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchHealthCheck, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateHealthCheck)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateHealthCheck(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateHealthCheck(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateHealthCheck, (google::cloud::cpp::compute::health_checks::v1:: UpdateHealthCheckRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateHealthCheck(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateHealthCheck, (NoAwaitTag, google::cloud::cpp::compute::health_checks::v1:: UpdateHealthCheckRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateHealthCheck(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateHealthCheck, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/http_health_checks/v1/mocks/mock_http_health_checks_connection.h b/google/cloud/compute/http_health_checks/v1/mocks/mock_http_health_checks_connection.h index 2f94a718f49ce..54cfe9551e577 100644 --- a/google/cloud/compute/http_health_checks/v1/mocks/mock_http_health_checks_connection.h +++ b/google/cloud/compute/http_health_checks/v1/mocks/mock_http_health_checks_connection.h @@ -47,21 +47,42 @@ class MockHttpHealthChecksConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteHttpHealthCheck)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteHttpHealthCheck(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteHttpHealthCheck(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteHttpHealthCheck, (google::cloud::cpp::compute::http_health_checks::v1:: DeleteHttpHealthCheckRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteHttpHealthCheck(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteHttpHealthCheck, (NoAwaitTag, google::cloud::cpp::compute::http_health_checks::v1:: DeleteHttpHealthCheckRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteHttpHealthCheck(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteHttpHealthCheck, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -73,21 +94,42 @@ class MockHttpHealthChecksConnection GetHttpHealthCheckRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InsertHttpHealthCheck)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, InsertHttpHealthCheck(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertHttpHealthCheck(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertHttpHealthCheck, (google::cloud::cpp::compute::http_health_checks::v1:: InsertHttpHealthCheckRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InsertHttpHealthCheck(_, _)) + /// @endcode MOCK_METHOD(StatusOr, InsertHttpHealthCheck, (NoAwaitTag, google::cloud::cpp::compute::http_health_checks::v1:: InsertHttpHealthCheckRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertHttpHealthCheck(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertHttpHealthCheck, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -99,41 +141,83 @@ class MockHttpHealthChecksConnection ListHttpHealthChecksRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, PatchHttpHealthCheck)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, PatchHttpHealthCheck(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchHttpHealthCheck(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchHttpHealthCheck, (google::cloud::cpp::compute::http_health_checks::v1:: PatchHttpHealthCheckRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, PatchHttpHealthCheck(_, _)) + /// @endcode MOCK_METHOD(StatusOr, PatchHttpHealthCheck, (NoAwaitTag, google::cloud::cpp::compute::http_health_checks::v1:: PatchHttpHealthCheckRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchHttpHealthCheck(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchHttpHealthCheck, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateHttpHealthCheck)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateHttpHealthCheck(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateHttpHealthCheck(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateHttpHealthCheck, (google::cloud::cpp::compute::http_health_checks::v1:: UpdateHttpHealthCheckRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateHttpHealthCheck(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateHttpHealthCheck, (NoAwaitTag, google::cloud::cpp::compute::http_health_checks::v1:: UpdateHttpHealthCheckRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateHttpHealthCheck(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateHttpHealthCheck, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/https_health_checks/v1/mocks/mock_https_health_checks_connection.h b/google/cloud/compute/https_health_checks/v1/mocks/mock_https_health_checks_connection.h index 14dbc34c89620..c069fb07ad5cb 100644 --- a/google/cloud/compute/https_health_checks/v1/mocks/mock_https_health_checks_connection.h +++ b/google/cloud/compute/https_health_checks/v1/mocks/mock_https_health_checks_connection.h @@ -47,15 +47,27 @@ class MockHttpsHealthChecksConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteHttpsHealthCheck)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteHttpsHealthCheck(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteHttpsHealthCheck(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteHttpsHealthCheck, (google::cloud::cpp::compute::https_health_checks::v1:: DeleteHttpsHealthCheckRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteHttpsHealthCheck(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteHttpsHealthCheck, (NoAwaitTag, @@ -63,6 +75,15 @@ class MockHttpsHealthChecksConnection DeleteHttpsHealthCheckRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteHttpsHealthCheck(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteHttpsHealthCheck, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -74,15 +95,27 @@ class MockHttpsHealthChecksConnection GetHttpsHealthCheckRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InsertHttpsHealthCheck)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, InsertHttpsHealthCheck(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertHttpsHealthCheck(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertHttpsHealthCheck, (google::cloud::cpp::compute::https_health_checks::v1:: InsertHttpsHealthCheckRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InsertHttpsHealthCheck(_, _)) + /// @endcode MOCK_METHOD(StatusOr, InsertHttpsHealthCheck, (NoAwaitTag, @@ -90,6 +123,15 @@ class MockHttpsHealthChecksConnection InsertHttpsHealthCheckRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertHttpsHealthCheck(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertHttpsHealthCheck, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -101,35 +143,68 @@ class MockHttpsHealthChecksConnection ListHttpsHealthChecksRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, PatchHttpsHealthCheck)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, PatchHttpsHealthCheck(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchHttpsHealthCheck(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchHttpsHealthCheck, (google::cloud::cpp::compute::https_health_checks::v1:: PatchHttpsHealthCheckRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, PatchHttpsHealthCheck(_, _)) + /// @endcode MOCK_METHOD(StatusOr, PatchHttpsHealthCheck, (NoAwaitTag, google::cloud::cpp::compute::https_health_checks:: v1::PatchHttpsHealthCheckRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchHttpsHealthCheck(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchHttpsHealthCheck, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateHttpsHealthCheck)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateHttpsHealthCheck(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateHttpsHealthCheck(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateHttpsHealthCheck, (google::cloud::cpp::compute::https_health_checks::v1:: UpdateHttpsHealthCheckRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateHttpsHealthCheck(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateHttpsHealthCheck, (NoAwaitTag, @@ -137,6 +212,15 @@ class MockHttpsHealthChecksConnection UpdateHttpsHealthCheckRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateHttpsHealthCheck(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateHttpsHealthCheck, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/images/v1/mocks/mock_images_connection.h b/google/cloud/compute/images/v1/mocks/mock_images_connection.h index 14a92df6371a0..a689392056b80 100644 --- a/google/cloud/compute/images/v1/mocks/mock_images_connection.h +++ b/google/cloud/compute/images/v1/mocks/mock_images_connection.h @@ -46,15 +46,27 @@ class MockImagesConnection : public compute_images_v1::ImagesConnection { public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteImage)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteImage(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteImage(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteImage, (google::cloud::cpp::compute::images::v1::DeleteImageRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteImage(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteImage, (NoAwaitTag, @@ -62,26 +74,55 @@ class MockImagesConnection : public compute_images_v1::ImagesConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteImage(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteImage, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, Deprecate)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, Deprecate(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// Deprecate(Matcher(_))) + /// @endcode MOCK_METHOD(future>, Deprecate, (google::cloud::cpp::compute::images::v1::DeprecateRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, Deprecate(_, _)) + /// @endcode MOCK_METHOD(StatusOr, Deprecate, (NoAwaitTag, google::cloud::cpp::compute::images::v1::DeprecateRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// Deprecate(Matcher(_))) + /// @endcode MOCK_METHOD(future>, Deprecate, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -104,15 +145,27 @@ class MockImagesConnection : public compute_images_v1::ImagesConnection { request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InsertImage)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, InsertImage(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertImage(Matcher(_))) + /// @endcode MOCK_METHOD( future>, InsertImage, (google::cloud::cpp::compute::images::v1::InsertImageRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InsertImage(_, _)) + /// @endcode MOCK_METHOD( StatusOr, InsertImage, (NoAwaitTag, @@ -120,6 +173,15 @@ class MockImagesConnection : public compute_images_v1::ImagesConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertImage(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertImage, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -130,21 +192,41 @@ class MockImagesConnection : public compute_images_v1::ImagesConnection { (google::cloud::cpp::compute::images::v1::ListImagesRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, PatchImage)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, PatchImage(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchImage(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchImage, (google::cloud::cpp::compute::images::v1::PatchImageRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, PatchImage(_, _)) + /// @endcode MOCK_METHOD(StatusOr, PatchImage, (NoAwaitTag, google::cloud::cpp::compute::images::v1::PatchImageRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchImage(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchImage, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -156,21 +238,41 @@ class MockImagesConnection : public compute_images_v1::ImagesConnection { request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SetLabels)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SetLabels(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetLabels(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetLabels, (google::cloud::cpp::compute::images::v1::SetLabelsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SetLabels(_, _)) + /// @endcode MOCK_METHOD(StatusOr, SetLabels, (NoAwaitTag, google::cloud::cpp::compute::images::v1::SetLabelsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetLabels(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetLabels, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/instance_group_manager_resize_requests/v1/mocks/mock_instance_group_manager_resize_requests_connection.h b/google/cloud/compute/instance_group_manager_resize_requests/v1/mocks/mock_instance_group_manager_resize_requests_connection.h index 2dfa458a5700c..a4a78309104ca 100644 --- a/google/cloud/compute/instance_group_manager_resize_requests/v1/mocks/mock_instance_group_manager_resize_requests_connection.h +++ b/google/cloud/compute/instance_group_manager_resize_requests/v1/mocks/mock_instance_group_manager_resize_requests_connection.h @@ -50,15 +50,27 @@ class MockInstanceGroupManagerResizeRequestsConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, Cancel)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, Cancel(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// Cancel(Matcher(_))) + /// @endcode MOCK_METHOD( future>, Cancel, (google::cloud::cpp::compute::instance_group_manager_resize_requests::v1:: CancelRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, Cancel(_, _)) + /// @endcode MOCK_METHOD( StatusOr, Cancel, (NoAwaitTag, @@ -66,15 +78,28 @@ class MockInstanceGroupManagerResizeRequestsConnection CancelRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// Cancel(Matcher(_))) + /// @endcode MOCK_METHOD(future>, Cancel, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteInstanceGroupManagerResizeRequest)` is now - /// ambiguous. Use `EXPECT_CALL(*mock, - /// DeleteInstanceGroupManagerResizeRequest(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteInstanceGroupManagerResizeRequest(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteInstanceGroupManagerResizeRequest, @@ -82,6 +107,12 @@ class MockInstanceGroupManagerResizeRequestsConnection DeleteInstanceGroupManagerResizeRequestRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteInstanceGroupManagerResizeRequest(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteInstanceGroupManagerResizeRequest, @@ -90,6 +121,15 @@ class MockInstanceGroupManagerResizeRequestsConnection DeleteInstanceGroupManagerResizeRequestRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteInstanceGroupManagerResizeRequest(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteInstanceGroupManagerResizeRequest, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -103,10 +143,15 @@ class MockInstanceGroupManagerResizeRequestsConnection GetInstanceGroupManagerResizeRequestRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InsertInstanceGroupManagerResizeRequest)` is now - /// ambiguous. Use `EXPECT_CALL(*mock, - /// InsertInstanceGroupManagerResizeRequest(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertInstanceGroupManagerResizeRequest(Matcher(_))) + /// @endcode MOCK_METHOD( future>, InsertInstanceGroupManagerResizeRequest, @@ -114,6 +159,12 @@ class MockInstanceGroupManagerResizeRequestsConnection InsertInstanceGroupManagerResizeRequestRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InsertInstanceGroupManagerResizeRequest(_, _)) + /// @endcode MOCK_METHOD( StatusOr, InsertInstanceGroupManagerResizeRequest, @@ -122,6 +173,15 @@ class MockInstanceGroupManagerResizeRequestsConnection InsertInstanceGroupManagerResizeRequestRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertInstanceGroupManagerResizeRequest(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertInstanceGroupManagerResizeRequest, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/instance_group_managers/v1/mocks/mock_instance_group_managers_connection.h b/google/cloud/compute/instance_group_managers/v1/mocks/mock_instance_group_managers_connection.h index 8e014702b1707..06894eeca3bb4 100644 --- a/google/cloud/compute/instance_group_managers/v1/mocks/mock_instance_group_managers_connection.h +++ b/google/cloud/compute/instance_group_managers/v1/mocks/mock_instance_group_managers_connection.h @@ -49,15 +49,27 @@ class MockInstanceGroupManagersConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, AbandonInstances)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, AbandonInstances(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// AbandonInstances(Matcher(_))) + /// @endcode MOCK_METHOD(future>, AbandonInstances, (google::cloud::cpp::compute::instance_group_managers::v1:: AbandonInstancesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, AbandonInstances(_, _)) + /// @endcode MOCK_METHOD(StatusOr, AbandonInstances, (NoAwaitTag, @@ -65,6 +77,15 @@ class MockInstanceGroupManagersConnection AbandonInstancesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// AbandonInstances(Matcher(_))) + /// @endcode MOCK_METHOD(future>, AbandonInstances, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -79,15 +100,27 @@ class MockInstanceGroupManagersConnection AggregatedListInstanceGroupManagersRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ApplyUpdatesToInstances)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ApplyUpdatesToInstances(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ApplyUpdatesToInstances(Matcher(_))) + /// @endcode MOCK_METHOD(future>, ApplyUpdatesToInstances, (google::cloud::cpp::compute::instance_group_managers::v1:: ApplyUpdatesToInstancesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ApplyUpdatesToInstances(_, _)) + /// @endcode MOCK_METHOD(StatusOr, ApplyUpdatesToInstances, (NoAwaitTag, @@ -95,20 +128,41 @@ class MockInstanceGroupManagersConnection ApplyUpdatesToInstancesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ApplyUpdatesToInstances(Matcher(_))) + /// @endcode MOCK_METHOD(future>, ApplyUpdatesToInstances, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateInstances)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateInstances(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateInstances(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateInstances, (google::cloud::cpp::compute::instance_group_managers::v1:: CreateInstancesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateInstances(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateInstances, (NoAwaitTag, @@ -116,20 +170,41 @@ class MockInstanceGroupManagersConnection CreateInstancesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateInstances(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateInstances, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteInstanceGroupManager)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteInstanceGroupManager(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteInstanceGroupManager(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteInstanceGroupManager, (google::cloud::cpp::compute::instance_group_managers::v1:: DeleteInstanceGroupManagerRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteInstanceGroupManager(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteInstanceGroupManager, (NoAwaitTag, @@ -137,20 +212,41 @@ class MockInstanceGroupManagersConnection DeleteInstanceGroupManagerRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteInstanceGroupManager(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteInstanceGroupManager, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteInstances)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteInstances(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteInstances(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteInstances, (google::cloud::cpp::compute::instance_group_managers::v1:: DeleteInstancesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteInstances(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteInstances, (NoAwaitTag, @@ -158,20 +254,41 @@ class MockInstanceGroupManagersConnection DeleteInstancesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteInstances(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteInstances, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeletePerInstanceConfigs)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeletePerInstanceConfigs(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeletePerInstanceConfigs(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeletePerInstanceConfigs, (google::cloud::cpp::compute::instance_group_managers::v1:: DeletePerInstanceConfigsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeletePerInstanceConfigs(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeletePerInstanceConfigs, (NoAwaitTag, @@ -179,6 +296,15 @@ class MockInstanceGroupManagersConnection DeletePerInstanceConfigsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeletePerInstanceConfigs(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeletePerInstanceConfigs, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -190,15 +316,27 @@ class MockInstanceGroupManagersConnection GetInstanceGroupManagerRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InsertInstanceGroupManager)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, InsertInstanceGroupManager(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertInstanceGroupManager(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertInstanceGroupManager, (google::cloud::cpp::compute::instance_group_managers::v1:: InsertInstanceGroupManagerRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InsertInstanceGroupManager(_, _)) + /// @endcode MOCK_METHOD(StatusOr, InsertInstanceGroupManager, (NoAwaitTag, @@ -206,6 +344,15 @@ class MockInstanceGroupManagersConnection InsertInstanceGroupManagerRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertInstanceGroupManager(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertInstanceGroupManager, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -238,15 +385,27 @@ class MockInstanceGroupManagersConnection ListPerInstanceConfigsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, PatchInstanceGroupManager)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, PatchInstanceGroupManager(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchInstanceGroupManager(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchInstanceGroupManager, (google::cloud::cpp::compute::instance_group_managers::v1:: PatchInstanceGroupManagerRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, PatchInstanceGroupManager(_, _)) + /// @endcode MOCK_METHOD(StatusOr, PatchInstanceGroupManager, (NoAwaitTag, @@ -254,20 +413,41 @@ class MockInstanceGroupManagersConnection PatchInstanceGroupManagerRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchInstanceGroupManager(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchInstanceGroupManager, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, PatchPerInstanceConfigs)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, PatchPerInstanceConfigs(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchPerInstanceConfigs(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchPerInstanceConfigs, (google::cloud::cpp::compute::instance_group_managers::v1:: PatchPerInstanceConfigsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, PatchPerInstanceConfigs(_, _)) + /// @endcode MOCK_METHOD(StatusOr, PatchPerInstanceConfigs, (NoAwaitTag, @@ -275,20 +455,41 @@ class MockInstanceGroupManagersConnection PatchPerInstanceConfigsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchPerInstanceConfigs(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchPerInstanceConfigs, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, RecreateInstances)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, RecreateInstances(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RecreateInstances(Matcher(_))) + /// @endcode MOCK_METHOD(future>, RecreateInstances, (google::cloud::cpp::compute::instance_group_managers::v1:: RecreateInstancesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, RecreateInstances(_, _)) + /// @endcode MOCK_METHOD(StatusOr, RecreateInstances, (NoAwaitTag, @@ -296,40 +497,81 @@ class MockInstanceGroupManagersConnection RecreateInstancesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RecreateInstances(Matcher(_))) + /// @endcode MOCK_METHOD(future>, RecreateInstances, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, Resize)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, Resize(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// Resize(Matcher(_))) + /// @endcode MOCK_METHOD(future>, Resize, (google::cloud::cpp::compute::instance_group_managers::v1:: ResizeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, Resize(_, _)) + /// @endcode MOCK_METHOD(StatusOr, Resize, (NoAwaitTag, google::cloud::cpp::compute::instance_group_managers::v1:: ResizeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// Resize(Matcher(_))) + /// @endcode MOCK_METHOD(future>, Resize, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SetInstanceTemplate)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SetInstanceTemplate(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetInstanceTemplate(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetInstanceTemplate, (google::cloud::cpp::compute::instance_group_managers::v1:: SetInstanceTemplateRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SetInstanceTemplate(_, _)) + /// @endcode MOCK_METHOD(StatusOr, SetInstanceTemplate, (NoAwaitTag, @@ -337,20 +579,41 @@ class MockInstanceGroupManagersConnection SetInstanceTemplateRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetInstanceTemplate(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetInstanceTemplate, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SetTargetPools)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SetTargetPools(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetTargetPools(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetTargetPools, (google::cloud::cpp::compute::instance_group_managers::v1:: SetTargetPoolsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SetTargetPools(_, _)) + /// @endcode MOCK_METHOD(StatusOr, SetTargetPools, (NoAwaitTag, @@ -358,20 +621,41 @@ class MockInstanceGroupManagersConnection SetTargetPoolsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetTargetPools(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetTargetPools, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdatePerInstanceConfigs)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdatePerInstanceConfigs(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdatePerInstanceConfigs(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdatePerInstanceConfigs, (google::cloud::cpp::compute::instance_group_managers::v1:: UpdatePerInstanceConfigsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdatePerInstanceConfigs(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdatePerInstanceConfigs, (NoAwaitTag, @@ -379,6 +663,15 @@ class MockInstanceGroupManagersConnection UpdatePerInstanceConfigsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdatePerInstanceConfigs(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdatePerInstanceConfigs, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/instance_groups/v1/mocks/mock_instance_groups_connection.h b/google/cloud/compute/instance_groups/v1/mocks/mock_instance_groups_connection.h index ba26f9e8154ca..1118009602807 100644 --- a/google/cloud/compute/instance_groups/v1/mocks/mock_instance_groups_connection.h +++ b/google/cloud/compute/instance_groups/v1/mocks/mock_instance_groups_connection.h @@ -47,21 +47,42 @@ class MockInstanceGroupsConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, AddInstances)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, AddInstances(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// AddInstances(Matcher(_))) + /// @endcode MOCK_METHOD(future>, AddInstances, (google::cloud::cpp::compute::instance_groups::v1:: AddInstancesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, AddInstances(_, _)) + /// @endcode MOCK_METHOD(StatusOr, AddInstances, (NoAwaitTag, google::cloud::cpp::compute::instance_groups::v1:: AddInstancesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// AddInstances(Matcher(_))) + /// @endcode MOCK_METHOD(future>, AddInstances, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -75,21 +96,42 @@ class MockInstanceGroupsConnection AggregatedListInstanceGroupsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteInstanceGroup)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteInstanceGroup(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteInstanceGroup(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteInstanceGroup, (google::cloud::cpp::compute::instance_groups::v1:: DeleteInstanceGroupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteInstanceGroup(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteInstanceGroup, (NoAwaitTag, google::cloud::cpp::compute::instance_groups::v1:: DeleteInstanceGroupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteInstanceGroup(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteInstanceGroup, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -101,21 +143,42 @@ class MockInstanceGroupsConnection GetInstanceGroupRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InsertInstanceGroup)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, InsertInstanceGroup(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertInstanceGroup(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertInstanceGroup, (google::cloud::cpp::compute::instance_groups::v1:: InsertInstanceGroupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InsertInstanceGroup(_, _)) + /// @endcode MOCK_METHOD(StatusOr, InsertInstanceGroup, (NoAwaitTag, google::cloud::cpp::compute::instance_groups::v1:: InsertInstanceGroupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertInstanceGroup(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertInstanceGroup, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -134,41 +197,83 @@ class MockInstanceGroupsConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, RemoveInstances)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, RemoveInstances(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RemoveInstances(Matcher(_))) + /// @endcode MOCK_METHOD(future>, RemoveInstances, (google::cloud::cpp::compute::instance_groups::v1:: RemoveInstancesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, RemoveInstances(_, _)) + /// @endcode MOCK_METHOD(StatusOr, RemoveInstances, (NoAwaitTag, google::cloud::cpp::compute::instance_groups::v1:: RemoveInstancesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RemoveInstances(Matcher(_))) + /// @endcode MOCK_METHOD(future>, RemoveInstances, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SetNamedPorts)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SetNamedPorts(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetNamedPorts(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetNamedPorts, (google::cloud::cpp::compute::instance_groups::v1:: SetNamedPortsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SetNamedPorts(_, _)) + /// @endcode MOCK_METHOD(StatusOr, SetNamedPorts, (NoAwaitTag, google::cloud::cpp::compute::instance_groups::v1:: SetNamedPortsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetNamedPorts(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetNamedPorts, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/instance_settings/v1/mocks/mock_instance_settings_connection.h b/google/cloud/compute/instance_settings/v1/mocks/mock_instance_settings_connection.h index 4c0ce821853b7..bc905f37534ab 100644 --- a/google/cloud/compute/instance_settings/v1/mocks/mock_instance_settings_connection.h +++ b/google/cloud/compute/instance_settings/v1/mocks/mock_instance_settings_connection.h @@ -53,21 +53,42 @@ class MockInstanceSettingsConnection GetInstanceSettingsRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, PatchInstanceSettings)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, PatchInstanceSettings(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchInstanceSettings(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchInstanceSettings, (google::cloud::cpp::compute::instance_settings::v1:: PatchInstanceSettingsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, PatchInstanceSettings(_, _)) + /// @endcode MOCK_METHOD(StatusOr, PatchInstanceSettings, (NoAwaitTag, google::cloud::cpp::compute::instance_settings::v1:: PatchInstanceSettingsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchInstanceSettings(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchInstanceSettings, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/instance_templates/v1/mocks/mock_instance_templates_connection.h b/google/cloud/compute/instance_templates/v1/mocks/mock_instance_templates_connection.h index 2100b08a74cdd..1caff31e858a7 100644 --- a/google/cloud/compute/instance_templates/v1/mocks/mock_instance_templates_connection.h +++ b/google/cloud/compute/instance_templates/v1/mocks/mock_instance_templates_connection.h @@ -55,21 +55,42 @@ class MockInstanceTemplatesConnection AggregatedListInstanceTemplatesRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteInstanceTemplate)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteInstanceTemplate(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteInstanceTemplate(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteInstanceTemplate, (google::cloud::cpp::compute::instance_templates::v1:: DeleteInstanceTemplateRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteInstanceTemplate(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteInstanceTemplate, (NoAwaitTag, google::cloud::cpp::compute::instance_templates::v1:: DeleteInstanceTemplateRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteInstanceTemplate(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteInstanceTemplate, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -86,21 +107,42 @@ class MockInstanceTemplatesConnection GetIamPolicyRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InsertInstanceTemplate)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, InsertInstanceTemplate(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertInstanceTemplate(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertInstanceTemplate, (google::cloud::cpp::compute::instance_templates::v1:: InsertInstanceTemplateRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InsertInstanceTemplate(_, _)) + /// @endcode MOCK_METHOD(StatusOr, InsertInstanceTemplate, (NoAwaitTag, google::cloud::cpp::compute::instance_templates::v1:: InsertInstanceTemplateRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertInstanceTemplate(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertInstanceTemplate, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/instances/v1/mocks/mock_instances_connection.h b/google/cloud/compute/instances/v1/mocks/mock_instances_connection.h index b5327d81fe44f..3fbf2890499df 100644 --- a/google/cloud/compute/instances/v1/mocks/mock_instances_connection.h +++ b/google/cloud/compute/instances/v1/mocks/mock_instances_connection.h @@ -47,9 +47,15 @@ class MockInstancesConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, AddAccessConfig)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, AddAccessConfig(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// AddAccessConfig(Matcher(_))) + /// @endcode MOCK_METHOD( future>, AddAccessConfig, @@ -57,6 +63,12 @@ class MockInstancesConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, AddAccessConfig(_, _)) + /// @endcode MOCK_METHOD( StatusOr, AddAccessConfig, (NoAwaitTag, @@ -64,26 +76,56 @@ class MockInstancesConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// AddAccessConfig(Matcher(_))) + /// @endcode MOCK_METHOD(future>, AddAccessConfig, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, AddResourcePolicies)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, AddResourcePolicies(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// AddResourcePolicies(Matcher(_))) + /// @endcode MOCK_METHOD(future>, AddResourcePolicies, (google::cloud::cpp::compute::instances::v1:: AddResourcePoliciesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, AddResourcePolicies(_, _)) + /// @endcode MOCK_METHOD(StatusOr, AddResourcePolicies, (NoAwaitTag, google::cloud::cpp::compute::instances::v1:: AddResourcePoliciesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// AddResourcePolicies(Matcher(_))) + /// @endcode MOCK_METHOD(future>, AddResourcePolicies, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -97,15 +139,27 @@ class MockInstancesConnection AggregatedListInstancesRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, AttachDisk)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, AttachDisk(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// AttachDisk(Matcher(_))) + /// @endcode MOCK_METHOD( future>, AttachDisk, (google::cloud::cpp::compute::instances::v1::AttachDiskRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, AttachDisk(_, _)) + /// @endcode MOCK_METHOD( StatusOr, AttachDisk, (NoAwaitTag, @@ -113,20 +167,40 @@ class MockInstancesConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// AttachDisk(Matcher(_))) + /// @endcode MOCK_METHOD(future>, AttachDisk, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, BulkInsert)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, BulkInsert(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// BulkInsert(Matcher(_))) + /// @endcode MOCK_METHOD( future>, BulkInsert, (google::cloud::cpp::compute::instances::v1::BulkInsertRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, BulkInsert(_, _)) + /// @endcode MOCK_METHOD( StatusOr, BulkInsert, (NoAwaitTag, @@ -134,14 +208,28 @@ class MockInstancesConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// BulkInsert(Matcher(_))) + /// @endcode MOCK_METHOD(future>, BulkInsert, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteInstance)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteInstance(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteInstance(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteInstance, @@ -149,6 +237,12 @@ class MockInstancesConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteInstance(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteInstance, (NoAwaitTag, @@ -156,40 +250,82 @@ class MockInstancesConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteInstance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteInstance, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteAccessConfig)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteAccessConfig(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteAccessConfig(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteAccessConfig, (google::cloud::cpp::compute::instances::v1:: DeleteAccessConfigRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteAccessConfig(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteAccessConfig, (NoAwaitTag, google::cloud::cpp::compute::instances::v1:: DeleteAccessConfigRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteAccessConfig(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteAccessConfig, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DetachDisk)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DetachDisk(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DetachDisk(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DetachDisk, (google::cloud::cpp::compute::instances::v1::DetachDiskRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DetachDisk(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DetachDisk, (NoAwaitTag, @@ -197,6 +333,14 @@ class MockInstancesConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DetachDisk(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DetachDisk, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -246,9 +390,15 @@ class MockInstancesConnection GetShieldedInstanceIdentityRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InsertInstance)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, InsertInstance(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertInstance(Matcher(_))) + /// @endcode MOCK_METHOD( future>, InsertInstance, @@ -256,6 +406,12 @@ class MockInstancesConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InsertInstance(_, _)) + /// @endcode MOCK_METHOD( StatusOr, InsertInstance, (NoAwaitTag, @@ -263,6 +419,15 @@ class MockInstancesConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertInstance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertInstance, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -280,80 +445,162 @@ class MockInstancesConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, PerformMaintenance)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, PerformMaintenance(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PerformMaintenance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PerformMaintenance, (google::cloud::cpp::compute::instances::v1:: PerformMaintenanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, PerformMaintenance(_, _)) + /// @endcode MOCK_METHOD(StatusOr, PerformMaintenance, (NoAwaitTag, google::cloud::cpp::compute::instances::v1:: PerformMaintenanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PerformMaintenance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PerformMaintenance, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, RemoveResourcePolicies)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, RemoveResourcePolicies(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RemoveResourcePolicies(Matcher(_))) + /// @endcode MOCK_METHOD(future>, RemoveResourcePolicies, (google::cloud::cpp::compute::instances::v1:: RemoveResourcePoliciesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, RemoveResourcePolicies(_, _)) + /// @endcode MOCK_METHOD(StatusOr, RemoveResourcePolicies, (NoAwaitTag, google::cloud::cpp::compute::instances::v1:: RemoveResourcePoliciesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RemoveResourcePolicies(Matcher(_))) + /// @endcode MOCK_METHOD(future>, RemoveResourcePolicies, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, Reset)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, Reset(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// Reset(Matcher(_))) + /// @endcode MOCK_METHOD( future>, Reset, (google::cloud::cpp::compute::instances::v1::ResetRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, Reset(_, _)) + /// @endcode MOCK_METHOD( StatusOr, Reset, (NoAwaitTag, google::cloud::cpp::compute::instances::v1::ResetRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// Reset(Matcher(_))) + /// @endcode MOCK_METHOD(future>, Reset, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, Resume)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, Resume(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// Resume(Matcher(_))) + /// @endcode MOCK_METHOD(future>, Resume, (google::cloud::cpp::compute::instances::v1::ResumeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, Resume(_, _)) + /// @endcode MOCK_METHOD(StatusOr, Resume, (NoAwaitTag, google::cloud::cpp::compute::instances::v1::ResumeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// Resume(Matcher(_))) + /// @endcode MOCK_METHOD(future>, Resume, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -364,41 +611,83 @@ class MockInstancesConnection SendDiagnosticInterruptRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SetDeletionProtection)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SetDeletionProtection(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetDeletionProtection(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetDeletionProtection, (google::cloud::cpp::compute::instances::v1:: SetDeletionProtectionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SetDeletionProtection(_, _)) + /// @endcode MOCK_METHOD(StatusOr, SetDeletionProtection, (NoAwaitTag, google::cloud::cpp::compute::instances::v1:: SetDeletionProtectionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetDeletionProtection(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetDeletionProtection, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SetDiskAutoDelete)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SetDiskAutoDelete(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetDiskAutoDelete(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetDiskAutoDelete, (google::cloud::cpp::compute::instances::v1:: SetDiskAutoDeleteRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SetDiskAutoDelete(_, _)) + /// @endcode MOCK_METHOD(StatusOr, SetDiskAutoDelete, (NoAwaitTag, google::cloud::cpp::compute::instances::v1:: SetDiskAutoDeleteRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetDiskAutoDelete(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetDiskAutoDelete, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -410,15 +699,27 @@ class MockInstancesConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SetLabels)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SetLabels(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetLabels(Matcher(_))) + /// @endcode MOCK_METHOD( future>, SetLabels, (google::cloud::cpp::compute::instances::v1::SetLabelsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SetLabels(_, _)) + /// @endcode MOCK_METHOD( StatusOr, SetLabels, (NoAwaitTag, @@ -426,34 +727,69 @@ class MockInstancesConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetLabels(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetLabels, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SetMachineResources)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SetMachineResources(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetMachineResources(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetMachineResources, (google::cloud::cpp::compute::instances::v1:: SetMachineResourcesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SetMachineResources(_, _)) + /// @endcode MOCK_METHOD(StatusOr, SetMachineResources, (NoAwaitTag, google::cloud::cpp::compute::instances::v1:: SetMachineResourcesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetMachineResources(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetMachineResources, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SetMachineType)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SetMachineType(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetMachineType(Matcher(_))) + /// @endcode MOCK_METHOD( future>, SetMachineType, @@ -461,6 +797,12 @@ class MockInstancesConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SetMachineType(_, _)) + /// @endcode MOCK_METHOD( StatusOr, SetMachineType, (NoAwaitTag, @@ -468,20 +810,41 @@ class MockInstancesConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetMachineType(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetMachineType, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SetMetadata)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SetMetadata(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetMetadata(Matcher(_))) + /// @endcode MOCK_METHOD( future>, SetMetadata, (google::cloud::cpp::compute::instances::v1::SetMetadataRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SetMetadata(_, _)) + /// @endcode MOCK_METHOD( StatusOr, SetMetadata, (NoAwaitTag, @@ -489,54 +852,110 @@ class MockInstancesConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetMetadata(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetMetadata, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SetMinCpuPlatform)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SetMinCpuPlatform(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetMinCpuPlatform(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetMinCpuPlatform, (google::cloud::cpp::compute::instances::v1:: SetMinCpuPlatformRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SetMinCpuPlatform(_, _)) + /// @endcode MOCK_METHOD(StatusOr, SetMinCpuPlatform, (NoAwaitTag, google::cloud::cpp::compute::instances::v1:: SetMinCpuPlatformRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetMinCpuPlatform(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetMinCpuPlatform, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SetName)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SetName(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetName(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetName, (google::cloud::cpp::compute::instances::v1::SetNameRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SetName(_, _)) + /// @endcode MOCK_METHOD(StatusOr, SetName, (NoAwaitTag, google::cloud::cpp::compute::instances::v1::SetNameRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetName(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetName, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SetScheduling)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SetScheduling(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetScheduling(Matcher(_))) + /// @endcode MOCK_METHOD( future>, SetScheduling, @@ -544,6 +963,12 @@ class MockInstancesConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SetScheduling(_, _)) + /// @endcode MOCK_METHOD( StatusOr, SetScheduling, (NoAwaitTag, @@ -551,61 +976,123 @@ class MockInstancesConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetScheduling(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetScheduling, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SetSecurityPolicy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SetSecurityPolicy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetSecurityPolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetSecurityPolicy, (google::cloud::cpp::compute::instances::v1:: SetSecurityPolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SetSecurityPolicy(_, _)) + /// @endcode MOCK_METHOD(StatusOr, SetSecurityPolicy, (NoAwaitTag, google::cloud::cpp::compute::instances::v1:: SetSecurityPolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetSecurityPolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetSecurityPolicy, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SetServiceAccount)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SetServiceAccount(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetServiceAccount(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetServiceAccount, (google::cloud::cpp::compute::instances::v1:: SetServiceAccountRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SetServiceAccount(_, _)) + /// @endcode MOCK_METHOD(StatusOr, SetServiceAccount, (NoAwaitTag, google::cloud::cpp::compute::instances::v1:: SetServiceAccountRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetServiceAccount(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetServiceAccount, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SetShieldedInstanceIntegrityPolicy)` is now ambiguous. - /// Use `EXPECT_CALL(*mock, SetShieldedInstanceIntegrityPolicy(::testing::_))` - /// instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetShieldedInstanceIntegrityPolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetShieldedInstanceIntegrityPolicy, (google::cloud::cpp::compute::instances::v1:: SetShieldedInstanceIntegrityPolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SetShieldedInstanceIntegrityPolicy(_, _)) + /// @endcode MOCK_METHOD(StatusOr, SetShieldedInstanceIntegrityPolicy, (NoAwaitTag, @@ -613,124 +1100,255 @@ class MockInstancesConnection SetShieldedInstanceIntegrityPolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetShieldedInstanceIntegrityPolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetShieldedInstanceIntegrityPolicy, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SetTags)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SetTags(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetTags(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetTags, (google::cloud::cpp::compute::instances::v1::SetTagsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SetTags(_, _)) + /// @endcode MOCK_METHOD(StatusOr, SetTags, (NoAwaitTag, google::cloud::cpp::compute::instances::v1::SetTagsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetTags(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetTags, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SimulateMaintenanceEvent)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SimulateMaintenanceEvent(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SimulateMaintenanceEvent(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SimulateMaintenanceEvent, (google::cloud::cpp::compute::instances::v1:: SimulateMaintenanceEventRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SimulateMaintenanceEvent(_, _)) + /// @endcode MOCK_METHOD(StatusOr, SimulateMaintenanceEvent, (NoAwaitTag, google::cloud::cpp::compute::instances::v1:: SimulateMaintenanceEventRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SimulateMaintenanceEvent(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SimulateMaintenanceEvent, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, Start)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, Start(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// Start(Matcher(_))) + /// @endcode MOCK_METHOD( future>, Start, (google::cloud::cpp::compute::instances::v1::StartRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, Start(_, _)) + /// @endcode MOCK_METHOD( StatusOr, Start, (NoAwaitTag, google::cloud::cpp::compute::instances::v1::StartRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// Start(Matcher(_))) + /// @endcode MOCK_METHOD(future>, Start, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, StartWithEncryptionKey)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, StartWithEncryptionKey(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// StartWithEncryptionKey(Matcher(_))) + /// @endcode MOCK_METHOD(future>, StartWithEncryptionKey, (google::cloud::cpp::compute::instances::v1:: StartWithEncryptionKeyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, StartWithEncryptionKey(_, _)) + /// @endcode MOCK_METHOD(StatusOr, StartWithEncryptionKey, (NoAwaitTag, google::cloud::cpp::compute::instances::v1:: StartWithEncryptionKeyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// StartWithEncryptionKey(Matcher(_))) + /// @endcode MOCK_METHOD(future>, StartWithEncryptionKey, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, Stop)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, Stop(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// Stop(Matcher(_))) + /// @endcode MOCK_METHOD( future>, Stop, (google::cloud::cpp::compute::instances::v1::StopRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, Stop(_, _)) + /// @endcode MOCK_METHOD( StatusOr, Stop, (NoAwaitTag, google::cloud::cpp::compute::instances::v1::StopRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, Stop(Matcher(_))) + /// @endcode MOCK_METHOD(future>, Stop, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, Suspend)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, Suspend(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// Suspend(Matcher(_))) + /// @endcode MOCK_METHOD(future>, Suspend, (google::cloud::cpp::compute::instances::v1::SuspendRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, Suspend(_, _)) + /// @endcode MOCK_METHOD(StatusOr, Suspend, (NoAwaitTag, google::cloud::cpp::compute::instances::v1::SuspendRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// Suspend(Matcher(_))) + /// @endcode MOCK_METHOD(future>, Suspend, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -743,9 +1361,15 @@ class MockInstancesConnection TestIamPermissionsRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateInstance)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateInstance(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateInstance(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateInstance, @@ -753,6 +1377,12 @@ class MockInstancesConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateInstance(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateInstance, (NoAwaitTag, @@ -760,80 +1390,164 @@ class MockInstancesConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateInstance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateInstance, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateAccessConfig)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateAccessConfig(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateAccessConfig(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateAccessConfig, (google::cloud::cpp::compute::instances::v1:: UpdateAccessConfigRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateAccessConfig(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateAccessConfig, (NoAwaitTag, google::cloud::cpp::compute::instances::v1:: UpdateAccessConfigRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateAccessConfig(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateAccessConfig, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateDisplayDevice)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateDisplayDevice(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateDisplayDevice(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateDisplayDevice, (google::cloud::cpp::compute::instances::v1:: UpdateDisplayDeviceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateDisplayDevice(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateDisplayDevice, (NoAwaitTag, google::cloud::cpp::compute::instances::v1:: UpdateDisplayDeviceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateDisplayDevice(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateDisplayDevice, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateNetworkInterface)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateNetworkInterface(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateNetworkInterface(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateNetworkInterface, (google::cloud::cpp::compute::instances::v1:: UpdateNetworkInterfaceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateNetworkInterface(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateNetworkInterface, (NoAwaitTag, google::cloud::cpp::compute::instances::v1:: UpdateNetworkInterfaceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateNetworkInterface(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateNetworkInterface, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateShieldedInstanceConfig)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateShieldedInstanceConfig(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateShieldedInstanceConfig(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateShieldedInstanceConfig, (google::cloud::cpp::compute::instances::v1:: UpdateShieldedInstanceConfigRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateShieldedInstanceConfig(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateShieldedInstanceConfig, (NoAwaitTag, @@ -841,6 +1555,15 @@ class MockInstancesConnection UpdateShieldedInstanceConfigRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateShieldedInstanceConfig(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateShieldedInstanceConfig, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/interconnect_attachments/v1/mocks/mock_interconnect_attachments_connection.h b/google/cloud/compute/interconnect_attachments/v1/mocks/mock_interconnect_attachments_connection.h index a33d1ad4c1c7e..f2c89fea70b2c 100644 --- a/google/cloud/compute/interconnect_attachments/v1/mocks/mock_interconnect_attachments_connection.h +++ b/google/cloud/compute/interconnect_attachments/v1/mocks/mock_interconnect_attachments_connection.h @@ -57,15 +57,27 @@ class MockInterconnectAttachmentsConnection AggregatedListInterconnectAttachmentsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteInterconnectAttachment)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteInterconnectAttachment(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteInterconnectAttachment(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteInterconnectAttachment, (google::cloud::cpp::compute::interconnect_attachments::v1:: DeleteInterconnectAttachmentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteInterconnectAttachment(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteInterconnectAttachment, (NoAwaitTag, @@ -73,6 +85,15 @@ class MockInterconnectAttachmentsConnection DeleteInterconnectAttachmentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteInterconnectAttachment(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteInterconnectAttachment, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -84,15 +105,27 @@ class MockInterconnectAttachmentsConnection GetInterconnectAttachmentRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InsertInterconnectAttachment)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, InsertInterconnectAttachment(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertInterconnectAttachment(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertInterconnectAttachment, (google::cloud::cpp::compute::interconnect_attachments::v1:: InsertInterconnectAttachmentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InsertInterconnectAttachment(_, _)) + /// @endcode MOCK_METHOD(StatusOr, InsertInterconnectAttachment, (NoAwaitTag, @@ -100,6 +133,15 @@ class MockInterconnectAttachmentsConnection InsertInterconnectAttachmentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertInterconnectAttachment(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertInterconnectAttachment, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -112,15 +154,27 @@ class MockInterconnectAttachmentsConnection ListInterconnectAttachmentsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, PatchInterconnectAttachment)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, PatchInterconnectAttachment(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchInterconnectAttachment(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchInterconnectAttachment, (google::cloud::cpp::compute::interconnect_attachments::v1:: PatchInterconnectAttachmentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, PatchInterconnectAttachment(_, _)) + /// @endcode MOCK_METHOD(StatusOr, PatchInterconnectAttachment, (NoAwaitTag, @@ -128,26 +182,55 @@ class MockInterconnectAttachmentsConnection PatchInterconnectAttachmentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchInterconnectAttachment(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchInterconnectAttachment, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SetLabels)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SetLabels(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetLabels(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetLabels, (google::cloud::cpp::compute::interconnect_attachments::v1:: SetLabelsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SetLabels(_, _)) + /// @endcode MOCK_METHOD(StatusOr, SetLabels, (NoAwaitTag, google::cloud::cpp::compute::interconnect_attachments::v1:: SetLabelsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetLabels(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetLabels, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/interconnects/v1/mocks/mock_interconnects_connection.h b/google/cloud/compute/interconnects/v1/mocks/mock_interconnects_connection.h index e54152023ec48..2502a8609faf1 100644 --- a/google/cloud/compute/interconnects/v1/mocks/mock_interconnects_connection.h +++ b/google/cloud/compute/interconnects/v1/mocks/mock_interconnects_connection.h @@ -47,21 +47,42 @@ class MockInterconnectsConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteInterconnect)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteInterconnect(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteInterconnect(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteInterconnect, (google::cloud::cpp::compute::interconnects::v1:: DeleteInterconnectRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteInterconnect(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteInterconnect, (NoAwaitTag, google::cloud::cpp::compute::interconnects::v1:: DeleteInterconnectRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteInterconnect(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteInterconnect, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -88,21 +109,42 @@ class MockInterconnectsConnection GetMacsecConfigRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InsertInterconnect)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, InsertInterconnect(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertInterconnect(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertInterconnect, (google::cloud::cpp::compute::interconnects::v1:: InsertInterconnectRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InsertInterconnect(_, _)) + /// @endcode MOCK_METHOD(StatusOr, InsertInterconnect, (NoAwaitTag, google::cloud::cpp::compute::interconnects::v1:: InsertInterconnectRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertInterconnect(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertInterconnect, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -115,35 +157,68 @@ class MockInterconnectsConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, PatchInterconnect)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, PatchInterconnect(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchInterconnect(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchInterconnect, (google::cloud::cpp::compute::interconnects::v1:: PatchInterconnectRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, PatchInterconnect(_, _)) + /// @endcode MOCK_METHOD(StatusOr, PatchInterconnect, (NoAwaitTag, google::cloud::cpp::compute::interconnects::v1:: PatchInterconnectRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchInterconnect(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchInterconnect, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SetLabels)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SetLabels(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetLabels(Matcher(_))) + /// @endcode MOCK_METHOD( future>, SetLabels, (google::cloud::cpp::compute::interconnects::v1::SetLabelsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SetLabels(_, _)) + /// @endcode MOCK_METHOD( StatusOr, SetLabels, (NoAwaitTag, @@ -151,6 +226,14 @@ class MockInterconnectsConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetLabels(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetLabels, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/licenses/v1/mocks/mock_licenses_connection.h b/google/cloud/compute/licenses/v1/mocks/mock_licenses_connection.h index b47f19cf92ea0..5ba9fbe2e3054 100644 --- a/google/cloud/compute/licenses/v1/mocks/mock_licenses_connection.h +++ b/google/cloud/compute/licenses/v1/mocks/mock_licenses_connection.h @@ -46,9 +46,15 @@ class MockLicensesConnection : public compute_licenses_v1::LicensesConnection { public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteLicense)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteLicense(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteLicense(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteLicense, @@ -56,6 +62,12 @@ class MockLicensesConnection : public compute_licenses_v1::LicensesConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteLicense(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteLicense, (NoAwaitTag, @@ -63,6 +75,15 @@ class MockLicensesConnection : public compute_licenses_v1::LicensesConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteLicense(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteLicense, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -80,9 +101,15 @@ class MockLicensesConnection : public compute_licenses_v1::LicensesConnection { request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InsertLicense)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, InsertLicense(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertLicense(Matcher(_))) + /// @endcode MOCK_METHOD( future>, InsertLicense, @@ -90,6 +117,12 @@ class MockLicensesConnection : public compute_licenses_v1::LicensesConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InsertLicense(_, _)) + /// @endcode MOCK_METHOD( StatusOr, InsertLicense, (NoAwaitTag, @@ -97,6 +130,15 @@ class MockLicensesConnection : public compute_licenses_v1::LicensesConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertLicense(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertLicense, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/machine_images/v1/mocks/mock_machine_images_connection.h b/google/cloud/compute/machine_images/v1/mocks/mock_machine_images_connection.h index 1cdbb3b018a48..48ff175d502bd 100644 --- a/google/cloud/compute/machine_images/v1/mocks/mock_machine_images_connection.h +++ b/google/cloud/compute/machine_images/v1/mocks/mock_machine_images_connection.h @@ -47,21 +47,42 @@ class MockMachineImagesConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteMachineImage)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteMachineImage(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteMachineImage(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteMachineImage, (google::cloud::cpp::compute::machine_images::v1:: DeleteMachineImageRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteMachineImage(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteMachineImage, (NoAwaitTag, google::cloud::cpp::compute::machine_images::v1:: DeleteMachineImageRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteMachineImage(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteMachineImage, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -78,21 +99,42 @@ class MockMachineImagesConnection GetIamPolicyRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InsertMachineImage)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, InsertMachineImage(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertMachineImage(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertMachineImage, (google::cloud::cpp::compute::machine_images::v1:: InsertMachineImageRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InsertMachineImage(_, _)) + /// @endcode MOCK_METHOD(StatusOr, InsertMachineImage, (NoAwaitTag, google::cloud::cpp::compute::machine_images::v1:: InsertMachineImageRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertMachineImage(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertMachineImage, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/network_attachments/v1/mocks/mock_network_attachments_connection.h b/google/cloud/compute/network_attachments/v1/mocks/mock_network_attachments_connection.h index 77e0f22afc486..408f2b27492d3 100644 --- a/google/cloud/compute/network_attachments/v1/mocks/mock_network_attachments_connection.h +++ b/google/cloud/compute/network_attachments/v1/mocks/mock_network_attachments_connection.h @@ -55,15 +55,27 @@ class MockNetworkAttachmentsConnection AggregatedListNetworkAttachmentsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteNetworkAttachment)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteNetworkAttachment(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteNetworkAttachment(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteNetworkAttachment, (google::cloud::cpp::compute::network_attachments::v1:: DeleteNetworkAttachmentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteNetworkAttachment(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteNetworkAttachment, (NoAwaitTag, @@ -71,6 +83,15 @@ class MockNetworkAttachmentsConnection DeleteNetworkAttachmentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteNetworkAttachment(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteNetworkAttachment, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -87,15 +108,27 @@ class MockNetworkAttachmentsConnection GetIamPolicyRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InsertNetworkAttachment)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, InsertNetworkAttachment(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertNetworkAttachment(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertNetworkAttachment, (google::cloud::cpp::compute::network_attachments::v1:: InsertNetworkAttachmentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InsertNetworkAttachment(_, _)) + /// @endcode MOCK_METHOD(StatusOr, InsertNetworkAttachment, (NoAwaitTag, @@ -103,6 +136,15 @@ class MockNetworkAttachmentsConnection InsertNetworkAttachmentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertNetworkAttachment(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertNetworkAttachment, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -114,15 +156,27 @@ class MockNetworkAttachmentsConnection ListNetworkAttachmentsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, PatchNetworkAttachment)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, PatchNetworkAttachment(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchNetworkAttachment(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchNetworkAttachment, (google::cloud::cpp::compute::network_attachments::v1:: PatchNetworkAttachmentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, PatchNetworkAttachment(_, _)) + /// @endcode MOCK_METHOD(StatusOr, PatchNetworkAttachment, (NoAwaitTag, @@ -130,6 +184,15 @@ class MockNetworkAttachmentsConnection PatchNetworkAttachmentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchNetworkAttachment(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchNetworkAttachment, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/network_edge_security_services/v1/mocks/mock_network_edge_security_services_connection.h b/google/cloud/compute/network_edge_security_services/v1/mocks/mock_network_edge_security_services_connection.h index cbc3a39aeb1ab..a685232a8154a 100644 --- a/google/cloud/compute/network_edge_security_services/v1/mocks/mock_network_edge_security_services_connection.h +++ b/google/cloud/compute/network_edge_security_services/v1/mocks/mock_network_edge_security_services_connection.h @@ -58,16 +58,27 @@ class MockNetworkEdgeSecurityServicesConnection AggregatedListNetworkEdgeSecurityServicesRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteNetworkEdgeSecurityService)` is now ambiguous. - /// Use `EXPECT_CALL(*mock, DeleteNetworkEdgeSecurityService(::testing::_))` - /// instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteNetworkEdgeSecurityService(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteNetworkEdgeSecurityService, (google::cloud::cpp::compute::network_edge_security_services::v1:: DeleteNetworkEdgeSecurityServiceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteNetworkEdgeSecurityService(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteNetworkEdgeSecurityService, (NoAwaitTag, @@ -75,6 +86,15 @@ class MockNetworkEdgeSecurityServicesConnection DeleteNetworkEdgeSecurityServiceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteNetworkEdgeSecurityService(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteNetworkEdgeSecurityService, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -87,16 +107,27 @@ class MockNetworkEdgeSecurityServicesConnection GetNetworkEdgeSecurityServiceRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InsertNetworkEdgeSecurityService)` is now ambiguous. - /// Use `EXPECT_CALL(*mock, InsertNetworkEdgeSecurityService(::testing::_))` - /// instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertNetworkEdgeSecurityService(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertNetworkEdgeSecurityService, (google::cloud::cpp::compute::network_edge_security_services::v1:: InsertNetworkEdgeSecurityServiceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InsertNetworkEdgeSecurityService(_, _)) + /// @endcode MOCK_METHOD(StatusOr, InsertNetworkEdgeSecurityService, (NoAwaitTag, @@ -104,21 +135,41 @@ class MockNetworkEdgeSecurityServicesConnection InsertNetworkEdgeSecurityServiceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertNetworkEdgeSecurityService(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertNetworkEdgeSecurityService, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, PatchNetworkEdgeSecurityService)` is now ambiguous. - /// Use `EXPECT_CALL(*mock, PatchNetworkEdgeSecurityService(::testing::_))` - /// instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchNetworkEdgeSecurityService(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchNetworkEdgeSecurityService, (google::cloud::cpp::compute::network_edge_security_services::v1:: PatchNetworkEdgeSecurityServiceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, PatchNetworkEdgeSecurityService(_, _)) + /// @endcode MOCK_METHOD(StatusOr, PatchNetworkEdgeSecurityService, (NoAwaitTag, @@ -126,6 +177,15 @@ class MockNetworkEdgeSecurityServicesConnection PatchNetworkEdgeSecurityServiceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchNetworkEdgeSecurityService(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchNetworkEdgeSecurityService, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/network_endpoint_groups/v1/mocks/mock_network_endpoint_groups_connection.h b/google/cloud/compute/network_endpoint_groups/v1/mocks/mock_network_endpoint_groups_connection.h index 03d8cad5baf24..8079fa34911dd 100644 --- a/google/cloud/compute/network_endpoint_groups/v1/mocks/mock_network_endpoint_groups_connection.h +++ b/google/cloud/compute/network_endpoint_groups/v1/mocks/mock_network_endpoint_groups_connection.h @@ -58,15 +58,27 @@ class MockNetworkEndpointGroupsConnection AggregatedListNetworkEndpointGroupsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, AttachNetworkEndpoints)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, AttachNetworkEndpoints(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// AttachNetworkEndpoints(Matcher(_))) + /// @endcode MOCK_METHOD(future>, AttachNetworkEndpoints, (google::cloud::cpp::compute::network_endpoint_groups::v1:: AttachNetworkEndpointsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, AttachNetworkEndpoints(_, _)) + /// @endcode MOCK_METHOD(StatusOr, AttachNetworkEndpoints, (NoAwaitTag, @@ -74,20 +86,41 @@ class MockNetworkEndpointGroupsConnection AttachNetworkEndpointsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// AttachNetworkEndpoints(Matcher(_))) + /// @endcode MOCK_METHOD(future>, AttachNetworkEndpoints, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteNetworkEndpointGroup)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteNetworkEndpointGroup(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteNetworkEndpointGroup(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteNetworkEndpointGroup, (google::cloud::cpp::compute::network_endpoint_groups::v1:: DeleteNetworkEndpointGroupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteNetworkEndpointGroup(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteNetworkEndpointGroup, (NoAwaitTag, @@ -95,20 +128,41 @@ class MockNetworkEndpointGroupsConnection DeleteNetworkEndpointGroupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteNetworkEndpointGroup(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteNetworkEndpointGroup, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DetachNetworkEndpoints)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DetachNetworkEndpoints(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DetachNetworkEndpoints(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DetachNetworkEndpoints, (google::cloud::cpp::compute::network_endpoint_groups::v1:: DetachNetworkEndpointsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DetachNetworkEndpoints(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DetachNetworkEndpoints, (NoAwaitTag, @@ -116,6 +170,15 @@ class MockNetworkEndpointGroupsConnection DetachNetworkEndpointsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DetachNetworkEndpoints(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DetachNetworkEndpoints, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -127,15 +190,27 @@ class MockNetworkEndpointGroupsConnection GetNetworkEndpointGroupRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InsertNetworkEndpointGroup)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, InsertNetworkEndpointGroup(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertNetworkEndpointGroup(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertNetworkEndpointGroup, (google::cloud::cpp::compute::network_endpoint_groups::v1:: InsertNetworkEndpointGroupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InsertNetworkEndpointGroup(_, _)) + /// @endcode MOCK_METHOD(StatusOr, InsertNetworkEndpointGroup, (NoAwaitTag, @@ -143,6 +218,15 @@ class MockNetworkEndpointGroupsConnection InsertNetworkEndpointGroupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertNetworkEndpointGroup(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertNetworkEndpointGroup, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/network_firewall_policies/v1/mocks/mock_network_firewall_policies_connection.h b/google/cloud/compute/network_firewall_policies/v1/mocks/mock_network_firewall_policies_connection.h index 2a9306f76016e..9b22e2d6433bc 100644 --- a/google/cloud/compute/network_firewall_policies/v1/mocks/mock_network_firewall_policies_connection.h +++ b/google/cloud/compute/network_firewall_policies/v1/mocks/mock_network_firewall_policies_connection.h @@ -49,15 +49,27 @@ class MockNetworkFirewallPoliciesConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, AddAssociation)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, AddAssociation(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// AddAssociation(Matcher(_))) + /// @endcode MOCK_METHOD(future>, AddAssociation, (google::cloud::cpp::compute::network_firewall_policies::v1:: AddAssociationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, AddAssociation(_, _)) + /// @endcode MOCK_METHOD(StatusOr, AddAssociation, (NoAwaitTag, @@ -65,60 +77,121 @@ class MockNetworkFirewallPoliciesConnection AddAssociationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// AddAssociation(Matcher(_))) + /// @endcode MOCK_METHOD(future>, AddAssociation, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, AddRule)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, AddRule(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// AddRule(Matcher(_))) + /// @endcode MOCK_METHOD(future>, AddRule, (google::cloud::cpp::compute::network_firewall_policies::v1:: AddRuleRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, AddRule(_, _)) + /// @endcode MOCK_METHOD(StatusOr, AddRule, (NoAwaitTag, google::cloud::cpp::compute::network_firewall_policies::v1:: AddRuleRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// AddRule(Matcher(_))) + /// @endcode MOCK_METHOD(future>, AddRule, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CloneRules)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CloneRules(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CloneRules(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CloneRules, (google::cloud::cpp::compute::network_firewall_policies::v1:: CloneRulesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CloneRules(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CloneRules, (NoAwaitTag, google::cloud::cpp::compute::network_firewall_policies::v1:: CloneRulesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CloneRules(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CloneRules, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteFirewallPolicy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteFirewallPolicy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteFirewallPolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteFirewallPolicy, (google::cloud::cpp::compute::network_firewall_policies::v1:: DeleteFirewallPolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteFirewallPolicy(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteFirewallPolicy, (NoAwaitTag, @@ -126,6 +199,15 @@ class MockNetworkFirewallPoliciesConnection DeleteFirewallPolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteFirewallPolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteFirewallPolicy, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -155,15 +237,27 @@ class MockNetworkFirewallPoliciesConnection GetRuleRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InsertFirewallPolicy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, InsertFirewallPolicy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertFirewallPolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertFirewallPolicy, (google::cloud::cpp::compute::network_firewall_policies::v1:: InsertFirewallPolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InsertFirewallPolicy(_, _)) + /// @endcode MOCK_METHOD(StatusOr, InsertFirewallPolicy, (NoAwaitTag, @@ -171,6 +265,15 @@ class MockNetworkFirewallPoliciesConnection InsertFirewallPolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertFirewallPolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertFirewallPolicy, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -182,15 +285,27 @@ class MockNetworkFirewallPoliciesConnection ListNetworkFirewallPoliciesRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, PatchFirewallPolicy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, PatchFirewallPolicy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchFirewallPolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchFirewallPolicy, (google::cloud::cpp::compute::network_firewall_policies::v1:: PatchFirewallPolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, PatchFirewallPolicy(_, _)) + /// @endcode MOCK_METHOD(StatusOr, PatchFirewallPolicy, (NoAwaitTag, @@ -198,40 +313,81 @@ class MockNetworkFirewallPoliciesConnection PatchFirewallPolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchFirewallPolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchFirewallPolicy, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, PatchRule)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, PatchRule(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchRule(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchRule, (google::cloud::cpp::compute::network_firewall_policies::v1:: PatchRuleRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, PatchRule(_, _)) + /// @endcode MOCK_METHOD(StatusOr, PatchRule, (NoAwaitTag, google::cloud::cpp::compute::network_firewall_policies::v1:: PatchRuleRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchRule(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchRule, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, RemoveAssociation)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, RemoveAssociation(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RemoveAssociation(Matcher(_))) + /// @endcode MOCK_METHOD(future>, RemoveAssociation, (google::cloud::cpp::compute::network_firewall_policies::v1:: RemoveAssociationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, RemoveAssociation(_, _)) + /// @endcode MOCK_METHOD(StatusOr, RemoveAssociation, (NoAwaitTag, @@ -239,26 +395,55 @@ class MockNetworkFirewallPoliciesConnection RemoveAssociationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RemoveAssociation(Matcher(_))) + /// @endcode MOCK_METHOD(future>, RemoveAssociation, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, RemoveRule)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, RemoveRule(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RemoveRule(Matcher(_))) + /// @endcode MOCK_METHOD(future>, RemoveRule, (google::cloud::cpp::compute::network_firewall_policies::v1:: RemoveRuleRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, RemoveRule(_, _)) + /// @endcode MOCK_METHOD(StatusOr, RemoveRule, (NoAwaitTag, google::cloud::cpp::compute::network_firewall_policies::v1:: RemoveRuleRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RemoveRule(Matcher(_))) + /// @endcode MOCK_METHOD(future>, RemoveRule, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/networks/v1/mocks/mock_networks_connection.h b/google/cloud/compute/networks/v1/mocks/mock_networks_connection.h index 53b42b69ea635..2bcc1a1b0a201 100644 --- a/google/cloud/compute/networks/v1/mocks/mock_networks_connection.h +++ b/google/cloud/compute/networks/v1/mocks/mock_networks_connection.h @@ -46,15 +46,27 @@ class MockNetworksConnection : public compute_networks_v1::NetworksConnection { public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, AddPeering)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, AddPeering(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// AddPeering(Matcher(_))) + /// @endcode MOCK_METHOD( future>, AddPeering, (google::cloud::cpp::compute::networks::v1::AddPeeringRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, AddPeering(_, _)) + /// @endcode MOCK_METHOD( StatusOr, AddPeering, (NoAwaitTag, @@ -62,14 +74,28 @@ class MockNetworksConnection : public compute_networks_v1::NetworksConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// AddPeering(Matcher(_))) + /// @endcode MOCK_METHOD(future>, AddPeering, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteNetwork)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteNetwork(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteNetwork(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteNetwork, @@ -77,6 +103,12 @@ class MockNetworksConnection : public compute_networks_v1::NetworksConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteNetwork(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteNetwork, (NoAwaitTag, @@ -84,6 +116,15 @@ class MockNetworksConnection : public compute_networks_v1::NetworksConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteNetwork(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteNetwork, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -102,9 +143,15 @@ class MockNetworksConnection : public compute_networks_v1::NetworksConnection { GetEffectiveFirewallsRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InsertNetwork)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, InsertNetwork(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertNetwork(Matcher(_))) + /// @endcode MOCK_METHOD( future>, InsertNetwork, @@ -112,6 +159,12 @@ class MockNetworksConnection : public compute_networks_v1::NetworksConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InsertNetwork(_, _)) + /// @endcode MOCK_METHOD( StatusOr, InsertNetwork, (NoAwaitTag, @@ -119,6 +172,15 @@ class MockNetworksConnection : public compute_networks_v1::NetworksConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertNetwork(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertNetwork, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -136,9 +198,15 @@ class MockNetworksConnection : public compute_networks_v1::NetworksConnection { request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, PatchNetwork)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, PatchNetwork(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchNetwork(Matcher(_))) + /// @endcode MOCK_METHOD( future>, PatchNetwork, @@ -146,6 +214,12 @@ class MockNetworksConnection : public compute_networks_v1::NetworksConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, PatchNetwork(_, _)) + /// @endcode MOCK_METHOD( StatusOr, PatchNetwork, (NoAwaitTag, @@ -153,14 +227,29 @@ class MockNetworksConnection : public compute_networks_v1::NetworksConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchNetwork(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchNetwork, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, RemovePeering)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, RemovePeering(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RemovePeering(Matcher(_))) + /// @endcode MOCK_METHOD( future>, RemovePeering, @@ -168,6 +257,12 @@ class MockNetworksConnection : public compute_networks_v1::NetworksConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, RemovePeering(_, _)) + /// @endcode MOCK_METHOD( StatusOr, RemovePeering, (NoAwaitTag, @@ -175,34 +270,70 @@ class MockNetworksConnection : public compute_networks_v1::NetworksConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RemovePeering(Matcher(_))) + /// @endcode MOCK_METHOD(future>, RemovePeering, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SwitchToCustomMode)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SwitchToCustomMode(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SwitchToCustomMode(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SwitchToCustomMode, (google::cloud::cpp::compute::networks::v1:: SwitchToCustomModeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SwitchToCustomMode(_, _)) + /// @endcode MOCK_METHOD(StatusOr, SwitchToCustomMode, (NoAwaitTag, google::cloud::cpp::compute::networks::v1:: SwitchToCustomModeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SwitchToCustomMode(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SwitchToCustomMode, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdatePeering)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdatePeering(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdatePeering(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdatePeering, @@ -210,6 +341,12 @@ class MockNetworksConnection : public compute_networks_v1::NetworksConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdatePeering(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdatePeering, (NoAwaitTag, @@ -217,6 +354,15 @@ class MockNetworksConnection : public compute_networks_v1::NetworksConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdatePeering(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdatePeering, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/node_groups/v1/mocks/mock_node_groups_connection.h b/google/cloud/compute/node_groups/v1/mocks/mock_node_groups_connection.h index d30a34e008f7e..db995c8dfedcf 100644 --- a/google/cloud/compute/node_groups/v1/mocks/mock_node_groups_connection.h +++ b/google/cloud/compute/node_groups/v1/mocks/mock_node_groups_connection.h @@ -47,15 +47,27 @@ class MockNodeGroupsConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, AddNodes)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, AddNodes(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// AddNodes(Matcher(_))) + /// @endcode MOCK_METHOD( future>, AddNodes, (google::cloud::cpp::compute::node_groups::v1::AddNodesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, AddNodes(_, _)) + /// @endcode MOCK_METHOD( StatusOr, AddNodes, (NoAwaitTag, @@ -63,6 +75,14 @@ class MockNodeGroupsConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// AddNodes(Matcher(_))) + /// @endcode MOCK_METHOD(future>, AddNodes, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -77,35 +97,68 @@ class MockNodeGroupsConnection AggregatedListNodeGroupsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteNodeGroup)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteNodeGroup(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteNodeGroup(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteNodeGroup, (google::cloud::cpp::compute::node_groups::v1:: DeleteNodeGroupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteNodeGroup(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteNodeGroup, (NoAwaitTag, google::cloud::cpp::compute::node_groups::v1:: DeleteNodeGroupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteNodeGroup(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteNodeGroup, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteNodes)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteNodes(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteNodes(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteNodes, (google::cloud::cpp::compute::node_groups::v1::DeleteNodesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteNodes(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteNodes, (NoAwaitTag, @@ -113,6 +166,15 @@ class MockNodeGroupsConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteNodes(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteNodes, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -130,21 +192,42 @@ class MockNodeGroupsConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InsertNodeGroup)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, InsertNodeGroup(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertNodeGroup(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertNodeGroup, (google::cloud::cpp::compute::node_groups::v1:: InsertNodeGroupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InsertNodeGroup(_, _)) + /// @endcode MOCK_METHOD(StatusOr, InsertNodeGroup, (NoAwaitTag, google::cloud::cpp::compute::node_groups::v1:: InsertNodeGroupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertNodeGroup(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertNodeGroup, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -161,41 +244,83 @@ class MockNodeGroupsConnection (google::cloud::cpp::compute::node_groups::v1::ListNodesRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, PatchNodeGroup)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, PatchNodeGroup(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchNodeGroup(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchNodeGroup, (google::cloud::cpp::compute::node_groups::v1:: PatchNodeGroupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, PatchNodeGroup(_, _)) + /// @endcode MOCK_METHOD(StatusOr, PatchNodeGroup, (NoAwaitTag, google::cloud::cpp::compute::node_groups::v1:: PatchNodeGroupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchNodeGroup(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchNodeGroup, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, PerformMaintenance)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, PerformMaintenance(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PerformMaintenance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PerformMaintenance, (google::cloud::cpp::compute::node_groups::v1:: PerformMaintenanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, PerformMaintenance(_, _)) + /// @endcode MOCK_METHOD(StatusOr, PerformMaintenance, (NoAwaitTag, google::cloud::cpp::compute::node_groups::v1:: PerformMaintenanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PerformMaintenance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PerformMaintenance, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -207,41 +332,83 @@ class MockNodeGroupsConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SetNodeTemplate)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SetNodeTemplate(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetNodeTemplate(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetNodeTemplate, (google::cloud::cpp::compute::node_groups::v1:: SetNodeTemplateRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SetNodeTemplate(_, _)) + /// @endcode MOCK_METHOD(StatusOr, SetNodeTemplate, (NoAwaitTag, google::cloud::cpp::compute::node_groups::v1:: SetNodeTemplateRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetNodeTemplate(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetNodeTemplate, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SimulateMaintenanceEvent)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SimulateMaintenanceEvent(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SimulateMaintenanceEvent(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SimulateMaintenanceEvent, (google::cloud::cpp::compute::node_groups::v1:: SimulateMaintenanceEventRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SimulateMaintenanceEvent(_, _)) + /// @endcode MOCK_METHOD(StatusOr, SimulateMaintenanceEvent, (NoAwaitTag, google::cloud::cpp::compute::node_groups::v1:: SimulateMaintenanceEventRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SimulateMaintenanceEvent(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SimulateMaintenanceEvent, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/node_templates/v1/mocks/mock_node_templates_connection.h b/google/cloud/compute/node_templates/v1/mocks/mock_node_templates_connection.h index 36424a35aeb99..07d1357a9540f 100644 --- a/google/cloud/compute/node_templates/v1/mocks/mock_node_templates_connection.h +++ b/google/cloud/compute/node_templates/v1/mocks/mock_node_templates_connection.h @@ -56,21 +56,42 @@ class MockNodeTemplatesConnection AggregatedListNodeTemplatesRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteNodeTemplate)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteNodeTemplate(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteNodeTemplate(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteNodeTemplate, (google::cloud::cpp::compute::node_templates::v1:: DeleteNodeTemplateRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteNodeTemplate(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteNodeTemplate, (NoAwaitTag, google::cloud::cpp::compute::node_templates::v1:: DeleteNodeTemplateRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteNodeTemplate(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteNodeTemplate, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -87,21 +108,42 @@ class MockNodeTemplatesConnection GetIamPolicyRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InsertNodeTemplate)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, InsertNodeTemplate(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertNodeTemplate(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertNodeTemplate, (google::cloud::cpp::compute::node_templates::v1:: InsertNodeTemplateRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InsertNodeTemplate(_, _)) + /// @endcode MOCK_METHOD(StatusOr, InsertNodeTemplate, (NoAwaitTag, google::cloud::cpp::compute::node_templates::v1:: InsertNodeTemplateRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertNodeTemplate(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertNodeTemplate, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/packet_mirrorings/v1/mocks/mock_packet_mirrorings_connection.h b/google/cloud/compute/packet_mirrorings/v1/mocks/mock_packet_mirrorings_connection.h index 45732793fbc37..d7155e4d78ead 100644 --- a/google/cloud/compute/packet_mirrorings/v1/mocks/mock_packet_mirrorings_connection.h +++ b/google/cloud/compute/packet_mirrorings/v1/mocks/mock_packet_mirrorings_connection.h @@ -55,21 +55,42 @@ class MockPacketMirroringsConnection AggregatedListPacketMirroringsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeletePacketMirroring)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeletePacketMirroring(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeletePacketMirroring(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeletePacketMirroring, (google::cloud::cpp::compute::packet_mirrorings::v1:: DeletePacketMirroringRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeletePacketMirroring(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeletePacketMirroring, (NoAwaitTag, google::cloud::cpp::compute::packet_mirrorings::v1:: DeletePacketMirroringRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeletePacketMirroring(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeletePacketMirroring, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -81,21 +102,42 @@ class MockPacketMirroringsConnection GetPacketMirroringRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InsertPacketMirroring)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, InsertPacketMirroring(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertPacketMirroring(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertPacketMirroring, (google::cloud::cpp::compute::packet_mirrorings::v1:: InsertPacketMirroringRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InsertPacketMirroring(_, _)) + /// @endcode MOCK_METHOD(StatusOr, InsertPacketMirroring, (NoAwaitTag, google::cloud::cpp::compute::packet_mirrorings::v1:: InsertPacketMirroringRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertPacketMirroring(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertPacketMirroring, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -107,21 +149,42 @@ class MockPacketMirroringsConnection ListPacketMirroringsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, PatchPacketMirroring)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, PatchPacketMirroring(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchPacketMirroring(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchPacketMirroring, (google::cloud::cpp::compute::packet_mirrorings::v1:: PatchPacketMirroringRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, PatchPacketMirroring(_, _)) + /// @endcode MOCK_METHOD(StatusOr, PatchPacketMirroring, (NoAwaitTag, google::cloud::cpp::compute::packet_mirrorings::v1:: PatchPacketMirroringRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchPacketMirroring(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchPacketMirroring, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/projects/v1/mocks/mock_projects_connection.h b/google/cloud/compute/projects/v1/mocks/mock_projects_connection.h index 943f77bc63331..0d668f870af58 100644 --- a/google/cloud/compute/projects/v1/mocks/mock_projects_connection.h +++ b/google/cloud/compute/projects/v1/mocks/mock_projects_connection.h @@ -46,9 +46,15 @@ class MockProjectsConnection : public compute_projects_v1::ProjectsConnection { public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DisableXpnHost)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DisableXpnHost(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DisableXpnHost(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DisableXpnHost, @@ -56,6 +62,12 @@ class MockProjectsConnection : public compute_projects_v1::ProjectsConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DisableXpnHost(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DisableXpnHost, (NoAwaitTag, @@ -63,34 +75,70 @@ class MockProjectsConnection : public compute_projects_v1::ProjectsConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DisableXpnHost(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DisableXpnHost, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DisableXpnResource)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DisableXpnResource(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DisableXpnResource(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DisableXpnResource, (google::cloud::cpp::compute::projects::v1:: DisableXpnResourceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DisableXpnResource(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DisableXpnResource, (NoAwaitTag, google::cloud::cpp::compute::projects::v1:: DisableXpnResourceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DisableXpnResource(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DisableXpnResource, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, EnableXpnHost)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, EnableXpnHost(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// EnableXpnHost(Matcher(_))) + /// @endcode MOCK_METHOD( future>, EnableXpnHost, @@ -98,6 +146,12 @@ class MockProjectsConnection : public compute_projects_v1::ProjectsConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, EnableXpnHost(_, _)) + /// @endcode MOCK_METHOD( StatusOr, EnableXpnHost, (NoAwaitTag, @@ -105,26 +159,56 @@ class MockProjectsConnection : public compute_projects_v1::ProjectsConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// EnableXpnHost(Matcher(_))) + /// @endcode MOCK_METHOD(future>, EnableXpnHost, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, EnableXpnResource)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, EnableXpnResource(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// EnableXpnResource(Matcher(_))) + /// @endcode MOCK_METHOD(future>, EnableXpnResource, (google::cloud::cpp::compute::projects::v1:: EnableXpnResourceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, EnableXpnResource(_, _)) + /// @endcode MOCK_METHOD(StatusOr, EnableXpnResource, (NoAwaitTag, google::cloud::cpp::compute::projects::v1:: EnableXpnResourceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// EnableXpnResource(Matcher(_))) + /// @endcode MOCK_METHOD(future>, EnableXpnResource, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -154,29 +238,55 @@ class MockProjectsConnection : public compute_projects_v1::ProjectsConnection { (google::cloud::cpp::compute::projects::v1::ListXpnHostsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, MoveDisk)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, MoveDisk(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// MoveDisk(Matcher(_))) + /// @endcode MOCK_METHOD(future>, MoveDisk, (google::cloud::cpp::compute::projects::v1::MoveDiskRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, MoveDisk(_, _)) + /// @endcode MOCK_METHOD(StatusOr, MoveDisk, (NoAwaitTag, google::cloud::cpp::compute::projects::v1::MoveDiskRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// MoveDisk(Matcher(_))) + /// @endcode MOCK_METHOD(future>, MoveDisk, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, MoveInstance)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, MoveInstance(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// MoveInstance(Matcher(_))) + /// @endcode MOCK_METHOD( future>, MoveInstance, @@ -184,6 +294,12 @@ class MockProjectsConnection : public compute_projects_v1::ProjectsConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, MoveInstance(_, _)) + /// @endcode MOCK_METHOD( StatusOr, MoveInstance, (NoAwaitTag, @@ -191,86 +307,179 @@ class MockProjectsConnection : public compute_projects_v1::ProjectsConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// MoveInstance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, MoveInstance, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SetCloudArmorTier)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SetCloudArmorTier(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetCloudArmorTier(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetCloudArmorTier, (google::cloud::cpp::compute::projects::v1:: SetCloudArmorTierRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SetCloudArmorTier(_, _)) + /// @endcode MOCK_METHOD(StatusOr, SetCloudArmorTier, (NoAwaitTag, google::cloud::cpp::compute::projects::v1:: SetCloudArmorTierRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetCloudArmorTier(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetCloudArmorTier, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SetCommonInstanceMetadata)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SetCommonInstanceMetadata(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetCommonInstanceMetadata(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetCommonInstanceMetadata, (google::cloud::cpp::compute::projects::v1:: SetCommonInstanceMetadataRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SetCommonInstanceMetadata(_, _)) + /// @endcode MOCK_METHOD(StatusOr, SetCommonInstanceMetadata, (NoAwaitTag, google::cloud::cpp::compute::projects::v1:: SetCommonInstanceMetadataRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetCommonInstanceMetadata(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetCommonInstanceMetadata, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SetDefaultNetworkTier)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SetDefaultNetworkTier(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetDefaultNetworkTier(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetDefaultNetworkTier, (google::cloud::cpp::compute::projects::v1:: SetDefaultNetworkTierRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SetDefaultNetworkTier(_, _)) + /// @endcode MOCK_METHOD(StatusOr, SetDefaultNetworkTier, (NoAwaitTag, google::cloud::cpp::compute::projects::v1:: SetDefaultNetworkTierRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetDefaultNetworkTier(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetDefaultNetworkTier, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SetUsageExportBucket)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SetUsageExportBucket(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetUsageExportBucket(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetUsageExportBucket, (google::cloud::cpp::compute::projects::v1:: SetUsageExportBucketRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SetUsageExportBucket(_, _)) + /// @endcode MOCK_METHOD(StatusOr, SetUsageExportBucket, (NoAwaitTag, google::cloud::cpp::compute::projects::v1:: SetUsageExportBucketRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetUsageExportBucket(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetUsageExportBucket, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/public_advertised_prefixes/v1/mocks/mock_public_advertised_prefixes_connection.h b/google/cloud/compute/public_advertised_prefixes/v1/mocks/mock_public_advertised_prefixes_connection.h index a83987661949f..c1e3ba4aab30f 100644 --- a/google/cloud/compute/public_advertised_prefixes/v1/mocks/mock_public_advertised_prefixes_connection.h +++ b/google/cloud/compute/public_advertised_prefixes/v1/mocks/mock_public_advertised_prefixes_connection.h @@ -49,35 +49,67 @@ class MockPublicAdvertisedPrefixesConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, Announce)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, Announce(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// Announce(Matcher(_))) + /// @endcode MOCK_METHOD(future>, Announce, (google::cloud::cpp::compute::public_advertised_prefixes::v1:: AnnounceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, Announce(_, _)) + /// @endcode MOCK_METHOD(StatusOr, Announce, (NoAwaitTag, google::cloud::cpp::compute::public_advertised_prefixes::v1:: AnnounceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// Announce(Matcher(_))) + /// @endcode MOCK_METHOD(future>, Announce, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeletePublicAdvertisedPrefix)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeletePublicAdvertisedPrefix(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeletePublicAdvertisedPrefix(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeletePublicAdvertisedPrefix, (google::cloud::cpp::compute::public_advertised_prefixes::v1:: DeletePublicAdvertisedPrefixRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeletePublicAdvertisedPrefix(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeletePublicAdvertisedPrefix, (NoAwaitTag, @@ -85,6 +117,15 @@ class MockPublicAdvertisedPrefixesConnection DeletePublicAdvertisedPrefixRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeletePublicAdvertisedPrefix(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeletePublicAdvertisedPrefix, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -96,15 +137,27 @@ class MockPublicAdvertisedPrefixesConnection GetPublicAdvertisedPrefixRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InsertPublicAdvertisedPrefix)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, InsertPublicAdvertisedPrefix(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertPublicAdvertisedPrefix(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertPublicAdvertisedPrefix, (google::cloud::cpp::compute::public_advertised_prefixes::v1:: InsertPublicAdvertisedPrefixRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InsertPublicAdvertisedPrefix(_, _)) + /// @endcode MOCK_METHOD(StatusOr, InsertPublicAdvertisedPrefix, (NoAwaitTag, @@ -112,6 +165,15 @@ class MockPublicAdvertisedPrefixesConnection InsertPublicAdvertisedPrefixRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertPublicAdvertisedPrefix(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertPublicAdvertisedPrefix, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -124,15 +186,27 @@ class MockPublicAdvertisedPrefixesConnection ListPublicAdvertisedPrefixesRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, PatchPublicAdvertisedPrefix)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, PatchPublicAdvertisedPrefix(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchPublicAdvertisedPrefix(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchPublicAdvertisedPrefix, (google::cloud::cpp::compute::public_advertised_prefixes::v1:: PatchPublicAdvertisedPrefixRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, PatchPublicAdvertisedPrefix(_, _)) + /// @endcode MOCK_METHOD(StatusOr, PatchPublicAdvertisedPrefix, (NoAwaitTag, @@ -140,26 +214,55 @@ class MockPublicAdvertisedPrefixesConnection PatchPublicAdvertisedPrefixRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchPublicAdvertisedPrefix(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchPublicAdvertisedPrefix, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, Withdraw)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, Withdraw(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// Withdraw(Matcher(_))) + /// @endcode MOCK_METHOD(future>, Withdraw, (google::cloud::cpp::compute::public_advertised_prefixes::v1:: WithdrawRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, Withdraw(_, _)) + /// @endcode MOCK_METHOD(StatusOr, Withdraw, (NoAwaitTag, google::cloud::cpp::compute::public_advertised_prefixes::v1:: WithdrawRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// Withdraw(Matcher(_))) + /// @endcode MOCK_METHOD(future>, Withdraw, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/public_delegated_prefixes/v1/mocks/mock_public_delegated_prefixes_connection.h b/google/cloud/compute/public_delegated_prefixes/v1/mocks/mock_public_delegated_prefixes_connection.h index 01b5d7be1052d..2bf23acd5796a 100644 --- a/google/cloud/compute/public_delegated_prefixes/v1/mocks/mock_public_delegated_prefixes_connection.h +++ b/google/cloud/compute/public_delegated_prefixes/v1/mocks/mock_public_delegated_prefixes_connection.h @@ -57,35 +57,67 @@ class MockPublicDelegatedPrefixesConnection AggregatedListPublicDelegatedPrefixesRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, Announce)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, Announce(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// Announce(Matcher(_))) + /// @endcode MOCK_METHOD(future>, Announce, (google::cloud::cpp::compute::public_delegated_prefixes::v1:: AnnounceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, Announce(_, _)) + /// @endcode MOCK_METHOD(StatusOr, Announce, (NoAwaitTag, google::cloud::cpp::compute::public_delegated_prefixes::v1:: AnnounceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// Announce(Matcher(_))) + /// @endcode MOCK_METHOD(future>, Announce, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeletePublicDelegatedPrefix)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeletePublicDelegatedPrefix(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeletePublicDelegatedPrefix(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeletePublicDelegatedPrefix, (google::cloud::cpp::compute::public_delegated_prefixes::v1:: DeletePublicDelegatedPrefixRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeletePublicDelegatedPrefix(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeletePublicDelegatedPrefix, (NoAwaitTag, @@ -93,6 +125,15 @@ class MockPublicDelegatedPrefixesConnection DeletePublicDelegatedPrefixRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeletePublicDelegatedPrefix(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeletePublicDelegatedPrefix, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -104,15 +145,27 @@ class MockPublicDelegatedPrefixesConnection GetPublicDelegatedPrefixRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InsertPublicDelegatedPrefix)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, InsertPublicDelegatedPrefix(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertPublicDelegatedPrefix(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertPublicDelegatedPrefix, (google::cloud::cpp::compute::public_delegated_prefixes::v1:: InsertPublicDelegatedPrefixRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InsertPublicDelegatedPrefix(_, _)) + /// @endcode MOCK_METHOD(StatusOr, InsertPublicDelegatedPrefix, (NoAwaitTag, @@ -120,6 +173,15 @@ class MockPublicDelegatedPrefixesConnection InsertPublicDelegatedPrefixRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertPublicDelegatedPrefix(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertPublicDelegatedPrefix, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -132,15 +194,27 @@ class MockPublicDelegatedPrefixesConnection ListPublicDelegatedPrefixesRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, PatchPublicDelegatedPrefix)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, PatchPublicDelegatedPrefix(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchPublicDelegatedPrefix(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchPublicDelegatedPrefix, (google::cloud::cpp::compute::public_delegated_prefixes::v1:: PatchPublicDelegatedPrefixRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, PatchPublicDelegatedPrefix(_, _)) + /// @endcode MOCK_METHOD(StatusOr, PatchPublicDelegatedPrefix, (NoAwaitTag, @@ -148,26 +222,55 @@ class MockPublicDelegatedPrefixesConnection PatchPublicDelegatedPrefixRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchPublicDelegatedPrefix(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchPublicDelegatedPrefix, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, Withdraw)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, Withdraw(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// Withdraw(Matcher(_))) + /// @endcode MOCK_METHOD(future>, Withdraw, (google::cloud::cpp::compute::public_delegated_prefixes::v1:: WithdrawRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, Withdraw(_, _)) + /// @endcode MOCK_METHOD(StatusOr, Withdraw, (NoAwaitTag, google::cloud::cpp::compute::public_delegated_prefixes::v1:: WithdrawRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// Withdraw(Matcher(_))) + /// @endcode MOCK_METHOD(future>, Withdraw, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/region_autoscalers/v1/mocks/mock_region_autoscalers_connection.h b/google/cloud/compute/region_autoscalers/v1/mocks/mock_region_autoscalers_connection.h index 30c9b4a40c728..34b9490469684 100644 --- a/google/cloud/compute/region_autoscalers/v1/mocks/mock_region_autoscalers_connection.h +++ b/google/cloud/compute/region_autoscalers/v1/mocks/mock_region_autoscalers_connection.h @@ -47,21 +47,42 @@ class MockRegionAutoscalersConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteAutoscaler)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteAutoscaler(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteAutoscaler(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteAutoscaler, (google::cloud::cpp::compute::region_autoscalers::v1:: DeleteAutoscalerRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteAutoscaler(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteAutoscaler, (NoAwaitTag, google::cloud::cpp::compute::region_autoscalers::v1:: DeleteAutoscalerRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteAutoscaler(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteAutoscaler, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -73,21 +94,42 @@ class MockRegionAutoscalersConnection GetAutoscalerRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InsertAutoscaler)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, InsertAutoscaler(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertAutoscaler(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertAutoscaler, (google::cloud::cpp::compute::region_autoscalers::v1:: InsertAutoscalerRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InsertAutoscaler(_, _)) + /// @endcode MOCK_METHOD(StatusOr, InsertAutoscaler, (NoAwaitTag, google::cloud::cpp::compute::region_autoscalers::v1:: InsertAutoscalerRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertAutoscaler(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertAutoscaler, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -99,41 +141,83 @@ class MockRegionAutoscalersConnection ListRegionAutoscalersRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, PatchAutoscaler)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, PatchAutoscaler(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchAutoscaler(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchAutoscaler, (google::cloud::cpp::compute::region_autoscalers::v1:: PatchAutoscalerRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, PatchAutoscaler(_, _)) + /// @endcode MOCK_METHOD(StatusOr, PatchAutoscaler, (NoAwaitTag, google::cloud::cpp::compute::region_autoscalers::v1:: PatchAutoscalerRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchAutoscaler(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchAutoscaler, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateAutoscaler)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateAutoscaler(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateAutoscaler(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateAutoscaler, (google::cloud::cpp::compute::region_autoscalers::v1:: UpdateAutoscalerRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateAutoscaler(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateAutoscaler, (NoAwaitTag, google::cloud::cpp::compute::region_autoscalers::v1:: UpdateAutoscalerRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateAutoscaler(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateAutoscaler, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/region_backend_services/v1/mocks/mock_region_backend_services_connection.h b/google/cloud/compute/region_backend_services/v1/mocks/mock_region_backend_services_connection.h index 9f96e06c420b9..f873ef4af5640 100644 --- a/google/cloud/compute/region_backend_services/v1/mocks/mock_region_backend_services_connection.h +++ b/google/cloud/compute/region_backend_services/v1/mocks/mock_region_backend_services_connection.h @@ -49,15 +49,27 @@ class MockRegionBackendServicesConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteBackendService)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteBackendService(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteBackendService(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteBackendService, (google::cloud::cpp::compute::region_backend_services::v1:: DeleteBackendServiceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteBackendService(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteBackendService, (NoAwaitTag, @@ -65,6 +77,15 @@ class MockRegionBackendServicesConnection DeleteBackendServiceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteBackendService(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteBackendService, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -88,15 +109,27 @@ class MockRegionBackendServicesConnection GetIamPolicyRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InsertBackendService)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, InsertBackendService(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertBackendService(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertBackendService, (google::cloud::cpp::compute::region_backend_services::v1:: InsertBackendServiceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InsertBackendService(_, _)) + /// @endcode MOCK_METHOD(StatusOr, InsertBackendService, (NoAwaitTag, @@ -104,6 +137,15 @@ class MockRegionBackendServicesConnection InsertBackendServiceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertBackendService(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertBackendService, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -121,15 +163,27 @@ class MockRegionBackendServicesConnection ListUsableRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, PatchBackendService)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, PatchBackendService(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchBackendService(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchBackendService, (google::cloud::cpp::compute::region_backend_services::v1:: PatchBackendServiceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, PatchBackendService(_, _)) + /// @endcode MOCK_METHOD(StatusOr, PatchBackendService, (NoAwaitTag, @@ -137,6 +191,15 @@ class MockRegionBackendServicesConnection PatchBackendServiceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchBackendService(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchBackendService, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -147,15 +210,27 @@ class MockRegionBackendServicesConnection SetIamPolicyRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SetSecurityPolicy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SetSecurityPolicy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetSecurityPolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetSecurityPolicy, (google::cloud::cpp::compute::region_backend_services::v1:: SetSecurityPolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SetSecurityPolicy(_, _)) + /// @endcode MOCK_METHOD(StatusOr, SetSecurityPolicy, (NoAwaitTag, @@ -163,6 +238,15 @@ class MockRegionBackendServicesConnection SetSecurityPolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetSecurityPolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetSecurityPolicy, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -175,15 +259,27 @@ class MockRegionBackendServicesConnection TestIamPermissionsRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateBackendService)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateBackendService(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateBackendService(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateBackendService, (google::cloud::cpp::compute::region_backend_services::v1:: UpdateBackendServiceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateBackendService(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateBackendService, (NoAwaitTag, @@ -191,6 +287,15 @@ class MockRegionBackendServicesConnection UpdateBackendServiceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateBackendService(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateBackendService, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/region_commitments/v1/mocks/mock_region_commitments_connection.h b/google/cloud/compute/region_commitments/v1/mocks/mock_region_commitments_connection.h index 5545768d1e289..608e1b6c4ecf4 100644 --- a/google/cloud/compute/region_commitments/v1/mocks/mock_region_commitments_connection.h +++ b/google/cloud/compute/region_commitments/v1/mocks/mock_region_commitments_connection.h @@ -62,21 +62,42 @@ class MockRegionCommitmentsConnection GetCommitmentRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InsertCommitment)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, InsertCommitment(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertCommitment(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertCommitment, (google::cloud::cpp::compute::region_commitments::v1:: InsertCommitmentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InsertCommitment(_, _)) + /// @endcode MOCK_METHOD(StatusOr, InsertCommitment, (NoAwaitTag, google::cloud::cpp::compute::region_commitments::v1:: InsertCommitmentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertCommitment(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertCommitment, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -88,21 +109,42 @@ class MockRegionCommitmentsConnection ListRegionCommitmentsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateCommitment)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateCommitment(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateCommitment(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateCommitment, (google::cloud::cpp::compute::region_commitments::v1:: UpdateCommitmentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateCommitment(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateCommitment, (NoAwaitTag, google::cloud::cpp::compute::region_commitments::v1:: UpdateCommitmentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateCommitment(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateCommitment, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/region_disks/v1/mocks/mock_region_disks_connection.h b/google/cloud/compute/region_disks/v1/mocks/mock_region_disks_connection.h index 777da5dd3f131..1f2b8938ce7f7 100644 --- a/google/cloud/compute/region_disks/v1/mocks/mock_region_disks_connection.h +++ b/google/cloud/compute/region_disks/v1/mocks/mock_region_disks_connection.h @@ -47,35 +47,68 @@ class MockRegionDisksConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, AddResourcePolicies)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, AddResourcePolicies(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// AddResourcePolicies(Matcher(_))) + /// @endcode MOCK_METHOD(future>, AddResourcePolicies, (google::cloud::cpp::compute::region_disks::v1:: AddResourcePoliciesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, AddResourcePolicies(_, _)) + /// @endcode MOCK_METHOD(StatusOr, AddResourcePolicies, (NoAwaitTag, google::cloud::cpp::compute::region_disks::v1:: AddResourcePoliciesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// AddResourcePolicies(Matcher(_))) + /// @endcode MOCK_METHOD(future>, AddResourcePolicies, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, BulkInsert)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, BulkInsert(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// BulkInsert(Matcher(_))) + /// @endcode MOCK_METHOD( future>, BulkInsert, (google::cloud::cpp::compute::region_disks::v1::BulkInsertRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, BulkInsert(_, _)) + /// @endcode MOCK_METHOD( StatusOr, BulkInsert, (NoAwaitTag, @@ -83,40 +116,81 @@ class MockRegionDisksConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// BulkInsert(Matcher(_))) + /// @endcode MOCK_METHOD(future>, BulkInsert, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateSnapshot)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateSnapshot(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateSnapshot(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateSnapshot, (google::cloud::cpp::compute::region_disks::v1:: CreateSnapshotRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateSnapshot(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateSnapshot, (NoAwaitTag, google::cloud::cpp::compute::region_disks::v1:: CreateSnapshotRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateSnapshot(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateSnapshot, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteDisk)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteDisk(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteDisk(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteDisk, (google::cloud::cpp::compute::region_disks::v1::DeleteDiskRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteDisk(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteDisk, (NoAwaitTag, @@ -124,6 +198,14 @@ class MockRegionDisksConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteDisk(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteDisk, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -141,15 +223,27 @@ class MockRegionDisksConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InsertDisk)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, InsertDisk(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertDisk(Matcher(_))) + /// @endcode MOCK_METHOD( future>, InsertDisk, (google::cloud::cpp::compute::region_disks::v1::InsertDiskRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InsertDisk(_, _)) + /// @endcode MOCK_METHOD( StatusOr, InsertDisk, (NoAwaitTag, @@ -157,6 +251,14 @@ class MockRegionDisksConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertDisk(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertDisk, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -168,35 +270,68 @@ class MockRegionDisksConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, RemoveResourcePolicies)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, RemoveResourcePolicies(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RemoveResourcePolicies(Matcher(_))) + /// @endcode MOCK_METHOD(future>, RemoveResourcePolicies, (google::cloud::cpp::compute::region_disks::v1:: RemoveResourcePoliciesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, RemoveResourcePolicies(_, _)) + /// @endcode MOCK_METHOD(StatusOr, RemoveResourcePolicies, (NoAwaitTag, google::cloud::cpp::compute::region_disks::v1:: RemoveResourcePoliciesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RemoveResourcePolicies(Matcher(_))) + /// @endcode MOCK_METHOD(future>, RemoveResourcePolicies, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, Resize)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, Resize(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// Resize(Matcher(_))) + /// @endcode MOCK_METHOD( future>, Resize, (google::cloud::cpp::compute::region_disks::v1::ResizeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, Resize(_, _)) + /// @endcode MOCK_METHOD( StatusOr, Resize, (NoAwaitTag, @@ -204,6 +339,14 @@ class MockRegionDisksConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// Resize(Matcher(_))) + /// @endcode MOCK_METHOD(future>, Resize, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -215,15 +358,27 @@ class MockRegionDisksConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SetLabels)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SetLabels(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetLabels(Matcher(_))) + /// @endcode MOCK_METHOD( future>, SetLabels, (google::cloud::cpp::compute::region_disks::v1::SetLabelsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SetLabels(_, _)) + /// @endcode MOCK_METHOD( StatusOr, SetLabels, (NoAwaitTag, @@ -231,66 +386,137 @@ class MockRegionDisksConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetLabels(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetLabels, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, StartAsyncReplication)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, StartAsyncReplication(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// StartAsyncReplication(Matcher(_))) + /// @endcode MOCK_METHOD(future>, StartAsyncReplication, (google::cloud::cpp::compute::region_disks::v1:: StartAsyncReplicationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, StartAsyncReplication(_, _)) + /// @endcode MOCK_METHOD(StatusOr, StartAsyncReplication, (NoAwaitTag, google::cloud::cpp::compute::region_disks::v1:: StartAsyncReplicationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// StartAsyncReplication(Matcher(_))) + /// @endcode MOCK_METHOD(future>, StartAsyncReplication, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, StopAsyncReplication)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, StopAsyncReplication(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// StopAsyncReplication(Matcher(_))) + /// @endcode MOCK_METHOD(future>, StopAsyncReplication, (google::cloud::cpp::compute::region_disks::v1:: StopAsyncReplicationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, StopAsyncReplication(_, _)) + /// @endcode MOCK_METHOD(StatusOr, StopAsyncReplication, (NoAwaitTag, google::cloud::cpp::compute::region_disks::v1:: StopAsyncReplicationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// StopAsyncReplication(Matcher(_))) + /// @endcode MOCK_METHOD(future>, StopAsyncReplication, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, StopGroupAsyncReplication)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, StopGroupAsyncReplication(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// StopGroupAsyncReplication(Matcher(_))) + /// @endcode MOCK_METHOD(future>, StopGroupAsyncReplication, (google::cloud::cpp::compute::region_disks::v1:: StopGroupAsyncReplicationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, StopGroupAsyncReplication(_, _)) + /// @endcode MOCK_METHOD(StatusOr, StopGroupAsyncReplication, (NoAwaitTag, google::cloud::cpp::compute::region_disks::v1:: StopGroupAsyncReplicationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// StopGroupAsyncReplication(Matcher(_))) + /// @endcode MOCK_METHOD(future>, StopGroupAsyncReplication, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -303,15 +529,27 @@ class MockRegionDisksConnection TestIamPermissionsRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateDisk)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateDisk(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateDisk(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateDisk, (google::cloud::cpp::compute::region_disks::v1::UpdateDiskRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateDisk(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateDisk, (NoAwaitTag, @@ -319,6 +557,14 @@ class MockRegionDisksConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateDisk(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateDisk, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/region_health_check_services/v1/mocks/mock_region_health_check_services_connection.h b/google/cloud/compute/region_health_check_services/v1/mocks/mock_region_health_check_services_connection.h index c341fe9a157fd..2b941fbff1648 100644 --- a/google/cloud/compute/region_health_check_services/v1/mocks/mock_region_health_check_services_connection.h +++ b/google/cloud/compute/region_health_check_services/v1/mocks/mock_region_health_check_services_connection.h @@ -49,15 +49,27 @@ class MockRegionHealthCheckServicesConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteHealthCheckService)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteHealthCheckService(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteHealthCheckService(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteHealthCheckService, (google::cloud::cpp::compute::region_health_check_services::v1:: DeleteHealthCheckServiceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteHealthCheckService(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteHealthCheckService, (NoAwaitTag, @@ -65,6 +77,15 @@ class MockRegionHealthCheckServicesConnection DeleteHealthCheckServiceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteHealthCheckService(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteHealthCheckService, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -76,15 +97,27 @@ class MockRegionHealthCheckServicesConnection GetHealthCheckServiceRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InsertHealthCheckService)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, InsertHealthCheckService(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertHealthCheckService(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertHealthCheckService, (google::cloud::cpp::compute::region_health_check_services::v1:: InsertHealthCheckServiceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InsertHealthCheckService(_, _)) + /// @endcode MOCK_METHOD(StatusOr, InsertHealthCheckService, (NoAwaitTag, @@ -92,6 +125,15 @@ class MockRegionHealthCheckServicesConnection InsertHealthCheckServiceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertHealthCheckService(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertHealthCheckService, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -104,15 +146,27 @@ class MockRegionHealthCheckServicesConnection ListRegionHealthCheckServicesRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, PatchHealthCheckService)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, PatchHealthCheckService(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchHealthCheckService(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchHealthCheckService, (google::cloud::cpp::compute::region_health_check_services::v1:: PatchHealthCheckServiceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, PatchHealthCheckService(_, _)) + /// @endcode MOCK_METHOD(StatusOr, PatchHealthCheckService, (NoAwaitTag, @@ -120,6 +174,15 @@ class MockRegionHealthCheckServicesConnection PatchHealthCheckServiceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchHealthCheckService(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchHealthCheckService, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/region_health_checks/v1/mocks/mock_region_health_checks_connection.h b/google/cloud/compute/region_health_checks/v1/mocks/mock_region_health_checks_connection.h index 4e05b97ef5a43..d94a379c4b3d8 100644 --- a/google/cloud/compute/region_health_checks/v1/mocks/mock_region_health_checks_connection.h +++ b/google/cloud/compute/region_health_checks/v1/mocks/mock_region_health_checks_connection.h @@ -48,21 +48,42 @@ class MockRegionHealthChecksConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteHealthCheck)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteHealthCheck(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteHealthCheck(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteHealthCheck, (google::cloud::cpp::compute::region_health_checks::v1:: DeleteHealthCheckRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteHealthCheck(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteHealthCheck, (NoAwaitTag, google::cloud::cpp::compute::region_health_checks:: v1::DeleteHealthCheckRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteHealthCheck(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteHealthCheck, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -74,21 +95,42 @@ class MockRegionHealthChecksConnection GetHealthCheckRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InsertHealthCheck)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, InsertHealthCheck(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertHealthCheck(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertHealthCheck, (google::cloud::cpp::compute::region_health_checks::v1:: InsertHealthCheckRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InsertHealthCheck(_, _)) + /// @endcode MOCK_METHOD(StatusOr, InsertHealthCheck, (NoAwaitTag, google::cloud::cpp::compute::region_health_checks:: v1::InsertHealthCheckRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertHealthCheck(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertHealthCheck, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -100,41 +142,83 @@ class MockRegionHealthChecksConnection ListRegionHealthChecksRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, PatchHealthCheck)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, PatchHealthCheck(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchHealthCheck(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchHealthCheck, (google::cloud::cpp::compute::region_health_checks::v1:: PatchHealthCheckRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, PatchHealthCheck(_, _)) + /// @endcode MOCK_METHOD(StatusOr, PatchHealthCheck, (NoAwaitTag, google::cloud::cpp::compute::region_health_checks:: v1::PatchHealthCheckRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchHealthCheck(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchHealthCheck, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateHealthCheck)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateHealthCheck(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateHealthCheck(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateHealthCheck, (google::cloud::cpp::compute::region_health_checks::v1:: UpdateHealthCheckRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateHealthCheck(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateHealthCheck, (NoAwaitTag, google::cloud::cpp::compute::region_health_checks:: v1::UpdateHealthCheckRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateHealthCheck(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateHealthCheck, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/region_instance_group_managers/v1/mocks/mock_region_instance_group_managers_connection.h b/google/cloud/compute/region_instance_group_managers/v1/mocks/mock_region_instance_group_managers_connection.h index 3540772b72ec7..b3d27dc06605c 100644 --- a/google/cloud/compute/region_instance_group_managers/v1/mocks/mock_region_instance_group_managers_connection.h +++ b/google/cloud/compute/region_instance_group_managers/v1/mocks/mock_region_instance_group_managers_connection.h @@ -49,15 +49,27 @@ class MockRegionInstanceGroupManagersConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, AbandonInstances)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, AbandonInstances(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// AbandonInstances(Matcher(_))) + /// @endcode MOCK_METHOD(future>, AbandonInstances, (google::cloud::cpp::compute::region_instance_group_managers::v1:: AbandonInstancesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, AbandonInstances(_, _)) + /// @endcode MOCK_METHOD(StatusOr, AbandonInstances, (NoAwaitTag, @@ -65,20 +77,41 @@ class MockRegionInstanceGroupManagersConnection AbandonInstancesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// AbandonInstances(Matcher(_))) + /// @endcode MOCK_METHOD(future>, AbandonInstances, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ApplyUpdatesToInstances)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ApplyUpdatesToInstances(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ApplyUpdatesToInstances(Matcher(_))) + /// @endcode MOCK_METHOD(future>, ApplyUpdatesToInstances, (google::cloud::cpp::compute::region_instance_group_managers::v1:: ApplyUpdatesToInstancesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ApplyUpdatesToInstances(_, _)) + /// @endcode MOCK_METHOD(StatusOr, ApplyUpdatesToInstances, (NoAwaitTag, @@ -86,20 +119,41 @@ class MockRegionInstanceGroupManagersConnection ApplyUpdatesToInstancesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ApplyUpdatesToInstances(Matcher(_))) + /// @endcode MOCK_METHOD(future>, ApplyUpdatesToInstances, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateInstances)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateInstances(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateInstances(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateInstances, (google::cloud::cpp::compute::region_instance_group_managers::v1:: CreateInstancesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateInstances(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateInstances, (NoAwaitTag, @@ -107,20 +161,41 @@ class MockRegionInstanceGroupManagersConnection CreateInstancesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateInstances(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateInstances, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteInstanceGroupManager)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteInstanceGroupManager(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteInstanceGroupManager(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteInstanceGroupManager, (google::cloud::cpp::compute::region_instance_group_managers::v1:: DeleteInstanceGroupManagerRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteInstanceGroupManager(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteInstanceGroupManager, (NoAwaitTag, @@ -128,20 +203,41 @@ class MockRegionInstanceGroupManagersConnection DeleteInstanceGroupManagerRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteInstanceGroupManager(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteInstanceGroupManager, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteInstances)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteInstances(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteInstances(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteInstances, (google::cloud::cpp::compute::region_instance_group_managers::v1:: DeleteInstancesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteInstances(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteInstances, (NoAwaitTag, @@ -149,20 +245,41 @@ class MockRegionInstanceGroupManagersConnection DeleteInstancesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteInstances(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteInstances, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeletePerInstanceConfigs)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeletePerInstanceConfigs(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeletePerInstanceConfigs(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeletePerInstanceConfigs, (google::cloud::cpp::compute::region_instance_group_managers::v1:: DeletePerInstanceConfigsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeletePerInstanceConfigs(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeletePerInstanceConfigs, (NoAwaitTag, @@ -170,6 +287,15 @@ class MockRegionInstanceGroupManagersConnection DeletePerInstanceConfigsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeletePerInstanceConfigs(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeletePerInstanceConfigs, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -181,15 +307,27 @@ class MockRegionInstanceGroupManagersConnection GetInstanceGroupManagerRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InsertInstanceGroupManager)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, InsertInstanceGroupManager(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertInstanceGroupManager(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertInstanceGroupManager, (google::cloud::cpp::compute::region_instance_group_managers::v1:: InsertInstanceGroupManagerRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InsertInstanceGroupManager(_, _)) + /// @endcode MOCK_METHOD(StatusOr, InsertInstanceGroupManager, (NoAwaitTag, @@ -197,6 +335,15 @@ class MockRegionInstanceGroupManagersConnection InsertInstanceGroupManagerRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertInstanceGroupManager(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertInstanceGroupManager, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -229,15 +376,27 @@ class MockRegionInstanceGroupManagersConnection ListPerInstanceConfigsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, PatchInstanceGroupManager)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, PatchInstanceGroupManager(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchInstanceGroupManager(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchInstanceGroupManager, (google::cloud::cpp::compute::region_instance_group_managers::v1:: PatchInstanceGroupManagerRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, PatchInstanceGroupManager(_, _)) + /// @endcode MOCK_METHOD(StatusOr, PatchInstanceGroupManager, (NoAwaitTag, @@ -245,20 +404,41 @@ class MockRegionInstanceGroupManagersConnection PatchInstanceGroupManagerRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchInstanceGroupManager(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchInstanceGroupManager, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, PatchPerInstanceConfigs)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, PatchPerInstanceConfigs(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchPerInstanceConfigs(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchPerInstanceConfigs, (google::cloud::cpp::compute::region_instance_group_managers::v1:: PatchPerInstanceConfigsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, PatchPerInstanceConfigs(_, _)) + /// @endcode MOCK_METHOD(StatusOr, PatchPerInstanceConfigs, (NoAwaitTag, @@ -266,20 +446,41 @@ class MockRegionInstanceGroupManagersConnection PatchPerInstanceConfigsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchPerInstanceConfigs(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchPerInstanceConfigs, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, RecreateInstances)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, RecreateInstances(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RecreateInstances(Matcher(_))) + /// @endcode MOCK_METHOD(future>, RecreateInstances, (google::cloud::cpp::compute::region_instance_group_managers::v1:: RecreateInstancesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, RecreateInstances(_, _)) + /// @endcode MOCK_METHOD(StatusOr, RecreateInstances, (NoAwaitTag, @@ -287,40 +488,81 @@ class MockRegionInstanceGroupManagersConnection RecreateInstancesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RecreateInstances(Matcher(_))) + /// @endcode MOCK_METHOD(future>, RecreateInstances, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, Resize)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, Resize(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// Resize(Matcher(_))) + /// @endcode MOCK_METHOD(future>, Resize, (google::cloud::cpp::compute::region_instance_group_managers::v1:: ResizeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, Resize(_, _)) + /// @endcode MOCK_METHOD(StatusOr, Resize, (NoAwaitTag, google::cloud::cpp::compute::region_instance_group_managers::v1:: ResizeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// Resize(Matcher(_))) + /// @endcode MOCK_METHOD(future>, Resize, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SetInstanceTemplate)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SetInstanceTemplate(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetInstanceTemplate(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetInstanceTemplate, (google::cloud::cpp::compute::region_instance_group_managers::v1:: SetInstanceTemplateRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SetInstanceTemplate(_, _)) + /// @endcode MOCK_METHOD(StatusOr, SetInstanceTemplate, (NoAwaitTag, @@ -328,20 +570,41 @@ class MockRegionInstanceGroupManagersConnection SetInstanceTemplateRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetInstanceTemplate(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetInstanceTemplate, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SetTargetPools)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SetTargetPools(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetTargetPools(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetTargetPools, (google::cloud::cpp::compute::region_instance_group_managers::v1:: SetTargetPoolsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SetTargetPools(_, _)) + /// @endcode MOCK_METHOD(StatusOr, SetTargetPools, (NoAwaitTag, @@ -349,20 +612,41 @@ class MockRegionInstanceGroupManagersConnection SetTargetPoolsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetTargetPools(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetTargetPools, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdatePerInstanceConfigs)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdatePerInstanceConfigs(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdatePerInstanceConfigs(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdatePerInstanceConfigs, (google::cloud::cpp::compute::region_instance_group_managers::v1:: UpdatePerInstanceConfigsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdatePerInstanceConfigs(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdatePerInstanceConfigs, (NoAwaitTag, @@ -370,6 +654,15 @@ class MockRegionInstanceGroupManagersConnection UpdatePerInstanceConfigsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdatePerInstanceConfigs(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdatePerInstanceConfigs, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/region_instance_groups/v1/mocks/mock_region_instance_groups_connection.h b/google/cloud/compute/region_instance_groups/v1/mocks/mock_region_instance_groups_connection.h index 8244a4c48ae1a..1f4a255233b64 100644 --- a/google/cloud/compute/region_instance_groups/v1/mocks/mock_region_instance_groups_connection.h +++ b/google/cloud/compute/region_instance_groups/v1/mocks/mock_region_instance_groups_connection.h @@ -67,21 +67,42 @@ class MockRegionInstanceGroupsConnection ListInstancesRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SetNamedPorts)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SetNamedPorts(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetNamedPorts(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetNamedPorts, (google::cloud::cpp::compute::region_instance_groups::v1:: SetNamedPortsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SetNamedPorts(_, _)) + /// @endcode MOCK_METHOD(StatusOr, SetNamedPorts, (NoAwaitTag, google::cloud::cpp::compute::region_instance_groups:: v1::SetNamedPortsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetNamedPorts(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetNamedPorts, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/region_instance_templates/v1/mocks/mock_region_instance_templates_connection.h b/google/cloud/compute/region_instance_templates/v1/mocks/mock_region_instance_templates_connection.h index 1ae521b62feba..f03a76921a431 100644 --- a/google/cloud/compute/region_instance_templates/v1/mocks/mock_region_instance_templates_connection.h +++ b/google/cloud/compute/region_instance_templates/v1/mocks/mock_region_instance_templates_connection.h @@ -49,15 +49,27 @@ class MockRegionInstanceTemplatesConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteInstanceTemplate)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteInstanceTemplate(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteInstanceTemplate(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteInstanceTemplate, (google::cloud::cpp::compute::region_instance_templates::v1:: DeleteInstanceTemplateRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteInstanceTemplate(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteInstanceTemplate, (NoAwaitTag, @@ -65,6 +77,15 @@ class MockRegionInstanceTemplatesConnection DeleteInstanceTemplateRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteInstanceTemplate(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteInstanceTemplate, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -76,15 +97,27 @@ class MockRegionInstanceTemplatesConnection GetInstanceTemplateRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InsertInstanceTemplate)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, InsertInstanceTemplate(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertInstanceTemplate(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertInstanceTemplate, (google::cloud::cpp::compute::region_instance_templates::v1:: InsertInstanceTemplateRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InsertInstanceTemplate(_, _)) + /// @endcode MOCK_METHOD(StatusOr, InsertInstanceTemplate, (NoAwaitTag, @@ -92,6 +125,15 @@ class MockRegionInstanceTemplatesConnection InsertInstanceTemplateRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertInstanceTemplate(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertInstanceTemplate, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/region_instances/v1/mocks/mock_region_instances_connection.h b/google/cloud/compute/region_instances/v1/mocks/mock_region_instances_connection.h index 1449377dad9c2..8b2924178ca02 100644 --- a/google/cloud/compute/region_instances/v1/mocks/mock_region_instances_connection.h +++ b/google/cloud/compute/region_instances/v1/mocks/mock_region_instances_connection.h @@ -47,20 +47,40 @@ class MockRegionInstancesConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, BulkInsert)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, BulkInsert(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// BulkInsert(Matcher(_))) + /// @endcode MOCK_METHOD(future>, BulkInsert, (google::cloud::cpp::compute::region_instances::v1:: BulkInsertRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, BulkInsert(_, _)) + /// @endcode MOCK_METHOD(StatusOr, BulkInsert, (NoAwaitTag, google::cloud::cpp::compute::region_instances::v1:: BulkInsertRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// BulkInsert(Matcher(_))) + /// @endcode MOCK_METHOD(future>, BulkInsert, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/region_network_endpoint_groups/v1/mocks/mock_region_network_endpoint_groups_connection.h b/google/cloud/compute/region_network_endpoint_groups/v1/mocks/mock_region_network_endpoint_groups_connection.h index 896138c15eabb..3b644d233a5f6 100644 --- a/google/cloud/compute/region_network_endpoint_groups/v1/mocks/mock_region_network_endpoint_groups_connection.h +++ b/google/cloud/compute/region_network_endpoint_groups/v1/mocks/mock_region_network_endpoint_groups_connection.h @@ -49,15 +49,27 @@ class MockRegionNetworkEndpointGroupsConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, AttachNetworkEndpoints)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, AttachNetworkEndpoints(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// AttachNetworkEndpoints(Matcher(_))) + /// @endcode MOCK_METHOD(future>, AttachNetworkEndpoints, (google::cloud::cpp::compute::region_network_endpoint_groups::v1:: AttachNetworkEndpointsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, AttachNetworkEndpoints(_, _)) + /// @endcode MOCK_METHOD(StatusOr, AttachNetworkEndpoints, (NoAwaitTag, @@ -65,20 +77,41 @@ class MockRegionNetworkEndpointGroupsConnection AttachNetworkEndpointsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// AttachNetworkEndpoints(Matcher(_))) + /// @endcode MOCK_METHOD(future>, AttachNetworkEndpoints, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteNetworkEndpointGroup)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteNetworkEndpointGroup(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteNetworkEndpointGroup(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteNetworkEndpointGroup, (google::cloud::cpp::compute::region_network_endpoint_groups::v1:: DeleteNetworkEndpointGroupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteNetworkEndpointGroup(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteNetworkEndpointGroup, (NoAwaitTag, @@ -86,20 +119,41 @@ class MockRegionNetworkEndpointGroupsConnection DeleteNetworkEndpointGroupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteNetworkEndpointGroup(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteNetworkEndpointGroup, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DetachNetworkEndpoints)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DetachNetworkEndpoints(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DetachNetworkEndpoints(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DetachNetworkEndpoints, (google::cloud::cpp::compute::region_network_endpoint_groups::v1:: DetachNetworkEndpointsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DetachNetworkEndpoints(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DetachNetworkEndpoints, (NoAwaitTag, @@ -107,6 +161,15 @@ class MockRegionNetworkEndpointGroupsConnection DetachNetworkEndpointsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DetachNetworkEndpoints(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DetachNetworkEndpoints, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -118,15 +181,27 @@ class MockRegionNetworkEndpointGroupsConnection GetNetworkEndpointGroupRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InsertNetworkEndpointGroup)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, InsertNetworkEndpointGroup(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertNetworkEndpointGroup(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertNetworkEndpointGroup, (google::cloud::cpp::compute::region_network_endpoint_groups::v1:: InsertNetworkEndpointGroupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InsertNetworkEndpointGroup(_, _)) + /// @endcode MOCK_METHOD(StatusOr, InsertNetworkEndpointGroup, (NoAwaitTag, @@ -134,6 +209,15 @@ class MockRegionNetworkEndpointGroupsConnection InsertNetworkEndpointGroupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertNetworkEndpointGroup(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertNetworkEndpointGroup, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/region_network_firewall_policies/v1/mocks/mock_region_network_firewall_policies_connection.h b/google/cloud/compute/region_network_firewall_policies/v1/mocks/mock_region_network_firewall_policies_connection.h index 0732850ddb0d9..9dd941976c52a 100644 --- a/google/cloud/compute/region_network_firewall_policies/v1/mocks/mock_region_network_firewall_policies_connection.h +++ b/google/cloud/compute/region_network_firewall_policies/v1/mocks/mock_region_network_firewall_policies_connection.h @@ -49,15 +49,27 @@ class MockRegionNetworkFirewallPoliciesConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, AddAssociation)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, AddAssociation(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// AddAssociation(Matcher(_))) + /// @endcode MOCK_METHOD(future>, AddAssociation, (google::cloud::cpp::compute::region_network_firewall_policies:: v1::AddAssociationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, AddAssociation(_, _)) + /// @endcode MOCK_METHOD(StatusOr, AddAssociation, (NoAwaitTag, @@ -65,60 +77,121 @@ class MockRegionNetworkFirewallPoliciesConnection v1::AddAssociationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// AddAssociation(Matcher(_))) + /// @endcode MOCK_METHOD(future>, AddAssociation, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, AddRule)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, AddRule(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// AddRule(Matcher(_))) + /// @endcode MOCK_METHOD(future>, AddRule, (google::cloud::cpp::compute::region_network_firewall_policies:: v1::AddRuleRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, AddRule(_, _)) + /// @endcode MOCK_METHOD(StatusOr, AddRule, (NoAwaitTag, google::cloud::cpp::compute::region_network_firewall_policies:: v1::AddRuleRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// AddRule(Matcher(_))) + /// @endcode MOCK_METHOD(future>, AddRule, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CloneRules)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CloneRules(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CloneRules(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CloneRules, (google::cloud::cpp::compute::region_network_firewall_policies:: v1::CloneRulesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CloneRules(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CloneRules, (NoAwaitTag, google::cloud::cpp::compute::region_network_firewall_policies:: v1::CloneRulesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CloneRules(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CloneRules, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteFirewallPolicy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteFirewallPolicy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteFirewallPolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteFirewallPolicy, (google::cloud::cpp::compute::region_network_firewall_policies:: v1::DeleteFirewallPolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteFirewallPolicy(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteFirewallPolicy, (NoAwaitTag, @@ -126,6 +199,15 @@ class MockRegionNetworkFirewallPoliciesConnection v1::DeleteFirewallPolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteFirewallPolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteFirewallPolicy, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -163,15 +245,27 @@ class MockRegionNetworkFirewallPoliciesConnection v1::GetRuleRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InsertFirewallPolicy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, InsertFirewallPolicy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertFirewallPolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertFirewallPolicy, (google::cloud::cpp::compute::region_network_firewall_policies:: v1::InsertFirewallPolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InsertFirewallPolicy(_, _)) + /// @endcode MOCK_METHOD(StatusOr, InsertFirewallPolicy, (NoAwaitTag, @@ -179,6 +273,15 @@ class MockRegionNetworkFirewallPoliciesConnection v1::InsertFirewallPolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertFirewallPolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertFirewallPolicy, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -190,15 +293,27 @@ class MockRegionNetworkFirewallPoliciesConnection v1::ListRegionNetworkFirewallPoliciesRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, PatchFirewallPolicy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, PatchFirewallPolicy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchFirewallPolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchFirewallPolicy, (google::cloud::cpp::compute::region_network_firewall_policies:: v1::PatchFirewallPolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, PatchFirewallPolicy(_, _)) + /// @endcode MOCK_METHOD(StatusOr, PatchFirewallPolicy, (NoAwaitTag, @@ -206,40 +321,81 @@ class MockRegionNetworkFirewallPoliciesConnection v1::PatchFirewallPolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchFirewallPolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchFirewallPolicy, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, PatchRule)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, PatchRule(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchRule(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchRule, (google::cloud::cpp::compute::region_network_firewall_policies:: v1::PatchRuleRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, PatchRule(_, _)) + /// @endcode MOCK_METHOD(StatusOr, PatchRule, (NoAwaitTag, google::cloud::cpp::compute::region_network_firewall_policies:: v1::PatchRuleRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchRule(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchRule, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, RemoveAssociation)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, RemoveAssociation(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RemoveAssociation(Matcher(_))) + /// @endcode MOCK_METHOD(future>, RemoveAssociation, (google::cloud::cpp::compute::region_network_firewall_policies:: v1::RemoveAssociationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, RemoveAssociation(_, _)) + /// @endcode MOCK_METHOD(StatusOr, RemoveAssociation, (NoAwaitTag, @@ -247,26 +403,55 @@ class MockRegionNetworkFirewallPoliciesConnection v1::RemoveAssociationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RemoveAssociation(Matcher(_))) + /// @endcode MOCK_METHOD(future>, RemoveAssociation, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, RemoveRule)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, RemoveRule(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RemoveRule(Matcher(_))) + /// @endcode MOCK_METHOD(future>, RemoveRule, (google::cloud::cpp::compute::region_network_firewall_policies:: v1::RemoveRuleRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, RemoveRule(_, _)) + /// @endcode MOCK_METHOD(StatusOr, RemoveRule, (NoAwaitTag, google::cloud::cpp::compute::region_network_firewall_policies:: v1::RemoveRuleRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RemoveRule(Matcher(_))) + /// @endcode MOCK_METHOD(future>, RemoveRule, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/region_notification_endpoints/v1/mocks/mock_region_notification_endpoints_connection.h b/google/cloud/compute/region_notification_endpoints/v1/mocks/mock_region_notification_endpoints_connection.h index c55f03bb21b80..1c8b22e97ecca 100644 --- a/google/cloud/compute/region_notification_endpoints/v1/mocks/mock_region_notification_endpoints_connection.h +++ b/google/cloud/compute/region_notification_endpoints/v1/mocks/mock_region_notification_endpoints_connection.h @@ -49,15 +49,27 @@ class MockRegionNotificationEndpointsConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteNotificationEndpoint)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteNotificationEndpoint(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteNotificationEndpoint(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteNotificationEndpoint, (google::cloud::cpp::compute::region_notification_endpoints::v1:: DeleteNotificationEndpointRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteNotificationEndpoint(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteNotificationEndpoint, (NoAwaitTag, @@ -65,6 +77,15 @@ class MockRegionNotificationEndpointsConnection DeleteNotificationEndpointRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteNotificationEndpoint(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteNotificationEndpoint, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -76,15 +97,27 @@ class MockRegionNotificationEndpointsConnection GetNotificationEndpointRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InsertNotificationEndpoint)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, InsertNotificationEndpoint(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertNotificationEndpoint(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertNotificationEndpoint, (google::cloud::cpp::compute::region_notification_endpoints::v1:: InsertNotificationEndpointRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InsertNotificationEndpoint(_, _)) + /// @endcode MOCK_METHOD(StatusOr, InsertNotificationEndpoint, (NoAwaitTag, @@ -92,6 +125,15 @@ class MockRegionNotificationEndpointsConnection InsertNotificationEndpointRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertNotificationEndpoint(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertNotificationEndpoint, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/region_security_policies/v1/mocks/mock_region_security_policies_connection.h b/google/cloud/compute/region_security_policies/v1/mocks/mock_region_security_policies_connection.h index 32d5da9c485be..9b5b17afcb728 100644 --- a/google/cloud/compute/region_security_policies/v1/mocks/mock_region_security_policies_connection.h +++ b/google/cloud/compute/region_security_policies/v1/mocks/mock_region_security_policies_connection.h @@ -49,35 +49,67 @@ class MockRegionSecurityPoliciesConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, AddRule)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, AddRule(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// AddRule(Matcher(_))) + /// @endcode MOCK_METHOD(future>, AddRule, (google::cloud::cpp::compute::region_security_policies::v1:: AddRuleRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, AddRule(_, _)) + /// @endcode MOCK_METHOD(StatusOr, AddRule, (NoAwaitTag, google::cloud::cpp::compute::region_security_policies::v1:: AddRuleRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// AddRule(Matcher(_))) + /// @endcode MOCK_METHOD(future>, AddRule, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteSecurityPolicy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteSecurityPolicy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteSecurityPolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteSecurityPolicy, (google::cloud::cpp::compute::region_security_policies::v1:: DeleteSecurityPolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteSecurityPolicy(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteSecurityPolicy, (NoAwaitTag, @@ -85,6 +117,15 @@ class MockRegionSecurityPoliciesConnection DeleteSecurityPolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteSecurityPolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteSecurityPolicy, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -102,15 +143,27 @@ class MockRegionSecurityPoliciesConnection GetRuleRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InsertSecurityPolicy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, InsertSecurityPolicy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertSecurityPolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertSecurityPolicy, (google::cloud::cpp::compute::region_security_policies::v1:: InsertSecurityPolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InsertSecurityPolicy(_, _)) + /// @endcode MOCK_METHOD(StatusOr, InsertSecurityPolicy, (NoAwaitTag, @@ -118,6 +171,15 @@ class MockRegionSecurityPoliciesConnection InsertSecurityPolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertSecurityPolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertSecurityPolicy, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -129,15 +191,27 @@ class MockRegionSecurityPoliciesConnection ListRegionSecurityPoliciesRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, PatchSecurityPolicy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, PatchSecurityPolicy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchSecurityPolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchSecurityPolicy, (google::cloud::cpp::compute::region_security_policies::v1:: PatchSecurityPolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, PatchSecurityPolicy(_, _)) + /// @endcode MOCK_METHOD(StatusOr, PatchSecurityPolicy, (NoAwaitTag, @@ -145,46 +219,95 @@ class MockRegionSecurityPoliciesConnection PatchSecurityPolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchSecurityPolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchSecurityPolicy, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, PatchRule)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, PatchRule(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchRule(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchRule, (google::cloud::cpp::compute::region_security_policies::v1:: PatchRuleRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, PatchRule(_, _)) + /// @endcode MOCK_METHOD(StatusOr, PatchRule, (NoAwaitTag, google::cloud::cpp::compute::region_security_policies::v1:: PatchRuleRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchRule(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchRule, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, RemoveRule)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, RemoveRule(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RemoveRule(Matcher(_))) + /// @endcode MOCK_METHOD(future>, RemoveRule, (google::cloud::cpp::compute::region_security_policies::v1:: RemoveRuleRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, RemoveRule(_, _)) + /// @endcode MOCK_METHOD(StatusOr, RemoveRule, (NoAwaitTag, google::cloud::cpp::compute::region_security_policies::v1:: RemoveRuleRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RemoveRule(Matcher(_))) + /// @endcode MOCK_METHOD(future>, RemoveRule, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/region_ssl_certificates/v1/mocks/mock_region_ssl_certificates_connection.h b/google/cloud/compute/region_ssl_certificates/v1/mocks/mock_region_ssl_certificates_connection.h index 11c5762506cab..4e173545e95cc 100644 --- a/google/cloud/compute/region_ssl_certificates/v1/mocks/mock_region_ssl_certificates_connection.h +++ b/google/cloud/compute/region_ssl_certificates/v1/mocks/mock_region_ssl_certificates_connection.h @@ -49,15 +49,27 @@ class MockRegionSslCertificatesConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteSslCertificate)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteSslCertificate(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteSslCertificate(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteSslCertificate, (google::cloud::cpp::compute::region_ssl_certificates::v1:: DeleteSslCertificateRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteSslCertificate(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteSslCertificate, (NoAwaitTag, @@ -65,6 +77,15 @@ class MockRegionSslCertificatesConnection DeleteSslCertificateRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteSslCertificate(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteSslCertificate, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -76,15 +97,27 @@ class MockRegionSslCertificatesConnection GetSslCertificateRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InsertSslCertificate)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, InsertSslCertificate(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertSslCertificate(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertSslCertificate, (google::cloud::cpp::compute::region_ssl_certificates::v1:: InsertSslCertificateRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InsertSslCertificate(_, _)) + /// @endcode MOCK_METHOD(StatusOr, InsertSslCertificate, (NoAwaitTag, @@ -92,6 +125,15 @@ class MockRegionSslCertificatesConnection InsertSslCertificateRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertSslCertificate(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertSslCertificate, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/region_ssl_policies/v1/mocks/mock_region_ssl_policies_connection.h b/google/cloud/compute/region_ssl_policies/v1/mocks/mock_region_ssl_policies_connection.h index 31a5baaafba55..d36d5346314a3 100644 --- a/google/cloud/compute/region_ssl_policies/v1/mocks/mock_region_ssl_policies_connection.h +++ b/google/cloud/compute/region_ssl_policies/v1/mocks/mock_region_ssl_policies_connection.h @@ -47,21 +47,42 @@ class MockRegionSslPoliciesConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteSslPolicy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteSslPolicy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteSslPolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteSslPolicy, (google::cloud::cpp::compute::region_ssl_policies::v1:: DeleteSslPolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteSslPolicy(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteSslPolicy, (NoAwaitTag, google::cloud::cpp::compute::region_ssl_policies:: v1::DeleteSslPolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteSslPolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteSslPolicy, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -73,21 +94,42 @@ class MockRegionSslPoliciesConnection GetSslPolicyRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InsertSslPolicy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, InsertSslPolicy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertSslPolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertSslPolicy, (google::cloud::cpp::compute::region_ssl_policies::v1:: InsertSslPolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InsertSslPolicy(_, _)) + /// @endcode MOCK_METHOD(StatusOr, InsertSslPolicy, (NoAwaitTag, google::cloud::cpp::compute::region_ssl_policies:: v1::InsertSslPolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertSslPolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertSslPolicy, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -106,21 +148,42 @@ class MockRegionSslPoliciesConnection ListAvailableFeaturesRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, PatchSslPolicy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, PatchSslPolicy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchSslPolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchSslPolicy, (google::cloud::cpp::compute::region_ssl_policies::v1:: PatchSslPolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, PatchSslPolicy(_, _)) + /// @endcode MOCK_METHOD(StatusOr, PatchSslPolicy, (NoAwaitTag, google::cloud::cpp::compute::region_ssl_policies:: v1::PatchSslPolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchSslPolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchSslPolicy, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/region_target_http_proxies/v1/mocks/mock_region_target_http_proxies_connection.h b/google/cloud/compute/region_target_http_proxies/v1/mocks/mock_region_target_http_proxies_connection.h index 639f873973e55..479d5dbd8a4cb 100644 --- a/google/cloud/compute/region_target_http_proxies/v1/mocks/mock_region_target_http_proxies_connection.h +++ b/google/cloud/compute/region_target_http_proxies/v1/mocks/mock_region_target_http_proxies_connection.h @@ -49,15 +49,27 @@ class MockRegionTargetHttpProxiesConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteTargetHttpProxy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteTargetHttpProxy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteTargetHttpProxy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteTargetHttpProxy, (google::cloud::cpp::compute::region_target_http_proxies::v1:: DeleteTargetHttpProxyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteTargetHttpProxy(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteTargetHttpProxy, (NoAwaitTag, @@ -65,6 +77,15 @@ class MockRegionTargetHttpProxiesConnection DeleteTargetHttpProxyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteTargetHttpProxy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteTargetHttpProxy, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -76,15 +97,27 @@ class MockRegionTargetHttpProxiesConnection GetTargetHttpProxyRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InsertTargetHttpProxy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, InsertTargetHttpProxy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertTargetHttpProxy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertTargetHttpProxy, (google::cloud::cpp::compute::region_target_http_proxies::v1:: InsertTargetHttpProxyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InsertTargetHttpProxy(_, _)) + /// @endcode MOCK_METHOD(StatusOr, InsertTargetHttpProxy, (NoAwaitTag, @@ -92,6 +125,15 @@ class MockRegionTargetHttpProxiesConnection InsertTargetHttpProxyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertTargetHttpProxy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertTargetHttpProxy, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -103,21 +145,41 @@ class MockRegionTargetHttpProxiesConnection ListRegionTargetHttpProxiesRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SetUrlMap)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SetUrlMap(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetUrlMap(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetUrlMap, (google::cloud::cpp::compute::region_target_http_proxies::v1:: SetUrlMapRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SetUrlMap(_, _)) + /// @endcode MOCK_METHOD(StatusOr, SetUrlMap, (NoAwaitTag, google::cloud::cpp::compute::region_target_http_proxies::v1:: SetUrlMapRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetUrlMap(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetUrlMap, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/region_target_https_proxies/v1/mocks/mock_region_target_https_proxies_connection.h b/google/cloud/compute/region_target_https_proxies/v1/mocks/mock_region_target_https_proxies_connection.h index 9522e9502f3a1..96704bfa4a577 100644 --- a/google/cloud/compute/region_target_https_proxies/v1/mocks/mock_region_target_https_proxies_connection.h +++ b/google/cloud/compute/region_target_https_proxies/v1/mocks/mock_region_target_https_proxies_connection.h @@ -49,15 +49,27 @@ class MockRegionTargetHttpsProxiesConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteTargetHttpsProxy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteTargetHttpsProxy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteTargetHttpsProxy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteTargetHttpsProxy, (google::cloud::cpp::compute::region_target_https_proxies::v1:: DeleteTargetHttpsProxyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteTargetHttpsProxy(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteTargetHttpsProxy, (NoAwaitTag, @@ -65,6 +77,15 @@ class MockRegionTargetHttpsProxiesConnection DeleteTargetHttpsProxyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteTargetHttpsProxy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteTargetHttpsProxy, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -76,15 +97,27 @@ class MockRegionTargetHttpsProxiesConnection GetTargetHttpsProxyRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InsertTargetHttpsProxy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, InsertTargetHttpsProxy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertTargetHttpsProxy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertTargetHttpsProxy, (google::cloud::cpp::compute::region_target_https_proxies::v1:: InsertTargetHttpsProxyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InsertTargetHttpsProxy(_, _)) + /// @endcode MOCK_METHOD(StatusOr, InsertTargetHttpsProxy, (NoAwaitTag, @@ -92,6 +125,15 @@ class MockRegionTargetHttpsProxiesConnection InsertTargetHttpsProxyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertTargetHttpsProxy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertTargetHttpsProxy, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -103,15 +145,27 @@ class MockRegionTargetHttpsProxiesConnection ListRegionTargetHttpsProxiesRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, PatchTargetHttpsProxy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, PatchTargetHttpsProxy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchTargetHttpsProxy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchTargetHttpsProxy, (google::cloud::cpp::compute::region_target_https_proxies::v1:: PatchTargetHttpsProxyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, PatchTargetHttpsProxy(_, _)) + /// @endcode MOCK_METHOD(StatusOr, PatchTargetHttpsProxy, (NoAwaitTag, @@ -119,20 +173,41 @@ class MockRegionTargetHttpsProxiesConnection PatchTargetHttpsProxyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchTargetHttpsProxy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchTargetHttpsProxy, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SetSslCertificates)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SetSslCertificates(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetSslCertificates(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetSslCertificates, (google::cloud::cpp::compute::region_target_https_proxies::v1:: SetSslCertificatesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SetSslCertificates(_, _)) + /// @endcode MOCK_METHOD(StatusOr, SetSslCertificates, (NoAwaitTag, @@ -140,26 +215,55 @@ class MockRegionTargetHttpsProxiesConnection SetSslCertificatesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetSslCertificates(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetSslCertificates, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SetUrlMap)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SetUrlMap(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetUrlMap(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetUrlMap, (google::cloud::cpp::compute::region_target_https_proxies::v1:: SetUrlMapRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SetUrlMap(_, _)) + /// @endcode MOCK_METHOD(StatusOr, SetUrlMap, (NoAwaitTag, google::cloud::cpp::compute::region_target_https_proxies::v1:: SetUrlMapRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetUrlMap(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetUrlMap, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/region_target_tcp_proxies/v1/mocks/mock_region_target_tcp_proxies_connection.h b/google/cloud/compute/region_target_tcp_proxies/v1/mocks/mock_region_target_tcp_proxies_connection.h index 099775e2cd17f..2b6a34969a802 100644 --- a/google/cloud/compute/region_target_tcp_proxies/v1/mocks/mock_region_target_tcp_proxies_connection.h +++ b/google/cloud/compute/region_target_tcp_proxies/v1/mocks/mock_region_target_tcp_proxies_connection.h @@ -49,15 +49,27 @@ class MockRegionTargetTcpProxiesConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteTargetTcpProxy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteTargetTcpProxy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteTargetTcpProxy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteTargetTcpProxy, (google::cloud::cpp::compute::region_target_tcp_proxies::v1:: DeleteTargetTcpProxyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteTargetTcpProxy(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteTargetTcpProxy, (NoAwaitTag, @@ -65,6 +77,15 @@ class MockRegionTargetTcpProxiesConnection DeleteTargetTcpProxyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteTargetTcpProxy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteTargetTcpProxy, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -76,15 +97,27 @@ class MockRegionTargetTcpProxiesConnection GetTargetTcpProxyRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InsertTargetTcpProxy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, InsertTargetTcpProxy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertTargetTcpProxy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertTargetTcpProxy, (google::cloud::cpp::compute::region_target_tcp_proxies::v1:: InsertTargetTcpProxyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InsertTargetTcpProxy(_, _)) + /// @endcode MOCK_METHOD(StatusOr, InsertTargetTcpProxy, (NoAwaitTag, @@ -92,6 +125,15 @@ class MockRegionTargetTcpProxiesConnection InsertTargetTcpProxyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertTargetTcpProxy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertTargetTcpProxy, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/region_url_maps/v1/mocks/mock_region_url_maps_connection.h b/google/cloud/compute/region_url_maps/v1/mocks/mock_region_url_maps_connection.h index 0b4ea83e8f7df..c829c69c5ee35 100644 --- a/google/cloud/compute/region_url_maps/v1/mocks/mock_region_url_maps_connection.h +++ b/google/cloud/compute/region_url_maps/v1/mocks/mock_region_url_maps_connection.h @@ -47,21 +47,42 @@ class MockRegionUrlMapsConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteUrlMap)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteUrlMap(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteUrlMap(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteUrlMap, (google::cloud::cpp::compute::region_url_maps::v1:: DeleteUrlMapRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteUrlMap(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteUrlMap, (NoAwaitTag, google::cloud::cpp::compute::region_url_maps::v1:: DeleteUrlMapRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteUrlMap(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteUrlMap, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -73,21 +94,42 @@ class MockRegionUrlMapsConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InsertUrlMap)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, InsertUrlMap(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertUrlMap(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertUrlMap, (google::cloud::cpp::compute::region_url_maps::v1:: InsertUrlMapRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InsertUrlMap(_, _)) + /// @endcode MOCK_METHOD(StatusOr, InsertUrlMap, (NoAwaitTag, google::cloud::cpp::compute::region_url_maps::v1:: InsertUrlMapRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertUrlMap(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertUrlMap, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -99,40 +141,82 @@ class MockRegionUrlMapsConnection ListRegionUrlMapsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, PatchUrlMap)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, PatchUrlMap(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchUrlMap(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchUrlMap, (google::cloud::cpp::compute::region_url_maps::v1:: PatchUrlMapRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, PatchUrlMap(_, _)) + /// @endcode MOCK_METHOD(StatusOr, PatchUrlMap, (NoAwaitTag, google::cloud::cpp::compute::region_url_maps::v1:: PatchUrlMapRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchUrlMap(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchUrlMap, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateUrlMap)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateUrlMap(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateUrlMap(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateUrlMap, (google::cloud::cpp::compute::region_url_maps::v1:: UpdateUrlMapRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateUrlMap(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateUrlMap, (NoAwaitTag, google::cloud::cpp::compute::region_url_maps::v1:: UpdateUrlMapRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateUrlMap(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateUrlMap, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/reservations/v1/mocks/mock_reservations_connection.h b/google/cloud/compute/reservations/v1/mocks/mock_reservations_connection.h index 81c54b33f1371..36b97cff25cdc 100644 --- a/google/cloud/compute/reservations/v1/mocks/mock_reservations_connection.h +++ b/google/cloud/compute/reservations/v1/mocks/mock_reservations_connection.h @@ -56,21 +56,42 @@ class MockReservationsConnection AggregatedListReservationsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteReservation)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteReservation(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteReservation(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteReservation, (google::cloud::cpp::compute::reservations::v1:: DeleteReservationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteReservation(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteReservation, (NoAwaitTag, google::cloud::cpp::compute::reservations::v1:: DeleteReservationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteReservation(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteReservation, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -88,21 +109,42 @@ class MockReservationsConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InsertReservation)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, InsertReservation(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertReservation(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertReservation, (google::cloud::cpp::compute::reservations::v1:: InsertReservationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InsertReservation(_, _)) + /// @endcode MOCK_METHOD(StatusOr, InsertReservation, (NoAwaitTag, google::cloud::cpp::compute::reservations::v1:: InsertReservationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertReservation(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertReservation, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -115,15 +157,27 @@ class MockReservationsConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, Resize)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, Resize(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// Resize(Matcher(_))) + /// @endcode MOCK_METHOD( future>, Resize, (google::cloud::cpp::compute::reservations::v1::ResizeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, Resize(_, _)) + /// @endcode MOCK_METHOD( StatusOr, Resize, (NoAwaitTag, @@ -131,6 +185,14 @@ class MockReservationsConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// Resize(Matcher(_))) + /// @endcode MOCK_METHOD(future>, Resize, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -149,21 +211,42 @@ class MockReservationsConnection TestIamPermissionsRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateReservation)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateReservation(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateReservation(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateReservation, (google::cloud::cpp::compute::reservations::v1:: UpdateReservationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateReservation(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateReservation, (NoAwaitTag, google::cloud::cpp::compute::reservations::v1:: UpdateReservationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateReservation(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateReservation, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/resource_policies/v1/mocks/mock_resource_policies_connection.h b/google/cloud/compute/resource_policies/v1/mocks/mock_resource_policies_connection.h index 4f3266a335b49..389d250ad95c4 100644 --- a/google/cloud/compute/resource_policies/v1/mocks/mock_resource_policies_connection.h +++ b/google/cloud/compute/resource_policies/v1/mocks/mock_resource_policies_connection.h @@ -55,21 +55,42 @@ class MockResourcePoliciesConnection AggregatedListResourcePoliciesRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteResourcePolicy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteResourcePolicy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteResourcePolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteResourcePolicy, (google::cloud::cpp::compute::resource_policies::v1:: DeleteResourcePolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteResourcePolicy(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteResourcePolicy, (NoAwaitTag, google::cloud::cpp::compute::resource_policies::v1:: DeleteResourcePolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteResourcePolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteResourcePolicy, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -86,21 +107,42 @@ class MockResourcePoliciesConnection GetIamPolicyRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InsertResourcePolicy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, InsertResourcePolicy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertResourcePolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertResourcePolicy, (google::cloud::cpp::compute::resource_policies::v1:: InsertResourcePolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InsertResourcePolicy(_, _)) + /// @endcode MOCK_METHOD(StatusOr, InsertResourcePolicy, (NoAwaitTag, google::cloud::cpp::compute::resource_policies::v1:: InsertResourcePolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertResourcePolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertResourcePolicy, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -112,21 +154,42 @@ class MockResourcePoliciesConnection ListResourcePoliciesRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, PatchResourcePolicy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, PatchResourcePolicy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchResourcePolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchResourcePolicy, (google::cloud::cpp::compute::resource_policies::v1:: PatchResourcePolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, PatchResourcePolicy(_, _)) + /// @endcode MOCK_METHOD(StatusOr, PatchResourcePolicy, (NoAwaitTag, google::cloud::cpp::compute::resource_policies::v1:: PatchResourcePolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchResourcePolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchResourcePolicy, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/routers/v1/mocks/mock_routers_connection.h b/google/cloud/compute/routers/v1/mocks/mock_routers_connection.h index d0ebd060fb30f..1a9eba27767e0 100644 --- a/google/cloud/compute/routers/v1/mocks/mock_routers_connection.h +++ b/google/cloud/compute/routers/v1/mocks/mock_routers_connection.h @@ -54,9 +54,15 @@ class MockRoutersConnection : public compute_routers_v1::RoutersConnection { request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteRouter)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteRouter(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteRouter(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteRouter, @@ -64,6 +70,12 @@ class MockRoutersConnection : public compute_routers_v1::RoutersConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteRouter(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteRouter, (NoAwaitTag, @@ -71,6 +83,15 @@ class MockRoutersConnection : public compute_routers_v1::RoutersConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteRouter(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteRouter, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -102,9 +123,15 @@ class MockRoutersConnection : public compute_routers_v1::RoutersConnection { request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InsertRouter)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, InsertRouter(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertRouter(Matcher(_))) + /// @endcode MOCK_METHOD( future>, InsertRouter, @@ -112,6 +139,12 @@ class MockRoutersConnection : public compute_routers_v1::RoutersConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InsertRouter(_, _)) + /// @endcode MOCK_METHOD( StatusOr, InsertRouter, (NoAwaitTag, @@ -119,6 +152,15 @@ class MockRoutersConnection : public compute_routers_v1::RoutersConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertRouter(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertRouter, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -129,15 +171,27 @@ class MockRoutersConnection : public compute_routers_v1::RoutersConnection { (google::cloud::cpp::compute::routers::v1::ListRoutersRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, PatchRouter)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, PatchRouter(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchRouter(Matcher(_))) + /// @endcode MOCK_METHOD( future>, PatchRouter, (google::cloud::cpp::compute::routers::v1::PatchRouterRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, PatchRouter(_, _)) + /// @endcode MOCK_METHOD( StatusOr, PatchRouter, (NoAwaitTag, @@ -145,6 +199,15 @@ class MockRoutersConnection : public compute_routers_v1::RoutersConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchRouter(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchRouter, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -156,9 +219,15 @@ class MockRoutersConnection : public compute_routers_v1::RoutersConnection { (google::cloud::cpp::compute::routers::v1::PreviewRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateRouter)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateRouter(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateRouter(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateRouter, @@ -166,6 +235,12 @@ class MockRoutersConnection : public compute_routers_v1::RoutersConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateRouter(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateRouter, (NoAwaitTag, @@ -173,6 +248,15 @@ class MockRoutersConnection : public compute_routers_v1::RoutersConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateRouter(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateRouter, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/routes/v1/mocks/mock_routes_connection.h b/google/cloud/compute/routes/v1/mocks/mock_routes_connection.h index 58425d6fcf00f..29bda66fbd1e6 100644 --- a/google/cloud/compute/routes/v1/mocks/mock_routes_connection.h +++ b/google/cloud/compute/routes/v1/mocks/mock_routes_connection.h @@ -46,15 +46,27 @@ class MockRoutesConnection : public compute_routes_v1::RoutesConnection { public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteRoute)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteRoute(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteRoute(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteRoute, (google::cloud::cpp::compute::routes::v1::DeleteRouteRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteRoute(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteRoute, (NoAwaitTag, @@ -62,6 +74,15 @@ class MockRoutesConnection : public compute_routes_v1::RoutesConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteRoute(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteRoute, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -72,15 +93,27 @@ class MockRoutesConnection : public compute_routes_v1::RoutesConnection { (google::cloud::cpp::compute::routes::v1::GetRouteRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InsertRoute)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, InsertRoute(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertRoute(Matcher(_))) + /// @endcode MOCK_METHOD( future>, InsertRoute, (google::cloud::cpp::compute::routes::v1::InsertRouteRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InsertRoute(_, _)) + /// @endcode MOCK_METHOD( StatusOr, InsertRoute, (NoAwaitTag, @@ -88,6 +121,15 @@ class MockRoutesConnection : public compute_routes_v1::RoutesConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertRoute(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertRoute, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/security_policies/v1/mocks/mock_security_policies_connection.h b/google/cloud/compute/security_policies/v1/mocks/mock_security_policies_connection.h index 11b612903d0f9..a99160c75a454 100644 --- a/google/cloud/compute/security_policies/v1/mocks/mock_security_policies_connection.h +++ b/google/cloud/compute/security_policies/v1/mocks/mock_security_policies_connection.h @@ -47,15 +47,27 @@ class MockSecurityPoliciesConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, AddRule)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, AddRule(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// AddRule(Matcher(_))) + /// @endcode MOCK_METHOD( future>, AddRule, (google::cloud::cpp::compute::security_policies::v1::AddRuleRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, AddRule(_, _)) + /// @endcode MOCK_METHOD( StatusOr, AddRule, (NoAwaitTag, @@ -63,6 +75,14 @@ class MockSecurityPoliciesConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// AddRule(Matcher(_))) + /// @endcode MOCK_METHOD(future>, AddRule, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -76,21 +96,42 @@ class MockSecurityPoliciesConnection AggregatedListSecurityPoliciesRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteSecurityPolicy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteSecurityPolicy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteSecurityPolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteSecurityPolicy, (google::cloud::cpp::compute::security_policies::v1:: DeleteSecurityPolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteSecurityPolicy(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteSecurityPolicy, (NoAwaitTag, google::cloud::cpp::compute::security_policies::v1:: DeleteSecurityPolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteSecurityPolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteSecurityPolicy, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -108,21 +149,42 @@ class MockSecurityPoliciesConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InsertSecurityPolicy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, InsertSecurityPolicy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertSecurityPolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertSecurityPolicy, (google::cloud::cpp::compute::security_policies::v1:: InsertSecurityPolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InsertSecurityPolicy(_, _)) + /// @endcode MOCK_METHOD(StatusOr, InsertSecurityPolicy, (NoAwaitTag, google::cloud::cpp::compute::security_policies::v1:: InsertSecurityPolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertSecurityPolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertSecurityPolicy, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -142,78 +204,159 @@ class MockSecurityPoliciesConnection ListPreconfiguredExpressionSetsRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, PatchSecurityPolicy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, PatchSecurityPolicy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchSecurityPolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchSecurityPolicy, (google::cloud::cpp::compute::security_policies::v1:: PatchSecurityPolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, PatchSecurityPolicy(_, _)) + /// @endcode MOCK_METHOD(StatusOr, PatchSecurityPolicy, (NoAwaitTag, google::cloud::cpp::compute::security_policies::v1:: PatchSecurityPolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchSecurityPolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchSecurityPolicy, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, PatchRule)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, PatchRule(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchRule(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchRule, (google::cloud::cpp::compute::security_policies::v1:: PatchRuleRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, PatchRule(_, _)) + /// @endcode MOCK_METHOD(StatusOr, PatchRule, (NoAwaitTag, google::cloud::cpp::compute::security_policies::v1:: PatchRuleRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchRule(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchRule, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, RemoveRule)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, RemoveRule(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RemoveRule(Matcher(_))) + /// @endcode MOCK_METHOD(future>, RemoveRule, (google::cloud::cpp::compute::security_policies::v1:: RemoveRuleRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, RemoveRule(_, _)) + /// @endcode MOCK_METHOD(StatusOr, RemoveRule, (NoAwaitTag, google::cloud::cpp::compute::security_policies::v1:: RemoveRuleRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RemoveRule(Matcher(_))) + /// @endcode MOCK_METHOD(future>, RemoveRule, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SetLabels)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SetLabels(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetLabels(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetLabels, (google::cloud::cpp::compute::security_policies::v1:: SetLabelsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SetLabels(_, _)) + /// @endcode MOCK_METHOD(StatusOr, SetLabels, (NoAwaitTag, google::cloud::cpp::compute::security_policies::v1:: SetLabelsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetLabels(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetLabels, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/service_attachments/v1/mocks/mock_service_attachments_connection.h b/google/cloud/compute/service_attachments/v1/mocks/mock_service_attachments_connection.h index fb2e5fd06ee48..b386d28fe1563 100644 --- a/google/cloud/compute/service_attachments/v1/mocks/mock_service_attachments_connection.h +++ b/google/cloud/compute/service_attachments/v1/mocks/mock_service_attachments_connection.h @@ -55,15 +55,27 @@ class MockServiceAttachmentsConnection AggregatedListServiceAttachmentsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteServiceAttachment)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteServiceAttachment(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteServiceAttachment(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteServiceAttachment, (google::cloud::cpp::compute::service_attachments::v1:: DeleteServiceAttachmentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteServiceAttachment(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteServiceAttachment, (NoAwaitTag, @@ -71,6 +83,15 @@ class MockServiceAttachmentsConnection DeleteServiceAttachmentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteServiceAttachment(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteServiceAttachment, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -87,15 +108,27 @@ class MockServiceAttachmentsConnection GetIamPolicyRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InsertServiceAttachment)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, InsertServiceAttachment(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertServiceAttachment(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertServiceAttachment, (google::cloud::cpp::compute::service_attachments::v1:: InsertServiceAttachmentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InsertServiceAttachment(_, _)) + /// @endcode MOCK_METHOD(StatusOr, InsertServiceAttachment, (NoAwaitTag, @@ -103,6 +136,15 @@ class MockServiceAttachmentsConnection InsertServiceAttachmentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertServiceAttachment(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertServiceAttachment, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -114,15 +156,27 @@ class MockServiceAttachmentsConnection ListServiceAttachmentsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, PatchServiceAttachment)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, PatchServiceAttachment(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchServiceAttachment(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchServiceAttachment, (google::cloud::cpp::compute::service_attachments::v1:: PatchServiceAttachmentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, PatchServiceAttachment(_, _)) + /// @endcode MOCK_METHOD(StatusOr, PatchServiceAttachment, (NoAwaitTag, @@ -130,6 +184,15 @@ class MockServiceAttachmentsConnection PatchServiceAttachmentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchServiceAttachment(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchServiceAttachment, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/snapshot_settings/v1/mocks/mock_snapshot_settings_connection.h b/google/cloud/compute/snapshot_settings/v1/mocks/mock_snapshot_settings_connection.h index 2f08486d68284..2bf9089b1b066 100644 --- a/google/cloud/compute/snapshot_settings/v1/mocks/mock_snapshot_settings_connection.h +++ b/google/cloud/compute/snapshot_settings/v1/mocks/mock_snapshot_settings_connection.h @@ -53,21 +53,42 @@ class MockSnapshotSettingsConnection GetSnapshotSettingsRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, PatchSnapshotSettings)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, PatchSnapshotSettings(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchSnapshotSettings(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchSnapshotSettings, (google::cloud::cpp::compute::snapshot_settings::v1:: PatchSnapshotSettingsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, PatchSnapshotSettings(_, _)) + /// @endcode MOCK_METHOD(StatusOr, PatchSnapshotSettings, (NoAwaitTag, google::cloud::cpp::compute::snapshot_settings::v1:: PatchSnapshotSettingsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchSnapshotSettings(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchSnapshotSettings, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/snapshots/v1/mocks/mock_snapshots_connection.h b/google/cloud/compute/snapshots/v1/mocks/mock_snapshots_connection.h index 496f797b8c5b3..00c9f9385d71d 100644 --- a/google/cloud/compute/snapshots/v1/mocks/mock_snapshots_connection.h +++ b/google/cloud/compute/snapshots/v1/mocks/mock_snapshots_connection.h @@ -47,9 +47,15 @@ class MockSnapshotsConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteSnapshot)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteSnapshot(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteSnapshot(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteSnapshot, @@ -57,6 +63,12 @@ class MockSnapshotsConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteSnapshot(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteSnapshot, (NoAwaitTag, @@ -64,6 +76,15 @@ class MockSnapshotsConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteSnapshot(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteSnapshot, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -81,9 +102,15 @@ class MockSnapshotsConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InsertSnapshot)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, InsertSnapshot(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertSnapshot(Matcher(_))) + /// @endcode MOCK_METHOD( future>, InsertSnapshot, @@ -91,6 +118,12 @@ class MockSnapshotsConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InsertSnapshot(_, _)) + /// @endcode MOCK_METHOD( StatusOr, InsertSnapshot, (NoAwaitTag, @@ -98,6 +131,15 @@ class MockSnapshotsConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertSnapshot(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertSnapshot, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -115,15 +157,27 @@ class MockSnapshotsConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SetLabels)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SetLabels(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetLabels(Matcher(_))) + /// @endcode MOCK_METHOD( future>, SetLabels, (google::cloud::cpp::compute::snapshots::v1::SetLabelsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SetLabels(_, _)) + /// @endcode MOCK_METHOD( StatusOr, SetLabels, (NoAwaitTag, @@ -131,6 +185,14 @@ class MockSnapshotsConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetLabels(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetLabels, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/ssl_certificates/v1/mocks/mock_ssl_certificates_connection.h b/google/cloud/compute/ssl_certificates/v1/mocks/mock_ssl_certificates_connection.h index 826610cfe8b4d..23ba2bdf081a3 100644 --- a/google/cloud/compute/ssl_certificates/v1/mocks/mock_ssl_certificates_connection.h +++ b/google/cloud/compute/ssl_certificates/v1/mocks/mock_ssl_certificates_connection.h @@ -55,21 +55,42 @@ class MockSslCertificatesConnection AggregatedListSslCertificatesRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteSslCertificate)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteSslCertificate(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteSslCertificate(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteSslCertificate, (google::cloud::cpp::compute::ssl_certificates::v1:: DeleteSslCertificateRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteSslCertificate(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteSslCertificate, (NoAwaitTag, google::cloud::cpp::compute::ssl_certificates::v1:: DeleteSslCertificateRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteSslCertificate(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteSslCertificate, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -81,21 +102,42 @@ class MockSslCertificatesConnection GetSslCertificateRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InsertSslCertificate)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, InsertSslCertificate(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertSslCertificate(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertSslCertificate, (google::cloud::cpp::compute::ssl_certificates::v1:: InsertSslCertificateRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InsertSslCertificate(_, _)) + /// @endcode MOCK_METHOD(StatusOr, InsertSslCertificate, (NoAwaitTag, google::cloud::cpp::compute::ssl_certificates::v1:: InsertSslCertificateRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertSslCertificate(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertSslCertificate, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/ssl_policies/v1/mocks/mock_ssl_policies_connection.h b/google/cloud/compute/ssl_policies/v1/mocks/mock_ssl_policies_connection.h index 3b242130dbb0e..cd0cc330c5d90 100644 --- a/google/cloud/compute/ssl_policies/v1/mocks/mock_ssl_policies_connection.h +++ b/google/cloud/compute/ssl_policies/v1/mocks/mock_ssl_policies_connection.h @@ -56,21 +56,42 @@ class MockSslPoliciesConnection AggregatedListSslPoliciesRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteSslPolicy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteSslPolicy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteSslPolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteSslPolicy, (google::cloud::cpp::compute::ssl_policies::v1:: DeleteSslPolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteSslPolicy(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteSslPolicy, (NoAwaitTag, google::cloud::cpp::compute::ssl_policies::v1:: DeleteSslPolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteSslPolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteSslPolicy, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -82,21 +103,42 @@ class MockSslPoliciesConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InsertSslPolicy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, InsertSslPolicy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertSslPolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertSslPolicy, (google::cloud::cpp::compute::ssl_policies::v1:: InsertSslPolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InsertSslPolicy(_, _)) + /// @endcode MOCK_METHOD(StatusOr, InsertSslPolicy, (NoAwaitTag, google::cloud::cpp::compute::ssl_policies::v1:: InsertSslPolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertSslPolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertSslPolicy, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -116,21 +158,42 @@ class MockSslPoliciesConnection ListAvailableFeaturesRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, PatchSslPolicy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, PatchSslPolicy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchSslPolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchSslPolicy, (google::cloud::cpp::compute::ssl_policies::v1:: PatchSslPolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, PatchSslPolicy(_, _)) + /// @endcode MOCK_METHOD(StatusOr, PatchSslPolicy, (NoAwaitTag, google::cloud::cpp::compute::ssl_policies::v1:: PatchSslPolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchSslPolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchSslPolicy, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/storage_pools/v1/mocks/mock_storage_pools_connection.h b/google/cloud/compute/storage_pools/v1/mocks/mock_storage_pools_connection.h index 472fb4002064a..22770f6fc334b 100644 --- a/google/cloud/compute/storage_pools/v1/mocks/mock_storage_pools_connection.h +++ b/google/cloud/compute/storage_pools/v1/mocks/mock_storage_pools_connection.h @@ -56,21 +56,42 @@ class MockStoragePoolsConnection AggregatedListStoragePoolsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteStoragePool)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteStoragePool(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteStoragePool(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteStoragePool, (google::cloud::cpp::compute::storage_pools::v1:: DeleteStoragePoolRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteStoragePool(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteStoragePool, (NoAwaitTag, google::cloud::cpp::compute::storage_pools::v1:: DeleteStoragePoolRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteStoragePool(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteStoragePool, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -87,21 +108,42 @@ class MockStoragePoolsConnection GetIamPolicyRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InsertStoragePool)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, InsertStoragePool(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertStoragePool(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertStoragePool, (google::cloud::cpp::compute::storage_pools::v1:: InsertStoragePoolRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InsertStoragePool(_, _)) + /// @endcode MOCK_METHOD(StatusOr, InsertStoragePool, (NoAwaitTag, google::cloud::cpp::compute::storage_pools::v1:: InsertStoragePoolRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertStoragePool(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertStoragePool, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -132,21 +174,42 @@ class MockStoragePoolsConnection TestIamPermissionsRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateStoragePool)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateStoragePool(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateStoragePool(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateStoragePool, (google::cloud::cpp::compute::storage_pools::v1:: UpdateStoragePoolRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateStoragePool(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateStoragePool, (NoAwaitTag, google::cloud::cpp::compute::storage_pools::v1:: UpdateStoragePoolRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateStoragePool(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateStoragePool, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/subnetworks/v1/mocks/mock_subnetworks_connection.h b/google/cloud/compute/subnetworks/v1/mocks/mock_subnetworks_connection.h index b44c519c754ac..c9ddd93e35845 100644 --- a/google/cloud/compute/subnetworks/v1/mocks/mock_subnetworks_connection.h +++ b/google/cloud/compute/subnetworks/v1/mocks/mock_subnetworks_connection.h @@ -56,41 +56,83 @@ class MockSubnetworksConnection AggregatedListSubnetworksRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteSubnetwork)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteSubnetwork(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteSubnetwork(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteSubnetwork, (google::cloud::cpp::compute::subnetworks::v1:: DeleteSubnetworkRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteSubnetwork(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteSubnetwork, (NoAwaitTag, google::cloud::cpp::compute::subnetworks::v1:: DeleteSubnetworkRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteSubnetwork(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteSubnetwork, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ExpandIpCidrRange)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ExpandIpCidrRange(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ExpandIpCidrRange(Matcher(_))) + /// @endcode MOCK_METHOD(future>, ExpandIpCidrRange, (google::cloud::cpp::compute::subnetworks::v1:: ExpandIpCidrRangeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ExpandIpCidrRange(_, _)) + /// @endcode MOCK_METHOD(StatusOr, ExpandIpCidrRange, (NoAwaitTag, google::cloud::cpp::compute::subnetworks::v1:: ExpandIpCidrRangeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ExpandIpCidrRange(Matcher(_))) + /// @endcode MOCK_METHOD(future>, ExpandIpCidrRange, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -108,21 +150,42 @@ class MockSubnetworksConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InsertSubnetwork)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, InsertSubnetwork(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertSubnetwork(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertSubnetwork, (google::cloud::cpp::compute::subnetworks::v1:: InsertSubnetworkRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InsertSubnetwork(_, _)) + /// @endcode MOCK_METHOD(StatusOr, InsertSubnetwork, (NoAwaitTag, google::cloud::cpp::compute::subnetworks::v1:: InsertSubnetworkRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertSubnetwork(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertSubnetwork, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -141,21 +204,42 @@ class MockSubnetworksConnection (google::cloud::cpp::compute::subnetworks::v1::ListUsableRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, PatchSubnetwork)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, PatchSubnetwork(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchSubnetwork(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchSubnetwork, (google::cloud::cpp::compute::subnetworks::v1:: PatchSubnetworkRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, PatchSubnetwork(_, _)) + /// @endcode MOCK_METHOD(StatusOr, PatchSubnetwork, (NoAwaitTag, google::cloud::cpp::compute::subnetworks::v1:: PatchSubnetworkRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchSubnetwork(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchSubnetwork, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -167,21 +251,42 @@ class MockSubnetworksConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SetPrivateIpGoogleAccess)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SetPrivateIpGoogleAccess(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetPrivateIpGoogleAccess(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetPrivateIpGoogleAccess, (google::cloud::cpp::compute::subnetworks::v1:: SetPrivateIpGoogleAccessRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SetPrivateIpGoogleAccess(_, _)) + /// @endcode MOCK_METHOD(StatusOr, SetPrivateIpGoogleAccess, (NoAwaitTag, google::cloud::cpp::compute::subnetworks::v1:: SetPrivateIpGoogleAccessRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetPrivateIpGoogleAccess(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetPrivateIpGoogleAccess, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/target_grpc_proxies/v1/mocks/mock_target_grpc_proxies_connection.h b/google/cloud/compute/target_grpc_proxies/v1/mocks/mock_target_grpc_proxies_connection.h index 58718dd8d67c5..5e7a866d99ebc 100644 --- a/google/cloud/compute/target_grpc_proxies/v1/mocks/mock_target_grpc_proxies_connection.h +++ b/google/cloud/compute/target_grpc_proxies/v1/mocks/mock_target_grpc_proxies_connection.h @@ -47,21 +47,42 @@ class MockTargetGrpcProxiesConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteTargetGrpcProxy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteTargetGrpcProxy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteTargetGrpcProxy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteTargetGrpcProxy, (google::cloud::cpp::compute::target_grpc_proxies::v1:: DeleteTargetGrpcProxyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteTargetGrpcProxy(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteTargetGrpcProxy, (NoAwaitTag, google::cloud::cpp::compute::target_grpc_proxies:: v1::DeleteTargetGrpcProxyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteTargetGrpcProxy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteTargetGrpcProxy, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -73,21 +94,42 @@ class MockTargetGrpcProxiesConnection GetTargetGrpcProxyRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InsertTargetGrpcProxy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, InsertTargetGrpcProxy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertTargetGrpcProxy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertTargetGrpcProxy, (google::cloud::cpp::compute::target_grpc_proxies::v1:: InsertTargetGrpcProxyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InsertTargetGrpcProxy(_, _)) + /// @endcode MOCK_METHOD(StatusOr, InsertTargetGrpcProxy, (NoAwaitTag, google::cloud::cpp::compute::target_grpc_proxies:: v1::InsertTargetGrpcProxyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertTargetGrpcProxy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertTargetGrpcProxy, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -99,21 +141,42 @@ class MockTargetGrpcProxiesConnection ListTargetGrpcProxiesRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, PatchTargetGrpcProxy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, PatchTargetGrpcProxy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchTargetGrpcProxy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchTargetGrpcProxy, (google::cloud::cpp::compute::target_grpc_proxies::v1:: PatchTargetGrpcProxyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, PatchTargetGrpcProxy(_, _)) + /// @endcode MOCK_METHOD(StatusOr, PatchTargetGrpcProxy, (NoAwaitTag, google::cloud::cpp::compute::target_grpc_proxies:: v1::PatchTargetGrpcProxyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchTargetGrpcProxy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchTargetGrpcProxy, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/target_http_proxies/v1/mocks/mock_target_http_proxies_connection.h b/google/cloud/compute/target_http_proxies/v1/mocks/mock_target_http_proxies_connection.h index 369d3549a5978..a9604d4b7b81d 100644 --- a/google/cloud/compute/target_http_proxies/v1/mocks/mock_target_http_proxies_connection.h +++ b/google/cloud/compute/target_http_proxies/v1/mocks/mock_target_http_proxies_connection.h @@ -55,21 +55,42 @@ class MockTargetHttpProxiesConnection AggregatedListTargetHttpProxiesRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteTargetHttpProxy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteTargetHttpProxy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteTargetHttpProxy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteTargetHttpProxy, (google::cloud::cpp::compute::target_http_proxies::v1:: DeleteTargetHttpProxyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteTargetHttpProxy(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteTargetHttpProxy, (NoAwaitTag, google::cloud::cpp::compute::target_http_proxies:: v1::DeleteTargetHttpProxyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteTargetHttpProxy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteTargetHttpProxy, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -81,21 +102,42 @@ class MockTargetHttpProxiesConnection GetTargetHttpProxyRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InsertTargetHttpProxy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, InsertTargetHttpProxy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertTargetHttpProxy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertTargetHttpProxy, (google::cloud::cpp::compute::target_http_proxies::v1:: InsertTargetHttpProxyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InsertTargetHttpProxy(_, _)) + /// @endcode MOCK_METHOD(StatusOr, InsertTargetHttpProxy, (NoAwaitTag, google::cloud::cpp::compute::target_http_proxies:: v1::InsertTargetHttpProxyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertTargetHttpProxy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertTargetHttpProxy, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -107,40 +149,81 @@ class MockTargetHttpProxiesConnection ListTargetHttpProxiesRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, PatchTargetHttpProxy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, PatchTargetHttpProxy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchTargetHttpProxy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchTargetHttpProxy, (google::cloud::cpp::compute::target_http_proxies::v1:: PatchTargetHttpProxyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, PatchTargetHttpProxy(_, _)) + /// @endcode MOCK_METHOD(StatusOr, PatchTargetHttpProxy, (NoAwaitTag, google::cloud::cpp::compute::target_http_proxies:: v1::PatchTargetHttpProxyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchTargetHttpProxy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchTargetHttpProxy, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SetUrlMap)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SetUrlMap(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetUrlMap(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetUrlMap, (google::cloud::cpp::compute::target_http_proxies::v1:: SetUrlMapRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SetUrlMap(_, _)) + /// @endcode MOCK_METHOD(StatusOr, SetUrlMap, (NoAwaitTag, google::cloud::cpp::compute::target_http_proxies:: v1::SetUrlMapRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetUrlMap(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetUrlMap, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/target_https_proxies/v1/mocks/mock_target_https_proxies_connection.h b/google/cloud/compute/target_https_proxies/v1/mocks/mock_target_https_proxies_connection.h index 8fa1e9ea371b5..f5811fa9f1939 100644 --- a/google/cloud/compute/target_https_proxies/v1/mocks/mock_target_https_proxies_connection.h +++ b/google/cloud/compute/target_https_proxies/v1/mocks/mock_target_https_proxies_connection.h @@ -56,15 +56,27 @@ class MockTargetHttpsProxiesConnection AggregatedListTargetHttpsProxiesRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteTargetHttpsProxy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteTargetHttpsProxy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteTargetHttpsProxy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteTargetHttpsProxy, (google::cloud::cpp::compute::target_https_proxies::v1:: DeleteTargetHttpsProxyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteTargetHttpsProxy(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteTargetHttpsProxy, (NoAwaitTag, @@ -72,6 +84,15 @@ class MockTargetHttpsProxiesConnection DeleteTargetHttpsProxyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteTargetHttpsProxy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteTargetHttpsProxy, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -83,15 +104,27 @@ class MockTargetHttpsProxiesConnection GetTargetHttpsProxyRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InsertTargetHttpsProxy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, InsertTargetHttpsProxy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertTargetHttpsProxy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertTargetHttpsProxy, (google::cloud::cpp::compute::target_https_proxies::v1:: InsertTargetHttpsProxyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InsertTargetHttpsProxy(_, _)) + /// @endcode MOCK_METHOD(StatusOr, InsertTargetHttpsProxy, (NoAwaitTag, @@ -99,6 +132,15 @@ class MockTargetHttpsProxiesConnection InsertTargetHttpsProxyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertTargetHttpsProxy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertTargetHttpsProxy, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -110,120 +152,245 @@ class MockTargetHttpsProxiesConnection ListTargetHttpsProxiesRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, PatchTargetHttpsProxy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, PatchTargetHttpsProxy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchTargetHttpsProxy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchTargetHttpsProxy, (google::cloud::cpp::compute::target_https_proxies::v1:: PatchTargetHttpsProxyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, PatchTargetHttpsProxy(_, _)) + /// @endcode MOCK_METHOD(StatusOr, PatchTargetHttpsProxy, (NoAwaitTag, google::cloud::cpp::compute::target_https_proxies:: v1::PatchTargetHttpsProxyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchTargetHttpsProxy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchTargetHttpsProxy, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SetCertificateMap)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SetCertificateMap(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetCertificateMap(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetCertificateMap, (google::cloud::cpp::compute::target_https_proxies::v1:: SetCertificateMapRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SetCertificateMap(_, _)) + /// @endcode MOCK_METHOD(StatusOr, SetCertificateMap, (NoAwaitTag, google::cloud::cpp::compute::target_https_proxies:: v1::SetCertificateMapRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetCertificateMap(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetCertificateMap, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SetQuicOverride)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SetQuicOverride(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetQuicOverride(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetQuicOverride, (google::cloud::cpp::compute::target_https_proxies::v1:: SetQuicOverrideRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SetQuicOverride(_, _)) + /// @endcode MOCK_METHOD(StatusOr, SetQuicOverride, (NoAwaitTag, google::cloud::cpp::compute::target_https_proxies:: v1::SetQuicOverrideRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetQuicOverride(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetQuicOverride, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SetSslCertificates)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SetSslCertificates(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetSslCertificates(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetSslCertificates, (google::cloud::cpp::compute::target_https_proxies::v1:: SetSslCertificatesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SetSslCertificates(_, _)) + /// @endcode MOCK_METHOD(StatusOr, SetSslCertificates, (NoAwaitTag, google::cloud::cpp::compute::target_https_proxies:: v1::SetSslCertificatesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetSslCertificates(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetSslCertificates, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SetSslPolicy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SetSslPolicy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetSslPolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetSslPolicy, (google::cloud::cpp::compute::target_https_proxies::v1:: SetSslPolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SetSslPolicy(_, _)) + /// @endcode MOCK_METHOD(StatusOr, SetSslPolicy, (NoAwaitTag, google::cloud::cpp::compute::target_https_proxies:: v1::SetSslPolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetSslPolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetSslPolicy, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SetUrlMap)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SetUrlMap(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetUrlMap(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetUrlMap, (google::cloud::cpp::compute::target_https_proxies::v1:: SetUrlMapRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SetUrlMap(_, _)) + /// @endcode MOCK_METHOD(StatusOr, SetUrlMap, (NoAwaitTag, google::cloud::cpp::compute::target_https_proxies:: v1::SetUrlMapRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetUrlMap(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetUrlMap, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/target_instances/v1/mocks/mock_target_instances_connection.h b/google/cloud/compute/target_instances/v1/mocks/mock_target_instances_connection.h index 85cfe12d49072..4684b2343ce10 100644 --- a/google/cloud/compute/target_instances/v1/mocks/mock_target_instances_connection.h +++ b/google/cloud/compute/target_instances/v1/mocks/mock_target_instances_connection.h @@ -55,21 +55,42 @@ class MockTargetInstancesConnection AggregatedListTargetInstancesRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteTargetInstance)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteTargetInstance(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteTargetInstance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteTargetInstance, (google::cloud::cpp::compute::target_instances::v1:: DeleteTargetInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteTargetInstance(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteTargetInstance, (NoAwaitTag, google::cloud::cpp::compute::target_instances::v1:: DeleteTargetInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteTargetInstance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteTargetInstance, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -81,21 +102,42 @@ class MockTargetInstancesConnection GetTargetInstanceRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InsertTargetInstance)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, InsertTargetInstance(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertTargetInstance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertTargetInstance, (google::cloud::cpp::compute::target_instances::v1:: InsertTargetInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InsertTargetInstance(_, _)) + /// @endcode MOCK_METHOD(StatusOr, InsertTargetInstance, (NoAwaitTag, google::cloud::cpp::compute::target_instances::v1:: InsertTargetInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertTargetInstance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertTargetInstance, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -107,21 +149,42 @@ class MockTargetInstancesConnection ListTargetInstancesRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SetSecurityPolicy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SetSecurityPolicy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetSecurityPolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetSecurityPolicy, (google::cloud::cpp::compute::target_instances::v1:: SetSecurityPolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SetSecurityPolicy(_, _)) + /// @endcode MOCK_METHOD(StatusOr, SetSecurityPolicy, (NoAwaitTag, google::cloud::cpp::compute::target_instances::v1:: SetSecurityPolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetSecurityPolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetSecurityPolicy, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/target_pools/v1/mocks/mock_target_pools_connection.h b/google/cloud/compute/target_pools/v1/mocks/mock_target_pools_connection.h index 0d2fdd0cb6838..7a3549f02573e 100644 --- a/google/cloud/compute/target_pools/v1/mocks/mock_target_pools_connection.h +++ b/google/cloud/compute/target_pools/v1/mocks/mock_target_pools_connection.h @@ -47,35 +47,68 @@ class MockTargetPoolsConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, AddHealthCheck)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, AddHealthCheck(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// AddHealthCheck(Matcher(_))) + /// @endcode MOCK_METHOD(future>, AddHealthCheck, (google::cloud::cpp::compute::target_pools::v1:: AddHealthCheckRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, AddHealthCheck(_, _)) + /// @endcode MOCK_METHOD(StatusOr, AddHealthCheck, (NoAwaitTag, google::cloud::cpp::compute::target_pools::v1:: AddHealthCheckRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// AddHealthCheck(Matcher(_))) + /// @endcode MOCK_METHOD(future>, AddHealthCheck, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, AddInstance)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, AddInstance(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// AddInstance(Matcher(_))) + /// @endcode MOCK_METHOD( future>, AddInstance, (google::cloud::cpp::compute::target_pools::v1::AddInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, AddInstance(_, _)) + /// @endcode MOCK_METHOD( StatusOr, AddInstance, (NoAwaitTag, @@ -83,6 +116,15 @@ class MockTargetPoolsConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// AddInstance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, AddInstance, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -97,21 +139,42 @@ class MockTargetPoolsConnection AggregatedListTargetPoolsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteTargetPool)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteTargetPool(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteTargetPool(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteTargetPool, (google::cloud::cpp::compute::target_pools::v1:: DeleteTargetPoolRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteTargetPool(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteTargetPool, (NoAwaitTag, google::cloud::cpp::compute::target_pools::v1:: DeleteTargetPoolRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteTargetPool(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteTargetPool, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -130,21 +193,42 @@ class MockTargetPoolsConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InsertTargetPool)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, InsertTargetPool(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertTargetPool(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertTargetPool, (google::cloud::cpp::compute::target_pools::v1:: InsertTargetPoolRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InsertTargetPool(_, _)) + /// @endcode MOCK_METHOD(StatusOr, InsertTargetPool, (NoAwaitTag, google::cloud::cpp::compute::target_pools::v1:: InsertTargetPoolRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertTargetPool(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertTargetPool, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -157,55 +241,109 @@ class MockTargetPoolsConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, RemoveHealthCheck)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, RemoveHealthCheck(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RemoveHealthCheck(Matcher(_))) + /// @endcode MOCK_METHOD(future>, RemoveHealthCheck, (google::cloud::cpp::compute::target_pools::v1:: RemoveHealthCheckRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, RemoveHealthCheck(_, _)) + /// @endcode MOCK_METHOD(StatusOr, RemoveHealthCheck, (NoAwaitTag, google::cloud::cpp::compute::target_pools::v1:: RemoveHealthCheckRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RemoveHealthCheck(Matcher(_))) + /// @endcode MOCK_METHOD(future>, RemoveHealthCheck, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, RemoveInstance)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, RemoveInstance(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RemoveInstance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, RemoveInstance, (google::cloud::cpp::compute::target_pools::v1:: RemoveInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, RemoveInstance(_, _)) + /// @endcode MOCK_METHOD(StatusOr, RemoveInstance, (NoAwaitTag, google::cloud::cpp::compute::target_pools::v1:: RemoveInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RemoveInstance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, RemoveInstance, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SetBackup)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SetBackup(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetBackup(Matcher(_))) + /// @endcode MOCK_METHOD( future>, SetBackup, (google::cloud::cpp::compute::target_pools::v1::SetBackupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SetBackup(_, _)) + /// @endcode MOCK_METHOD( StatusOr, SetBackup, (NoAwaitTag, @@ -213,26 +351,55 @@ class MockTargetPoolsConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetBackup(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetBackup, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SetSecurityPolicy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SetSecurityPolicy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetSecurityPolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetSecurityPolicy, (google::cloud::cpp::compute::target_pools::v1:: SetSecurityPolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SetSecurityPolicy(_, _)) + /// @endcode MOCK_METHOD(StatusOr, SetSecurityPolicy, (NoAwaitTag, google::cloud::cpp::compute::target_pools::v1:: SetSecurityPolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetSecurityPolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetSecurityPolicy, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/target_ssl_proxies/v1/mocks/mock_target_ssl_proxies_connection.h b/google/cloud/compute/target_ssl_proxies/v1/mocks/mock_target_ssl_proxies_connection.h index 17d18d2122603..75faf917f0229 100644 --- a/google/cloud/compute/target_ssl_proxies/v1/mocks/mock_target_ssl_proxies_connection.h +++ b/google/cloud/compute/target_ssl_proxies/v1/mocks/mock_target_ssl_proxies_connection.h @@ -47,21 +47,42 @@ class MockTargetSslProxiesConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteTargetSslProxy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteTargetSslProxy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteTargetSslProxy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteTargetSslProxy, (google::cloud::cpp::compute::target_ssl_proxies::v1:: DeleteTargetSslProxyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteTargetSslProxy(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteTargetSslProxy, (NoAwaitTag, google::cloud::cpp::compute::target_ssl_proxies::v1:: DeleteTargetSslProxyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteTargetSslProxy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteTargetSslProxy, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -73,21 +94,42 @@ class MockTargetSslProxiesConnection GetTargetSslProxyRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InsertTargetSslProxy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, InsertTargetSslProxy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertTargetSslProxy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertTargetSslProxy, (google::cloud::cpp::compute::target_ssl_proxies::v1:: InsertTargetSslProxyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InsertTargetSslProxy(_, _)) + /// @endcode MOCK_METHOD(StatusOr, InsertTargetSslProxy, (NoAwaitTag, google::cloud::cpp::compute::target_ssl_proxies::v1:: InsertTargetSslProxyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertTargetSslProxy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertTargetSslProxy, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -99,101 +141,206 @@ class MockTargetSslProxiesConnection ListTargetSslProxiesRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SetBackendService)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SetBackendService(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetBackendService(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetBackendService, (google::cloud::cpp::compute::target_ssl_proxies::v1:: SetBackendServiceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SetBackendService(_, _)) + /// @endcode MOCK_METHOD(StatusOr, SetBackendService, (NoAwaitTag, google::cloud::cpp::compute::target_ssl_proxies::v1:: SetBackendServiceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetBackendService(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetBackendService, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SetCertificateMap)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SetCertificateMap(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetCertificateMap(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetCertificateMap, (google::cloud::cpp::compute::target_ssl_proxies::v1:: SetCertificateMapRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SetCertificateMap(_, _)) + /// @endcode MOCK_METHOD(StatusOr, SetCertificateMap, (NoAwaitTag, google::cloud::cpp::compute::target_ssl_proxies::v1:: SetCertificateMapRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetCertificateMap(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetCertificateMap, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SetProxyHeader)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SetProxyHeader(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetProxyHeader(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetProxyHeader, (google::cloud::cpp::compute::target_ssl_proxies::v1:: SetProxyHeaderRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SetProxyHeader(_, _)) + /// @endcode MOCK_METHOD(StatusOr, SetProxyHeader, (NoAwaitTag, google::cloud::cpp::compute::target_ssl_proxies::v1:: SetProxyHeaderRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetProxyHeader(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetProxyHeader, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SetSslCertificates)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SetSslCertificates(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetSslCertificates(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetSslCertificates, (google::cloud::cpp::compute::target_ssl_proxies::v1:: SetSslCertificatesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SetSslCertificates(_, _)) + /// @endcode MOCK_METHOD(StatusOr, SetSslCertificates, (NoAwaitTag, google::cloud::cpp::compute::target_ssl_proxies::v1:: SetSslCertificatesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetSslCertificates(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetSslCertificates, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SetSslPolicy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SetSslPolicy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetSslPolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetSslPolicy, (google::cloud::cpp::compute::target_ssl_proxies::v1:: SetSslPolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SetSslPolicy(_, _)) + /// @endcode MOCK_METHOD(StatusOr, SetSslPolicy, (NoAwaitTag, google::cloud::cpp::compute::target_ssl_proxies::v1:: SetSslPolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetSslPolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetSslPolicy, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/target_tcp_proxies/v1/mocks/mock_target_tcp_proxies_connection.h b/google/cloud/compute/target_tcp_proxies/v1/mocks/mock_target_tcp_proxies_connection.h index 456b6408c554f..239416c9284d4 100644 --- a/google/cloud/compute/target_tcp_proxies/v1/mocks/mock_target_tcp_proxies_connection.h +++ b/google/cloud/compute/target_tcp_proxies/v1/mocks/mock_target_tcp_proxies_connection.h @@ -55,21 +55,42 @@ class MockTargetTcpProxiesConnection AggregatedListTargetTcpProxiesRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteTargetTcpProxy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteTargetTcpProxy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteTargetTcpProxy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteTargetTcpProxy, (google::cloud::cpp::compute::target_tcp_proxies::v1:: DeleteTargetTcpProxyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteTargetTcpProxy(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteTargetTcpProxy, (NoAwaitTag, google::cloud::cpp::compute::target_tcp_proxies::v1:: DeleteTargetTcpProxyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteTargetTcpProxy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteTargetTcpProxy, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -81,21 +102,42 @@ class MockTargetTcpProxiesConnection GetTargetTcpProxyRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InsertTargetTcpProxy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, InsertTargetTcpProxy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertTargetTcpProxy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertTargetTcpProxy, (google::cloud::cpp::compute::target_tcp_proxies::v1:: InsertTargetTcpProxyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InsertTargetTcpProxy(_, _)) + /// @endcode MOCK_METHOD(StatusOr, InsertTargetTcpProxy, (NoAwaitTag, google::cloud::cpp::compute::target_tcp_proxies::v1:: InsertTargetTcpProxyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertTargetTcpProxy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertTargetTcpProxy, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -107,41 +149,83 @@ class MockTargetTcpProxiesConnection ListTargetTcpProxiesRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SetBackendService)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SetBackendService(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetBackendService(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetBackendService, (google::cloud::cpp::compute::target_tcp_proxies::v1:: SetBackendServiceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SetBackendService(_, _)) + /// @endcode MOCK_METHOD(StatusOr, SetBackendService, (NoAwaitTag, google::cloud::cpp::compute::target_tcp_proxies::v1:: SetBackendServiceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetBackendService(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetBackendService, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SetProxyHeader)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SetProxyHeader(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetProxyHeader(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetProxyHeader, (google::cloud::cpp::compute::target_tcp_proxies::v1:: SetProxyHeaderRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SetProxyHeader(_, _)) + /// @endcode MOCK_METHOD(StatusOr, SetProxyHeader, (NoAwaitTag, google::cloud::cpp::compute::target_tcp_proxies::v1:: SetProxyHeaderRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetProxyHeader(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetProxyHeader, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/target_vpn_gateways/v1/mocks/mock_target_vpn_gateways_connection.h b/google/cloud/compute/target_vpn_gateways/v1/mocks/mock_target_vpn_gateways_connection.h index f14520452883e..e3ad7c1e72e87 100644 --- a/google/cloud/compute/target_vpn_gateways/v1/mocks/mock_target_vpn_gateways_connection.h +++ b/google/cloud/compute/target_vpn_gateways/v1/mocks/mock_target_vpn_gateways_connection.h @@ -55,15 +55,27 @@ class MockTargetVpnGatewaysConnection AggregatedListTargetVpnGatewaysRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteTargetVpnGateway)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteTargetVpnGateway(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteTargetVpnGateway(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteTargetVpnGateway, (google::cloud::cpp::compute::target_vpn_gateways::v1:: DeleteTargetVpnGatewayRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteTargetVpnGateway(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteTargetVpnGateway, (NoAwaitTag, @@ -71,6 +83,15 @@ class MockTargetVpnGatewaysConnection DeleteTargetVpnGatewayRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteTargetVpnGateway(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteTargetVpnGateway, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -82,15 +103,27 @@ class MockTargetVpnGatewaysConnection GetTargetVpnGatewayRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InsertTargetVpnGateway)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, InsertTargetVpnGateway(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertTargetVpnGateway(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertTargetVpnGateway, (google::cloud::cpp::compute::target_vpn_gateways::v1:: InsertTargetVpnGatewayRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InsertTargetVpnGateway(_, _)) + /// @endcode MOCK_METHOD(StatusOr, InsertTargetVpnGateway, (NoAwaitTag, @@ -98,6 +131,15 @@ class MockTargetVpnGatewaysConnection InsertTargetVpnGatewayRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertTargetVpnGateway(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertTargetVpnGateway, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -109,20 +151,40 @@ class MockTargetVpnGatewaysConnection ListTargetVpnGatewaysRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SetLabels)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SetLabels(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetLabels(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetLabels, (google::cloud::cpp::compute::target_vpn_gateways::v1:: SetLabelsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SetLabels(_, _)) + /// @endcode MOCK_METHOD(StatusOr, SetLabels, (NoAwaitTag, google::cloud::cpp::compute::target_vpn_gateways:: v1::SetLabelsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetLabels(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetLabels, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/url_maps/v1/mocks/mock_url_maps_connection.h b/google/cloud/compute/url_maps/v1/mocks/mock_url_maps_connection.h index 1a25c97c5730b..847cd2df3b6b9 100644 --- a/google/cloud/compute/url_maps/v1/mocks/mock_url_maps_connection.h +++ b/google/cloud/compute/url_maps/v1/mocks/mock_url_maps_connection.h @@ -54,9 +54,15 @@ class MockUrlMapsConnection : public compute_url_maps_v1::UrlMapsConnection { request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteUrlMap)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteUrlMap(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteUrlMap(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteUrlMap, @@ -64,6 +70,12 @@ class MockUrlMapsConnection : public compute_url_maps_v1::UrlMapsConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteUrlMap(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteUrlMap, (NoAwaitTag, @@ -71,6 +83,15 @@ class MockUrlMapsConnection : public compute_url_maps_v1::UrlMapsConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteUrlMap(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteUrlMap, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -82,9 +103,15 @@ class MockUrlMapsConnection : public compute_url_maps_v1::UrlMapsConnection { request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InsertUrlMap)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, InsertUrlMap(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertUrlMap(Matcher(_))) + /// @endcode MOCK_METHOD( future>, InsertUrlMap, @@ -92,6 +119,12 @@ class MockUrlMapsConnection : public compute_url_maps_v1::UrlMapsConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InsertUrlMap(_, _)) + /// @endcode MOCK_METHOD( StatusOr, InsertUrlMap, (NoAwaitTag, @@ -99,14 +132,29 @@ class MockUrlMapsConnection : public compute_url_maps_v1::UrlMapsConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertUrlMap(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertUrlMap, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InvalidateCache)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, InvalidateCache(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InvalidateCache(Matcher(_))) + /// @endcode MOCK_METHOD( future>, InvalidateCache, @@ -114,6 +162,12 @@ class MockUrlMapsConnection : public compute_url_maps_v1::UrlMapsConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InvalidateCache(_, _)) + /// @endcode MOCK_METHOD( StatusOr, InvalidateCache, (NoAwaitTag, @@ -121,6 +175,15 @@ class MockUrlMapsConnection : public compute_url_maps_v1::UrlMapsConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InvalidateCache(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InvalidateCache, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -131,15 +194,27 @@ class MockUrlMapsConnection : public compute_url_maps_v1::UrlMapsConnection { (google::cloud::cpp::compute::url_maps::v1::ListUrlMapsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, PatchUrlMap)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, PatchUrlMap(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchUrlMap(Matcher(_))) + /// @endcode MOCK_METHOD( future>, PatchUrlMap, (google::cloud::cpp::compute::url_maps::v1::PatchUrlMapRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, PatchUrlMap(_, _)) + /// @endcode MOCK_METHOD( StatusOr, PatchUrlMap, (NoAwaitTag, @@ -147,14 +222,29 @@ class MockUrlMapsConnection : public compute_url_maps_v1::UrlMapsConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PatchUrlMap(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PatchUrlMap, (google::cloud::cpp::compute::v1::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateUrlMap)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateUrlMap(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateUrlMap(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateUrlMap, @@ -162,6 +252,12 @@ class MockUrlMapsConnection : public compute_url_maps_v1::UrlMapsConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateUrlMap(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateUrlMap, (NoAwaitTag, @@ -169,6 +265,15 @@ class MockUrlMapsConnection : public compute_url_maps_v1::UrlMapsConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateUrlMap(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateUrlMap, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/vpn_gateways/v1/mocks/mock_vpn_gateways_connection.h b/google/cloud/compute/vpn_gateways/v1/mocks/mock_vpn_gateways_connection.h index b70e8103b83b3..ee6db4526a82f 100644 --- a/google/cloud/compute/vpn_gateways/v1/mocks/mock_vpn_gateways_connection.h +++ b/google/cloud/compute/vpn_gateways/v1/mocks/mock_vpn_gateways_connection.h @@ -56,21 +56,42 @@ class MockVpnGatewaysConnection AggregatedListVpnGatewaysRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteVpnGateway)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteVpnGateway(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteVpnGateway(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteVpnGateway, (google::cloud::cpp::compute::vpn_gateways::v1:: DeleteVpnGatewayRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteVpnGateway(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteVpnGateway, (NoAwaitTag, google::cloud::cpp::compute::vpn_gateways::v1:: DeleteVpnGatewayRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteVpnGateway(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteVpnGateway, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -89,21 +110,42 @@ class MockVpnGatewaysConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InsertVpnGateway)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, InsertVpnGateway(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertVpnGateway(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertVpnGateway, (google::cloud::cpp::compute::vpn_gateways::v1:: InsertVpnGatewayRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InsertVpnGateway(_, _)) + /// @endcode MOCK_METHOD(StatusOr, InsertVpnGateway, (NoAwaitTag, google::cloud::cpp::compute::vpn_gateways::v1:: InsertVpnGatewayRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertVpnGateway(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertVpnGateway, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -116,15 +158,27 @@ class MockVpnGatewaysConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SetLabels)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SetLabels(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetLabels(Matcher(_))) + /// @endcode MOCK_METHOD( future>, SetLabels, (google::cloud::cpp::compute::vpn_gateways::v1::SetLabelsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SetLabels(_, _)) + /// @endcode MOCK_METHOD( StatusOr, SetLabels, (NoAwaitTag, @@ -132,6 +186,14 @@ class MockVpnGatewaysConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetLabels(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetLabels, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/compute/vpn_tunnels/v1/mocks/mock_vpn_tunnels_connection.h b/google/cloud/compute/vpn_tunnels/v1/mocks/mock_vpn_tunnels_connection.h index 341214d536ff8..3903ec42b678f 100644 --- a/google/cloud/compute/vpn_tunnels/v1/mocks/mock_vpn_tunnels_connection.h +++ b/google/cloud/compute/vpn_tunnels/v1/mocks/mock_vpn_tunnels_connection.h @@ -56,21 +56,42 @@ class MockVpnTunnelsConnection AggregatedListVpnTunnelsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteVpnTunnel)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteVpnTunnel(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteVpnTunnel(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteVpnTunnel, (google::cloud::cpp::compute::vpn_tunnels::v1:: DeleteVpnTunnelRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteVpnTunnel(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteVpnTunnel, (NoAwaitTag, google::cloud::cpp::compute::vpn_tunnels::v1:: DeleteVpnTunnelRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteVpnTunnel(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteVpnTunnel, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -82,21 +103,42 @@ class MockVpnTunnelsConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InsertVpnTunnel)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, InsertVpnTunnel(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertVpnTunnel(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertVpnTunnel, (google::cloud::cpp::compute::vpn_tunnels::v1:: InsertVpnTunnelRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InsertVpnTunnel(_, _)) + /// @endcode MOCK_METHOD(StatusOr, InsertVpnTunnel, (NoAwaitTag, google::cloud::cpp::compute::vpn_tunnels::v1:: InsertVpnTunnelRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InsertVpnTunnel(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InsertVpnTunnel, (google::cloud::cpp::compute::v1::Operation const& operation), @@ -108,15 +150,27 @@ class MockVpnTunnelsConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SetLabels)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SetLabels(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetLabels(Matcher(_))) + /// @endcode MOCK_METHOD( future>, SetLabels, (google::cloud::cpp::compute::vpn_tunnels::v1::SetLabelsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SetLabels(_, _)) + /// @endcode MOCK_METHOD( StatusOr, SetLabels, (NoAwaitTag, @@ -124,6 +178,14 @@ class MockVpnTunnelsConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetLabels(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetLabels, (google::cloud::cpp::compute::v1::Operation const& operation), diff --git a/google/cloud/config/v1/mocks/mock_config_connection.h b/google/cloud/config/v1/mocks/mock_config_connection.h index 4954f3860b33d..99c4215c01a3f 100644 --- a/google/cloud/config/v1/mocks/mock_config_connection.h +++ b/google/cloud/config/v1/mocks/mock_config_connection.h @@ -55,56 +55,116 @@ class MockConfigConnection : public config_v1::ConfigConnection { (google::cloud::config::v1::GetDeploymentRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateDeployment)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateDeployment(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateDeployment(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateDeployment, (google::cloud::config::v1::CreateDeploymentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateDeployment(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateDeployment, (NoAwaitTag, google::cloud::config::v1::CreateDeploymentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateDeployment(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateDeployment, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateDeployment)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateDeployment(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateDeployment(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateDeployment, (google::cloud::config::v1::UpdateDeploymentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateDeployment(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateDeployment, (NoAwaitTag, google::cloud::config::v1::UpdateDeploymentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateDeployment(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateDeployment, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteDeployment)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteDeployment(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteDeployment(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteDeployment, (google::cloud::config::v1::DeleteDeploymentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteDeployment(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteDeployment, (NoAwaitTag, google::cloud::config::v1::DeleteDeploymentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteDeployment(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteDeployment, (google::longrunning::Operation const& operation), (override)); @@ -147,37 +207,77 @@ class MockConfigConnection : public config_v1::ConfigConnection { (google::cloud::config::v1::DeleteStatefileRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, LockDeployment)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, LockDeployment(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// LockDeployment(Matcher(_))) + /// @endcode MOCK_METHOD(future>, LockDeployment, (google::cloud::config::v1::LockDeploymentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, LockDeployment(_, _)) + /// @endcode MOCK_METHOD(StatusOr, LockDeployment, (NoAwaitTag, google::cloud::config::v1::LockDeploymentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, LockDeployment(Matcher(_))) + /// @endcode MOCK_METHOD(future>, LockDeployment, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UnlockDeployment)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UnlockDeployment(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UnlockDeployment(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UnlockDeployment, (google::cloud::config::v1::UnlockDeploymentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UnlockDeployment(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UnlockDeployment, (NoAwaitTag, google::cloud::config::v1::UnlockDeploymentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UnlockDeployment(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UnlockDeployment, (google::longrunning::Operation const& operation), (override)); @@ -186,19 +286,39 @@ class MockConfigConnection : public config_v1::ConfigConnection { (google::cloud::config::v1::ExportLockInfoRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreatePreview)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreatePreview(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreatePreview(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreatePreview, (google::cloud::config::v1::CreatePreviewRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreatePreview(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreatePreview, (NoAwaitTag, google::cloud::config::v1::CreatePreviewRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreatePreview(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreatePreview, (google::longrunning::Operation const& operation), (override)); @@ -211,19 +331,39 @@ class MockConfigConnection : public config_v1::ConfigConnection { (google::cloud::config::v1::ListPreviewsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeletePreview)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeletePreview(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeletePreview(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeletePreview, (google::cloud::config::v1::DeletePreviewRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeletePreview(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeletePreview, (NoAwaitTag, google::cloud::config::v1::DeletePreviewRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeletePreview(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeletePreview, (google::longrunning::Operation const& operation), (override)); diff --git a/google/cloud/connectors/v1/mocks/mock_connectors_connection.h b/google/cloud/connectors/v1/mocks/mock_connectors_connection.h index b2e1394e93891..30835760368e0 100644 --- a/google/cloud/connectors/v1/mocks/mock_connectors_connection.h +++ b/google/cloud/connectors/v1/mocks/mock_connectors_connection.h @@ -56,59 +56,119 @@ class MockConnectorsConnection : public connectors_v1::ConnectorsConnection { (google::cloud::connectors::v1::GetConnectionRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateConnection)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateConnection(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateConnection(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateConnection, (google::cloud::connectors::v1::CreateConnectionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateConnection(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateConnection, (NoAwaitTag, google::cloud::connectors::v1::CreateConnectionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateConnection(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateConnection, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateConnection)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateConnection(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateConnection(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateConnection, (google::cloud::connectors::v1::UpdateConnectionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateConnection(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateConnection, (NoAwaitTag, google::cloud::connectors::v1::UpdateConnectionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateConnection(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateConnection, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteConnection)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteConnection(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteConnection(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteConnection, (google::cloud::connectors::v1::DeleteConnectionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteConnection(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteConnection, (NoAwaitTag, google::cloud::connectors::v1::DeleteConnectionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteConnection(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteConnection, (google::longrunning::Operation const& operation), @@ -153,10 +213,15 @@ class MockConnectorsConnection : public connectors_v1::ConnectorsConnection { request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, RefreshConnectionSchemaMetadata)` is now ambiguous. - /// Use `EXPECT_CALL(*mock, RefreshConnectionSchemaMetadata(::testing::_))` - /// instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RefreshConnectionSchemaMetadata(Matcher(_))) + /// @endcode MOCK_METHOD( future>, RefreshConnectionSchemaMetadata, @@ -164,6 +229,12 @@ class MockConnectorsConnection : public connectors_v1::ConnectorsConnection { RefreshConnectionSchemaMetadataRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, RefreshConnectionSchemaMetadata(_, _)) + /// @endcode MOCK_METHOD(StatusOr, RefreshConnectionSchemaMetadata, (NoAwaitTag, @@ -171,6 +242,15 @@ class MockConnectorsConnection : public connectors_v1::ConnectorsConnection { RefreshConnectionSchemaMetadataRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RefreshConnectionSchemaMetadata(Matcher(_))) + /// @endcode MOCK_METHOD( future>, RefreshConnectionSchemaMetadata, diff --git a/google/cloud/contactcenterinsights/v1/mocks/mock_contact_center_insights_connection.h b/google/cloud/contactcenterinsights/v1/mocks/mock_contact_center_insights_connection.h index 937b9b54106a2..e35517f83d076 100644 --- a/google/cloud/contactcenterinsights/v1/mocks/mock_contact_center_insights_connection.h +++ b/google/cloud/contactcenterinsights/v1/mocks/mock_contact_center_insights_connection.h @@ -53,9 +53,15 @@ class MockContactCenterInsightsConnection CreateConversationRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UploadConversation)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UploadConversation(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UploadConversation(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UploadConversation, @@ -63,11 +69,25 @@ class MockContactCenterInsightsConnection UploadConversationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UploadConversation(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UploadConversation, (NoAwaitTag, google::cloud::contactcenterinsights::v1:: UploadConversationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UploadConversation(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UploadConversation, (google::longrunning::Operation const& operation), @@ -98,9 +118,15 @@ class MockContactCenterInsightsConnection DeleteConversationRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateAnalysis)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateAnalysis(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateAnalysis(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateAnalysis, @@ -108,6 +134,12 @@ class MockContactCenterInsightsConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateAnalysis(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateAnalysis, (NoAwaitTag, @@ -115,6 +147,14 @@ class MockContactCenterInsightsConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateAnalysis(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateAnalysis, (google::longrunning::Operation const& operation), @@ -138,9 +178,15 @@ class MockContactCenterInsightsConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, BulkAnalyzeConversations)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, BulkAnalyzeConversations(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// BulkAnalyzeConversations(Matcher(_))) + /// @endcode MOCK_METHOD(future>, BulkAnalyzeConversations, @@ -148,20 +194,41 @@ class MockContactCenterInsightsConnection BulkAnalyzeConversationsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, BulkAnalyzeConversations(_, _)) + /// @endcode MOCK_METHOD(StatusOr, BulkAnalyzeConversations, (NoAwaitTag, google::cloud::contactcenterinsights::v1:: BulkAnalyzeConversationsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// BulkAnalyzeConversations(Matcher(_))) + /// @endcode MOCK_METHOD(future>, BulkAnalyzeConversations, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, BulkDeleteConversations)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, BulkDeleteConversations(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// BulkDeleteConversations(Matcher(_))) + /// @endcode MOCK_METHOD(future>, BulkDeleteConversations, @@ -169,19 +236,40 @@ class MockContactCenterInsightsConnection BulkDeleteConversationsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, BulkDeleteConversations(_, _)) + /// @endcode MOCK_METHOD(StatusOr, BulkDeleteConversations, (NoAwaitTag, google::cloud::contactcenterinsights::v1:: BulkDeleteConversationsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// BulkDeleteConversations(Matcher(_))) + /// @endcode MOCK_METHOD(future>, BulkDeleteConversations, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, IngestConversations)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, IngestConversations(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// IngestConversations(Matcher(_))) + /// @endcode MOCK_METHOD(future>, IngestConversations, @@ -189,19 +277,39 @@ class MockContactCenterInsightsConnection IngestConversationsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, IngestConversations(_, _)) + /// @endcode MOCK_METHOD(StatusOr, IngestConversations, (NoAwaitTag, google::cloud::contactcenterinsights::v1:: IngestConversationsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// IngestConversations(Matcher(_))) + /// @endcode MOCK_METHOD(future>, IngestConversations, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ExportInsightsData)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ExportInsightsData(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ExportInsightsData(Matcher(_))) + /// @endcode MOCK_METHOD(future>, ExportInsightsData, @@ -209,19 +317,39 @@ class MockContactCenterInsightsConnection ExportInsightsDataRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ExportInsightsData(_, _)) + /// @endcode MOCK_METHOD(StatusOr, ExportInsightsData, (NoAwaitTag, google::cloud::contactcenterinsights::v1:: ExportInsightsDataRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ExportInsightsData(Matcher(_))) + /// @endcode MOCK_METHOD(future>, ExportInsightsData, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateIssueModel)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateIssueModel(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateIssueModel(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateIssueModel, @@ -229,6 +357,12 @@ class MockContactCenterInsightsConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateIssueModel(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateIssueModel, (NoAwaitTag, @@ -236,6 +370,14 @@ class MockContactCenterInsightsConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateIssueModel(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateIssueModel, (google::longrunning::Operation const& operation), @@ -263,9 +405,15 @@ class MockContactCenterInsightsConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteIssueModel)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteIssueModel(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteIssueModel(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -274,6 +422,12 @@ class MockContactCenterInsightsConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteIssueModel(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteIssueModel, (NoAwaitTag, @@ -281,15 +435,29 @@ class MockContactCenterInsightsConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteIssueModel(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteIssueModel, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeployIssueModel)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeployIssueModel(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeployIssueModel(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -298,6 +466,12 @@ class MockContactCenterInsightsConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeployIssueModel(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeployIssueModel, (NoAwaitTag, @@ -305,15 +479,29 @@ class MockContactCenterInsightsConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeployIssueModel(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeployIssueModel, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UndeployIssueModel)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UndeployIssueModel(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UndeployIssueModel(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UndeployIssueModel, @@ -321,11 +509,25 @@ class MockContactCenterInsightsConnection UndeployIssueModelRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UndeployIssueModel(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UndeployIssueModel, (NoAwaitTag, google::cloud::contactcenterinsights::v1:: UndeployIssueModelRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UndeployIssueModel(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UndeployIssueModel, diff --git a/google/cloud/contentwarehouse/v1/mocks/mock_pipeline_connection.h b/google/cloud/contentwarehouse/v1/mocks/mock_pipeline_connection.h index 0c7e0cdacb645..ce2b16d2e0396 100644 --- a/google/cloud/contentwarehouse/v1/mocks/mock_pipeline_connection.h +++ b/google/cloud/contentwarehouse/v1/mocks/mock_pipeline_connection.h @@ -47,9 +47,15 @@ class MockPipelineServiceConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, RunPipeline)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, RunPipeline(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RunPipeline(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, @@ -57,12 +63,26 @@ class MockPipelineServiceConnection (google::cloud::contentwarehouse::v1::RunPipelineRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, RunPipeline(_, _)) + /// @endcode MOCK_METHOD( StatusOr, RunPipeline, (NoAwaitTag, google::cloud::contentwarehouse::v1::RunPipelineRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, RunPipeline(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, diff --git a/google/cloud/datacatalog/lineage/v1/mocks/mock_lineage_connection.h b/google/cloud/datacatalog/lineage/v1/mocks/mock_lineage_connection.h index 0c2a959762e02..39729e77b916a 100644 --- a/google/cloud/datacatalog/lineage/v1/mocks/mock_lineage_connection.h +++ b/google/cloud/datacatalog/lineage/v1/mocks/mock_lineage_connection.h @@ -77,9 +77,15 @@ class MockLineageConnection : public datacatalog_lineage_v1::LineageConnection { (google::cloud::datacatalog::lineage::v1::ListProcessesRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteProcess)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteProcess(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteProcess(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, @@ -88,6 +94,12 @@ class MockLineageConnection : public datacatalog_lineage_v1::LineageConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteProcess(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteProcess, (NoAwaitTag, @@ -95,6 +107,14 @@ class MockLineageConnection : public datacatalog_lineage_v1::LineageConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteProcess(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, @@ -121,9 +141,15 @@ class MockLineageConnection : public datacatalog_lineage_v1::LineageConnection { (google::cloud::datacatalog::lineage::v1::ListRunsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteRun)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteRun(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteRun(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, @@ -132,12 +158,26 @@ class MockLineageConnection : public datacatalog_lineage_v1::LineageConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteRun(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteRun, (NoAwaitTag, google::cloud::datacatalog::lineage::v1::DeleteRunRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteRun(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, diff --git a/google/cloud/datacatalog/v1/mocks/mock_data_catalog_connection.h b/google/cloud/datacatalog/v1/mocks/mock_data_catalog_connection.h index 9e44e95754862..5907ce4bb1252 100644 --- a/google/cloud/datacatalog/v1/mocks/mock_data_catalog_connection.h +++ b/google/cloud/datacatalog/v1/mocks/mock_data_catalog_connection.h @@ -186,21 +186,41 @@ class MockDataCatalogConnection : public datacatalog_v1::DataCatalogConnection { (google::cloud::datacatalog::v1::ListTagsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ReconcileTags)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ReconcileTags(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ReconcileTags(Matcher(_))) + /// @endcode MOCK_METHOD( future>, ReconcileTags, (google::cloud::datacatalog::v1::ReconcileTagsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ReconcileTags(_, _)) + /// @endcode MOCK_METHOD( StatusOr, ReconcileTags, (NoAwaitTag, google::cloud::datacatalog::v1::ReconcileTagsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, ReconcileTags(Matcher(_))) + /// @endcode MOCK_METHOD( future>, ReconcileTags, (google::longrunning::Operation const& operation), @@ -230,21 +250,41 @@ class MockDataCatalogConnection : public datacatalog_v1::DataCatalogConnection { (google::iam::v1::TestIamPermissionsRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ImportEntries)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ImportEntries(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ImportEntries(Matcher(_))) + /// @endcode MOCK_METHOD( future>, ImportEntries, (google::cloud::datacatalog::v1::ImportEntriesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ImportEntries(_, _)) + /// @endcode MOCK_METHOD( StatusOr, ImportEntries, (NoAwaitTag, google::cloud::datacatalog::v1::ImportEntriesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, ImportEntries(Matcher(_))) + /// @endcode MOCK_METHOD( future>, ImportEntries, (google::longrunning::Operation const& operation), diff --git a/google/cloud/datafusion/v1/mocks/mock_data_fusion_connection.h b/google/cloud/datafusion/v1/mocks/mock_data_fusion_connection.h index 4302fbd478f1b..ae3c5178ce20d 100644 --- a/google/cloud/datafusion/v1/mocks/mock_data_fusion_connection.h +++ b/google/cloud/datafusion/v1/mocks/mock_data_fusion_connection.h @@ -62,77 +62,157 @@ class MockDataFusionConnection : public datafusion_v1::DataFusionConnection { (google::cloud::datafusion::v1::GetInstanceRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateInstance)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateInstance(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateInstance(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateInstance, (google::cloud::datafusion::v1::CreateInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateInstance(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateInstance, (NoAwaitTag, google::cloud::datafusion::v1::CreateInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateInstance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateInstance, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteInstance)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteInstance(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteInstance(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteInstance, (google::cloud::datafusion::v1::DeleteInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteInstance(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteInstance, (NoAwaitTag, google::cloud::datafusion::v1::DeleteInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteInstance(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteInstance, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateInstance)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateInstance(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateInstance(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateInstance, (google::cloud::datafusion::v1::UpdateInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateInstance(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateInstance, (NoAwaitTag, google::cloud::datafusion::v1::UpdateInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateInstance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateInstance, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, RestartInstance)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, RestartInstance(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RestartInstance(Matcher(_))) + /// @endcode MOCK_METHOD( future>, RestartInstance, (google::cloud::datafusion::v1::RestartInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, RestartInstance(_, _)) + /// @endcode MOCK_METHOD( StatusOr, RestartInstance, (NoAwaitTag, google::cloud::datafusion::v1::RestartInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, RestartInstance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, RestartInstance, (google::longrunning::Operation const& operation), (override)); diff --git a/google/cloud/datamigration/v1/mocks/mock_data_migration_connection.h b/google/cloud/datamigration/v1/mocks/mock_data_migration_connection.h index cc0533db6a870..77de8d82f462a 100644 --- a/google/cloud/datamigration/v1/mocks/mock_data_migration_connection.h +++ b/google/cloud/datamigration/v1/mocks/mock_data_migration_connection.h @@ -57,173 +57,353 @@ class MockDataMigrationServiceConnection (google::cloud::clouddms::v1::GetMigrationJobRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateMigrationJob)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateMigrationJob(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateMigrationJob(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateMigrationJob, (google::cloud::clouddms::v1::CreateMigrationJobRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateMigrationJob(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateMigrationJob, (NoAwaitTag, google::cloud::clouddms::v1::CreateMigrationJobRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateMigrationJob(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateMigrationJob, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateMigrationJob)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateMigrationJob(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateMigrationJob(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateMigrationJob, (google::cloud::clouddms::v1::UpdateMigrationJobRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateMigrationJob(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateMigrationJob, (NoAwaitTag, google::cloud::clouddms::v1::UpdateMigrationJobRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateMigrationJob(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateMigrationJob, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteMigrationJob)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteMigrationJob(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteMigrationJob(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteMigrationJob, (google::cloud::clouddms::v1::DeleteMigrationJobRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteMigrationJob(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteMigrationJob, (NoAwaitTag, google::cloud::clouddms::v1::DeleteMigrationJobRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteMigrationJob(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteMigrationJob, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, StartMigrationJob)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, StartMigrationJob(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// StartMigrationJob(Matcher(_))) + /// @endcode MOCK_METHOD( future>, StartMigrationJob, (google::cloud::clouddms::v1::StartMigrationJobRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, StartMigrationJob(_, _)) + /// @endcode MOCK_METHOD( StatusOr, StartMigrationJob, (NoAwaitTag, google::cloud::clouddms::v1::StartMigrationJobRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// StartMigrationJob(Matcher(_))) + /// @endcode MOCK_METHOD(future>, StartMigrationJob, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, StopMigrationJob)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, StopMigrationJob(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// StopMigrationJob(Matcher(_))) + /// @endcode MOCK_METHOD( future>, StopMigrationJob, (google::cloud::clouddms::v1::StopMigrationJobRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, StopMigrationJob(_, _)) + /// @endcode MOCK_METHOD( StatusOr, StopMigrationJob, (NoAwaitTag, google::cloud::clouddms::v1::StopMigrationJobRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, StopMigrationJob(Matcher(_))) + /// @endcode MOCK_METHOD(future>, StopMigrationJob, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ResumeMigrationJob)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ResumeMigrationJob(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ResumeMigrationJob(Matcher(_))) + /// @endcode MOCK_METHOD( future>, ResumeMigrationJob, (google::cloud::clouddms::v1::ResumeMigrationJobRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ResumeMigrationJob(_, _)) + /// @endcode MOCK_METHOD( StatusOr, ResumeMigrationJob, (NoAwaitTag, google::cloud::clouddms::v1::ResumeMigrationJobRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ResumeMigrationJob(Matcher(_))) + /// @endcode MOCK_METHOD(future>, ResumeMigrationJob, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, PromoteMigrationJob)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, PromoteMigrationJob(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PromoteMigrationJob(Matcher(_))) + /// @endcode MOCK_METHOD( future>, PromoteMigrationJob, (google::cloud::clouddms::v1::PromoteMigrationJobRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, PromoteMigrationJob(_, _)) + /// @endcode MOCK_METHOD( StatusOr, PromoteMigrationJob, (NoAwaitTag, google::cloud::clouddms::v1::PromoteMigrationJobRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PromoteMigrationJob(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PromoteMigrationJob, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, VerifyMigrationJob)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, VerifyMigrationJob(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// VerifyMigrationJob(Matcher(_))) + /// @endcode MOCK_METHOD( future>, VerifyMigrationJob, (google::cloud::clouddms::v1::VerifyMigrationJobRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, VerifyMigrationJob(_, _)) + /// @endcode MOCK_METHOD( StatusOr, VerifyMigrationJob, (NoAwaitTag, google::cloud::clouddms::v1::VerifyMigrationJobRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// VerifyMigrationJob(Matcher(_))) + /// @endcode MOCK_METHOD(future>, VerifyMigrationJob, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, RestartMigrationJob)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, RestartMigrationJob(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RestartMigrationJob(Matcher(_))) + /// @endcode MOCK_METHOD( future>, RestartMigrationJob, (google::cloud::clouddms::v1::RestartMigrationJobRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, RestartMigrationJob(_, _)) + /// @endcode MOCK_METHOD( StatusOr, RestartMigrationJob, (NoAwaitTag, google::cloud::clouddms::v1::RestartMigrationJobRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RestartMigrationJob(Matcher(_))) + /// @endcode MOCK_METHOD(future>, RestartMigrationJob, (google::longrunning::Operation const& operation), (override)); @@ -251,9 +431,15 @@ class MockDataMigrationServiceConnection (google::cloud::clouddms::v1::GetConnectionProfileRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateConnectionProfile)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateConnectionProfile(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateConnectionProfile(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateConnectionProfile, @@ -261,6 +447,12 @@ class MockDataMigrationServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateConnectionProfile(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateConnectionProfile, (NoAwaitTag, @@ -268,13 +460,28 @@ class MockDataMigrationServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateConnectionProfile(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateConnectionProfile, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateConnectionProfile)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateConnectionProfile(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateConnectionProfile(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateConnectionProfile, @@ -282,6 +489,12 @@ class MockDataMigrationServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateConnectionProfile(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateConnectionProfile, (NoAwaitTag, @@ -289,13 +502,28 @@ class MockDataMigrationServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateConnectionProfile(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateConnectionProfile, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteConnectionProfile)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteConnectionProfile(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteConnectionProfile(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteConnectionProfile, @@ -303,6 +531,12 @@ class MockDataMigrationServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteConnectionProfile(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteConnectionProfile, (NoAwaitTag, @@ -310,13 +544,28 @@ class MockDataMigrationServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteConnectionProfile(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteConnectionProfile, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreatePrivateConnection)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreatePrivateConnection(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreatePrivateConnection(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreatePrivateConnection, @@ -324,6 +573,12 @@ class MockDataMigrationServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreatePrivateConnection(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreatePrivateConnection, (NoAwaitTag, @@ -331,6 +586,15 @@ class MockDataMigrationServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreatePrivateConnection(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreatePrivateConnection, (google::longrunning::Operation const& operation), (override)); @@ -347,9 +611,15 @@ class MockDataMigrationServiceConnection (google::cloud::clouddms::v1::ListPrivateConnectionsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeletePrivateConnection)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeletePrivateConnection(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeletePrivateConnection(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeletePrivateConnection, @@ -357,6 +627,12 @@ class MockDataMigrationServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeletePrivateConnection(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeletePrivateConnection, (NoAwaitTag, @@ -364,6 +640,15 @@ class MockDataMigrationServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeletePrivateConnection(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeletePrivateConnection, (google::longrunning::Operation const& operation), (override)); @@ -380,9 +665,15 @@ class MockDataMigrationServiceConnection (google::cloud::clouddms::v1::ListConversionWorkspacesRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateConversionWorkspace)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateConversionWorkspace(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateConversionWorkspace(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateConversionWorkspace, @@ -390,6 +681,12 @@ class MockDataMigrationServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateConversionWorkspace(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateConversionWorkspace, (NoAwaitTag, @@ -397,14 +694,29 @@ class MockDataMigrationServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateConversionWorkspace(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateConversionWorkspace, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateConversionWorkspace)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateConversionWorkspace(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateConversionWorkspace(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateConversionWorkspace, @@ -412,6 +724,12 @@ class MockDataMigrationServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateConversionWorkspace(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateConversionWorkspace, (NoAwaitTag, @@ -419,14 +737,29 @@ class MockDataMigrationServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateConversionWorkspace(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateConversionWorkspace, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteConversionWorkspace)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteConversionWorkspace(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteConversionWorkspace(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteConversionWorkspace, @@ -434,6 +767,12 @@ class MockDataMigrationServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteConversionWorkspace(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteConversionWorkspace, (NoAwaitTag, @@ -441,6 +780,15 @@ class MockDataMigrationServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteConversionWorkspace(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteConversionWorkspace, (google::longrunning::Operation const& operation), (override)); @@ -465,9 +813,15 @@ class MockDataMigrationServiceConnection (google::cloud::clouddms::v1::GetMappingRuleRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SeedConversionWorkspace)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SeedConversionWorkspace(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SeedConversionWorkspace(Matcher(_))) + /// @endcode MOCK_METHOD( future>, SeedConversionWorkspace, @@ -475,6 +829,12 @@ class MockDataMigrationServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SeedConversionWorkspace(_, _)) + /// @endcode MOCK_METHOD( StatusOr, SeedConversionWorkspace, (NoAwaitTag, @@ -482,34 +842,69 @@ class MockDataMigrationServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SeedConversionWorkspace(Matcher(_))) + /// @endcode MOCK_METHOD( future>, SeedConversionWorkspace, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ImportMappingRules)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ImportMappingRules(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ImportMappingRules(Matcher(_))) + /// @endcode MOCK_METHOD( future>, ImportMappingRules, (google::cloud::clouddms::v1::ImportMappingRulesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ImportMappingRules(_, _)) + /// @endcode MOCK_METHOD( StatusOr, ImportMappingRules, (NoAwaitTag, google::cloud::clouddms::v1::ImportMappingRulesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ImportMappingRules(Matcher(_))) + /// @endcode MOCK_METHOD( future>, ImportMappingRules, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ConvertConversionWorkspace)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ConvertConversionWorkspace(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ConvertConversionWorkspace(Matcher(_))) + /// @endcode MOCK_METHOD( future>, ConvertConversionWorkspace, @@ -517,6 +912,12 @@ class MockDataMigrationServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ConvertConversionWorkspace(_, _)) + /// @endcode MOCK_METHOD( StatusOr, ConvertConversionWorkspace, (NoAwaitTag, @@ -524,14 +925,29 @@ class MockDataMigrationServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ConvertConversionWorkspace(Matcher(_))) + /// @endcode MOCK_METHOD( future>, ConvertConversionWorkspace, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CommitConversionWorkspace)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CommitConversionWorkspace(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CommitConversionWorkspace(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CommitConversionWorkspace, @@ -539,6 +955,12 @@ class MockDataMigrationServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CommitConversionWorkspace(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CommitConversionWorkspace, (NoAwaitTag, @@ -546,14 +968,29 @@ class MockDataMigrationServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CommitConversionWorkspace(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CommitConversionWorkspace, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, RollbackConversionWorkspace)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, RollbackConversionWorkspace(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RollbackConversionWorkspace(Matcher(_))) + /// @endcode MOCK_METHOD( future>, RollbackConversionWorkspace, @@ -561,6 +998,12 @@ class MockDataMigrationServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, RollbackConversionWorkspace(_, _)) + /// @endcode MOCK_METHOD( StatusOr, RollbackConversionWorkspace, (NoAwaitTag, @@ -568,14 +1011,29 @@ class MockDataMigrationServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RollbackConversionWorkspace(Matcher(_))) + /// @endcode MOCK_METHOD( future>, RollbackConversionWorkspace, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ApplyConversionWorkspace)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ApplyConversionWorkspace(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ApplyConversionWorkspace(Matcher(_))) + /// @endcode MOCK_METHOD( future>, ApplyConversionWorkspace, @@ -583,6 +1041,12 @@ class MockDataMigrationServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ApplyConversionWorkspace(_, _)) + /// @endcode MOCK_METHOD( StatusOr, ApplyConversionWorkspace, (NoAwaitTag, @@ -590,6 +1054,15 @@ class MockDataMigrationServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ApplyConversionWorkspace(Matcher(_))) + /// @endcode MOCK_METHOD( future>, ApplyConversionWorkspace, diff --git a/google/cloud/dataplex/v1/mocks/mock_catalog_connection.h b/google/cloud/dataplex/v1/mocks/mock_catalog_connection.h index ef1abfd0b985e..0fb35ba050d77 100644 --- a/google/cloud/dataplex/v1/mocks/mock_catalog_connection.h +++ b/google/cloud/dataplex/v1/mocks/mock_catalog_connection.h @@ -47,57 +47,117 @@ class MockCatalogServiceConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateEntryType)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateEntryType(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateEntryType(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateEntryType, (google::cloud::dataplex::v1::CreateEntryTypeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateEntryType(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateEntryType, (NoAwaitTag, google::cloud::dataplex::v1::CreateEntryTypeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateEntryType(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateEntryType, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateEntryType)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateEntryType(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateEntryType(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateEntryType, (google::cloud::dataplex::v1::UpdateEntryTypeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateEntryType(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateEntryType, (NoAwaitTag, google::cloud::dataplex::v1::UpdateEntryTypeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateEntryType(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateEntryType, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteEntryType)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteEntryType(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteEntryType(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteEntryType, (google::cloud::dataplex::v1::DeleteEntryTypeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteEntryType(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteEntryType, (NoAwaitTag, google::cloud::dataplex::v1::DeleteEntryTypeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteEntryType(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteEntryType, (google::longrunning::Operation const& operation), (override)); @@ -111,59 +171,119 @@ class MockCatalogServiceConnection (google::cloud::dataplex::v1::GetEntryTypeRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateAspectType)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateAspectType(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateAspectType(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateAspectType, (google::cloud::dataplex::v1::CreateAspectTypeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateAspectType(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateAspectType, (NoAwaitTag, google::cloud::dataplex::v1::CreateAspectTypeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateAspectType(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateAspectType, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateAspectType)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateAspectType(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateAspectType(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateAspectType, (google::cloud::dataplex::v1::UpdateAspectTypeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateAspectType(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateAspectType, (NoAwaitTag, google::cloud::dataplex::v1::UpdateAspectTypeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateAspectType(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateAspectType, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteAspectType)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteAspectType(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteAspectType(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteAspectType, (google::cloud::dataplex::v1::DeleteAspectTypeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteAspectType(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteAspectType, (NoAwaitTag, google::cloud::dataplex::v1::DeleteAspectTypeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteAspectType(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteAspectType, (google::longrunning::Operation const& operation), (override)); @@ -178,59 +298,119 @@ class MockCatalogServiceConnection (google::cloud::dataplex::v1::GetAspectTypeRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateEntryGroup)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateEntryGroup(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateEntryGroup(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateEntryGroup, (google::cloud::dataplex::v1::CreateEntryGroupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateEntryGroup(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateEntryGroup, (NoAwaitTag, google::cloud::dataplex::v1::CreateEntryGroupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateEntryGroup(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateEntryGroup, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateEntryGroup)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateEntryGroup(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateEntryGroup(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateEntryGroup, (google::cloud::dataplex::v1::UpdateEntryGroupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateEntryGroup(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateEntryGroup, (NoAwaitTag, google::cloud::dataplex::v1::UpdateEntryGroupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateEntryGroup(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateEntryGroup, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteEntryGroup)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteEntryGroup(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteEntryGroup(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteEntryGroup, (google::cloud::dataplex::v1::DeleteEntryGroupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteEntryGroup(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteEntryGroup, (NoAwaitTag, google::cloud::dataplex::v1::DeleteEntryGroupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteEntryGroup(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteEntryGroup, (google::longrunning::Operation const& operation), (override)); diff --git a/google/cloud/dataplex/v1/mocks/mock_data_scan_connection.h b/google/cloud/dataplex/v1/mocks/mock_data_scan_connection.h index 4d8eeadc279d8..148ea02a74810 100644 --- a/google/cloud/dataplex/v1/mocks/mock_data_scan_connection.h +++ b/google/cloud/dataplex/v1/mocks/mock_data_scan_connection.h @@ -47,57 +47,117 @@ class MockDataScanServiceConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateDataScan)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateDataScan(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateDataScan(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateDataScan, (google::cloud::dataplex::v1::CreateDataScanRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateDataScan(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateDataScan, (NoAwaitTag, google::cloud::dataplex::v1::CreateDataScanRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateDataScan(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateDataScan, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateDataScan)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateDataScan(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateDataScan(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateDataScan, (google::cloud::dataplex::v1::UpdateDataScanRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateDataScan(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateDataScan, (NoAwaitTag, google::cloud::dataplex::v1::UpdateDataScanRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateDataScan(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateDataScan, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteDataScan)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteDataScan(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteDataScan(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteDataScan, (google::cloud::dataplex::v1::DeleteDataScanRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteDataScan(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteDataScan, (NoAwaitTag, google::cloud::dataplex::v1::DeleteDataScanRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteDataScan(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteDataScan, (google::longrunning::Operation const& operation), (override)); diff --git a/google/cloud/dataplex/v1/mocks/mock_data_taxonomy_connection.h b/google/cloud/dataplex/v1/mocks/mock_data_taxonomy_connection.h index ff7c3380cb1ba..06cdbc81cde52 100644 --- a/google/cloud/dataplex/v1/mocks/mock_data_taxonomy_connection.h +++ b/google/cloud/dataplex/v1/mocks/mock_data_taxonomy_connection.h @@ -47,59 +47,119 @@ class MockDataTaxonomyServiceConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateDataTaxonomy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateDataTaxonomy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateDataTaxonomy(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateDataTaxonomy, (google::cloud::dataplex::v1::CreateDataTaxonomyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateDataTaxonomy(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateDataTaxonomy, (NoAwaitTag, google::cloud::dataplex::v1::CreateDataTaxonomyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateDataTaxonomy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateDataTaxonomy, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateDataTaxonomy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateDataTaxonomy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateDataTaxonomy(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateDataTaxonomy, (google::cloud::dataplex::v1::UpdateDataTaxonomyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateDataTaxonomy(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateDataTaxonomy, (NoAwaitTag, google::cloud::dataplex::v1::UpdateDataTaxonomyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateDataTaxonomy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateDataTaxonomy, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteDataTaxonomy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteDataTaxonomy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteDataTaxonomy(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteDataTaxonomy, (google::cloud::dataplex::v1::DeleteDataTaxonomyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteDataTaxonomy(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteDataTaxonomy, (NoAwaitTag, google::cloud::dataplex::v1::DeleteDataTaxonomyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteDataTaxonomy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteDataTaxonomy, (google::longrunning::Operation const& operation), (override)); @@ -114,9 +174,15 @@ class MockDataTaxonomyServiceConnection (google::cloud::dataplex::v1::GetDataTaxonomyRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateDataAttributeBinding)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateDataAttributeBinding(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateDataAttributeBinding(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateDataAttributeBinding, @@ -124,6 +190,12 @@ class MockDataTaxonomyServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateDataAttributeBinding(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateDataAttributeBinding, (NoAwaitTag, @@ -131,14 +203,29 @@ class MockDataTaxonomyServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateDataAttributeBinding(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateDataAttributeBinding, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateDataAttributeBinding)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateDataAttributeBinding(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateDataAttributeBinding(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateDataAttributeBinding, @@ -146,6 +233,12 @@ class MockDataTaxonomyServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateDataAttributeBinding(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateDataAttributeBinding, (NoAwaitTag, @@ -153,14 +246,29 @@ class MockDataTaxonomyServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateDataAttributeBinding(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateDataAttributeBinding, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteDataAttributeBinding)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteDataAttributeBinding(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteDataAttributeBinding(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteDataAttributeBinding, @@ -168,6 +276,12 @@ class MockDataTaxonomyServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteDataAttributeBinding(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteDataAttributeBinding, (NoAwaitTag, @@ -175,6 +289,15 @@ class MockDataTaxonomyServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteDataAttributeBinding(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteDataAttributeBinding, (google::longrunning::Operation const& operation), (override)); @@ -192,59 +315,119 @@ class MockDataTaxonomyServiceConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateDataAttribute)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateDataAttribute(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateDataAttribute(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateDataAttribute, (google::cloud::dataplex::v1::CreateDataAttributeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateDataAttribute(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateDataAttribute, (NoAwaitTag, google::cloud::dataplex::v1::CreateDataAttributeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateDataAttribute(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateDataAttribute, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateDataAttribute)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateDataAttribute(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateDataAttribute(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateDataAttribute, (google::cloud::dataplex::v1::UpdateDataAttributeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateDataAttribute(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateDataAttribute, (NoAwaitTag, google::cloud::dataplex::v1::UpdateDataAttributeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateDataAttribute(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateDataAttribute, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteDataAttribute)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteDataAttribute(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteDataAttribute(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteDataAttribute, (google::cloud::dataplex::v1::DeleteDataAttributeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteDataAttribute(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteDataAttribute, (NoAwaitTag, google::cloud::dataplex::v1::DeleteDataAttributeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteDataAttribute(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteDataAttribute, (google::longrunning::Operation const& operation), (override)); diff --git a/google/cloud/dataplex/v1/mocks/mock_dataplex_connection.h b/google/cloud/dataplex/v1/mocks/mock_dataplex_connection.h index 4dea91a59feb5..913592f717ed9 100644 --- a/google/cloud/dataplex/v1/mocks/mock_dataplex_connection.h +++ b/google/cloud/dataplex/v1/mocks/mock_dataplex_connection.h @@ -47,49 +47,109 @@ class MockDataplexServiceConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateLake)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateLake(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateLake(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateLake, (google::cloud::dataplex::v1::CreateLakeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateLake(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateLake, (NoAwaitTag, google::cloud::dataplex::v1::CreateLakeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateLake(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateLake, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateLake)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateLake(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateLake(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateLake, (google::cloud::dataplex::v1::UpdateLakeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateLake(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateLake, (NoAwaitTag, google::cloud::dataplex::v1::UpdateLakeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateLake(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateLake, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteLake)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteLake(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteLake(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteLake, (google::cloud::dataplex::v1::DeleteLakeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteLake(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteLake, (NoAwaitTag, google::cloud::dataplex::v1::DeleteLakeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteLake(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteLake, (google::longrunning::Operation const& operation), (override)); @@ -107,49 +167,109 @@ class MockDataplexServiceConnection (google::cloud::dataplex::v1::ListLakeActionsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateZone)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateZone(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateZone(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateZone, (google::cloud::dataplex::v1::CreateZoneRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateZone(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateZone, (NoAwaitTag, google::cloud::dataplex::v1::CreateZoneRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateZone(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateZone, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateZone)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateZone(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateZone(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateZone, (google::cloud::dataplex::v1::UpdateZoneRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateZone(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateZone, (NoAwaitTag, google::cloud::dataplex::v1::UpdateZoneRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateZone(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateZone, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteZone)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteZone(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteZone(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteZone, (google::cloud::dataplex::v1::DeleteZoneRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteZone(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteZone, (NoAwaitTag, google::cloud::dataplex::v1::DeleteZoneRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteZone(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteZone, (google::longrunning::Operation const& operation), (override)); @@ -167,49 +287,109 @@ class MockDataplexServiceConnection (google::cloud::dataplex::v1::ListZoneActionsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateAsset)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateAsset(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateAsset(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateAsset, (google::cloud::dataplex::v1::CreateAssetRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateAsset(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateAsset, (NoAwaitTag, google::cloud::dataplex::v1::CreateAssetRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateAsset(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateAsset, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateAsset)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateAsset(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateAsset(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateAsset, (google::cloud::dataplex::v1::UpdateAssetRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateAsset(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateAsset, (NoAwaitTag, google::cloud::dataplex::v1::UpdateAssetRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateAsset(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateAsset, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteAsset)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteAsset(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteAsset(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteAsset, (google::cloud::dataplex::v1::DeleteAssetRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteAsset(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteAsset, (NoAwaitTag, google::cloud::dataplex::v1::DeleteAssetRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteAsset(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteAsset, (google::longrunning::Operation const& operation), (override)); @@ -227,49 +407,109 @@ class MockDataplexServiceConnection (google::cloud::dataplex::v1::ListAssetActionsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateTask)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateTask(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateTask(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateTask, (google::cloud::dataplex::v1::CreateTaskRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateTask(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateTask, (NoAwaitTag, google::cloud::dataplex::v1::CreateTaskRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateTask(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateTask, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateTask)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateTask(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateTask(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateTask, (google::cloud::dataplex::v1::UpdateTaskRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateTask(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateTask, (NoAwaitTag, google::cloud::dataplex::v1::UpdateTaskRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateTask(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateTask, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteTask)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteTask(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteTask(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteTask, (google::cloud::dataplex::v1::DeleteTaskRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteTask(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteTask, (NoAwaitTag, google::cloud::dataplex::v1::DeleteTaskRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteTask(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteTask, (google::longrunning::Operation const& operation), (override)); @@ -298,59 +538,119 @@ class MockDataplexServiceConnection (google::cloud::dataplex::v1::CancelJobRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateEnvironment)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateEnvironment(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateEnvironment(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateEnvironment, (google::cloud::dataplex::v1::CreateEnvironmentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateEnvironment(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateEnvironment, (NoAwaitTag, google::cloud::dataplex::v1::CreateEnvironmentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateEnvironment(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateEnvironment, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateEnvironment)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateEnvironment(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateEnvironment(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateEnvironment, (google::cloud::dataplex::v1::UpdateEnvironmentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateEnvironment(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateEnvironment, (NoAwaitTag, google::cloud::dataplex::v1::UpdateEnvironmentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateEnvironment(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateEnvironment, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteEnvironment)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteEnvironment(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteEnvironment(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteEnvironment, (google::cloud::dataplex::v1::DeleteEnvironmentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteEnvironment(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteEnvironment, (NoAwaitTag, google::cloud::dataplex::v1::DeleteEnvironmentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteEnvironment(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteEnvironment, (google::longrunning::Operation const& operation), (override)); diff --git a/google/cloud/dataproc/v1/mocks/mock_batch_controller_connection.h b/google/cloud/dataproc/v1/mocks/mock_batch_controller_connection.h index 6743e2ff0a851..cd9746872eb26 100644 --- a/google/cloud/dataproc/v1/mocks/mock_batch_controller_connection.h +++ b/google/cloud/dataproc/v1/mocks/mock_batch_controller_connection.h @@ -47,18 +47,38 @@ class MockBatchControllerConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateBatch)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateBatch(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateBatch(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateBatch, (google::cloud::dataproc::v1::CreateBatchRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateBatch(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateBatch, (NoAwaitTag, google::cloud::dataproc::v1::CreateBatchRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateBatch(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateBatch, (google::longrunning::Operation const& operation), (override)); diff --git a/google/cloud/dataproc/v1/mocks/mock_cluster_controller_connection.h b/google/cloud/dataproc/v1/mocks/mock_cluster_controller_connection.h index 411de7880dfa9..e3262532d8dd5 100644 --- a/google/cloud/dataproc/v1/mocks/mock_cluster_controller_connection.h +++ b/google/cloud/dataproc/v1/mocks/mock_cluster_controller_connection.h @@ -47,91 +47,191 @@ class MockClusterControllerConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateCluster)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateCluster(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateCluster(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateCluster, (google::cloud::dataproc::v1::CreateClusterRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateCluster(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateCluster, (NoAwaitTag, google::cloud::dataproc::v1::CreateClusterRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateCluster(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateCluster, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateCluster)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateCluster(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateCluster(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateCluster, (google::cloud::dataproc::v1::UpdateClusterRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateCluster(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateCluster, (NoAwaitTag, google::cloud::dataproc::v1::UpdateClusterRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateCluster(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateCluster, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, StopCluster)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, StopCluster(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// StopCluster(Matcher(_))) + /// @endcode MOCK_METHOD(future>, StopCluster, (google::cloud::dataproc::v1::StopClusterRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, StopCluster(_, _)) + /// @endcode MOCK_METHOD(StatusOr, StopCluster, (NoAwaitTag, google::cloud::dataproc::v1::StopClusterRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, StopCluster(Matcher(_))) + /// @endcode MOCK_METHOD(future>, StopCluster, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, StartCluster)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, StartCluster(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// StartCluster(Matcher(_))) + /// @endcode MOCK_METHOD(future>, StartCluster, (google::cloud::dataproc::v1::StartClusterRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, StartCluster(_, _)) + /// @endcode MOCK_METHOD(StatusOr, StartCluster, (NoAwaitTag, google::cloud::dataproc::v1::StartClusterRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, StartCluster(Matcher(_))) + /// @endcode MOCK_METHOD(future>, StartCluster, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteCluster)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteCluster(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteCluster(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteCluster, (google::cloud::dataproc::v1::DeleteClusterRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteCluster(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteCluster, (NoAwaitTag, google::cloud::dataproc::v1::DeleteClusterRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteCluster(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteCluster, (google::longrunning::Operation const& operation), @@ -145,21 +245,41 @@ class MockClusterControllerConnection (google::cloud::dataproc::v1::ListClustersRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DiagnoseCluster)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DiagnoseCluster(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DiagnoseCluster(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DiagnoseCluster, (google::cloud::dataproc::v1::DiagnoseClusterRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DiagnoseCluster(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DiagnoseCluster, (NoAwaitTag, google::cloud::dataproc::v1::DiagnoseClusterRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DiagnoseCluster(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DiagnoseCluster, (google::longrunning::Operation const& operation), diff --git a/google/cloud/dataproc/v1/mocks/mock_job_controller_connection.h b/google/cloud/dataproc/v1/mocks/mock_job_controller_connection.h index cb603a3b6292e..f750fa5259995 100644 --- a/google/cloud/dataproc/v1/mocks/mock_job_controller_connection.h +++ b/google/cloud/dataproc/v1/mocks/mock_job_controller_connection.h @@ -51,19 +51,39 @@ class MockJobControllerConnection (google::cloud::dataproc::v1::SubmitJobRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SubmitJobAsOperation)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SubmitJobAsOperation(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SubmitJobAsOperation(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SubmitJobAsOperation, (google::cloud::dataproc::v1::SubmitJobRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SubmitJobAsOperation(_, _)) + /// @endcode MOCK_METHOD(StatusOr, SubmitJobAsOperation, (NoAwaitTag, google::cloud::dataproc::v1::SubmitJobRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SubmitJobAsOperation(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SubmitJobAsOperation, (google::longrunning::Operation const& operation), (override)); diff --git a/google/cloud/dataproc/v1/mocks/mock_node_group_controller_connection.h b/google/cloud/dataproc/v1/mocks/mock_node_group_controller_connection.h index 259d414998b6d..7922d8a4fdfac 100644 --- a/google/cloud/dataproc/v1/mocks/mock_node_group_controller_connection.h +++ b/google/cloud/dataproc/v1/mocks/mock_node_group_controller_connection.h @@ -47,38 +47,78 @@ class MockNodeGroupControllerConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateNodeGroup)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateNodeGroup(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateNodeGroup(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateNodeGroup, (google::cloud::dataproc::v1::CreateNodeGroupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateNodeGroup(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateNodeGroup, (NoAwaitTag, google::cloud::dataproc::v1::CreateNodeGroupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateNodeGroup(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateNodeGroup, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ResizeNodeGroup)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ResizeNodeGroup(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ResizeNodeGroup(Matcher(_))) + /// @endcode MOCK_METHOD( future>, ResizeNodeGroup, (google::cloud::dataproc::v1::ResizeNodeGroupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ResizeNodeGroup(_, _)) + /// @endcode MOCK_METHOD( StatusOr, ResizeNodeGroup, (NoAwaitTag, google::cloud::dataproc::v1::ResizeNodeGroupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, ResizeNodeGroup(Matcher(_))) + /// @endcode MOCK_METHOD(future>, ResizeNodeGroup, (google::longrunning::Operation const& operation), (override)); diff --git a/google/cloud/dataproc/v1/mocks/mock_session_controller_connection.h b/google/cloud/dataproc/v1/mocks/mock_session_controller_connection.h index 3764876e3de9b..dc008f7f216f6 100644 --- a/google/cloud/dataproc/v1/mocks/mock_session_controller_connection.h +++ b/google/cloud/dataproc/v1/mocks/mock_session_controller_connection.h @@ -47,20 +47,40 @@ class MockSessionControllerConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateSession)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateSession(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateSession(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateSession, (google::cloud::dataproc::v1::CreateSessionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateSession(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateSession, (NoAwaitTag, google::cloud::dataproc::v1::CreateSessionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateSession(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateSession, (google::longrunning::Operation const& operation), (override)); @@ -73,38 +93,78 @@ class MockSessionControllerConnection (google::cloud::dataproc::v1::ListSessionsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, TerminateSession)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, TerminateSession(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// TerminateSession(Matcher(_))) + /// @endcode MOCK_METHOD( future>, TerminateSession, (google::cloud::dataproc::v1::TerminateSessionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, TerminateSession(_, _)) + /// @endcode MOCK_METHOD( StatusOr, TerminateSession, (NoAwaitTag, google::cloud::dataproc::v1::TerminateSessionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, TerminateSession(Matcher(_))) + /// @endcode MOCK_METHOD(future>, TerminateSession, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteSession)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteSession(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteSession(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteSession, (google::cloud::dataproc::v1::DeleteSessionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteSession(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteSession, (NoAwaitTag, google::cloud::dataproc::v1::DeleteSessionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteSession(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteSession, (google::longrunning::Operation const& operation), (override)); diff --git a/google/cloud/dataproc/v1/mocks/mock_workflow_template_connection.h b/google/cloud/dataproc/v1/mocks/mock_workflow_template_connection.h index a78c3cddf37b0..0f2687a8f4f5b 100644 --- a/google/cloud/dataproc/v1/mocks/mock_workflow_template_connection.h +++ b/google/cloud/dataproc/v1/mocks/mock_workflow_template_connection.h @@ -59,9 +59,15 @@ class MockWorkflowTemplateServiceConnection (google::cloud::dataproc::v1::GetWorkflowTemplateRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InstantiateWorkflowTemplate)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, InstantiateWorkflowTemplate(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InstantiateWorkflowTemplate(Matcher(_))) + /// @endcode MOCK_METHOD( future>, InstantiateWorkflowTemplate, @@ -69,6 +75,12 @@ class MockWorkflowTemplateServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InstantiateWorkflowTemplate(_, _)) + /// @endcode MOCK_METHOD( StatusOr, InstantiateWorkflowTemplate, (NoAwaitTag, @@ -76,20 +88,40 @@ class MockWorkflowTemplateServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InstantiateWorkflowTemplate(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InstantiateWorkflowTemplate, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, InstantiateInlineWorkflowTemplate)` is now ambiguous. - /// Use `EXPECT_CALL(*mock, InstantiateInlineWorkflowTemplate(::testing::_))` - /// instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InstantiateInlineWorkflowTemplate(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InstantiateInlineWorkflowTemplate, (google::cloud::dataproc::v1:: InstantiateInlineWorkflowTemplateRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, InstantiateInlineWorkflowTemplate(_, _)) + /// @endcode MOCK_METHOD(StatusOr, InstantiateInlineWorkflowTemplate, (NoAwaitTag, @@ -97,6 +129,15 @@ class MockWorkflowTemplateServiceConnection InstantiateInlineWorkflowTemplateRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// InstantiateInlineWorkflowTemplate(Matcher(_))) + /// @endcode MOCK_METHOD(future>, InstantiateInlineWorkflowTemplate, (google::longrunning::Operation const& operation), (override)); diff --git a/google/cloud/datastore/admin/v1/mocks/mock_datastore_admin_connection.h b/google/cloud/datastore/admin/v1/mocks/mock_datastore_admin_connection.h index 0dd97d1f72377..bfa67cecf4fc4 100644 --- a/google/cloud/datastore/admin/v1/mocks/mock_datastore_admin_connection.h +++ b/google/cloud/datastore/admin/v1/mocks/mock_datastore_admin_connection.h @@ -47,76 +47,156 @@ class MockDatastoreAdminConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ExportEntities)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ExportEntities(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ExportEntities(Matcher(_))) + /// @endcode MOCK_METHOD( future>, ExportEntities, (google::datastore::admin::v1::ExportEntitiesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ExportEntities(_, _)) + /// @endcode MOCK_METHOD( StatusOr, ExportEntities, (NoAwaitTag, google::datastore::admin::v1::ExportEntitiesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, ExportEntities(Matcher(_))) + /// @endcode MOCK_METHOD( future>, ExportEntities, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ImportEntities)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ImportEntities(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ImportEntities(Matcher(_))) + /// @endcode MOCK_METHOD( future>, ImportEntities, (google::datastore::admin::v1::ImportEntitiesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ImportEntities(_, _)) + /// @endcode MOCK_METHOD( StatusOr, ImportEntities, (NoAwaitTag, google::datastore::admin::v1::ImportEntitiesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, ImportEntities(Matcher(_))) + /// @endcode MOCK_METHOD( future>, ImportEntities, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateIndex)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateIndex(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateIndex(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateIndex, (google::datastore::admin::v1::CreateIndexRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateIndex(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateIndex, (NoAwaitTag, google::datastore::admin::v1::CreateIndexRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateIndex(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateIndex, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteIndex)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteIndex(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteIndex(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteIndex, (google::datastore::admin::v1::DeleteIndexRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteIndex(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteIndex, (NoAwaitTag, google::datastore::admin::v1::DeleteIndexRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteIndex(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteIndex, (google::longrunning::Operation const& operation), (override)); diff --git a/google/cloud/datastream/v1/mocks/mock_datastream_connection.h b/google/cloud/datastream/v1/mocks/mock_datastream_connection.h index 31b7a34eb9dc1..4defdd5440170 100644 --- a/google/cloud/datastream/v1/mocks/mock_datastream_connection.h +++ b/google/cloud/datastream/v1/mocks/mock_datastream_connection.h @@ -58,9 +58,15 @@ class MockDatastreamConnection : public datastream_v1::DatastreamConnection { request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateConnectionProfile)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateConnectionProfile(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateConnectionProfile(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateConnectionProfile, @@ -68,6 +74,12 @@ class MockDatastreamConnection : public datastream_v1::DatastreamConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateConnectionProfile(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateConnectionProfile, (NoAwaitTag, @@ -75,14 +87,29 @@ class MockDatastreamConnection : public datastream_v1::DatastreamConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateConnectionProfile(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateConnectionProfile, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateConnectionProfile)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateConnectionProfile(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateConnectionProfile(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateConnectionProfile, @@ -90,6 +117,12 @@ class MockDatastreamConnection : public datastream_v1::DatastreamConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateConnectionProfile(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateConnectionProfile, (NoAwaitTag, @@ -97,14 +130,29 @@ class MockDatastreamConnection : public datastream_v1::DatastreamConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateConnectionProfile(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateConnectionProfile, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteConnectionProfile)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteConnectionProfile(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteConnectionProfile(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteConnectionProfile, @@ -112,6 +160,12 @@ class MockDatastreamConnection : public datastream_v1::DatastreamConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteConnectionProfile(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteConnectionProfile, (NoAwaitTag, @@ -119,6 +173,15 @@ class MockDatastreamConnection : public datastream_v1::DatastreamConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteConnectionProfile(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteConnectionProfile, @@ -140,57 +203,117 @@ class MockDatastreamConnection : public datastream_v1::DatastreamConnection { (google::cloud::datastream::v1::GetStreamRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateStream)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateStream(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateStream(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateStream, (google::cloud::datastream::v1::CreateStreamRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateStream(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateStream, (NoAwaitTag, google::cloud::datastream::v1::CreateStreamRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateStream(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateStream, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateStream)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateStream(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateStream(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateStream, (google::cloud::datastream::v1::UpdateStreamRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateStream(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateStream, (NoAwaitTag, google::cloud::datastream::v1::UpdateStreamRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateStream(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateStream, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteStream)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteStream(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteStream(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteStream, (google::cloud::datastream::v1::DeleteStreamRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteStream(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteStream, (NoAwaitTag, google::cloud::datastream::v1::DeleteStreamRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteStream(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteStream, (google::longrunning::Operation const& operation), @@ -227,9 +350,15 @@ class MockDatastreamConnection : public datastream_v1::DatastreamConnection { (google::cloud::datastream::v1::FetchStaticIpsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreatePrivateConnection)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreatePrivateConnection(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreatePrivateConnection(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreatePrivateConnection, @@ -237,6 +366,12 @@ class MockDatastreamConnection : public datastream_v1::DatastreamConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreatePrivateConnection(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreatePrivateConnection, (NoAwaitTag, @@ -244,6 +379,15 @@ class MockDatastreamConnection : public datastream_v1::DatastreamConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreatePrivateConnection(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreatePrivateConnection, @@ -261,9 +405,15 @@ class MockDatastreamConnection : public datastream_v1::DatastreamConnection { (google::cloud::datastream::v1::ListPrivateConnectionsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeletePrivateConnection)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeletePrivateConnection(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeletePrivateConnection(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeletePrivateConnection, @@ -271,6 +421,12 @@ class MockDatastreamConnection : public datastream_v1::DatastreamConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeletePrivateConnection(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeletePrivateConnection, (NoAwaitTag, @@ -278,25 +434,54 @@ class MockDatastreamConnection : public datastream_v1::DatastreamConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeletePrivateConnection(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeletePrivateConnection, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateRoute)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateRoute(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateRoute(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateRoute, (google::cloud::datastream::v1::CreateRouteRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateRoute(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateRoute, (NoAwaitTag, google::cloud::datastream::v1::CreateRouteRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateRoute(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateRoute, (google::longrunning::Operation const& operation), (override)); @@ -309,21 +494,41 @@ class MockDatastreamConnection : public datastream_v1::DatastreamConnection { (google::cloud::datastream::v1::ListRoutesRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteRoute)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteRoute(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteRoute(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteRoute, (google::cloud::datastream::v1::DeleteRouteRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteRoute(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteRoute, (NoAwaitTag, google::cloud::datastream::v1::DeleteRouteRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteRoute(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteRoute, (google::longrunning::Operation const& operation), diff --git a/google/cloud/deploy/v1/mocks/mock_cloud_deploy_connection.h b/google/cloud/deploy/v1/mocks/mock_cloud_deploy_connection.h index 72874d11c24c8..5f7d7b1ec7e18 100644 --- a/google/cloud/deploy/v1/mocks/mock_cloud_deploy_connection.h +++ b/google/cloud/deploy/v1/mocks/mock_cloud_deploy_connection.h @@ -57,59 +57,119 @@ class MockCloudDeployConnection : public deploy_v1::CloudDeployConnection { (google::cloud::deploy::v1::GetDeliveryPipelineRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateDeliveryPipeline)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateDeliveryPipeline(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateDeliveryPipeline(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateDeliveryPipeline, (google::cloud::deploy::v1::CreateDeliveryPipelineRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateDeliveryPipeline(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateDeliveryPipeline, (NoAwaitTag, google::cloud::deploy::v1::CreateDeliveryPipelineRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateDeliveryPipeline(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateDeliveryPipeline, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateDeliveryPipeline)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateDeliveryPipeline(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateDeliveryPipeline(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateDeliveryPipeline, (google::cloud::deploy::v1::UpdateDeliveryPipelineRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateDeliveryPipeline(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateDeliveryPipeline, (NoAwaitTag, google::cloud::deploy::v1::UpdateDeliveryPipelineRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateDeliveryPipeline(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateDeliveryPipeline, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteDeliveryPipeline)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteDeliveryPipeline(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteDeliveryPipeline(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteDeliveryPipeline, (google::cloud::deploy::v1::DeleteDeliveryPipelineRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteDeliveryPipeline(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteDeliveryPipeline, (NoAwaitTag, google::cloud::deploy::v1::DeleteDeliveryPipelineRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteDeliveryPipeline(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteDeliveryPipeline, (google::longrunning::Operation const& operation), (override)); @@ -127,49 +187,109 @@ class MockCloudDeployConnection : public deploy_v1::CloudDeployConnection { (google::cloud::deploy::v1::GetTargetRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateTarget)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateTarget(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateTarget(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateTarget, (google::cloud::deploy::v1::CreateTargetRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateTarget(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateTarget, (NoAwaitTag, google::cloud::deploy::v1::CreateTargetRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateTarget(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateTarget, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateTarget)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateTarget(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateTarget(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateTarget, (google::cloud::deploy::v1::UpdateTargetRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateTarget(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateTarget, (NoAwaitTag, google::cloud::deploy::v1::UpdateTargetRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateTarget(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateTarget, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteTarget)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteTarget(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteTarget(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteTarget, (google::cloud::deploy::v1::DeleteTargetRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteTarget(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteTarget, (NoAwaitTag, google::cloud::deploy::v1::DeleteTargetRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteTarget(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteTarget, (google::longrunning::Operation const& operation), (override)); @@ -185,59 +305,119 @@ class MockCloudDeployConnection : public deploy_v1::CloudDeployConnection { (google::cloud::deploy::v1::GetCustomTargetTypeRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateCustomTargetType)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateCustomTargetType(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateCustomTargetType(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateCustomTargetType, (google::cloud::deploy::v1::CreateCustomTargetTypeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateCustomTargetType(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateCustomTargetType, (NoAwaitTag, google::cloud::deploy::v1::CreateCustomTargetTypeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateCustomTargetType(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateCustomTargetType, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateCustomTargetType)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateCustomTargetType(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateCustomTargetType(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateCustomTargetType, (google::cloud::deploy::v1::UpdateCustomTargetTypeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateCustomTargetType(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateCustomTargetType, (NoAwaitTag, google::cloud::deploy::v1::UpdateCustomTargetTypeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateCustomTargetType(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateCustomTargetType, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteCustomTargetType)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteCustomTargetType(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteCustomTargetType(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteCustomTargetType, (google::cloud::deploy::v1::DeleteCustomTargetTypeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteCustomTargetType(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteCustomTargetType, (NoAwaitTag, google::cloud::deploy::v1::DeleteCustomTargetTypeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteCustomTargetType(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteCustomTargetType, (google::longrunning::Operation const& operation), (override)); @@ -250,19 +430,39 @@ class MockCloudDeployConnection : public deploy_v1::CloudDeployConnection { (google::cloud::deploy::v1::GetReleaseRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateRelease)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateRelease(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateRelease(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateRelease, (google::cloud::deploy::v1::CreateReleaseRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateRelease(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateRelease, (NoAwaitTag, google::cloud::deploy::v1::CreateReleaseRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateRelease(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateRelease, (google::longrunning::Operation const& operation), (override)); @@ -295,19 +495,39 @@ class MockCloudDeployConnection : public deploy_v1::CloudDeployConnection { (google::cloud::deploy::v1::GetRolloutRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateRollout)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateRollout(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateRollout(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateRollout, (google::cloud::deploy::v1::CreateRolloutRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateRollout(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateRollout, (NoAwaitTag, google::cloud::deploy::v1::CreateRolloutRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateRollout(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateRollout, (google::longrunning::Operation const& operation), (override)); @@ -338,57 +558,117 @@ class MockCloudDeployConnection : public deploy_v1::CloudDeployConnection { (google::cloud::deploy::v1::GetConfigRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateAutomation)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateAutomation(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateAutomation(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateAutomation, (google::cloud::deploy::v1::CreateAutomationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateAutomation(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateAutomation, (NoAwaitTag, google::cloud::deploy::v1::CreateAutomationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateAutomation(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateAutomation, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateAutomation)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateAutomation(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateAutomation(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateAutomation, (google::cloud::deploy::v1::UpdateAutomationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateAutomation(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateAutomation, (NoAwaitTag, google::cloud::deploy::v1::UpdateAutomationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateAutomation(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateAutomation, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteAutomation)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteAutomation(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteAutomation(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteAutomation, (google::cloud::deploy::v1::DeleteAutomationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteAutomation(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteAutomation, (NoAwaitTag, google::cloud::deploy::v1::DeleteAutomationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteAutomation(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteAutomation, (google::longrunning::Operation const& operation), (override)); diff --git a/google/cloud/developerconnect/v1/mocks/mock_developer_connect_connection.h b/google/cloud/developerconnect/v1/mocks/mock_developer_connect_connection.h index 683cf9f16068a..b20d697dd2f52 100644 --- a/google/cloud/developerconnect/v1/mocks/mock_developer_connect_connection.h +++ b/google/cloud/developerconnect/v1/mocks/mock_developer_connect_connection.h @@ -59,9 +59,15 @@ class MockDeveloperConnectConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateConnection)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateConnection(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateConnection(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateConnection, @@ -69,6 +75,12 @@ class MockDeveloperConnectConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateConnection(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateConnection, (NoAwaitTag, @@ -76,13 +88,27 @@ class MockDeveloperConnectConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateConnection(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateConnection, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateConnection)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateConnection(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateConnection(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateConnection, @@ -90,6 +116,12 @@ class MockDeveloperConnectConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateConnection(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateConnection, (NoAwaitTag, @@ -97,13 +129,27 @@ class MockDeveloperConnectConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateConnection(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateConnection, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteConnection)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteConnection(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteConnection(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteConnection, @@ -111,6 +157,12 @@ class MockDeveloperConnectConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteConnection(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteConnection, (NoAwaitTag, @@ -118,14 +170,28 @@ class MockDeveloperConnectConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteConnection(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteConnection, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateGitRepositoryLink)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateGitRepositoryLink(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateGitRepositoryLink(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateGitRepositoryLink, @@ -133,19 +199,40 @@ class MockDeveloperConnectConnection CreateGitRepositoryLinkRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateGitRepositoryLink(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateGitRepositoryLink, (NoAwaitTag, google::cloud::developerconnect::v1:: CreateGitRepositoryLinkRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateGitRepositoryLink(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateGitRepositoryLink, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteGitRepositoryLink)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteGitRepositoryLink(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteGitRepositoryLink(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteGitRepositoryLink, @@ -153,11 +240,26 @@ class MockDeveloperConnectConnection DeleteGitRepositoryLinkRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteGitRepositoryLink(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteGitRepositoryLink, (NoAwaitTag, google::cloud::developerconnect::v1:: DeleteGitRepositoryLinkRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteGitRepositoryLink(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteGitRepositoryLink, diff --git a/google/cloud/dialogflow_cx/mocks/mock_agents_connection.h b/google/cloud/dialogflow_cx/mocks/mock_agents_connection.h index 7e182d8c9a8ff..ef107f766d956 100644 --- a/google/cloud/dialogflow_cx/mocks/mock_agents_connection.h +++ b/google/cloud/dialogflow_cx/mocks/mock_agents_connection.h @@ -71,40 +71,80 @@ class MockAgentsConnection : public dialogflow_cx::AgentsConnection { (google::cloud::dialogflow::cx::v3::DeleteAgentRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ExportAgent)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ExportAgent(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ExportAgent(Matcher(_))) + /// @endcode MOCK_METHOD( future>, ExportAgent, (google::cloud::dialogflow::cx::v3::ExportAgentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ExportAgent(_, _)) + /// @endcode MOCK_METHOD( StatusOr, ExportAgent, (NoAwaitTag, google::cloud::dialogflow::cx::v3::ExportAgentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, ExportAgent(Matcher(_))) + /// @endcode MOCK_METHOD( future>, ExportAgent, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, RestoreAgent)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, RestoreAgent(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RestoreAgent(Matcher(_))) + /// @endcode MOCK_METHOD( future>, RestoreAgent, (google::cloud::dialogflow::cx::v3::RestoreAgentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, RestoreAgent(_, _)) + /// @endcode MOCK_METHOD( StatusOr, RestoreAgent, (NoAwaitTag, google::cloud::dialogflow::cx::v3::RestoreAgentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, RestoreAgent(Matcher(_))) + /// @endcode MOCK_METHOD(future>, RestoreAgent, (google::longrunning::Operation const& operation), (override)); diff --git a/google/cloud/dialogflow_cx/mocks/mock_entity_types_connection.h b/google/cloud/dialogflow_cx/mocks/mock_entity_types_connection.h index 3c7710c8ba657..ad1715b27ea34 100644 --- a/google/cloud/dialogflow_cx/mocks/mock_entity_types_connection.h +++ b/google/cloud/dialogflow_cx/mocks/mock_entity_types_connection.h @@ -74,9 +74,15 @@ class MockEntityTypesConnection : public dialogflow_cx::EntityTypesConnection { (google::cloud::dialogflow::cx::v3::ListEntityTypesRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ExportEntityTypes)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ExportEntityTypes(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ExportEntityTypes(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -85,6 +91,12 @@ class MockEntityTypesConnection : public dialogflow_cx::EntityTypesConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ExportEntityTypes(_, _)) + /// @endcode MOCK_METHOD( StatusOr, ExportEntityTypes, (NoAwaitTag, @@ -92,15 +104,29 @@ class MockEntityTypesConnection : public dialogflow_cx::EntityTypesConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ExportEntityTypes(Matcher(_))) + /// @endcode MOCK_METHOD( future>, ExportEntityTypes, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ImportEntityTypes)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ImportEntityTypes(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ImportEntityTypes(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -109,6 +135,12 @@ class MockEntityTypesConnection : public dialogflow_cx::EntityTypesConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ImportEntityTypes(_, _)) + /// @endcode MOCK_METHOD( StatusOr, ImportEntityTypes, (NoAwaitTag, @@ -116,6 +148,14 @@ class MockEntityTypesConnection : public dialogflow_cx::EntityTypesConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ImportEntityTypes(Matcher(_))) + /// @endcode MOCK_METHOD( future>, diff --git a/google/cloud/dialogflow_cx/mocks/mock_environments_connection.h b/google/cloud/dialogflow_cx/mocks/mock_environments_connection.h index 8c70472da7448..cd491f7d4c5ef 100644 --- a/google/cloud/dialogflow_cx/mocks/mock_environments_connection.h +++ b/google/cloud/dialogflow_cx/mocks/mock_environments_connection.h @@ -58,9 +58,15 @@ class MockEnvironmentsConnection (google::cloud::dialogflow::cx::v3::GetEnvironmentRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateEnvironment)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateEnvironment(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateEnvironment(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateEnvironment, @@ -68,6 +74,12 @@ class MockEnvironmentsConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateEnvironment(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateEnvironment, (NoAwaitTag, @@ -75,13 +87,27 @@ class MockEnvironmentsConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateEnvironment(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateEnvironment, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateEnvironment)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateEnvironment(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateEnvironment(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateEnvironment, @@ -89,6 +115,12 @@ class MockEnvironmentsConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateEnvironment(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateEnvironment, (NoAwaitTag, @@ -96,6 +128,14 @@ class MockEnvironmentsConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateEnvironment(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateEnvironment, (google::longrunning::Operation const& operation), (override)); @@ -113,9 +153,15 @@ class MockEnvironmentsConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, RunContinuousTest)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, RunContinuousTest(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RunContinuousTest(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -124,6 +170,12 @@ class MockEnvironmentsConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, RunContinuousTest(_, _)) + /// @endcode MOCK_METHOD( StatusOr, RunContinuousTest, (NoAwaitTag, @@ -131,6 +183,14 @@ class MockEnvironmentsConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RunContinuousTest(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -144,21 +204,41 @@ class MockEnvironmentsConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeployFlow)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeployFlow(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeployFlow(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeployFlow, (google::cloud::dialogflow::cx::v3::DeployFlowRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeployFlow(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeployFlow, (NoAwaitTag, google::cloud::dialogflow::cx::v3::DeployFlowRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeployFlow(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeployFlow, (google::longrunning::Operation const& operation), diff --git a/google/cloud/dialogflow_cx/mocks/mock_flows_connection.h b/google/cloud/dialogflow_cx/mocks/mock_flows_connection.h index 5a210b62855ad..f7e3cb0beb4cf 100644 --- a/google/cloud/dialogflow_cx/mocks/mock_flows_connection.h +++ b/google/cloud/dialogflow_cx/mocks/mock_flows_connection.h @@ -70,20 +70,40 @@ class MockFlowsConnection : public dialogflow_cx::FlowsConnection { (google::cloud::dialogflow::cx::v3::UpdateFlowRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, TrainFlow)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, TrainFlow(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// TrainFlow(Matcher(_))) + /// @endcode MOCK_METHOD( future>, TrainFlow, (google::cloud::dialogflow::cx::v3::TrainFlowRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, TrainFlow(_, _)) + /// @endcode MOCK_METHOD( StatusOr, TrainFlow, (NoAwaitTag, google::cloud::dialogflow::cx::v3::TrainFlowRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, TrainFlow(Matcher(_))) + /// @endcode MOCK_METHOD(future>, TrainFlow, (google::longrunning::Operation const& operation), (override)); @@ -100,41 +120,81 @@ class MockFlowsConnection : public dialogflow_cx::FlowsConnection { request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ImportFlow)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ImportFlow(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ImportFlow(Matcher(_))) + /// @endcode MOCK_METHOD( future>, ImportFlow, (google::cloud::dialogflow::cx::v3::ImportFlowRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ImportFlow(_, _)) + /// @endcode MOCK_METHOD( StatusOr, ImportFlow, (NoAwaitTag, google::cloud::dialogflow::cx::v3::ImportFlowRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, ImportFlow(Matcher(_))) + /// @endcode MOCK_METHOD( future>, ImportFlow, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ExportFlow)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ExportFlow(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ExportFlow(Matcher(_))) + /// @endcode MOCK_METHOD( future>, ExportFlow, (google::cloud::dialogflow::cx::v3::ExportFlowRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ExportFlow(_, _)) + /// @endcode MOCK_METHOD( StatusOr, ExportFlow, (NoAwaitTag, google::cloud::dialogflow::cx::v3::ExportFlowRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, ExportFlow(Matcher(_))) + /// @endcode MOCK_METHOD( future>, ExportFlow, (google::longrunning::Operation const& operation), diff --git a/google/cloud/dialogflow_cx/mocks/mock_intents_connection.h b/google/cloud/dialogflow_cx/mocks/mock_intents_connection.h index 10fccce3f2014..84fffa5af5e3b 100644 --- a/google/cloud/dialogflow_cx/mocks/mock_intents_connection.h +++ b/google/cloud/dialogflow_cx/mocks/mock_intents_connection.h @@ -71,9 +71,15 @@ class MockIntentsConnection : public dialogflow_cx::IntentsConnection { (google::cloud::dialogflow::cx::v3::DeleteIntentRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ImportIntents)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ImportIntents(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ImportIntents(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, @@ -81,21 +87,41 @@ class MockIntentsConnection : public dialogflow_cx::IntentsConnection { (google::cloud::dialogflow::cx::v3::ImportIntentsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ImportIntents(_, _)) + /// @endcode MOCK_METHOD( StatusOr, ImportIntents, (NoAwaitTag, google::cloud::dialogflow::cx::v3::ImportIntentsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, ImportIntents(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, ImportIntents, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ExportIntents)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ExportIntents(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ExportIntents(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, @@ -103,12 +129,26 @@ class MockIntentsConnection : public dialogflow_cx::IntentsConnection { (google::cloud::dialogflow::cx::v3::ExportIntentsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ExportIntents(_, _)) + /// @endcode MOCK_METHOD( StatusOr, ExportIntents, (NoAwaitTag, google::cloud::dialogflow::cx::v3::ExportIntentsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, ExportIntents(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, diff --git a/google/cloud/dialogflow_cx/mocks/mock_test_cases_connection.h b/google/cloud/dialogflow_cx/mocks/mock_test_cases_connection.h index d79957144bbda..84344c3e09a76 100644 --- a/google/cloud/dialogflow_cx/mocks/mock_test_cases_connection.h +++ b/google/cloud/dialogflow_cx/mocks/mock_test_cases_connection.h @@ -72,29 +72,55 @@ class MockTestCasesConnection : public dialogflow_cx::TestCasesConnection { (google::cloud::dialogflow::cx::v3::UpdateTestCaseRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, RunTestCase)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, RunTestCase(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RunTestCase(Matcher(_))) + /// @endcode MOCK_METHOD( future>, RunTestCase, (google::cloud::dialogflow::cx::v3::RunTestCaseRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, RunTestCase(_, _)) + /// @endcode MOCK_METHOD( StatusOr, RunTestCase, (NoAwaitTag, google::cloud::dialogflow::cx::v3::RunTestCaseRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, RunTestCase(Matcher(_))) + /// @endcode MOCK_METHOD( future>, RunTestCase, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, BatchRunTestCases)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, BatchRunTestCases(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// BatchRunTestCases(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -103,6 +129,12 @@ class MockTestCasesConnection : public dialogflow_cx::TestCasesConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, BatchRunTestCases(_, _)) + /// @endcode MOCK_METHOD( StatusOr, BatchRunTestCases, (NoAwaitTag, @@ -110,6 +142,14 @@ class MockTestCasesConnection : public dialogflow_cx::TestCasesConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// BatchRunTestCases(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -123,9 +163,15 @@ class MockTestCasesConnection : public dialogflow_cx::TestCasesConnection { request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ImportTestCases)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ImportTestCases(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ImportTestCases(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, @@ -134,21 +180,41 @@ class MockTestCasesConnection : public dialogflow_cx::TestCasesConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ImportTestCases(_, _)) + /// @endcode MOCK_METHOD(StatusOr, ImportTestCases, (NoAwaitTag, google::cloud::dialogflow::cx::v3::ImportTestCasesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, ImportTestCases(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, ImportTestCases, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ExportTestCases)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ExportTestCases(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ExportTestCases(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, @@ -157,12 +223,26 @@ class MockTestCasesConnection : public dialogflow_cx::TestCasesConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ExportTestCases(_, _)) + /// @endcode MOCK_METHOD(StatusOr, ExportTestCases, (NoAwaitTag, google::cloud::dialogflow::cx::v3::ExportTestCasesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, ExportTestCases(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, diff --git a/google/cloud/dialogflow_cx/mocks/mock_versions_connection.h b/google/cloud/dialogflow_cx/mocks/mock_versions_connection.h index 8a191021b0528..46602755985a3 100644 --- a/google/cloud/dialogflow_cx/mocks/mock_versions_connection.h +++ b/google/cloud/dialogflow_cx/mocks/mock_versions_connection.h @@ -56,21 +56,41 @@ class MockVersionsConnection : public dialogflow_cx::VersionsConnection { (google::cloud::dialogflow::cx::v3::GetVersionRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateVersion)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateVersion(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateVersion(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateVersion, (google::cloud::dialogflow::cx::v3::CreateVersionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateVersion(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateVersion, (NoAwaitTag, google::cloud::dialogflow::cx::v3::CreateVersionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateVersion(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateVersion, (google::longrunning::Operation const& operation), (override)); @@ -85,20 +105,40 @@ class MockVersionsConnection : public dialogflow_cx::VersionsConnection { (google::cloud::dialogflow::cx::v3::DeleteVersionRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, LoadVersion)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, LoadVersion(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// LoadVersion(Matcher(_))) + /// @endcode MOCK_METHOD( future>, LoadVersion, (google::cloud::dialogflow::cx::v3::LoadVersionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, LoadVersion(_, _)) + /// @endcode MOCK_METHOD( StatusOr, LoadVersion, (NoAwaitTag, google::cloud::dialogflow::cx::v3::LoadVersionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, LoadVersion(Matcher(_))) + /// @endcode MOCK_METHOD(future>, LoadVersion, (google::longrunning::Operation const& operation), (override)); diff --git a/google/cloud/dialogflow_es/mocks/mock_agents_connection.h b/google/cloud/dialogflow_es/mocks/mock_agents_connection.h index 3a2ed747f3dfe..4f81635f95316 100644 --- a/google/cloud/dialogflow_es/mocks/mock_agents_connection.h +++ b/google/cloud/dialogflow_es/mocks/mock_agents_connection.h @@ -63,72 +63,152 @@ class MockAgentsConnection : public dialogflow_es::AgentsConnection { (google::cloud::dialogflow::v2::SearchAgentsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, TrainAgent)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, TrainAgent(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// TrainAgent(Matcher(_))) + /// @endcode MOCK_METHOD(future>, TrainAgent, (google::cloud::dialogflow::v2::TrainAgentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, TrainAgent(_, _)) + /// @endcode MOCK_METHOD(StatusOr, TrainAgent, (NoAwaitTag, google::cloud::dialogflow::v2::TrainAgentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, TrainAgent(Matcher(_))) + /// @endcode MOCK_METHOD(future>, TrainAgent, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ExportAgent)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ExportAgent(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ExportAgent(Matcher(_))) + /// @endcode MOCK_METHOD( future>, ExportAgent, (google::cloud::dialogflow::v2::ExportAgentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ExportAgent(_, _)) + /// @endcode MOCK_METHOD( StatusOr, ExportAgent, (NoAwaitTag, google::cloud::dialogflow::v2::ExportAgentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, ExportAgent(Matcher(_))) + /// @endcode MOCK_METHOD( future>, ExportAgent, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ImportAgent)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ImportAgent(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ImportAgent(Matcher(_))) + /// @endcode MOCK_METHOD( future>, ImportAgent, (google::cloud::dialogflow::v2::ImportAgentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ImportAgent(_, _)) + /// @endcode MOCK_METHOD( StatusOr, ImportAgent, (NoAwaitTag, google::cloud::dialogflow::v2::ImportAgentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, ImportAgent(Matcher(_))) + /// @endcode MOCK_METHOD(future>, ImportAgent, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, RestoreAgent)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, RestoreAgent(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RestoreAgent(Matcher(_))) + /// @endcode MOCK_METHOD( future>, RestoreAgent, (google::cloud::dialogflow::v2::RestoreAgentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, RestoreAgent(_, _)) + /// @endcode MOCK_METHOD( StatusOr, RestoreAgent, (NoAwaitTag, google::cloud::dialogflow::v2::RestoreAgentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, RestoreAgent(Matcher(_))) + /// @endcode MOCK_METHOD(future>, RestoreAgent, (google::longrunning::Operation const& operation), (override)); diff --git a/google/cloud/dialogflow_es/mocks/mock_conversation_datasets_connection.h b/google/cloud/dialogflow_es/mocks/mock_conversation_datasets_connection.h index 362daf93f2c4d..1b400f8919cb9 100644 --- a/google/cloud/dialogflow_es/mocks/mock_conversation_datasets_connection.h +++ b/google/cloud/dialogflow_es/mocks/mock_conversation_datasets_connection.h @@ -47,9 +47,15 @@ class MockConversationDatasetsConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateConversationDataset)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateConversationDataset(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateConversationDataset(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateConversationDataset, @@ -57,6 +63,12 @@ class MockConversationDatasetsConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateConversationDataset(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateConversationDataset, (NoAwaitTag, @@ -64,6 +76,15 @@ class MockConversationDatasetsConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateConversationDataset(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateConversationDataset, @@ -82,9 +103,15 @@ class MockConversationDatasetsConnection (google::cloud::dialogflow::v2::ListConversationDatasetsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteConversationDataset)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteConversationDataset(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteConversationDataset(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -93,6 +120,12 @@ class MockConversationDatasetsConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteConversationDataset(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteConversationDataset, (NoAwaitTag, @@ -100,14 +133,29 @@ class MockConversationDatasetsConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteConversationDataset(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteConversationDataset, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ImportConversationData)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ImportConversationData(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ImportConversationData(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -116,6 +164,12 @@ class MockConversationDatasetsConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ImportConversationData(_, _)) + /// @endcode MOCK_METHOD( StatusOr, ImportConversationData, (NoAwaitTag, @@ -123,6 +177,14 @@ class MockConversationDatasetsConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ImportConversationData(Matcher(_))) + /// @endcode MOCK_METHOD(future>, ImportConversationData, diff --git a/google/cloud/dialogflow_es/mocks/mock_conversation_models_connection.h b/google/cloud/dialogflow_es/mocks/mock_conversation_models_connection.h index bb9e67d989771..fc2f214a4cd6a 100644 --- a/google/cloud/dialogflow_es/mocks/mock_conversation_models_connection.h +++ b/google/cloud/dialogflow_es/mocks/mock_conversation_models_connection.h @@ -47,9 +47,15 @@ class MockConversationModelsConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateConversationModel)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateConversationModel(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateConversationModel(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateConversationModel, @@ -57,6 +63,12 @@ class MockConversationModelsConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateConversationModel(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateConversationModel, (NoAwaitTag, @@ -64,6 +76,15 @@ class MockConversationModelsConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateConversationModel(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateConversationModel, @@ -81,9 +102,15 @@ class MockConversationModelsConnection (google::cloud::dialogflow::v2::ListConversationModelsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteConversationModel)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteConversationModel(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteConversationModel(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -92,6 +119,12 @@ class MockConversationModelsConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteConversationModel(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteConversationModel, (NoAwaitTag, @@ -99,14 +132,29 @@ class MockConversationModelsConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteConversationModel(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteConversationModel, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeployConversationModel)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeployConversationModel(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeployConversationModel(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -115,6 +163,12 @@ class MockConversationModelsConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeployConversationModel(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeployConversationModel, (NoAwaitTag, @@ -122,14 +176,29 @@ class MockConversationModelsConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeployConversationModel(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeployConversationModel, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UndeployConversationModel)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UndeployConversationModel(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UndeployConversationModel(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -138,6 +207,12 @@ class MockConversationModelsConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UndeployConversationModel(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UndeployConversationModel, (NoAwaitTag, @@ -145,6 +220,15 @@ class MockConversationModelsConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UndeployConversationModel(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UndeployConversationModel, @@ -164,10 +248,15 @@ class MockConversationModelsConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateConversationModelEvaluation)` is now ambiguous. - /// Use `EXPECT_CALL(*mock, CreateConversationModelEvaluation(::testing::_))` - /// instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateConversationModelEvaluation(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, @@ -176,6 +265,12 @@ class MockConversationModelsConnection CreateConversationModelEvaluationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateConversationModelEvaluation(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateConversationModelEvaluation, (NoAwaitTag, @@ -183,6 +278,15 @@ class MockConversationModelsConnection CreateConversationModelEvaluationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateConversationModelEvaluation(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, diff --git a/google/cloud/dialogflow_es/mocks/mock_conversation_profiles_connection.h b/google/cloud/dialogflow_es/mocks/mock_conversation_profiles_connection.h index f79733e9f21e1..0abe9e1a2f94c 100644 --- a/google/cloud/dialogflow_es/mocks/mock_conversation_profiles_connection.h +++ b/google/cloud/dialogflow_es/mocks/mock_conversation_profiles_connection.h @@ -80,9 +80,15 @@ class MockConversationProfilesConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SetSuggestionFeatureConfig)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SetSuggestionFeatureConfig(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetSuggestionFeatureConfig(Matcher(_))) + /// @endcode MOCK_METHOD( future>, SetSuggestionFeatureConfig, @@ -90,6 +96,12 @@ class MockConversationProfilesConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SetSuggestionFeatureConfig(_, _)) + /// @endcode MOCK_METHOD( StatusOr, SetSuggestionFeatureConfig, (NoAwaitTag, @@ -97,14 +109,29 @@ class MockConversationProfilesConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetSuggestionFeatureConfig(Matcher(_))) + /// @endcode MOCK_METHOD( future>, SetSuggestionFeatureConfig, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ClearSuggestionFeatureConfig)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ClearSuggestionFeatureConfig(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ClearSuggestionFeatureConfig(Matcher(_))) + /// @endcode MOCK_METHOD( future>, ClearSuggestionFeatureConfig, @@ -112,6 +139,12 @@ class MockConversationProfilesConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ClearSuggestionFeatureConfig(_, _)) + /// @endcode MOCK_METHOD( StatusOr, ClearSuggestionFeatureConfig, (NoAwaitTag, @@ -119,6 +152,15 @@ class MockConversationProfilesConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ClearSuggestionFeatureConfig(Matcher(_))) + /// @endcode MOCK_METHOD( future>, ClearSuggestionFeatureConfig, diff --git a/google/cloud/dialogflow_es/mocks/mock_documents_connection.h b/google/cloud/dialogflow_es/mocks/mock_documents_connection.h index d7416b04eac8a..0f81470304b6d 100644 --- a/google/cloud/dialogflow_es/mocks/mock_documents_connection.h +++ b/google/cloud/dialogflow_es/mocks/mock_documents_connection.h @@ -56,47 +56,93 @@ class MockDocumentsConnection : public dialogflow_es::DocumentsConnection { (google::cloud::dialogflow::v2::GetDocumentRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateDocument)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateDocument(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateDocument(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateDocument, (google::cloud::dialogflow::v2::CreateDocumentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateDocument(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateDocument, (NoAwaitTag, google::cloud::dialogflow::v2::CreateDocumentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateDocument(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateDocument, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ImportDocuments)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ImportDocuments(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ImportDocuments(Matcher(_))) + /// @endcode MOCK_METHOD( future>, ImportDocuments, (google::cloud::dialogflow::v2::ImportDocumentsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ImportDocuments(_, _)) + /// @endcode MOCK_METHOD( StatusOr, ImportDocuments, (NoAwaitTag, google::cloud::dialogflow::v2::ImportDocumentsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, ImportDocuments(Matcher(_))) + /// @endcode MOCK_METHOD( future>, ImportDocuments, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteDocument)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteDocument(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteDocument(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, @@ -104,68 +150,142 @@ class MockDocumentsConnection : public dialogflow_es::DocumentsConnection { (google::cloud::dialogflow::v2::DeleteDocumentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteDocument(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteDocument, (NoAwaitTag, google::cloud::dialogflow::v2::DeleteDocumentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteDocument(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, DeleteDocument, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateDocument)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateDocument(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateDocument(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateDocument, (google::cloud::dialogflow::v2::UpdateDocumentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateDocument(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateDocument, (NoAwaitTag, google::cloud::dialogflow::v2::UpdateDocumentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateDocument(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateDocument, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ReloadDocument)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ReloadDocument(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ReloadDocument(Matcher(_))) + /// @endcode MOCK_METHOD( future>, ReloadDocument, (google::cloud::dialogflow::v2::ReloadDocumentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ReloadDocument(_, _)) + /// @endcode MOCK_METHOD( StatusOr, ReloadDocument, (NoAwaitTag, google::cloud::dialogflow::v2::ReloadDocumentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, ReloadDocument(Matcher(_))) + /// @endcode MOCK_METHOD(future>, ReloadDocument, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ExportDocument)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ExportDocument(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ExportDocument(Matcher(_))) + /// @endcode MOCK_METHOD( future>, ExportDocument, (google::cloud::dialogflow::v2::ExportDocumentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ExportDocument(_, _)) + /// @endcode MOCK_METHOD( StatusOr, ExportDocument, (NoAwaitTag, google::cloud::dialogflow::v2::ExportDocumentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, ExportDocument(Matcher(_))) + /// @endcode MOCK_METHOD(future>, ExportDocument, (google::longrunning::Operation const& operation), (override)); diff --git a/google/cloud/dialogflow_es/mocks/mock_entity_types_connection.h b/google/cloud/dialogflow_es/mocks/mock_entity_types_connection.h index 863ccdd40851a..cd0b9c21b8f1c 100644 --- a/google/cloud/dialogflow_es/mocks/mock_entity_types_connection.h +++ b/google/cloud/dialogflow_es/mocks/mock_entity_types_connection.h @@ -71,9 +71,15 @@ class MockEntityTypesConnection : public dialogflow_es::EntityTypesConnection { (google::cloud::dialogflow::v2::DeleteEntityTypeRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, BatchUpdateEntityTypes)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, BatchUpdateEntityTypes(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// BatchUpdateEntityTypes(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -82,6 +88,12 @@ class MockEntityTypesConnection : public dialogflow_es::EntityTypesConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, BatchUpdateEntityTypes(_, _)) + /// @endcode MOCK_METHOD( StatusOr, BatchUpdateEntityTypes, (NoAwaitTag, @@ -89,21 +101,41 @@ class MockEntityTypesConnection : public dialogflow_es::EntityTypesConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// BatchUpdateEntityTypes(Matcher(_))) + /// @endcode MOCK_METHOD( future>, BatchUpdateEntityTypes, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, BatchDeleteEntityTypes)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, BatchDeleteEntityTypes(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// BatchDeleteEntityTypes(Matcher(_))) + /// @endcode MOCK_METHOD( future>, BatchDeleteEntityTypes, (google::cloud::dialogflow::v2::BatchDeleteEntityTypesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, BatchDeleteEntityTypes(_, _)) + /// @endcode MOCK_METHOD( StatusOr, BatchDeleteEntityTypes, (NoAwaitTag, @@ -111,58 +143,126 @@ class MockEntityTypesConnection : public dialogflow_es::EntityTypesConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// BatchDeleteEntityTypes(Matcher(_))) + /// @endcode MOCK_METHOD(future>, BatchDeleteEntityTypes, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, BatchCreateEntities)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, BatchCreateEntities(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// BatchCreateEntities(Matcher(_))) + /// @endcode MOCK_METHOD(future>, BatchCreateEntities, (google::cloud::dialogflow::v2::BatchCreateEntitiesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, BatchCreateEntities(_, _)) + /// @endcode MOCK_METHOD(StatusOr, BatchCreateEntities, (NoAwaitTag, google::cloud::dialogflow::v2::BatchCreateEntitiesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// BatchCreateEntities(Matcher(_))) + /// @endcode MOCK_METHOD(future>, BatchCreateEntities, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, BatchUpdateEntities)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, BatchUpdateEntities(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// BatchUpdateEntities(Matcher(_))) + /// @endcode MOCK_METHOD(future>, BatchUpdateEntities, (google::cloud::dialogflow::v2::BatchUpdateEntitiesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, BatchUpdateEntities(_, _)) + /// @endcode MOCK_METHOD(StatusOr, BatchUpdateEntities, (NoAwaitTag, google::cloud::dialogflow::v2::BatchUpdateEntitiesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// BatchUpdateEntities(Matcher(_))) + /// @endcode MOCK_METHOD(future>, BatchUpdateEntities, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, BatchDeleteEntities)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, BatchDeleteEntities(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// BatchDeleteEntities(Matcher(_))) + /// @endcode MOCK_METHOD(future>, BatchDeleteEntities, (google::cloud::dialogflow::v2::BatchDeleteEntitiesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, BatchDeleteEntities(_, _)) + /// @endcode MOCK_METHOD(StatusOr, BatchDeleteEntities, (NoAwaitTag, google::cloud::dialogflow::v2::BatchDeleteEntitiesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// BatchDeleteEntities(Matcher(_))) + /// @endcode MOCK_METHOD(future>, BatchDeleteEntities, (google::longrunning::Operation const& operation), (override)); }; diff --git a/google/cloud/dialogflow_es/mocks/mock_intents_connection.h b/google/cloud/dialogflow_es/mocks/mock_intents_connection.h index d10ddb1c039d3..fcbbfdb3e088d 100644 --- a/google/cloud/dialogflow_es/mocks/mock_intents_connection.h +++ b/google/cloud/dialogflow_es/mocks/mock_intents_connection.h @@ -69,9 +69,15 @@ class MockIntentsConnection : public dialogflow_es::IntentsConnection { (google::cloud::dialogflow::v2::DeleteIntentRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, BatchUpdateIntents)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, BatchUpdateIntents(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// BatchUpdateIntents(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, @@ -79,32 +85,66 @@ class MockIntentsConnection : public dialogflow_es::IntentsConnection { (google::cloud::dialogflow::v2::BatchUpdateIntentsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, BatchUpdateIntents(_, _)) + /// @endcode MOCK_METHOD( StatusOr, BatchUpdateIntents, (NoAwaitTag, google::cloud::dialogflow::v2::BatchUpdateIntentsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// BatchUpdateIntents(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, BatchUpdateIntents, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, BatchDeleteIntents)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, BatchDeleteIntents(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// BatchDeleteIntents(Matcher(_))) + /// @endcode MOCK_METHOD( future>, BatchDeleteIntents, (google::cloud::dialogflow::v2::BatchDeleteIntentsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, BatchDeleteIntents(_, _)) + /// @endcode MOCK_METHOD( StatusOr, BatchDeleteIntents, (NoAwaitTag, google::cloud::dialogflow::v2::BatchDeleteIntentsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// BatchDeleteIntents(Matcher(_))) + /// @endcode MOCK_METHOD(future>, BatchDeleteIntents, (google::longrunning::Operation const& operation), (override)); }; diff --git a/google/cloud/discoveryengine/v1/mocks/mock_completion_connection.h b/google/cloud/discoveryengine/v1/mocks/mock_completion_connection.h index cc9b1f692fef3..bfd2db53ee783 100644 --- a/google/cloud/discoveryengine/v1/mocks/mock_completion_connection.h +++ b/google/cloud/discoveryengine/v1/mocks/mock_completion_connection.h @@ -53,10 +53,15 @@ class MockCompletionServiceConnection (google::cloud::discoveryengine::v1::CompleteQueryRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ImportSuggestionDenyListEntries)` is now ambiguous. - /// Use `EXPECT_CALL(*mock, ImportSuggestionDenyListEntries(::testing::_))` - /// instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ImportSuggestionDenyListEntries(Matcher(_))) + /// @endcode MOCK_METHOD(future>, ImportSuggestionDenyListEntries, @@ -64,6 +69,12 @@ class MockCompletionServiceConnection ImportSuggestionDenyListEntriesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ImportSuggestionDenyListEntries(_, _)) + /// @endcode MOCK_METHOD(StatusOr, ImportSuggestionDenyListEntries, (NoAwaitTag, @@ -71,15 +82,29 @@ class MockCompletionServiceConnection ImportSuggestionDenyListEntriesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ImportSuggestionDenyListEntries(Matcher(_))) + /// @endcode MOCK_METHOD(future>, ImportSuggestionDenyListEntries, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, PurgeSuggestionDenyListEntries)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, PurgeSuggestionDenyListEntries(::testing::_))` - /// instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PurgeSuggestionDenyListEntries(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PurgeSuggestionDenyListEntries, @@ -87,6 +112,12 @@ class MockCompletionServiceConnection PurgeSuggestionDenyListEntriesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, PurgeSuggestionDenyListEntries(_, _)) + /// @endcode MOCK_METHOD(StatusOr, PurgeSuggestionDenyListEntries, (NoAwaitTag, @@ -94,14 +125,29 @@ class MockCompletionServiceConnection PurgeSuggestionDenyListEntriesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PurgeSuggestionDenyListEntries(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PurgeSuggestionDenyListEntries, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ImportCompletionSuggestions)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ImportCompletionSuggestions(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ImportCompletionSuggestions(Matcher(_))) + /// @endcode MOCK_METHOD(future>, ImportCompletionSuggestions, @@ -109,6 +155,12 @@ class MockCompletionServiceConnection ImportCompletionSuggestionsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ImportCompletionSuggestions(_, _)) + /// @endcode MOCK_METHOD(StatusOr, ImportCompletionSuggestions, (NoAwaitTag, @@ -116,14 +168,29 @@ class MockCompletionServiceConnection ImportCompletionSuggestionsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ImportCompletionSuggestions(Matcher(_))) + /// @endcode MOCK_METHOD(future>, ImportCompletionSuggestions, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, PurgeCompletionSuggestions)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, PurgeCompletionSuggestions(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PurgeCompletionSuggestions(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PurgeCompletionSuggestions, @@ -131,6 +198,12 @@ class MockCompletionServiceConnection PurgeCompletionSuggestionsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, PurgeCompletionSuggestions(_, _)) + /// @endcode MOCK_METHOD(StatusOr, PurgeCompletionSuggestions, (NoAwaitTag, @@ -138,6 +211,15 @@ class MockCompletionServiceConnection PurgeCompletionSuggestionsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PurgeCompletionSuggestions(Matcher(_))) + /// @endcode MOCK_METHOD(future>, PurgeCompletionSuggestions, diff --git a/google/cloud/discoveryengine/v1/mocks/mock_data_store_connection.h b/google/cloud/discoveryengine/v1/mocks/mock_data_store_connection.h index d18ded37562e3..e304df4469415 100644 --- a/google/cloud/discoveryengine/v1/mocks/mock_data_store_connection.h +++ b/google/cloud/discoveryengine/v1/mocks/mock_data_store_connection.h @@ -47,21 +47,41 @@ class MockDataStoreServiceConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateDataStore)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateDataStore(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateDataStore(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateDataStore, (google::cloud::discoveryengine::v1::CreateDataStoreRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateDataStore(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateDataStore, (NoAwaitTag, google::cloud::discoveryengine::v1::CreateDataStoreRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateDataStore(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateDataStore, (google::longrunning::Operation const& operation), (override)); @@ -77,9 +97,15 @@ class MockDataStoreServiceConnection (google::cloud::discoveryengine::v1::ListDataStoresRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteDataStore)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteDataStore(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteDataStore(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteDataStore, @@ -87,12 +113,26 @@ class MockDataStoreServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteDataStore(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteDataStore, (NoAwaitTag, google::cloud::discoveryengine::v1::DeleteDataStoreRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteDataStore(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteDataStore, diff --git a/google/cloud/discoveryengine/v1/mocks/mock_document_connection.h b/google/cloud/discoveryengine/v1/mocks/mock_document_connection.h index b29de3267329d..29fb2cc49d4ab 100644 --- a/google/cloud/discoveryengine/v1/mocks/mock_document_connection.h +++ b/google/cloud/discoveryengine/v1/mocks/mock_document_connection.h @@ -75,9 +75,15 @@ class MockDocumentServiceConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ImportDocuments)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ImportDocuments(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ImportDocuments(Matcher(_))) + /// @endcode MOCK_METHOD(future>, ImportDocuments, @@ -85,20 +91,40 @@ class MockDocumentServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ImportDocuments(_, _)) + /// @endcode MOCK_METHOD(StatusOr, ImportDocuments, (NoAwaitTag, google::cloud::discoveryengine::v1::ImportDocumentsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, ImportDocuments(Matcher(_))) + /// @endcode MOCK_METHOD(future>, ImportDocuments, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, PurgeDocuments)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, PurgeDocuments(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PurgeDocuments(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, @@ -107,12 +133,26 @@ class MockDocumentServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, PurgeDocuments(_, _)) + /// @endcode MOCK_METHOD(StatusOr, PurgeDocuments, (NoAwaitTag, google::cloud::discoveryengine::v1::PurgeDocumentsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, PurgeDocuments(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, diff --git a/google/cloud/discoveryengine/v1/mocks/mock_engine_connection.h b/google/cloud/discoveryengine/v1/mocks/mock_engine_connection.h index eb6b2d7522159..b55fe8fff45a2 100644 --- a/google/cloud/discoveryengine/v1/mocks/mock_engine_connection.h +++ b/google/cloud/discoveryengine/v1/mocks/mock_engine_connection.h @@ -47,28 +47,54 @@ class MockEngineServiceConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateEngine)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateEngine(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateEngine(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateEngine, (google::cloud::discoveryengine::v1::CreateEngineRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateEngine(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateEngine, (NoAwaitTag, google::cloud::discoveryengine::v1::CreateEngineRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateEngine(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateEngine, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteEngine)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteEngine(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteEngine(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, @@ -76,12 +102,26 @@ class MockEngineServiceConnection (google::cloud::discoveryengine::v1::DeleteEngineRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteEngine(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteEngine, (NoAwaitTag, google::cloud::discoveryengine::v1::DeleteEngineRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteEngine(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, diff --git a/google/cloud/discoveryengine/v1/mocks/mock_project_connection.h b/google/cloud/discoveryengine/v1/mocks/mock_project_connection.h index ea53d87c1c8d7..df7a8c4b520c4 100644 --- a/google/cloud/discoveryengine/v1/mocks/mock_project_connection.h +++ b/google/cloud/discoveryengine/v1/mocks/mock_project_connection.h @@ -47,9 +47,15 @@ class MockProjectServiceConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ProvisionProject)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ProvisionProject(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ProvisionProject(Matcher(_))) + /// @endcode MOCK_METHOD( future>, ProvisionProject, @@ -57,6 +63,12 @@ class MockProjectServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ProvisionProject(_, _)) + /// @endcode MOCK_METHOD( StatusOr, ProvisionProject, (NoAwaitTag, @@ -64,6 +76,14 @@ class MockProjectServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, ProvisionProject(Matcher(_))) + /// @endcode MOCK_METHOD(future>, ProvisionProject, (google::longrunning::Operation const& operation), (override)); diff --git a/google/cloud/discoveryengine/v1/mocks/mock_schema_connection.h b/google/cloud/discoveryengine/v1/mocks/mock_schema_connection.h index 130f11b519c3f..cd7b6abd9e656 100644 --- a/google/cloud/discoveryengine/v1/mocks/mock_schema_connection.h +++ b/google/cloud/discoveryengine/v1/mocks/mock_schema_connection.h @@ -57,47 +57,93 @@ class MockSchemaServiceConnection (google::cloud::discoveryengine::v1::ListSchemasRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateSchema)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateSchema(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateSchema(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateSchema, (google::cloud::discoveryengine::v1::CreateSchemaRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateSchema(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateSchema, (NoAwaitTag, google::cloud::discoveryengine::v1::CreateSchemaRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateSchema(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateSchema, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateSchema)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateSchema(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateSchema(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateSchema, (google::cloud::discoveryengine::v1::UpdateSchemaRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateSchema(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateSchema, (NoAwaitTag, google::cloud::discoveryengine::v1::UpdateSchemaRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateSchema(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateSchema, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteSchema)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteSchema(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteSchema(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, @@ -105,12 +151,26 @@ class MockSchemaServiceConnection (google::cloud::discoveryengine::v1::DeleteSchemaRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteSchema(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteSchema, (NoAwaitTag, google::cloud::discoveryengine::v1::DeleteSchemaRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteSchema(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, diff --git a/google/cloud/discoveryengine/v1/mocks/mock_site_search_engine_connection.h b/google/cloud/discoveryengine/v1/mocks/mock_site_search_engine_connection.h index c149943da088b..961dbd09115d3 100644 --- a/google/cloud/discoveryengine/v1/mocks/mock_site_search_engine_connection.h +++ b/google/cloud/discoveryengine/v1/mocks/mock_site_search_engine_connection.h @@ -54,9 +54,15 @@ class MockSiteSearchEngineServiceConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateTargetSite)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateTargetSite(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateTargetSite(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateTargetSite, @@ -64,6 +70,12 @@ class MockSiteSearchEngineServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateTargetSite(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateTargetSite, (NoAwaitTag, @@ -71,13 +83,27 @@ class MockSiteSearchEngineServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateTargetSite(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateTargetSite, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, BatchCreateTargetSites)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, BatchCreateTargetSites(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// BatchCreateTargetSites(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -86,6 +112,12 @@ class MockSiteSearchEngineServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, BatchCreateTargetSites(_, _)) + /// @endcode MOCK_METHOD( StatusOr, BatchCreateTargetSites, (NoAwaitTag, @@ -93,6 +125,14 @@ class MockSiteSearchEngineServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// BatchCreateTargetSites(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -104,9 +144,15 @@ class MockSiteSearchEngineServiceConnection (google::cloud::discoveryengine::v1::GetTargetSiteRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateTargetSite)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateTargetSite(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateTargetSite(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateTargetSite, @@ -114,6 +160,12 @@ class MockSiteSearchEngineServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateTargetSite(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateTargetSite, (NoAwaitTag, @@ -121,13 +173,27 @@ class MockSiteSearchEngineServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateTargetSite(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateTargetSite, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteTargetSite)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteTargetSite(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteTargetSite(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -136,6 +202,12 @@ class MockSiteSearchEngineServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteTargetSite(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteTargetSite, (NoAwaitTag, @@ -143,6 +215,14 @@ class MockSiteSearchEngineServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteTargetSite(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -155,9 +235,15 @@ class MockSiteSearchEngineServiceConnection (google::cloud::discoveryengine::v1::ListTargetSitesRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, EnableAdvancedSiteSearch)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, EnableAdvancedSiteSearch(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// EnableAdvancedSiteSearch(Matcher(_))) + /// @endcode MOCK_METHOD(future>, EnableAdvancedSiteSearch, @@ -165,20 +251,41 @@ class MockSiteSearchEngineServiceConnection EnableAdvancedSiteSearchRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, EnableAdvancedSiteSearch(_, _)) + /// @endcode MOCK_METHOD(StatusOr, EnableAdvancedSiteSearch, (NoAwaitTag, google::cloud::discoveryengine::v1:: EnableAdvancedSiteSearchRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// EnableAdvancedSiteSearch(Matcher(_))) + /// @endcode MOCK_METHOD(future>, EnableAdvancedSiteSearch, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DisableAdvancedSiteSearch)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DisableAdvancedSiteSearch(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DisableAdvancedSiteSearch(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DisableAdvancedSiteSearch, @@ -186,40 +293,81 @@ class MockSiteSearchEngineServiceConnection DisableAdvancedSiteSearchRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DisableAdvancedSiteSearch(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DisableAdvancedSiteSearch, (NoAwaitTag, google::cloud::discoveryengine::v1:: DisableAdvancedSiteSearchRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DisableAdvancedSiteSearch(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DisableAdvancedSiteSearch, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, RecrawlUris)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, RecrawlUris(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RecrawlUris(Matcher(_))) + /// @endcode MOCK_METHOD( future>, RecrawlUris, (google::cloud::discoveryengine::v1::RecrawlUrisRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, RecrawlUris(_, _)) + /// @endcode MOCK_METHOD( StatusOr, RecrawlUris, (NoAwaitTag, google::cloud::discoveryengine::v1::RecrawlUrisRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, RecrawlUris(Matcher(_))) + /// @endcode MOCK_METHOD( future>, RecrawlUris, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, BatchVerifyTargetSites)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, BatchVerifyTargetSites(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// BatchVerifyTargetSites(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -228,6 +376,12 @@ class MockSiteSearchEngineServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, BatchVerifyTargetSites(_, _)) + /// @endcode MOCK_METHOD( StatusOr, BatchVerifyTargetSites, (NoAwaitTag, @@ -235,6 +389,14 @@ class MockSiteSearchEngineServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// BatchVerifyTargetSites(Matcher(_))) + /// @endcode MOCK_METHOD( future>, diff --git a/google/cloud/discoveryengine/v1/mocks/mock_user_event_connection.h b/google/cloud/discoveryengine/v1/mocks/mock_user_event_connection.h index 21513ddcdb7d3..9a0d9a8af7488 100644 --- a/google/cloud/discoveryengine/v1/mocks/mock_user_event_connection.h +++ b/google/cloud/discoveryengine/v1/mocks/mock_user_event_connection.h @@ -59,9 +59,15 @@ class MockUserEventServiceConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ImportUserEvents)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ImportUserEvents(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ImportUserEvents(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -70,6 +76,12 @@ class MockUserEventServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ImportUserEvents(_, _)) + /// @endcode MOCK_METHOD( StatusOr, ImportUserEvents, (NoAwaitTag, @@ -77,6 +89,14 @@ class MockUserEventServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, ImportUserEvents(Matcher(_))) + /// @endcode MOCK_METHOD( future>, diff --git a/google/cloud/documentai/v1/mocks/mock_document_processor_connection.h b/google/cloud/documentai/v1/mocks/mock_document_processor_connection.h index 8b25c8de29f2c..7ec966286b4d8 100644 --- a/google/cloud/documentai/v1/mocks/mock_document_processor_connection.h +++ b/google/cloud/documentai/v1/mocks/mock_document_processor_connection.h @@ -52,21 +52,41 @@ class MockDocumentProcessorServiceConnection (google::cloud::documentai::v1::ProcessRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, BatchProcessDocuments)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, BatchProcessDocuments(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// BatchProcessDocuments(Matcher(_))) + /// @endcode MOCK_METHOD( future>, BatchProcessDocuments, (google::cloud::documentai::v1::BatchProcessRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, BatchProcessDocuments(_, _)) + /// @endcode MOCK_METHOD( StatusOr, BatchProcessDocuments, (NoAwaitTag, google::cloud::documentai::v1::BatchProcessRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// BatchProcessDocuments(Matcher(_))) + /// @endcode MOCK_METHOD( future>, BatchProcessDocuments, (google::longrunning::Operation const& operation), @@ -100,9 +120,15 @@ class MockDocumentProcessorServiceConnection (google::cloud::documentai::v1::GetProcessorRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, TrainProcessorVersion)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, TrainProcessorVersion(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// TrainProcessorVersion(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -111,6 +137,12 @@ class MockDocumentProcessorServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, TrainProcessorVersion(_, _)) + /// @endcode MOCK_METHOD( StatusOr, TrainProcessorVersion, (NoAwaitTag, @@ -118,6 +150,14 @@ class MockDocumentProcessorServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// TrainProcessorVersion(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -136,9 +176,15 @@ class MockDocumentProcessorServiceConnection (google::cloud::documentai::v1::ListProcessorVersionsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteProcessorVersion)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteProcessorVersion(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteProcessorVersion(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -147,6 +193,12 @@ class MockDocumentProcessorServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteProcessorVersion(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteProcessorVersion, (NoAwaitTag, @@ -154,15 +206,29 @@ class MockDocumentProcessorServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteProcessorVersion(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteProcessorVersion, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeployProcessorVersion)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeployProcessorVersion(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeployProcessorVersion(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -171,6 +237,12 @@ class MockDocumentProcessorServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeployProcessorVersion(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeployProcessorVersion, (NoAwaitTag, @@ -178,15 +250,29 @@ class MockDocumentProcessorServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeployProcessorVersion(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeployProcessorVersion, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UndeployProcessorVersion)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UndeployProcessorVersion(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UndeployProcessorVersion(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -195,6 +281,12 @@ class MockDocumentProcessorServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UndeployProcessorVersion(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UndeployProcessorVersion, (NoAwaitTag, @@ -202,6 +294,15 @@ class MockDocumentProcessorServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UndeployProcessorVersion(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -213,69 +314,135 @@ class MockDocumentProcessorServiceConnection (google::cloud::documentai::v1::CreateProcessorRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteProcessor)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteProcessor(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteProcessor(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteProcessor, (google::cloud::documentai::v1::DeleteProcessorRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteProcessor(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteProcessor, (NoAwaitTag, google::cloud::documentai::v1::DeleteProcessorRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteProcessor(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteProcessor, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, EnableProcessor)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, EnableProcessor(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// EnableProcessor(Matcher(_))) + /// @endcode MOCK_METHOD( future>, EnableProcessor, (google::cloud::documentai::v1::EnableProcessorRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, EnableProcessor(_, _)) + /// @endcode MOCK_METHOD( StatusOr, EnableProcessor, (NoAwaitTag, google::cloud::documentai::v1::EnableProcessorRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, EnableProcessor(Matcher(_))) + /// @endcode MOCK_METHOD( future>, EnableProcessor, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DisableProcessor)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DisableProcessor(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DisableProcessor(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DisableProcessor, (google::cloud::documentai::v1::DisableProcessorRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DisableProcessor(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DisableProcessor, (NoAwaitTag, google::cloud::documentai::v1::DisableProcessorRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DisableProcessor(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DisableProcessor, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SetDefaultProcessorVersion)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SetDefaultProcessorVersion(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetDefaultProcessorVersion(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -284,6 +451,12 @@ class MockDocumentProcessorServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SetDefaultProcessorVersion(_, _)) + /// @endcode MOCK_METHOD( StatusOr, SetDefaultProcessorVersion, (NoAwaitTag, @@ -291,35 +464,70 @@ class MockDocumentProcessorServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetDefaultProcessorVersion(Matcher(_))) + /// @endcode MOCK_METHOD( future>, SetDefaultProcessorVersion, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ReviewDocument)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ReviewDocument(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ReviewDocument(Matcher(_))) + /// @endcode MOCK_METHOD( future>, ReviewDocument, (google::cloud::documentai::v1::ReviewDocumentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ReviewDocument(_, _)) + /// @endcode MOCK_METHOD( StatusOr, ReviewDocument, (NoAwaitTag, google::cloud::documentai::v1::ReviewDocumentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, ReviewDocument(Matcher(_))) + /// @endcode MOCK_METHOD( future>, ReviewDocument, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, EvaluateProcessorVersion)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, EvaluateProcessorVersion(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// EvaluateProcessorVersion(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -328,6 +536,12 @@ class MockDocumentProcessorServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, EvaluateProcessorVersion(_, _)) + /// @endcode MOCK_METHOD( StatusOr, EvaluateProcessorVersion, (NoAwaitTag, @@ -335,6 +549,15 @@ class MockDocumentProcessorServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// EvaluateProcessorVersion(Matcher(_))) + /// @endcode MOCK_METHOD( future>, diff --git a/google/cloud/domains/v1/mocks/mock_domains_connection.h b/google/cloud/domains/v1/mocks/mock_domains_connection.h index feab825dc3375..4854347220216 100644 --- a/google/cloud/domains/v1/mocks/mock_domains_connection.h +++ b/google/cloud/domains/v1/mocks/mock_domains_connection.h @@ -58,21 +58,41 @@ class MockDomainsConnection : public domains_v1::DomainsConnection { request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, RegisterDomain)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, RegisterDomain(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RegisterDomain(Matcher(_))) + /// @endcode MOCK_METHOD( future>, RegisterDomain, (google::cloud::domains::v1::RegisterDomainRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, RegisterDomain(_, _)) + /// @endcode MOCK_METHOD( StatusOr, RegisterDomain, (NoAwaitTag, google::cloud::domains::v1::RegisterDomainRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, RegisterDomain(Matcher(_))) + /// @endcode MOCK_METHOD(future>, RegisterDomain, (google::longrunning::Operation const& operation), (override)); @@ -84,21 +104,41 @@ class MockDomainsConnection : public domains_v1::DomainsConnection { request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, TransferDomain)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, TransferDomain(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// TransferDomain(Matcher(_))) + /// @endcode MOCK_METHOD( future>, TransferDomain, (google::cloud::domains::v1::TransferDomainRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, TransferDomain(_, _)) + /// @endcode MOCK_METHOD( StatusOr, TransferDomain, (NoAwaitTag, google::cloud::domains::v1::TransferDomainRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, TransferDomain(Matcher(_))) + /// @endcode MOCK_METHOD(future>, TransferDomain, (google::longrunning::Operation const& operation), (override)); @@ -113,28 +153,54 @@ class MockDomainsConnection : public domains_v1::DomainsConnection { (google::cloud::domains::v1::GetRegistrationRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateRegistration)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateRegistration(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateRegistration(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateRegistration, (google::cloud::domains::v1::UpdateRegistrationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateRegistration(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateRegistration, (NoAwaitTag, google::cloud::domains::v1::UpdateRegistrationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateRegistration(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateRegistration, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ConfigureManagementSettings)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ConfigureManagementSettings(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ConfigureManagementSettings(Matcher(_))) + /// @endcode MOCK_METHOD( future>, ConfigureManagementSettings, @@ -142,6 +208,12 @@ class MockDomainsConnection : public domains_v1::DomainsConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ConfigureManagementSettings(_, _)) + /// @endcode MOCK_METHOD( StatusOr, ConfigureManagementSettings, (NoAwaitTag, @@ -149,32 +221,67 @@ class MockDomainsConnection : public domains_v1::DomainsConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ConfigureManagementSettings(Matcher(_))) + /// @endcode MOCK_METHOD(future>, ConfigureManagementSettings, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ConfigureDnsSettings)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ConfigureDnsSettings(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ConfigureDnsSettings(Matcher(_))) + /// @endcode MOCK_METHOD( future>, ConfigureDnsSettings, (google::cloud::domains::v1::ConfigureDnsSettingsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ConfigureDnsSettings(_, _)) + /// @endcode MOCK_METHOD( StatusOr, ConfigureDnsSettings, (NoAwaitTag, google::cloud::domains::v1::ConfigureDnsSettingsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ConfigureDnsSettings(Matcher(_))) + /// @endcode MOCK_METHOD(future>, ConfigureDnsSettings, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ConfigureContactSettings)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ConfigureContactSettings(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ConfigureContactSettings(Matcher(_))) + /// @endcode MOCK_METHOD( future>, ConfigureContactSettings, @@ -182,6 +289,12 @@ class MockDomainsConnection : public domains_v1::DomainsConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ConfigureContactSettings(_, _)) + /// @endcode MOCK_METHOD( StatusOr, ConfigureContactSettings, (NoAwaitTag, @@ -189,44 +302,93 @@ class MockDomainsConnection : public domains_v1::DomainsConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ConfigureContactSettings(Matcher(_))) + /// @endcode MOCK_METHOD(future>, ConfigureContactSettings, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ExportRegistration)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ExportRegistration(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ExportRegistration(Matcher(_))) + /// @endcode MOCK_METHOD( future>, ExportRegistration, (google::cloud::domains::v1::ExportRegistrationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ExportRegistration(_, _)) + /// @endcode MOCK_METHOD( StatusOr, ExportRegistration, (NoAwaitTag, google::cloud::domains::v1::ExportRegistrationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ExportRegistration(Matcher(_))) + /// @endcode MOCK_METHOD(future>, ExportRegistration, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteRegistration)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteRegistration(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteRegistration(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteRegistration, (google::cloud::domains::v1::DeleteRegistrationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteRegistration(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteRegistration, (NoAwaitTag, google::cloud::domains::v1::DeleteRegistrationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteRegistration(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteRegistration, (google::longrunning::Operation const& operation), (override)); diff --git a/google/cloud/edgecontainer/v1/mocks/mock_edge_container_connection.h b/google/cloud/edgecontainer/v1/mocks/mock_edge_container_connection.h index 36631fb54e4a1..0e5fb3c2b7559 100644 --- a/google/cloud/edgecontainer/v1/mocks/mock_edge_container_connection.h +++ b/google/cloud/edgecontainer/v1/mocks/mock_edge_container_connection.h @@ -57,78 +57,158 @@ class MockEdgeContainerConnection (google::cloud::edgecontainer::v1::GetClusterRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateCluster)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateCluster(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateCluster(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateCluster, (google::cloud::edgecontainer::v1::CreateClusterRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateCluster(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateCluster, (NoAwaitTag, google::cloud::edgecontainer::v1::CreateClusterRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateCluster(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateCluster, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateCluster)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateCluster(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateCluster(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateCluster, (google::cloud::edgecontainer::v1::UpdateClusterRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateCluster(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateCluster, (NoAwaitTag, google::cloud::edgecontainer::v1::UpdateClusterRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateCluster(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateCluster, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpgradeCluster)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpgradeCluster(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpgradeCluster(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpgradeCluster, (google::cloud::edgecontainer::v1::UpgradeClusterRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpgradeCluster(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpgradeCluster, (NoAwaitTag, google::cloud::edgecontainer::v1::UpgradeClusterRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpgradeCluster(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpgradeCluster, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteCluster)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteCluster(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteCluster(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteCluster, (google::cloud::edgecontainer::v1::DeleteClusterRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteCluster(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteCluster, (NoAwaitTag, google::cloud::edgecontainer::v1::DeleteClusterRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteCluster(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteCluster, (google::longrunning::Operation const& operation), @@ -159,59 +239,119 @@ class MockEdgeContainerConnection (google::cloud::edgecontainer::v1::GetNodePoolRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateNodePool)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateNodePool(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateNodePool(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateNodePool, (google::cloud::edgecontainer::v1::CreateNodePoolRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateNodePool(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateNodePool, (NoAwaitTag, google::cloud::edgecontainer::v1::CreateNodePoolRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateNodePool(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateNodePool, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateNodePool)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateNodePool(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateNodePool(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateNodePool, (google::cloud::edgecontainer::v1::UpdateNodePoolRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateNodePool(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateNodePool, (NoAwaitTag, google::cloud::edgecontainer::v1::UpdateNodePoolRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateNodePool(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateNodePool, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteNodePool)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteNodePool(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteNodePool(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteNodePool, (google::cloud::edgecontainer::v1::DeleteNodePoolRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteNodePool(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteNodePool, (NoAwaitTag, google::cloud::edgecontainer::v1::DeleteNodePoolRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteNodePool(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteNodePool, (google::longrunning::Operation const& operation), @@ -239,9 +379,15 @@ class MockEdgeContainerConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateVpnConnection)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateVpnConnection(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateVpnConnection(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateVpnConnection, @@ -249,6 +395,12 @@ class MockEdgeContainerConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateVpnConnection(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateVpnConnection, (NoAwaitTag, @@ -256,13 +408,27 @@ class MockEdgeContainerConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateVpnConnection(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateVpnConnection, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteVpnConnection)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteVpnConnection(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteVpnConnection(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteVpnConnection, @@ -270,6 +436,12 @@ class MockEdgeContainerConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteVpnConnection(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteVpnConnection, (NoAwaitTag, @@ -277,6 +449,14 @@ class MockEdgeContainerConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteVpnConnection(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteVpnConnection, (google::longrunning::Operation const& operation), diff --git a/google/cloud/edgenetwork/v1/mocks/mock_edge_network_connection.h b/google/cloud/edgenetwork/v1/mocks/mock_edge_network_connection.h index e4e8042fa5b75..4b52b87820be8 100644 --- a/google/cloud/edgenetwork/v1/mocks/mock_edge_network_connection.h +++ b/google/cloud/edgenetwork/v1/mocks/mock_edge_network_connection.h @@ -76,39 +76,79 @@ class MockEdgeNetworkConnection : public edgenetwork_v1::EdgeNetworkConnection { (google::cloud::edgenetwork::v1::DiagnoseNetworkRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateNetwork)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateNetwork(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateNetwork(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateNetwork, (google::cloud::edgenetwork::v1::CreateNetworkRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateNetwork(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateNetwork, (NoAwaitTag, google::cloud::edgenetwork::v1::CreateNetworkRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateNetwork(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateNetwork, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteNetwork)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteNetwork(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteNetwork(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteNetwork, (google::cloud::edgenetwork::v1::DeleteNetworkRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteNetwork(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteNetwork, (NoAwaitTag, google::cloud::edgenetwork::v1::DeleteNetworkRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteNetwork(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteNetwork, (google::longrunning::Operation const& operation), @@ -123,57 +163,117 @@ class MockEdgeNetworkConnection : public edgenetwork_v1::EdgeNetworkConnection { (google::cloud::edgenetwork::v1::GetSubnetRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateSubnet)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateSubnet(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateSubnet(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateSubnet, (google::cloud::edgenetwork::v1::CreateSubnetRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateSubnet(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateSubnet, (NoAwaitTag, google::cloud::edgenetwork::v1::CreateSubnetRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateSubnet(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateSubnet, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateSubnet)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateSubnet(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateSubnet(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateSubnet, (google::cloud::edgenetwork::v1::UpdateSubnetRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateSubnet(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateSubnet, (NoAwaitTag, google::cloud::edgenetwork::v1::UpdateSubnetRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateSubnet(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateSubnet, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteSubnet)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteSubnet(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteSubnet(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteSubnet, (google::cloud::edgenetwork::v1::DeleteSubnetRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteSubnet(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteSubnet, (NoAwaitTag, google::cloud::edgenetwork::v1::DeleteSubnetRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteSubnet(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteSubnet, (google::longrunning::Operation const& operation), @@ -211,9 +311,15 @@ class MockEdgeNetworkConnection : public edgenetwork_v1::EdgeNetworkConnection { request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateInterconnectAttachment)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateInterconnectAttachment(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateInterconnectAttachment(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateInterconnectAttachment, @@ -221,6 +327,12 @@ class MockEdgeNetworkConnection : public edgenetwork_v1::EdgeNetworkConnection { CreateInterconnectAttachmentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateInterconnectAttachment(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateInterconnectAttachment, (NoAwaitTag, @@ -228,14 +340,29 @@ class MockEdgeNetworkConnection : public edgenetwork_v1::EdgeNetworkConnection { CreateInterconnectAttachmentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateInterconnectAttachment(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateInterconnectAttachment, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteInterconnectAttachment)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteInterconnectAttachment(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteInterconnectAttachment(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteInterconnectAttachment, @@ -243,6 +370,12 @@ class MockEdgeNetworkConnection : public edgenetwork_v1::EdgeNetworkConnection { DeleteInterconnectAttachmentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteInterconnectAttachment(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteInterconnectAttachment, (NoAwaitTag, @@ -250,6 +383,15 @@ class MockEdgeNetworkConnection : public edgenetwork_v1::EdgeNetworkConnection { DeleteInterconnectAttachmentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteInterconnectAttachment(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteInterconnectAttachment, @@ -270,57 +412,117 @@ class MockEdgeNetworkConnection : public edgenetwork_v1::EdgeNetworkConnection { (google::cloud::edgenetwork::v1::DiagnoseRouterRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateRouter)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateRouter(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateRouter(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateRouter, (google::cloud::edgenetwork::v1::CreateRouterRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateRouter(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateRouter, (NoAwaitTag, google::cloud::edgenetwork::v1::CreateRouterRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateRouter(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateRouter, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateRouter)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateRouter(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateRouter(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateRouter, (google::cloud::edgenetwork::v1::UpdateRouterRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateRouter(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateRouter, (NoAwaitTag, google::cloud::edgenetwork::v1::UpdateRouterRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateRouter(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateRouter, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteRouter)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteRouter(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteRouter(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteRouter, (google::cloud::edgenetwork::v1::DeleteRouterRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteRouter(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteRouter, (NoAwaitTag, google::cloud::edgenetwork::v1::DeleteRouterRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteRouter(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteRouter, (google::longrunning::Operation const& operation), diff --git a/google/cloud/eventarc/v1/mocks/mock_eventarc_connection.h b/google/cloud/eventarc/v1/mocks/mock_eventarc_connection.h index f8c026b09ea8f..cfd8a87f47122 100644 --- a/google/cloud/eventarc/v1/mocks/mock_eventarc_connection.h +++ b/google/cloud/eventarc/v1/mocks/mock_eventarc_connection.h @@ -54,56 +54,116 @@ class MockEventarcConnection : public eventarc_v1::EventarcConnection { (google::cloud::eventarc::v1::ListTriggersRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateTrigger)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateTrigger(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateTrigger(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateTrigger, (google::cloud::eventarc::v1::CreateTriggerRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateTrigger(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateTrigger, (NoAwaitTag, google::cloud::eventarc::v1::CreateTriggerRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateTrigger(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateTrigger, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateTrigger)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateTrigger(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateTrigger(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateTrigger, (google::cloud::eventarc::v1::UpdateTriggerRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateTrigger(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateTrigger, (NoAwaitTag, google::cloud::eventarc::v1::UpdateTriggerRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateTrigger(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateTrigger, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteTrigger)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteTrigger(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteTrigger(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteTrigger, (google::cloud::eventarc::v1::DeleteTriggerRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteTrigger(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteTrigger, (NoAwaitTag, google::cloud::eventarc::v1::DeleteTriggerRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteTrigger(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteTrigger, (google::longrunning::Operation const& operation), (override)); @@ -116,56 +176,116 @@ class MockEventarcConnection : public eventarc_v1::EventarcConnection { (google::cloud::eventarc::v1::ListChannelsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateChannel)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateChannel(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateChannel(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateChannel, (google::cloud::eventarc::v1::CreateChannelRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateChannel(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateChannel, (NoAwaitTag, google::cloud::eventarc::v1::CreateChannelRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateChannel(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateChannel, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateChannel)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateChannel(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateChannel(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateChannel, (google::cloud::eventarc::v1::UpdateChannelRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateChannel(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateChannel, (NoAwaitTag, google::cloud::eventarc::v1::UpdateChannelRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateChannel(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateChannel, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteChannel)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteChannel(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteChannel(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteChannel, (google::cloud::eventarc::v1::DeleteChannelRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteChannel(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteChannel, (NoAwaitTag, google::cloud::eventarc::v1::DeleteChannelRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteChannel(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteChannel, (google::longrunning::Operation const& operation), (override)); @@ -191,9 +311,15 @@ class MockEventarcConnection : public eventarc_v1::EventarcConnection { (google::cloud::eventarc::v1::ListChannelConnectionsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateChannelConnection)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateChannelConnection(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateChannelConnection(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateChannelConnection, @@ -201,6 +327,12 @@ class MockEventarcConnection : public eventarc_v1::EventarcConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateChannelConnection(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateChannelConnection, (NoAwaitTag, @@ -208,13 +340,28 @@ class MockEventarcConnection : public eventarc_v1::EventarcConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateChannelConnection(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateChannelConnection, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteChannelConnection)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteChannelConnection(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteChannelConnection(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteChannelConnection, @@ -222,6 +369,12 @@ class MockEventarcConnection : public eventarc_v1::EventarcConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteChannelConnection(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteChannelConnection, (NoAwaitTag, @@ -229,6 +382,15 @@ class MockEventarcConnection : public eventarc_v1::EventarcConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteChannelConnection(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteChannelConnection, (google::longrunning::Operation const& operation), (override)); diff --git a/google/cloud/filestore/v1/mocks/mock_cloud_filestore_manager_connection.h b/google/cloud/filestore/v1/mocks/mock_cloud_filestore_manager_connection.h index e9bc4e3096588..7418cf8d8e579 100644 --- a/google/cloud/filestore/v1/mocks/mock_cloud_filestore_manager_connection.h +++ b/google/cloud/filestore/v1/mocks/mock_cloud_filestore_manager_connection.h @@ -56,93 +56,193 @@ class MockCloudFilestoreManagerConnection (google::cloud::filestore::v1::GetInstanceRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateInstance)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateInstance(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateInstance(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateInstance, (google::cloud::filestore::v1::CreateInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateInstance(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateInstance, (NoAwaitTag, google::cloud::filestore::v1::CreateInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateInstance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateInstance, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateInstance)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateInstance(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateInstance(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateInstance, (google::cloud::filestore::v1::UpdateInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateInstance(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateInstance, (NoAwaitTag, google::cloud::filestore::v1::UpdateInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateInstance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateInstance, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, RestoreInstance)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, RestoreInstance(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RestoreInstance(Matcher(_))) + /// @endcode MOCK_METHOD( future>, RestoreInstance, (google::cloud::filestore::v1::RestoreInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, RestoreInstance(_, _)) + /// @endcode MOCK_METHOD( StatusOr, RestoreInstance, (NoAwaitTag, google::cloud::filestore::v1::RestoreInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, RestoreInstance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, RestoreInstance, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, RevertInstance)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, RevertInstance(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RevertInstance(Matcher(_))) + /// @endcode MOCK_METHOD( future>, RevertInstance, (google::cloud::filestore::v1::RevertInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, RevertInstance(_, _)) + /// @endcode MOCK_METHOD( StatusOr, RevertInstance, (NoAwaitTag, google::cloud::filestore::v1::RevertInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, RevertInstance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, RevertInstance, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteInstance)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteInstance(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteInstance(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteInstance, (google::cloud::filestore::v1::DeleteInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteInstance(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteInstance, (NoAwaitTag, google::cloud::filestore::v1::DeleteInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteInstance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteInstance, (google::longrunning::Operation const& operation), (override)); @@ -156,57 +256,117 @@ class MockCloudFilestoreManagerConnection (google::cloud::filestore::v1::GetSnapshotRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateSnapshot)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateSnapshot(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateSnapshot(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateSnapshot, (google::cloud::filestore::v1::CreateSnapshotRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateSnapshot(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateSnapshot, (NoAwaitTag, google::cloud::filestore::v1::CreateSnapshotRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateSnapshot(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateSnapshot, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteSnapshot)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteSnapshot(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteSnapshot(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteSnapshot, (google::cloud::filestore::v1::DeleteSnapshotRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteSnapshot(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteSnapshot, (NoAwaitTag, google::cloud::filestore::v1::DeleteSnapshotRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteSnapshot(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteSnapshot, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateSnapshot)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateSnapshot(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateSnapshot(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateSnapshot, (google::cloud::filestore::v1::UpdateSnapshotRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateSnapshot(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateSnapshot, (NoAwaitTag, google::cloud::filestore::v1::UpdateSnapshotRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateSnapshot(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateSnapshot, (google::longrunning::Operation const& operation), (override)); @@ -219,56 +379,116 @@ class MockCloudFilestoreManagerConnection (google::cloud::filestore::v1::GetBackupRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateBackup)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateBackup(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateBackup(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateBackup, (google::cloud::filestore::v1::CreateBackupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateBackup(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateBackup, (NoAwaitTag, google::cloud::filestore::v1::CreateBackupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateBackup(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateBackup, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteBackup)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteBackup(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteBackup(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteBackup, (google::cloud::filestore::v1::DeleteBackupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteBackup(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteBackup, (NoAwaitTag, google::cloud::filestore::v1::DeleteBackupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteBackup(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteBackup, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateBackup)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateBackup(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateBackup(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateBackup, (google::cloud::filestore::v1::UpdateBackupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateBackup(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateBackup, (NoAwaitTag, google::cloud::filestore::v1::UpdateBackupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateBackup(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateBackup, (google::longrunning::Operation const& operation), (override)); diff --git a/google/cloud/functions/v1/mocks/mock_cloud_functions_connection.h b/google/cloud/functions/v1/mocks/mock_cloud_functions_connection.h index 4f32cb47cb141..ccdaa78d3de91 100644 --- a/google/cloud/functions/v1/mocks/mock_cloud_functions_connection.h +++ b/google/cloud/functions/v1/mocks/mock_cloud_functions_connection.h @@ -57,59 +57,119 @@ class MockCloudFunctionsServiceConnection (google::cloud::functions::v1::GetFunctionRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateFunction)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateFunction(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateFunction(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateFunction, (google::cloud::functions::v1::CreateFunctionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateFunction(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateFunction, (NoAwaitTag, google::cloud::functions::v1::CreateFunctionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateFunction(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateFunction, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateFunction)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateFunction(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateFunction(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateFunction, (google::cloud::functions::v1::UpdateFunctionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateFunction(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateFunction, (NoAwaitTag, google::cloud::functions::v1::UpdateFunctionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateFunction(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateFunction, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteFunction)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteFunction(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteFunction(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteFunction, (google::cloud::functions::v1::DeleteFunctionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteFunction(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteFunction, (NoAwaitTag, google::cloud::functions::v1::DeleteFunctionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteFunction(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteFunction, (google::longrunning::Operation const& operation), diff --git a/google/cloud/functions/v2/mocks/mock_function_connection.h b/google/cloud/functions/v2/mocks/mock_function_connection.h index 4b59cba0a580b..2e33629d1be7f 100644 --- a/google/cloud/functions/v2/mocks/mock_function_connection.h +++ b/google/cloud/functions/v2/mocks/mock_function_connection.h @@ -56,57 +56,117 @@ class MockFunctionServiceConnection (google::cloud::functions::v2::ListFunctionsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateFunction)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateFunction(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateFunction(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateFunction, (google::cloud::functions::v2::CreateFunctionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateFunction(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateFunction, (NoAwaitTag, google::cloud::functions::v2::CreateFunctionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateFunction(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateFunction, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateFunction)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateFunction(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateFunction(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateFunction, (google::cloud::functions::v2::UpdateFunctionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateFunction(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateFunction, (NoAwaitTag, google::cloud::functions::v2::UpdateFunctionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateFunction(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateFunction, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteFunction)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteFunction(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteFunction(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteFunction, (google::cloud::functions::v2::DeleteFunctionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteFunction(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteFunction, (NoAwaitTag, google::cloud::functions::v2::DeleteFunctionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteFunction(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteFunction, (google::longrunning::Operation const& operation), (override)); diff --git a/google/cloud/gkebackup/v1/mocks/mock_backup_for_gke_connection.h b/google/cloud/gkebackup/v1/mocks/mock_backup_for_gke_connection.h index 1d52816adc2a9..ca4cccdafc0de 100644 --- a/google/cloud/gkebackup/v1/mocks/mock_backup_for_gke_connection.h +++ b/google/cloud/gkebackup/v1/mocks/mock_backup_for_gke_connection.h @@ -46,21 +46,41 @@ class MockBackupForGKEConnection : public gkebackup_v1::BackupForGKEConnection { public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateBackupPlan)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateBackupPlan(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateBackupPlan(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateBackupPlan, (google::cloud::gkebackup::v1::CreateBackupPlanRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateBackupPlan(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateBackupPlan, (NoAwaitTag, google::cloud::gkebackup::v1::CreateBackupPlanRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateBackupPlan(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateBackupPlan, (google::longrunning::Operation const& operation), (override)); @@ -75,58 +95,118 @@ class MockBackupForGKEConnection : public gkebackup_v1::BackupForGKEConnection { (google::cloud::gkebackup::v1::GetBackupPlanRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateBackupPlan)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateBackupPlan(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateBackupPlan(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateBackupPlan, (google::cloud::gkebackup::v1::UpdateBackupPlanRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateBackupPlan(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateBackupPlan, (NoAwaitTag, google::cloud::gkebackup::v1::UpdateBackupPlanRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateBackupPlan(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateBackupPlan, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteBackupPlan)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteBackupPlan(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteBackupPlan(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteBackupPlan, (google::cloud::gkebackup::v1::DeleteBackupPlanRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteBackupPlan(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteBackupPlan, (NoAwaitTag, google::cloud::gkebackup::v1::DeleteBackupPlanRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteBackupPlan(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteBackupPlan, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateBackup)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateBackup(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateBackup(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateBackup, (google::cloud::gkebackup::v1::CreateBackupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateBackup(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateBackup, (NoAwaitTag, google::cloud::gkebackup::v1::CreateBackupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateBackup(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateBackup, (google::longrunning::Operation const& operation), (override)); @@ -139,39 +219,79 @@ class MockBackupForGKEConnection : public gkebackup_v1::BackupForGKEConnection { (google::cloud::gkebackup::v1::GetBackupRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateBackup)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateBackup(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateBackup(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateBackup, (google::cloud::gkebackup::v1::UpdateBackupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateBackup(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateBackup, (NoAwaitTag, google::cloud::gkebackup::v1::UpdateBackupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateBackup(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateBackup, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteBackup)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteBackup(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteBackup(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteBackup, (google::cloud::gkebackup::v1::DeleteBackupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteBackup(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteBackup, (NoAwaitTag, google::cloud::gkebackup::v1::DeleteBackupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteBackup(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteBackup, (google::longrunning::Operation const& operation), (override)); @@ -186,21 +306,41 @@ class MockBackupForGKEConnection : public gkebackup_v1::BackupForGKEConnection { (google::cloud::gkebackup::v1::GetVolumeBackupRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateRestorePlan)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateRestorePlan(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateRestorePlan(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateRestorePlan, (google::cloud::gkebackup::v1::CreateRestorePlanRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateRestorePlan(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateRestorePlan, (NoAwaitTag, google::cloud::gkebackup::v1::CreateRestorePlanRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateRestorePlan(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateRestorePlan, (google::longrunning::Operation const& operation), (override)); @@ -215,58 +355,118 @@ class MockBackupForGKEConnection : public gkebackup_v1::BackupForGKEConnection { (google::cloud::gkebackup::v1::GetRestorePlanRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateRestorePlan)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateRestorePlan(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateRestorePlan(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateRestorePlan, (google::cloud::gkebackup::v1::UpdateRestorePlanRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateRestorePlan(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateRestorePlan, (NoAwaitTag, google::cloud::gkebackup::v1::UpdateRestorePlanRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateRestorePlan(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateRestorePlan, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteRestorePlan)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteRestorePlan(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteRestorePlan(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteRestorePlan, (google::cloud::gkebackup::v1::DeleteRestorePlanRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteRestorePlan(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteRestorePlan, (NoAwaitTag, google::cloud::gkebackup::v1::DeleteRestorePlanRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteRestorePlan(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteRestorePlan, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateRestore)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateRestore(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateRestore(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateRestore, (google::cloud::gkebackup::v1::CreateRestoreRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateRestore(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateRestore, (NoAwaitTag, google::cloud::gkebackup::v1::CreateRestoreRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateRestore(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateRestore, (google::longrunning::Operation const& operation), (override)); @@ -280,39 +480,79 @@ class MockBackupForGKEConnection : public gkebackup_v1::BackupForGKEConnection { (google::cloud::gkebackup::v1::GetRestoreRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateRestore)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateRestore(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateRestore(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateRestore, (google::cloud::gkebackup::v1::UpdateRestoreRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateRestore(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateRestore, (NoAwaitTag, google::cloud::gkebackup::v1::UpdateRestoreRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateRestore(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateRestore, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteRestore)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteRestore(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteRestore(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteRestore, (google::cloud::gkebackup::v1::DeleteRestoreRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteRestore(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteRestore, (NoAwaitTag, google::cloud::gkebackup::v1::DeleteRestoreRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteRestore(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteRestore, (google::longrunning::Operation const& operation), (override)); diff --git a/google/cloud/gkehub/v1/mocks/mock_gke_hub_connection.h b/google/cloud/gkehub/v1/mocks/mock_gke_hub_connection.h index 67f6e9df8b4b7..e9e2c07e109e3 100644 --- a/google/cloud/gkehub/v1/mocks/mock_gke_hub_connection.h +++ b/google/cloud/gkehub/v1/mocks/mock_gke_hub_connection.h @@ -63,108 +63,228 @@ class MockGkeHubConnection : public gkehub_v1::GkeHubConnection { (google::cloud::gkehub::v1::GetFeatureRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateMembership)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateMembership(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateMembership(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateMembership, (google::cloud::gkehub::v1::CreateMembershipRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateMembership(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateMembership, (NoAwaitTag, google::cloud::gkehub::v1::CreateMembershipRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateMembership(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateMembership, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateFeature)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateFeature(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateFeature(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateFeature, (google::cloud::gkehub::v1::CreateFeatureRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateFeature(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateFeature, (NoAwaitTag, google::cloud::gkehub::v1::CreateFeatureRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateFeature(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateFeature, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteMembership)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteMembership(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteMembership(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteMembership, (google::cloud::gkehub::v1::DeleteMembershipRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteMembership(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteMembership, (NoAwaitTag, google::cloud::gkehub::v1::DeleteMembershipRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteMembership(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteMembership, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteFeature)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteFeature(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteFeature(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteFeature, (google::cloud::gkehub::v1::DeleteFeatureRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteFeature(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteFeature, (NoAwaitTag, google::cloud::gkehub::v1::DeleteFeatureRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteFeature(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteFeature, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateMembership)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateMembership(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateMembership(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateMembership, (google::cloud::gkehub::v1::UpdateMembershipRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateMembership(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateMembership, (NoAwaitTag, google::cloud::gkehub::v1::UpdateMembershipRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateMembership(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateMembership, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateFeature)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateFeature(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateFeature(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateFeature, (google::cloud::gkehub::v1::UpdateFeatureRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateFeature(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateFeature, (NoAwaitTag, google::cloud::gkehub::v1::UpdateFeatureRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateFeature(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateFeature, (google::longrunning::Operation const& operation), (override)); diff --git a/google/cloud/gkemulticloud/v1/mocks/mock_attached_clusters_connection.h b/google/cloud/gkemulticloud/v1/mocks/mock_attached_clusters_connection.h index 9939954b77ff5..8e114760c052a 100644 --- a/google/cloud/gkemulticloud/v1/mocks/mock_attached_clusters_connection.h +++ b/google/cloud/gkemulticloud/v1/mocks/mock_attached_clusters_connection.h @@ -47,9 +47,15 @@ class MockAttachedClustersConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateAttachedCluster)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateAttachedCluster(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateAttachedCluster(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateAttachedCluster, @@ -57,6 +63,12 @@ class MockAttachedClustersConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateAttachedCluster(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateAttachedCluster, (NoAwaitTag, @@ -64,14 +76,28 @@ class MockAttachedClustersConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateAttachedCluster(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateAttachedCluster, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateAttachedCluster)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateAttachedCluster(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateAttachedCluster(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateAttachedCluster, @@ -79,6 +105,12 @@ class MockAttachedClustersConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateAttachedCluster(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateAttachedCluster, (NoAwaitTag, @@ -86,14 +118,28 @@ class MockAttachedClustersConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateAttachedCluster(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateAttachedCluster, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ImportAttachedCluster)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ImportAttachedCluster(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ImportAttachedCluster(Matcher(_))) + /// @endcode MOCK_METHOD( future>, ImportAttachedCluster, @@ -101,6 +147,12 @@ class MockAttachedClustersConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ImportAttachedCluster(_, _)) + /// @endcode MOCK_METHOD( StatusOr, ImportAttachedCluster, (NoAwaitTag, @@ -108,6 +160,14 @@ class MockAttachedClustersConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ImportAttachedCluster(Matcher(_))) + /// @endcode MOCK_METHOD( future>, ImportAttachedCluster, (google::longrunning::Operation const& operation), @@ -126,9 +186,15 @@ class MockAttachedClustersConnection (google::cloud::gkemulticloud::v1::ListAttachedClustersRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteAttachedCluster)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteAttachedCluster(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteAttachedCluster(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteAttachedCluster, @@ -136,6 +202,12 @@ class MockAttachedClustersConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteAttachedCluster(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteAttachedCluster, (NoAwaitTag, @@ -143,6 +215,14 @@ class MockAttachedClustersConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteAttachedCluster(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteAttachedCluster, (google::longrunning::Operation const& operation), diff --git a/google/cloud/gkemulticloud/v1/mocks/mock_aws_clusters_connection.h b/google/cloud/gkemulticloud/v1/mocks/mock_aws_clusters_connection.h index 3b912ff738f54..24ed867648e6f 100644 --- a/google/cloud/gkemulticloud/v1/mocks/mock_aws_clusters_connection.h +++ b/google/cloud/gkemulticloud/v1/mocks/mock_aws_clusters_connection.h @@ -47,40 +47,80 @@ class MockAwsClustersConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateAwsCluster)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateAwsCluster(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateAwsCluster(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateAwsCluster, (google::cloud::gkemulticloud::v1::CreateAwsClusterRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateAwsCluster(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateAwsCluster, (NoAwaitTag, google::cloud::gkemulticloud::v1::CreateAwsClusterRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateAwsCluster(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateAwsCluster, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateAwsCluster)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateAwsCluster(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateAwsCluster(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateAwsCluster, (google::cloud::gkemulticloud::v1::UpdateAwsClusterRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateAwsCluster(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateAwsCluster, (NoAwaitTag, google::cloud::gkemulticloud::v1::UpdateAwsClusterRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateAwsCluster(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateAwsCluster, (google::longrunning::Operation const& operation), (override)); @@ -96,9 +136,15 @@ class MockAwsClustersConnection (google::cloud::gkemulticloud::v1::ListAwsClustersRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteAwsCluster)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteAwsCluster(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteAwsCluster(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteAwsCluster, @@ -106,12 +152,26 @@ class MockAwsClustersConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteAwsCluster(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteAwsCluster, (NoAwaitTag, google::cloud::gkemulticloud::v1::DeleteAwsClusterRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteAwsCluster(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteAwsCluster, (google::longrunning::Operation const& operation), @@ -132,47 +192,93 @@ class MockAwsClustersConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateAwsNodePool)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateAwsNodePool(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateAwsNodePool(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateAwsNodePool, (google::cloud::gkemulticloud::v1::CreateAwsNodePoolRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateAwsNodePool(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateAwsNodePool, (NoAwaitTag, google::cloud::gkemulticloud::v1::CreateAwsNodePoolRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateAwsNodePool(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateAwsNodePool, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateAwsNodePool)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateAwsNodePool(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateAwsNodePool(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateAwsNodePool, (google::cloud::gkemulticloud::v1::UpdateAwsNodePoolRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateAwsNodePool(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateAwsNodePool, (NoAwaitTag, google::cloud::gkemulticloud::v1::UpdateAwsNodePoolRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateAwsNodePool(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateAwsNodePool, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, RollbackAwsNodePoolUpdate)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, RollbackAwsNodePoolUpdate(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RollbackAwsNodePoolUpdate(Matcher(_))) + /// @endcode MOCK_METHOD( future>, RollbackAwsNodePoolUpdate, @@ -180,6 +286,12 @@ class MockAwsClustersConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, RollbackAwsNodePoolUpdate(_, _)) + /// @endcode MOCK_METHOD( StatusOr, RollbackAwsNodePoolUpdate, (NoAwaitTag, @@ -187,6 +299,15 @@ class MockAwsClustersConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RollbackAwsNodePoolUpdate(Matcher(_))) + /// @endcode MOCK_METHOD(future>, RollbackAwsNodePoolUpdate, (google::longrunning::Operation const& operation), (override)); @@ -202,9 +323,15 @@ class MockAwsClustersConnection (google::cloud::gkemulticloud::v1::ListAwsNodePoolsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteAwsNodePool)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteAwsNodePool(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteAwsNodePool(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteAwsNodePool, @@ -212,12 +339,26 @@ class MockAwsClustersConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteAwsNodePool(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteAwsNodePool, (NoAwaitTag, google::cloud::gkemulticloud::v1::DeleteAwsNodePoolRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteAwsNodePool(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteAwsNodePool, (google::longrunning::Operation const& operation), diff --git a/google/cloud/gkemulticloud/v1/mocks/mock_azure_clusters_connection.h b/google/cloud/gkemulticloud/v1/mocks/mock_azure_clusters_connection.h index 2548ae2cb6d80..41659c327b496 100644 --- a/google/cloud/gkemulticloud/v1/mocks/mock_azure_clusters_connection.h +++ b/google/cloud/gkemulticloud/v1/mocks/mock_azure_clusters_connection.h @@ -47,21 +47,41 @@ class MockAzureClustersConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateAzureClient)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateAzureClient(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateAzureClient(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateAzureClient, (google::cloud::gkemulticloud::v1::CreateAzureClientRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateAzureClient(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateAzureClient, (NoAwaitTag, google::cloud::gkemulticloud::v1::CreateAzureClientRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateAzureClient(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateAzureClient, (google::longrunning::Operation const& operation), (override)); @@ -77,9 +97,15 @@ class MockAzureClustersConnection (google::cloud::gkemulticloud::v1::ListAzureClientsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteAzureClient)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteAzureClient(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteAzureClient(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteAzureClient, @@ -87,20 +113,40 @@ class MockAzureClustersConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteAzureClient(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteAzureClient, (NoAwaitTag, google::cloud::gkemulticloud::v1::DeleteAzureClientRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteAzureClient(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteAzureClient, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateAzureCluster)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateAzureCluster(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateAzureCluster(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateAzureCluster, @@ -108,6 +154,12 @@ class MockAzureClustersConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateAzureCluster(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateAzureCluster, (NoAwaitTag, @@ -115,13 +167,27 @@ class MockAzureClustersConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateAzureCluster(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateAzureCluster, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateAzureCluster)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateAzureCluster(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateAzureCluster(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateAzureCluster, @@ -129,6 +195,12 @@ class MockAzureClustersConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateAzureCluster(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateAzureCluster, (NoAwaitTag, @@ -136,6 +208,14 @@ class MockAzureClustersConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateAzureCluster(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateAzureCluster, (google::longrunning::Operation const& operation), (override)); @@ -151,9 +231,15 @@ class MockAzureClustersConnection (google::cloud::gkemulticloud::v1::ListAzureClustersRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteAzureCluster)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteAzureCluster(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteAzureCluster(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteAzureCluster, @@ -161,6 +247,12 @@ class MockAzureClustersConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteAzureCluster(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteAzureCluster, (NoAwaitTag, @@ -168,6 +260,14 @@ class MockAzureClustersConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteAzureCluster(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteAzureCluster, (google::longrunning::Operation const& operation), @@ -188,9 +288,15 @@ class MockAzureClustersConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateAzureNodePool)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateAzureNodePool(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateAzureNodePool(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateAzureNodePool, @@ -198,6 +304,12 @@ class MockAzureClustersConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateAzureNodePool(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateAzureNodePool, (NoAwaitTag, @@ -205,13 +317,27 @@ class MockAzureClustersConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateAzureNodePool(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateAzureNodePool, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateAzureNodePool)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateAzureNodePool(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateAzureNodePool(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateAzureNodePool, @@ -219,6 +345,12 @@ class MockAzureClustersConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateAzureNodePool(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateAzureNodePool, (NoAwaitTag, @@ -226,6 +358,14 @@ class MockAzureClustersConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateAzureNodePool(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateAzureNodePool, (google::longrunning::Operation const& operation), (override)); @@ -242,9 +382,15 @@ class MockAzureClustersConnection (google::cloud::gkemulticloud::v1::ListAzureNodePoolsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteAzureNodePool)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteAzureNodePool(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteAzureNodePool(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteAzureNodePool, @@ -252,6 +398,12 @@ class MockAzureClustersConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteAzureNodePool(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteAzureNodePool, (NoAwaitTag, @@ -259,6 +411,14 @@ class MockAzureClustersConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteAzureNodePool(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteAzureNodePool, (google::longrunning::Operation const& operation), diff --git a/google/cloud/iam/v2/mocks/mock_policies_connection.h b/google/cloud/iam/v2/mocks/mock_policies_connection.h index 01c90d798844c..024b1a76c11fb 100644 --- a/google/cloud/iam/v2/mocks/mock_policies_connection.h +++ b/google/cloud/iam/v2/mocks/mock_policies_connection.h @@ -52,45 +52,102 @@ class MockPoliciesConnection : public iam_v2::PoliciesConnection { MOCK_METHOD(StatusOr, GetPolicy, (google::iam::v2::GetPolicyRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreatePolicy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreatePolicy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreatePolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreatePolicy, (google::iam::v2::CreatePolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreatePolicy(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreatePolicy, (NoAwaitTag, google::iam::v2::CreatePolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreatePolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreatePolicy, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdatePolicy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdatePolicy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdatePolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdatePolicy, (google::iam::v2::UpdatePolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdatePolicy(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdatePolicy, (NoAwaitTag, google::iam::v2::UpdatePolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdatePolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdatePolicy, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeletePolicy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeletePolicy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeletePolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeletePolicy, (google::iam::v2::DeletePolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeletePolicy(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeletePolicy, (NoAwaitTag, google::iam::v2::DeletePolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeletePolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeletePolicy, (google::longrunning::Operation const& operation), (override)); }; diff --git a/google/cloud/ids/v1/mocks/mock_ids_connection.h b/google/cloud/ids/v1/mocks/mock_ids_connection.h index 526b914f7c28e..1c47bbb2b9b99 100644 --- a/google/cloud/ids/v1/mocks/mock_ids_connection.h +++ b/google/cloud/ids/v1/mocks/mock_ids_connection.h @@ -54,36 +54,76 @@ class MockIDSConnection : public ids_v1::IDSConnection { (google::cloud::ids::v1::GetEndpointRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateEndpoint)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateEndpoint(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateEndpoint(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateEndpoint, (google::cloud::ids::v1::CreateEndpointRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateEndpoint(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateEndpoint, (NoAwaitTag, google::cloud::ids::v1::CreateEndpointRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateEndpoint(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateEndpoint, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteEndpoint)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteEndpoint(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteEndpoint(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteEndpoint, (google::cloud::ids::v1::DeleteEndpointRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteEndpoint(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteEndpoint, (NoAwaitTag, google::cloud::ids::v1::DeleteEndpointRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteEndpoint(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteEndpoint, (google::longrunning::Operation const& operation), (override)); diff --git a/google/cloud/kms/v1/mocks/mock_autokey_connection.h b/google/cloud/kms/v1/mocks/mock_autokey_connection.h index 9e6b03376ee54..14dd1c8750cc2 100644 --- a/google/cloud/kms/v1/mocks/mock_autokey_connection.h +++ b/google/cloud/kms/v1/mocks/mock_autokey_connection.h @@ -46,19 +46,39 @@ class MockAutokeyConnection : public kms_v1::AutokeyConnection { public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateKeyHandle)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateKeyHandle(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateKeyHandle(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateKeyHandle, (google::cloud::kms::v1::CreateKeyHandleRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateKeyHandle(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateKeyHandle, (NoAwaitTag, google::cloud::kms::v1::CreateKeyHandleRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateKeyHandle(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateKeyHandle, (google::longrunning::Operation const& operation), (override)); diff --git a/google/cloud/logging/v2/mocks/mock_config_service_v2_connection.h b/google/cloud/logging/v2/mocks/mock_config_service_v2_connection.h index aee9c33e3728d..2d290bd8e6ee1 100644 --- a/google/cloud/logging/v2/mocks/mock_config_service_v2_connection.h +++ b/google/cloud/logging/v2/mocks/mock_config_service_v2_connection.h @@ -54,36 +54,76 @@ class MockConfigServiceV2Connection (google::logging::v2::GetBucketRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateBucketAsync)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateBucketAsync(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateBucketAsync(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateBucketAsync, (google::logging::v2::CreateBucketRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateBucketAsync(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateBucketAsync, (NoAwaitTag, google::logging::v2::CreateBucketRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateBucketAsync(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateBucketAsync, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateBucketAsync)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateBucketAsync(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateBucketAsync(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateBucketAsync, (google::logging::v2::UpdateBucketRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateBucketAsync(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateBucketAsync, (NoAwaitTag, google::logging::v2::UpdateBucketRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateBucketAsync(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateBucketAsync, (google::longrunning::Operation const& operation), (override)); @@ -140,33 +180,71 @@ class MockConfigServiceV2Connection (google::logging::v2::DeleteSinkRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateLink)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateLink(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateLink(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateLink, (google::logging::v2::CreateLinkRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateLink(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateLink, (NoAwaitTag, google::logging::v2::CreateLinkRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateLink(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateLink, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteLink)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteLink(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteLink(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteLink, (google::logging::v2::DeleteLinkRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteLink(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteLink, (NoAwaitTag, google::logging::v2::DeleteLinkRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteLink(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteLink, (google::longrunning::Operation const& operation), (override)); @@ -211,19 +289,39 @@ class MockConfigServiceV2Connection (google::logging::v2::UpdateSettingsRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CopyLogEntries)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CopyLogEntries(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CopyLogEntries(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CopyLogEntries, (google::logging::v2::CopyLogEntriesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CopyLogEntries(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CopyLogEntries, (NoAwaitTag, google::logging::v2::CopyLogEntriesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CopyLogEntries(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CopyLogEntries, (google::longrunning::Operation const& operation), (override)); diff --git a/google/cloud/managedidentities/v1/mocks/mock_managed_identities_connection.h b/google/cloud/managedidentities/v1/mocks/mock_managed_identities_connection.h index 989efbdc66c42..7ee15f0ea8fb8 100644 --- a/google/cloud/managedidentities/v1/mocks/mock_managed_identities_connection.h +++ b/google/cloud/managedidentities/v1/mocks/mock_managed_identities_connection.h @@ -47,20 +47,41 @@ class MockManagedIdentitiesServiceConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateMicrosoftAdDomain)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateMicrosoftAdDomain(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateMicrosoftAdDomain(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateMicrosoftAdDomain, (google::cloud::managedidentities::v1:: CreateMicrosoftAdDomainRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateMicrosoftAdDomain(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateMicrosoftAdDomain, (NoAwaitTag, google::cloud::managedidentities::v1:: CreateMicrosoftAdDomainRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateMicrosoftAdDomain(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateMicrosoftAdDomain, (google::longrunning::Operation const& operation), (override)); @@ -83,28 +104,54 @@ class MockManagedIdentitiesServiceConnection (google::cloud::managedidentities::v1::GetDomainRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateDomain)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateDomain(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateDomain(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateDomain, (google::cloud::managedidentities::v1::UpdateDomainRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateDomain(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateDomain, (NoAwaitTag, google::cloud::managedidentities::v1::UpdateDomainRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateDomain(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateDomain, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteDomain)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteDomain(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteDomain(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteDomain, @@ -112,39 +159,79 @@ class MockManagedIdentitiesServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteDomain(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteDomain, (NoAwaitTag, google::cloud::managedidentities::v1::DeleteDomainRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteDomain(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteDomain, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, AttachTrust)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, AttachTrust(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// AttachTrust(Matcher(_))) + /// @endcode MOCK_METHOD( future>, AttachTrust, (google::cloud::managedidentities::v1::AttachTrustRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, AttachTrust(_, _)) + /// @endcode MOCK_METHOD( StatusOr, AttachTrust, (NoAwaitTag, google::cloud::managedidentities::v1::AttachTrustRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, AttachTrust(Matcher(_))) + /// @endcode MOCK_METHOD(future>, AttachTrust, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ReconfigureTrust)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ReconfigureTrust(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ReconfigureTrust(Matcher(_))) + /// @endcode MOCK_METHOD( future>, ReconfigureTrust, @@ -152,6 +239,12 @@ class MockManagedIdentitiesServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ReconfigureTrust(_, _)) + /// @endcode MOCK_METHOD( StatusOr, ReconfigureTrust, (NoAwaitTag, @@ -159,44 +252,92 @@ class MockManagedIdentitiesServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, ReconfigureTrust(Matcher(_))) + /// @endcode MOCK_METHOD(future>, ReconfigureTrust, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DetachTrust)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DetachTrust(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DetachTrust(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DetachTrust, (google::cloud::managedidentities::v1::DetachTrustRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DetachTrust(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DetachTrust, (NoAwaitTag, google::cloud::managedidentities::v1::DetachTrustRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DetachTrust(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DetachTrust, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ValidateTrust)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ValidateTrust(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ValidateTrust(Matcher(_))) + /// @endcode MOCK_METHOD(future>, ValidateTrust, (google::cloud::managedidentities::v1::ValidateTrustRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ValidateTrust(_, _)) + /// @endcode MOCK_METHOD(StatusOr, ValidateTrust, (NoAwaitTag, google::cloud::managedidentities::v1::ValidateTrustRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, ValidateTrust(Matcher(_))) + /// @endcode MOCK_METHOD(future>, ValidateTrust, (google::longrunning::Operation const& operation), (override)); diff --git a/google/cloud/managedkafka/v1/mocks/mock_managed_kafka_connection.h b/google/cloud/managedkafka/v1/mocks/mock_managed_kafka_connection.h index e6e1d52adf620..f6245087c42df 100644 --- a/google/cloud/managedkafka/v1/mocks/mock_managed_kafka_connection.h +++ b/google/cloud/managedkafka/v1/mocks/mock_managed_kafka_connection.h @@ -57,57 +57,117 @@ class MockManagedKafkaConnection (google::cloud::managedkafka::v1::GetClusterRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateCluster)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateCluster(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateCluster(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateCluster, (google::cloud::managedkafka::v1::CreateClusterRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateCluster(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateCluster, (NoAwaitTag, google::cloud::managedkafka::v1::CreateClusterRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateCluster(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateCluster, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateCluster)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateCluster(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateCluster(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateCluster, (google::cloud::managedkafka::v1::UpdateClusterRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateCluster(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateCluster, (NoAwaitTag, google::cloud::managedkafka::v1::UpdateClusterRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateCluster(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateCluster, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteCluster)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteCluster(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteCluster(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteCluster, (google::cloud::managedkafka::v1::DeleteClusterRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteCluster(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteCluster, (NoAwaitTag, google::cloud::managedkafka::v1::DeleteClusterRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteCluster(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteCluster, (google::longrunning::Operation const& operation), diff --git a/google/cloud/memcache/v1/mocks/mock_cloud_memcache_connection.h b/google/cloud/memcache/v1/mocks/mock_cloud_memcache_connection.h index 25a1667d68976..64da16af52482 100644 --- a/google/cloud/memcache/v1/mocks/mock_cloud_memcache_connection.h +++ b/google/cloud/memcache/v1/mocks/mock_cloud_memcache_connection.h @@ -56,112 +56,232 @@ class MockCloudMemcacheConnection (google::cloud::memcache::v1::GetInstanceRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateInstance)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateInstance(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateInstance(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateInstance, (google::cloud::memcache::v1::CreateInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateInstance(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateInstance, (NoAwaitTag, google::cloud::memcache::v1::CreateInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateInstance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateInstance, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateInstance)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateInstance(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateInstance(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateInstance, (google::cloud::memcache::v1::UpdateInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateInstance(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateInstance, (NoAwaitTag, google::cloud::memcache::v1::UpdateInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateInstance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateInstance, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateParameters)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateParameters(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateParameters(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateParameters, (google::cloud::memcache::v1::UpdateParametersRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateParameters(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateParameters, (NoAwaitTag, google::cloud::memcache::v1::UpdateParametersRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateParameters(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateParameters, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteInstance)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteInstance(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteInstance(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteInstance, (google::cloud::memcache::v1::DeleteInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteInstance(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteInstance, (NoAwaitTag, google::cloud::memcache::v1::DeleteInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteInstance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteInstance, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ApplyParameters)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ApplyParameters(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ApplyParameters(Matcher(_))) + /// @endcode MOCK_METHOD( future>, ApplyParameters, (google::cloud::memcache::v1::ApplyParametersRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ApplyParameters(_, _)) + /// @endcode MOCK_METHOD( StatusOr, ApplyParameters, (NoAwaitTag, google::cloud::memcache::v1::ApplyParametersRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, ApplyParameters(Matcher(_))) + /// @endcode MOCK_METHOD(future>, ApplyParameters, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, RescheduleMaintenance)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, RescheduleMaintenance(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RescheduleMaintenance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, RescheduleMaintenance, (google::cloud::memcache::v1::RescheduleMaintenanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, RescheduleMaintenance(_, _)) + /// @endcode MOCK_METHOD(StatusOr, RescheduleMaintenance, (NoAwaitTag, google::cloud::memcache::v1::RescheduleMaintenanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RescheduleMaintenance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, RescheduleMaintenance, (google::longrunning::Operation const& operation), (override)); diff --git a/google/cloud/metastore/v1/mocks/mock_dataproc_metastore_connection.h b/google/cloud/metastore/v1/mocks/mock_dataproc_metastore_connection.h index 13c206e9a9f0d..347fa58a63b9e 100644 --- a/google/cloud/metastore/v1/mocks/mock_dataproc_metastore_connection.h +++ b/google/cloud/metastore/v1/mocks/mock_dataproc_metastore_connection.h @@ -56,57 +56,117 @@ class MockDataprocMetastoreConnection (google::cloud::metastore::v1::GetServiceRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateService)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateService(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateService(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateService, (google::cloud::metastore::v1::CreateServiceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateService(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateService, (NoAwaitTag, google::cloud::metastore::v1::CreateServiceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateService(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateService, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateService)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateService(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateService(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateService, (google::cloud::metastore::v1::UpdateServiceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateService(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateService, (NoAwaitTag, google::cloud::metastore::v1::UpdateServiceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateService(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateService, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteService)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteService(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteService(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteService, (google::cloud::metastore::v1::DeleteServiceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteService(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteService, (NoAwaitTag, google::cloud::metastore::v1::DeleteServiceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteService(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteService, (google::longrunning::Operation const& operation), (override)); @@ -122,77 +182,157 @@ class MockDataprocMetastoreConnection (google::cloud::metastore::v1::GetMetadataImportRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateMetadataImport)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateMetadataImport(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateMetadataImport(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateMetadataImport, (google::cloud::metastore::v1::CreateMetadataImportRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateMetadataImport(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateMetadataImport, (NoAwaitTag, google::cloud::metastore::v1::CreateMetadataImportRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateMetadataImport(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateMetadataImport, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateMetadataImport)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateMetadataImport(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateMetadataImport(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateMetadataImport, (google::cloud::metastore::v1::UpdateMetadataImportRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateMetadataImport(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateMetadataImport, (NoAwaitTag, google::cloud::metastore::v1::UpdateMetadataImportRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateMetadataImport(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateMetadataImport, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ExportMetadata)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ExportMetadata(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ExportMetadata(Matcher(_))) + /// @endcode MOCK_METHOD( future>, ExportMetadata, (google::cloud::metastore::v1::ExportMetadataRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ExportMetadata(_, _)) + /// @endcode MOCK_METHOD( StatusOr, ExportMetadata, (NoAwaitTag, google::cloud::metastore::v1::ExportMetadataRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, ExportMetadata(Matcher(_))) + /// @endcode MOCK_METHOD(future>, ExportMetadata, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, RestoreService)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, RestoreService(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RestoreService(Matcher(_))) + /// @endcode MOCK_METHOD( future>, RestoreService, (google::cloud::metastore::v1::RestoreServiceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, RestoreService(_, _)) + /// @endcode MOCK_METHOD( StatusOr, RestoreService, (NoAwaitTag, google::cloud::metastore::v1::RestoreServiceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, RestoreService(Matcher(_))) + /// @endcode MOCK_METHOD(future>, RestoreService, (google::longrunning::Operation const& operation), (override)); @@ -205,66 +345,132 @@ class MockDataprocMetastoreConnection (google::cloud::metastore::v1::GetBackupRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateBackup)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateBackup(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateBackup(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateBackup, (google::cloud::metastore::v1::CreateBackupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateBackup(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateBackup, (NoAwaitTag, google::cloud::metastore::v1::CreateBackupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateBackup(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateBackup, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteBackup)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteBackup(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteBackup(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteBackup, (google::cloud::metastore::v1::DeleteBackupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteBackup(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteBackup, (NoAwaitTag, google::cloud::metastore::v1::DeleteBackupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteBackup(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteBackup, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, QueryMetadata)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, QueryMetadata(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// QueryMetadata(Matcher(_))) + /// @endcode MOCK_METHOD( future>, QueryMetadata, (google::cloud::metastore::v1::QueryMetadataRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, QueryMetadata(_, _)) + /// @endcode MOCK_METHOD( StatusOr, QueryMetadata, (NoAwaitTag, google::cloud::metastore::v1::QueryMetadataRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, QueryMetadata(Matcher(_))) + /// @endcode MOCK_METHOD( future>, QueryMetadata, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, MoveTableToDatabase)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, MoveTableToDatabase(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// MoveTableToDatabase(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, @@ -272,21 +478,41 @@ class MockDataprocMetastoreConnection (google::cloud::metastore::v1::MoveTableToDatabaseRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, MoveTableToDatabase(_, _)) + /// @endcode MOCK_METHOD( StatusOr, MoveTableToDatabase, (NoAwaitTag, google::cloud::metastore::v1::MoveTableToDatabaseRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// MoveTableToDatabase(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, MoveTableToDatabase, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, AlterMetadataResourceLocation)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, AlterMetadataResourceLocation(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// AlterMetadataResourceLocation(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -295,6 +521,12 @@ class MockDataprocMetastoreConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, AlterMetadataResourceLocation(_, _)) + /// @endcode MOCK_METHOD( StatusOr, AlterMetadataResourceLocation, (NoAwaitTag, @@ -302,6 +534,15 @@ class MockDataprocMetastoreConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// AlterMetadataResourceLocation(Matcher(_))) + /// @endcode MOCK_METHOD( future>, diff --git a/google/cloud/metastore/v1/mocks/mock_dataproc_metastore_federation_connection.h b/google/cloud/metastore/v1/mocks/mock_dataproc_metastore_federation_connection.h index 7e5a7b2fc5396..6c8a0e440e928 100644 --- a/google/cloud/metastore/v1/mocks/mock_dataproc_metastore_federation_connection.h +++ b/google/cloud/metastore/v1/mocks/mock_dataproc_metastore_federation_connection.h @@ -57,59 +57,119 @@ class MockDataprocMetastoreFederationConnection (google::cloud::metastore::v1::GetFederationRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateFederation)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateFederation(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateFederation(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateFederation, (google::cloud::metastore::v1::CreateFederationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateFederation(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateFederation, (NoAwaitTag, google::cloud::metastore::v1::CreateFederationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateFederation(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateFederation, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateFederation)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateFederation(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateFederation(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateFederation, (google::cloud::metastore::v1::UpdateFederationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateFederation(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateFederation, (NoAwaitTag, google::cloud::metastore::v1::UpdateFederationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateFederation(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateFederation, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteFederation)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteFederation(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteFederation(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteFederation, (google::cloud::metastore::v1::DeleteFederationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteFederation(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteFederation, (NoAwaitTag, google::cloud::metastore::v1::DeleteFederationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteFederation(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteFederation, (google::longrunning::Operation const& operation), (override)); diff --git a/google/cloud/migrationcenter/v1/mocks/mock_migration_center_connection.h b/google/cloud/migrationcenter/v1/mocks/mock_migration_center_connection.h index 280ca1f58ade0..51b4140abed47 100644 --- a/google/cloud/migrationcenter/v1/mocks/mock_migration_center_connection.h +++ b/google/cloud/migrationcenter/v1/mocks/mock_migration_center_connection.h @@ -95,21 +95,41 @@ class MockMigrationCenterConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateImportJob)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateImportJob(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateImportJob(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateImportJob, (google::cloud::migrationcenter::v1::CreateImportJobRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateImportJob(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateImportJob, (NoAwaitTag, google::cloud::migrationcenter::v1::CreateImportJobRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateImportJob(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateImportJob, (google::longrunning::Operation const& operation), (override)); @@ -125,9 +145,15 @@ class MockMigrationCenterConnection (google::cloud::migrationcenter::v1::GetImportJobRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteImportJob)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteImportJob(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteImportJob(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteImportJob, @@ -135,39 +161,79 @@ class MockMigrationCenterConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteImportJob(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteImportJob, (NoAwaitTag, google::cloud::migrationcenter::v1::DeleteImportJobRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteImportJob(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteImportJob, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateImportJob)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateImportJob(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateImportJob(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateImportJob, (google::cloud::migrationcenter::v1::UpdateImportJobRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateImportJob(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateImportJob, (NoAwaitTag, google::cloud::migrationcenter::v1::UpdateImportJobRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateImportJob(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateImportJob, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ValidateImportJob)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ValidateImportJob(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ValidateImportJob(Matcher(_))) + /// @endcode MOCK_METHOD( future>, ValidateImportJob, @@ -175,6 +241,12 @@ class MockMigrationCenterConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ValidateImportJob(_, _)) + /// @endcode MOCK_METHOD( StatusOr, ValidateImportJob, (NoAwaitTag, @@ -182,26 +254,54 @@ class MockMigrationCenterConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ValidateImportJob(Matcher(_))) + /// @endcode MOCK_METHOD( future>, ValidateImportJob, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, RunImportJob)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, RunImportJob(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RunImportJob(Matcher(_))) + /// @endcode MOCK_METHOD( future>, RunImportJob, (google::cloud::migrationcenter::v1::RunImportJobRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, RunImportJob(_, _)) + /// @endcode MOCK_METHOD( StatusOr, RunImportJob, (NoAwaitTag, google::cloud::migrationcenter::v1::RunImportJobRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, RunImportJob(Matcher(_))) + /// @endcode MOCK_METHOD( future>, RunImportJob, (google::longrunning::Operation const& operation), @@ -220,9 +320,15 @@ class MockMigrationCenterConnection (google::cloud::migrationcenter::v1::ListImportDataFilesRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateImportDataFile)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateImportDataFile(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateImportDataFile(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateImportDataFile, @@ -230,6 +336,12 @@ class MockMigrationCenterConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateImportDataFile(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateImportDataFile, (NoAwaitTag, @@ -237,14 +349,28 @@ class MockMigrationCenterConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateImportDataFile(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateImportDataFile, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteImportDataFile)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteImportDataFile(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteImportDataFile(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteImportDataFile, @@ -252,6 +378,12 @@ class MockMigrationCenterConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteImportDataFile(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteImportDataFile, (NoAwaitTag, @@ -259,6 +391,14 @@ class MockMigrationCenterConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteImportDataFile(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteImportDataFile, (google::longrunning::Operation const& operation), @@ -274,65 +414,131 @@ class MockMigrationCenterConnection (google::cloud::migrationcenter::v1::GetGroupRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateGroup)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateGroup(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateGroup(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateGroup, (google::cloud::migrationcenter::v1::CreateGroupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateGroup(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateGroup, (NoAwaitTag, google::cloud::migrationcenter::v1::CreateGroupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateGroup(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateGroup, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateGroup)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateGroup(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateGroup(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateGroup, (google::cloud::migrationcenter::v1::UpdateGroupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateGroup(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateGroup, (NoAwaitTag, google::cloud::migrationcenter::v1::UpdateGroupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateGroup(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateGroup, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteGroup)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteGroup(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteGroup(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteGroup, (google::cloud::migrationcenter::v1::DeleteGroupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteGroup(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteGroup, (NoAwaitTag, google::cloud::migrationcenter::v1::DeleteGroupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteGroup(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteGroup, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, AddAssetsToGroup)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, AddAssetsToGroup(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// AddAssetsToGroup(Matcher(_))) + /// @endcode MOCK_METHOD( future>, AddAssetsToGroup, @@ -340,6 +546,12 @@ class MockMigrationCenterConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, AddAssetsToGroup(_, _)) + /// @endcode MOCK_METHOD( StatusOr, AddAssetsToGroup, (NoAwaitTag, @@ -347,13 +559,27 @@ class MockMigrationCenterConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, AddAssetsToGroup(Matcher(_))) + /// @endcode MOCK_METHOD(future>, AddAssetsToGroup, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, RemoveAssetsFromGroup)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, RemoveAssetsFromGroup(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RemoveAssetsFromGroup(Matcher(_))) + /// @endcode MOCK_METHOD( future>, RemoveAssetsFromGroup, @@ -361,6 +587,12 @@ class MockMigrationCenterConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, RemoveAssetsFromGroup(_, _)) + /// @endcode MOCK_METHOD( StatusOr, RemoveAssetsFromGroup, (NoAwaitTag, @@ -368,6 +600,14 @@ class MockMigrationCenterConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RemoveAssetsFromGroup(Matcher(_))) + /// @endcode MOCK_METHOD(future>, RemoveAssetsFromGroup, (google::longrunning::Operation const& operation), (override)); @@ -393,59 +633,119 @@ class MockMigrationCenterConnection (google::cloud::migrationcenter::v1::GetSourceRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateSource)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateSource(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateSource(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateSource, (google::cloud::migrationcenter::v1::CreateSourceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateSource(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateSource, (NoAwaitTag, google::cloud::migrationcenter::v1::CreateSourceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateSource(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateSource, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateSource)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateSource(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateSource(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateSource, (google::cloud::migrationcenter::v1::UpdateSourceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateSource(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateSource, (NoAwaitTag, google::cloud::migrationcenter::v1::UpdateSourceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateSource(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateSource, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteSource)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteSource(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteSource(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteSource, (google::cloud::migrationcenter::v1::DeleteSourceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteSource(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteSource, (NoAwaitTag, google::cloud::migrationcenter::v1::DeleteSourceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteSource(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteSource, (google::longrunning::Operation const& operation), @@ -464,9 +764,15 @@ class MockMigrationCenterConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreatePreferenceSet)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreatePreferenceSet(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreatePreferenceSet(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreatePreferenceSet, @@ -474,6 +780,12 @@ class MockMigrationCenterConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreatePreferenceSet(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreatePreferenceSet, (NoAwaitTag, @@ -481,14 +793,28 @@ class MockMigrationCenterConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreatePreferenceSet(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreatePreferenceSet, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdatePreferenceSet)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdatePreferenceSet(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdatePreferenceSet(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdatePreferenceSet, @@ -496,6 +822,12 @@ class MockMigrationCenterConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdatePreferenceSet(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdatePreferenceSet, (NoAwaitTag, @@ -503,14 +835,28 @@ class MockMigrationCenterConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdatePreferenceSet(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdatePreferenceSet, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeletePreferenceSet)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeletePreferenceSet(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeletePreferenceSet(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeletePreferenceSet, @@ -518,6 +864,12 @@ class MockMigrationCenterConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeletePreferenceSet(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeletePreferenceSet, (NoAwaitTag, @@ -525,6 +877,14 @@ class MockMigrationCenterConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeletePreferenceSet(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeletePreferenceSet, (google::longrunning::Operation const& operation), @@ -535,28 +895,54 @@ class MockMigrationCenterConnection (google::cloud::migrationcenter::v1::GetSettingsRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateSettings)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateSettings(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateSettings(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateSettings, (google::cloud::migrationcenter::v1::UpdateSettingsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateSettings(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateSettings, (NoAwaitTag, google::cloud::migrationcenter::v1::UpdateSettingsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateSettings(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateSettings, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateReportConfig)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateReportConfig(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateReportConfig(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateReportConfig, @@ -564,6 +950,12 @@ class MockMigrationCenterConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateReportConfig(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateReportConfig, (NoAwaitTag, @@ -571,6 +963,14 @@ class MockMigrationCenterConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateReportConfig(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateReportConfig, (google::longrunning::Operation const& operation), @@ -588,9 +988,15 @@ class MockMigrationCenterConnection (google::cloud::migrationcenter::v1::ListReportConfigsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteReportConfig)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteReportConfig(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteReportConfig(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteReportConfig, @@ -598,6 +1004,12 @@ class MockMigrationCenterConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteReportConfig(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteReportConfig, (NoAwaitTag, @@ -605,26 +1017,54 @@ class MockMigrationCenterConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteReportConfig(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteReportConfig, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateReport)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateReport(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateReport(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateReport, (google::cloud::migrationcenter::v1::CreateReportRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateReport(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateReport, (NoAwaitTag, google::cloud::migrationcenter::v1::CreateReportRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateReport(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateReport, (google::longrunning::Operation const& operation), (override)); @@ -639,21 +1079,41 @@ class MockMigrationCenterConnection (google::cloud::migrationcenter::v1::ListReportsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteReport)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteReport(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteReport(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteReport, (google::cloud::migrationcenter::v1::DeleteReportRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteReport(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteReport, (NoAwaitTag, google::cloud::migrationcenter::v1::DeleteReportRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteReport(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteReport, (google::longrunning::Operation const& operation), diff --git a/google/cloud/monitoring/metricsscope/v1/mocks/mock_metrics_scopes_connection.h b/google/cloud/monitoring/metricsscope/v1/mocks/mock_metrics_scopes_connection.h index 2c7eb275001aa..2d099a552ad65 100644 --- a/google/cloud/monitoring/metricsscope/v1/mocks/mock_metrics_scopes_connection.h +++ b/google/cloud/monitoring/metricsscope/v1/mocks/mock_metrics_scopes_connection.h @@ -61,9 +61,15 @@ class MockMetricsScopesConnection ListMetricsScopesByMonitoredProjectRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateMonitoredProject)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateMonitoredProject(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateMonitoredProject(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateMonitoredProject, @@ -71,19 +77,39 @@ class MockMetricsScopesConnection CreateMonitoredProjectRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateMonitoredProject(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateMonitoredProject, (NoAwaitTag, google::monitoring::metricsscope::v1:: CreateMonitoredProjectRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateMonitoredProject(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateMonitoredProject, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteMonitoredProject)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteMonitoredProject(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteMonitoredProject(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteMonitoredProject, @@ -91,11 +117,25 @@ class MockMetricsScopesConnection DeleteMonitoredProjectRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteMonitoredProject(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteMonitoredProject, (NoAwaitTag, google::monitoring::metricsscope::v1:: DeleteMonitoredProjectRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteMonitoredProject(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteMonitoredProject, (google::longrunning::Operation const& operation), diff --git a/google/cloud/netapp/v1/mocks/mock_net_app_connection.h b/google/cloud/netapp/v1/mocks/mock_net_app_connection.h index 4b9b390f770cd..f93896f3e765c 100644 --- a/google/cloud/netapp/v1/mocks/mock_net_app_connection.h +++ b/google/cloud/netapp/v1/mocks/mock_net_app_connection.h @@ -51,21 +51,41 @@ class MockNetAppConnection : public netapp_v1::NetAppConnection { (google::cloud::netapp::v1::ListStoragePoolsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateStoragePool)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateStoragePool(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateStoragePool(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateStoragePool, (google::cloud::netapp::v1::CreateStoragePoolRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateStoragePool(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateStoragePool, (NoAwaitTag, google::cloud::netapp::v1::CreateStoragePoolRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateStoragePool(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateStoragePool, (google::longrunning::Operation const& operation), (override)); @@ -74,40 +94,80 @@ class MockNetAppConnection : public netapp_v1::NetAppConnection { (google::cloud::netapp::v1::GetStoragePoolRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateStoragePool)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateStoragePool(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateStoragePool(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateStoragePool, (google::cloud::netapp::v1::UpdateStoragePoolRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateStoragePool(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateStoragePool, (NoAwaitTag, google::cloud::netapp::v1::UpdateStoragePoolRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateStoragePool(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateStoragePool, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteStoragePool)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteStoragePool(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteStoragePool(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteStoragePool, (google::cloud::netapp::v1::DeleteStoragePoolRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteStoragePool(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteStoragePool, (NoAwaitTag, google::cloud::netapp::v1::DeleteStoragePoolRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteStoragePool(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteStoragePool, (google::longrunning::Operation const& operation), (override)); @@ -120,65 +180,145 @@ class MockNetAppConnection : public netapp_v1::NetAppConnection { (google::cloud::netapp::v1::GetVolumeRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateVolume)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateVolume(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateVolume(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateVolume, (google::cloud::netapp::v1::CreateVolumeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateVolume(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateVolume, (NoAwaitTag, google::cloud::netapp::v1::CreateVolumeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateVolume(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateVolume, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateVolume)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateVolume(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateVolume(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateVolume, (google::cloud::netapp::v1::UpdateVolumeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateVolume(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateVolume, (NoAwaitTag, google::cloud::netapp::v1::UpdateVolumeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateVolume(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateVolume, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteVolume)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteVolume(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteVolume(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteVolume, (google::cloud::netapp::v1::DeleteVolumeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteVolume(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteVolume, (NoAwaitTag, google::cloud::netapp::v1::DeleteVolumeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteVolume(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteVolume, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, RevertVolume)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, RevertVolume(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RevertVolume(Matcher(_))) + /// @endcode MOCK_METHOD(future>, RevertVolume, (google::cloud::netapp::v1::RevertVolumeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, RevertVolume(_, _)) + /// @endcode MOCK_METHOD(StatusOr, RevertVolume, (NoAwaitTag, google::cloud::netapp::v1::RevertVolumeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, RevertVolume(Matcher(_))) + /// @endcode MOCK_METHOD(future>, RevertVolume, (google::longrunning::Operation const& operation), (override)); @@ -190,53 +330,113 @@ class MockNetAppConnection : public netapp_v1::NetAppConnection { (google::cloud::netapp::v1::GetSnapshotRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateSnapshot)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateSnapshot(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateSnapshot(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateSnapshot, (google::cloud::netapp::v1::CreateSnapshotRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateSnapshot(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateSnapshot, (NoAwaitTag, google::cloud::netapp::v1::CreateSnapshotRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateSnapshot(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateSnapshot, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteSnapshot)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteSnapshot(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteSnapshot(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteSnapshot, (google::cloud::netapp::v1::DeleteSnapshotRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteSnapshot(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteSnapshot, (NoAwaitTag, google::cloud::netapp::v1::DeleteSnapshotRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteSnapshot(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteSnapshot, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateSnapshot)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateSnapshot(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateSnapshot(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateSnapshot, (google::cloud::netapp::v1::UpdateSnapshotRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateSnapshot(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateSnapshot, (NoAwaitTag, google::cloud::netapp::v1::UpdateSnapshotRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateSnapshot(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateSnapshot, (google::longrunning::Operation const& operation), (override)); @@ -251,59 +451,119 @@ class MockNetAppConnection : public netapp_v1::NetAppConnection { (google::cloud::netapp::v1::GetActiveDirectoryRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateActiveDirectory)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateActiveDirectory(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateActiveDirectory(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateActiveDirectory, (google::cloud::netapp::v1::CreateActiveDirectoryRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateActiveDirectory(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateActiveDirectory, (NoAwaitTag, google::cloud::netapp::v1::CreateActiveDirectoryRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateActiveDirectory(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateActiveDirectory, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateActiveDirectory)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateActiveDirectory(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateActiveDirectory(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateActiveDirectory, (google::cloud::netapp::v1::UpdateActiveDirectoryRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateActiveDirectory(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateActiveDirectory, (NoAwaitTag, google::cloud::netapp::v1::UpdateActiveDirectoryRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateActiveDirectory(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateActiveDirectory, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteActiveDirectory)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteActiveDirectory(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteActiveDirectory(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteActiveDirectory, (google::cloud::netapp::v1::DeleteActiveDirectoryRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteActiveDirectory(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteActiveDirectory, (NoAwaitTag, google::cloud::netapp::v1::DeleteActiveDirectoryRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteActiveDirectory(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteActiveDirectory, (google::longrunning::Operation const& operation), (override)); @@ -313,20 +573,40 @@ class MockNetAppConnection : public netapp_v1::NetAppConnection { (google::cloud::netapp::v1::ListKmsConfigsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateKmsConfig)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateKmsConfig(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateKmsConfig(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateKmsConfig, (google::cloud::netapp::v1::CreateKmsConfigRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateKmsConfig(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateKmsConfig, (NoAwaitTag, google::cloud::netapp::v1::CreateKmsConfigRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateKmsConfig(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateKmsConfig, (google::longrunning::Operation const& operation), (override)); @@ -335,37 +615,77 @@ class MockNetAppConnection : public netapp_v1::NetAppConnection { (google::cloud::netapp::v1::GetKmsConfigRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateKmsConfig)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateKmsConfig(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateKmsConfig(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateKmsConfig, (google::cloud::netapp::v1::UpdateKmsConfigRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateKmsConfig(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateKmsConfig, (NoAwaitTag, google::cloud::netapp::v1::UpdateKmsConfigRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateKmsConfig(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateKmsConfig, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, EncryptVolumes)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, EncryptVolumes(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// EncryptVolumes(Matcher(_))) + /// @endcode MOCK_METHOD(future>, EncryptVolumes, (google::cloud::netapp::v1::EncryptVolumesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, EncryptVolumes(_, _)) + /// @endcode MOCK_METHOD(StatusOr, EncryptVolumes, (NoAwaitTag, google::cloud::netapp::v1::EncryptVolumesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, EncryptVolumes(Matcher(_))) + /// @endcode MOCK_METHOD(future>, EncryptVolumes, (google::longrunning::Operation const& operation), (override)); @@ -376,21 +696,41 @@ class MockNetAppConnection : public netapp_v1::NetAppConnection { (google::cloud::netapp::v1::VerifyKmsConfigRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteKmsConfig)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteKmsConfig(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteKmsConfig(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteKmsConfig, (google::cloud::netapp::v1::DeleteKmsConfigRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteKmsConfig(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteKmsConfig, (NoAwaitTag, google::cloud::netapp::v1::DeleteKmsConfigRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteKmsConfig(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteKmsConfig, (google::longrunning::Operation const& operation), (override)); @@ -404,103 +744,209 @@ class MockNetAppConnection : public netapp_v1::NetAppConnection { (google::cloud::netapp::v1::GetReplicationRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateReplication)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateReplication(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateReplication(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateReplication, (google::cloud::netapp::v1::CreateReplicationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateReplication(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateReplication, (NoAwaitTag, google::cloud::netapp::v1::CreateReplicationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateReplication(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateReplication, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteReplication)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteReplication(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteReplication(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteReplication, (google::cloud::netapp::v1::DeleteReplicationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteReplication(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteReplication, (NoAwaitTag, google::cloud::netapp::v1::DeleteReplicationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteReplication(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteReplication, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateReplication)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateReplication(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateReplication(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateReplication, (google::cloud::netapp::v1::UpdateReplicationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateReplication(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateReplication, (NoAwaitTag, google::cloud::netapp::v1::UpdateReplicationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateReplication(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateReplication, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, StopReplication)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, StopReplication(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// StopReplication(Matcher(_))) + /// @endcode MOCK_METHOD( future>, StopReplication, (google::cloud::netapp::v1::StopReplicationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, StopReplication(_, _)) + /// @endcode MOCK_METHOD( StatusOr, StopReplication, (NoAwaitTag, google::cloud::netapp::v1::StopReplicationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, StopReplication(Matcher(_))) + /// @endcode MOCK_METHOD(future>, StopReplication, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ResumeReplication)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ResumeReplication(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ResumeReplication(Matcher(_))) + /// @endcode MOCK_METHOD( future>, ResumeReplication, (google::cloud::netapp::v1::ResumeReplicationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ResumeReplication(_, _)) + /// @endcode MOCK_METHOD( StatusOr, ResumeReplication, (NoAwaitTag, google::cloud::netapp::v1::ResumeReplicationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ResumeReplication(Matcher(_))) + /// @endcode MOCK_METHOD(future>, ResumeReplication, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ReverseReplicationDirection)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ReverseReplicationDirection(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ReverseReplicationDirection(Matcher(_))) + /// @endcode MOCK_METHOD( future>, ReverseReplicationDirection, @@ -508,6 +954,12 @@ class MockNetAppConnection : public netapp_v1::NetAppConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ReverseReplicationDirection(_, _)) + /// @endcode MOCK_METHOD( StatusOr, ReverseReplicationDirection, (NoAwaitTag, @@ -515,25 +967,54 @@ class MockNetAppConnection : public netapp_v1::NetAppConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ReverseReplicationDirection(Matcher(_))) + /// @endcode MOCK_METHOD(future>, ReverseReplicationDirection, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateBackupVault)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateBackupVault(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateBackupVault(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateBackupVault, (google::cloud::netapp::v1::CreateBackupVaultRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateBackupVault(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateBackupVault, (NoAwaitTag, google::cloud::netapp::v1::CreateBackupVaultRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateBackupVault(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateBackupVault, (google::longrunning::Operation const& operation), (override)); @@ -547,56 +1028,116 @@ class MockNetAppConnection : public netapp_v1::NetAppConnection { (google::cloud::netapp::v1::ListBackupVaultsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateBackupVault)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateBackupVault(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateBackupVault(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateBackupVault, (google::cloud::netapp::v1::UpdateBackupVaultRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateBackupVault(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateBackupVault, (NoAwaitTag, google::cloud::netapp::v1::UpdateBackupVaultRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateBackupVault(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateBackupVault, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteBackupVault)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteBackupVault(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteBackupVault(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteBackupVault, (google::cloud::netapp::v1::DeleteBackupVaultRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteBackupVault(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteBackupVault, (NoAwaitTag, google::cloud::netapp::v1::DeleteBackupVaultRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteBackupVault(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteBackupVault, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateBackup)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateBackup(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateBackup(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateBackup, (google::cloud::netapp::v1::CreateBackupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateBackup(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateBackup, (NoAwaitTag, google::cloud::netapp::v1::CreateBackupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateBackup(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateBackup, (google::longrunning::Operation const& operation), (override)); @@ -608,53 +1149,113 @@ class MockNetAppConnection : public netapp_v1::NetAppConnection { (google::cloud::netapp::v1::ListBackupsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteBackup)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteBackup(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteBackup(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteBackup, (google::cloud::netapp::v1::DeleteBackupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteBackup(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteBackup, (NoAwaitTag, google::cloud::netapp::v1::DeleteBackupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteBackup(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteBackup, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateBackup)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateBackup(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateBackup(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateBackup, (google::cloud::netapp::v1::UpdateBackupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateBackup(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateBackup, (NoAwaitTag, google::cloud::netapp::v1::UpdateBackupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateBackup(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateBackup, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateBackupPolicy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateBackupPolicy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateBackupPolicy(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateBackupPolicy, (google::cloud::netapp::v1::CreateBackupPolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateBackupPolicy(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateBackupPolicy, (NoAwaitTag, google::cloud::netapp::v1::CreateBackupPolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateBackupPolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateBackupPolicy, (google::longrunning::Operation const& operation), (override)); @@ -669,40 +1270,80 @@ class MockNetAppConnection : public netapp_v1::NetAppConnection { (google::cloud::netapp::v1::ListBackupPoliciesRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateBackupPolicy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateBackupPolicy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateBackupPolicy(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateBackupPolicy, (google::cloud::netapp::v1::UpdateBackupPolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateBackupPolicy(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateBackupPolicy, (NoAwaitTag, google::cloud::netapp::v1::UpdateBackupPolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateBackupPolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateBackupPolicy, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteBackupPolicy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteBackupPolicy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteBackupPolicy(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteBackupPolicy, (google::cloud::netapp::v1::DeleteBackupPolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteBackupPolicy(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteBackupPolicy, (NoAwaitTag, google::cloud::netapp::v1::DeleteBackupPolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteBackupPolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteBackupPolicy, (google::longrunning::Operation const& operation), (override)); diff --git a/google/cloud/networkconnectivity/v1/mocks/mock_hub_connection.h b/google/cloud/networkconnectivity/v1/mocks/mock_hub_connection.h index 521b0280c7df3..cbee419d6e030 100644 --- a/google/cloud/networkconnectivity/v1/mocks/mock_hub_connection.h +++ b/google/cloud/networkconnectivity/v1/mocks/mock_hub_connection.h @@ -57,45 +57,91 @@ class MockHubServiceConnection (google::cloud::networkconnectivity::v1::GetHubRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateHub)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateHub(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateHub(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateHub, (google::cloud::networkconnectivity::v1::CreateHubRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateHub(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateHub, (NoAwaitTag, google::cloud::networkconnectivity::v1::CreateHubRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateHub(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateHub, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateHub)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateHub(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateHub(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateHub, (google::cloud::networkconnectivity::v1::UpdateHubRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateHub(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateHub, (NoAwaitTag, google::cloud::networkconnectivity::v1::UpdateHubRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateHub(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateHub, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteHub)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteHub(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteHub(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, @@ -103,12 +149,26 @@ class MockHubServiceConnection (google::cloud::networkconnectivity::v1::DeleteHubRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteHub(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteHub, (NoAwaitTag, google::cloud::networkconnectivity::v1::DeleteHubRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteHub(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, @@ -130,47 +190,93 @@ class MockHubServiceConnection (google::cloud::networkconnectivity::v1::GetSpokeRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateSpoke)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateSpoke(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateSpoke(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateSpoke, (google::cloud::networkconnectivity::v1::CreateSpokeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateSpoke(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateSpoke, (NoAwaitTag, google::cloud::networkconnectivity::v1::CreateSpokeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateSpoke(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateSpoke, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateSpoke)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateSpoke(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateSpoke(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateSpoke, (google::cloud::networkconnectivity::v1::UpdateSpokeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateSpoke(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateSpoke, (NoAwaitTag, google::cloud::networkconnectivity::v1::UpdateSpokeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateSpoke(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateSpoke, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, RejectHubSpoke)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, RejectHubSpoke(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RejectHubSpoke(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -179,6 +285,12 @@ class MockHubServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, RejectHubSpoke(_, _)) + /// @endcode MOCK_METHOD( StatusOr, RejectHubSpoke, (NoAwaitTag, @@ -186,15 +298,29 @@ class MockHubServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, RejectHubSpoke(Matcher(_))) + /// @endcode MOCK_METHOD( future>, RejectHubSpoke, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, AcceptHubSpoke)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, AcceptHubSpoke(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// AcceptHubSpoke(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -203,6 +329,12 @@ class MockHubServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, AcceptHubSpoke(_, _)) + /// @endcode MOCK_METHOD( StatusOr, AcceptHubSpoke, (NoAwaitTag, @@ -210,15 +342,29 @@ class MockHubServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, AcceptHubSpoke(Matcher(_))) + /// @endcode MOCK_METHOD( future>, AcceptHubSpoke, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteSpoke)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteSpoke(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteSpoke(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, @@ -227,12 +373,26 @@ class MockHubServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteSpoke(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteSpoke, (NoAwaitTag, google::cloud::networkconnectivity::v1::DeleteSpokeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteSpoke(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, diff --git a/google/cloud/networkconnectivity/v1/mocks/mock_policy_based_routing_connection.h b/google/cloud/networkconnectivity/v1/mocks/mock_policy_based_routing_connection.h index c8bdc4597ff3a..102067bf6b732 100644 --- a/google/cloud/networkconnectivity/v1/mocks/mock_policy_based_routing_connection.h +++ b/google/cloud/networkconnectivity/v1/mocks/mock_policy_based_routing_connection.h @@ -61,9 +61,15 @@ class MockPolicyBasedRoutingServiceConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreatePolicyBasedRoute)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreatePolicyBasedRoute(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreatePolicyBasedRoute(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, @@ -72,20 +78,40 @@ class MockPolicyBasedRoutingServiceConnection CreatePolicyBasedRouteRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreatePolicyBasedRoute(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreatePolicyBasedRoute, (NoAwaitTag, google::cloud::networkconnectivity::v1:: CreatePolicyBasedRouteRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreatePolicyBasedRoute(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, CreatePolicyBasedRoute, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeletePolicyBasedRoute)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeletePolicyBasedRoute(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeletePolicyBasedRoute(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, @@ -94,11 +120,25 @@ class MockPolicyBasedRoutingServiceConnection DeletePolicyBasedRouteRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeletePolicyBasedRoute(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeletePolicyBasedRoute, (NoAwaitTag, google::cloud::networkconnectivity::v1:: DeletePolicyBasedRouteRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeletePolicyBasedRoute(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, diff --git a/google/cloud/networkmanagement/v1/mocks/mock_reachability_connection.h b/google/cloud/networkmanagement/v1/mocks/mock_reachability_connection.h index 898f74084a6c6..71752c9815aa4 100644 --- a/google/cloud/networkmanagement/v1/mocks/mock_reachability_connection.h +++ b/google/cloud/networkmanagement/v1/mocks/mock_reachability_connection.h @@ -61,9 +61,15 @@ class MockReachabilityServiceConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateConnectivityTest)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateConnectivityTest(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateConnectivityTest(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateConnectivityTest, @@ -71,19 +77,39 @@ class MockReachabilityServiceConnection CreateConnectivityTestRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateConnectivityTest(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateConnectivityTest, (NoAwaitTag, google::cloud::networkmanagement::v1:: CreateConnectivityTestRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateConnectivityTest(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateConnectivityTest, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateConnectivityTest)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateConnectivityTest(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateConnectivityTest(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateConnectivityTest, @@ -91,19 +117,39 @@ class MockReachabilityServiceConnection UpdateConnectivityTestRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateConnectivityTest(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateConnectivityTest, (NoAwaitTag, google::cloud::networkmanagement::v1:: UpdateConnectivityTestRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateConnectivityTest(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateConnectivityTest, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, RerunConnectivityTest)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, RerunConnectivityTest(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RerunConnectivityTest(Matcher(_))) + /// @endcode MOCK_METHOD( future>, RerunConnectivityTest, @@ -111,6 +157,12 @@ class MockReachabilityServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, RerunConnectivityTest(_, _)) + /// @endcode MOCK_METHOD( StatusOr, RerunConnectivityTest, (NoAwaitTag, @@ -118,14 +170,28 @@ class MockReachabilityServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RerunConnectivityTest(Matcher(_))) + /// @endcode MOCK_METHOD( future>, RerunConnectivityTest, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteConnectivityTest)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteConnectivityTest(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteConnectivityTest(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteConnectivityTest, @@ -133,11 +199,25 @@ class MockReachabilityServiceConnection DeleteConnectivityTestRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteConnectivityTest(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteConnectivityTest, (NoAwaitTag, google::cloud::networkmanagement::v1:: DeleteConnectivityTestRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteConnectivityTest(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteConnectivityTest, (google::longrunning::Operation const& operation), diff --git a/google/cloud/networksecurity/v1/mocks/mock_network_security_connection.h b/google/cloud/networksecurity/v1/mocks/mock_network_security_connection.h index 8d60d05805ecf..7e0f9c0b9b8e2 100644 --- a/google/cloud/networksecurity/v1/mocks/mock_network_security_connection.h +++ b/google/cloud/networksecurity/v1/mocks/mock_network_security_connection.h @@ -61,9 +61,15 @@ class MockNetworkSecurityConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateAuthorizationPolicy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateAuthorizationPolicy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateAuthorizationPolicy(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateAuthorizationPolicy, @@ -71,20 +77,41 @@ class MockNetworkSecurityConnection CreateAuthorizationPolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateAuthorizationPolicy(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateAuthorizationPolicy, (NoAwaitTag, google::cloud::networksecurity::v1:: CreateAuthorizationPolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateAuthorizationPolicy(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateAuthorizationPolicy, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateAuthorizationPolicy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateAuthorizationPolicy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateAuthorizationPolicy(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateAuthorizationPolicy, @@ -92,20 +119,41 @@ class MockNetworkSecurityConnection UpdateAuthorizationPolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateAuthorizationPolicy(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateAuthorizationPolicy, (NoAwaitTag, google::cloud::networksecurity::v1:: UpdateAuthorizationPolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateAuthorizationPolicy(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateAuthorizationPolicy, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteAuthorizationPolicy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteAuthorizationPolicy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteAuthorizationPolicy(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteAuthorizationPolicy, @@ -113,12 +161,27 @@ class MockNetworkSecurityConnection DeleteAuthorizationPolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteAuthorizationPolicy(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteAuthorizationPolicy, (NoAwaitTag, google::cloud::networksecurity::v1:: DeleteAuthorizationPolicyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteAuthorizationPolicy(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteAuthorizationPolicy, @@ -138,9 +201,15 @@ class MockNetworkSecurityConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateServerTlsPolicy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateServerTlsPolicy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateServerTlsPolicy(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateServerTlsPolicy, @@ -148,6 +217,12 @@ class MockNetworkSecurityConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateServerTlsPolicy(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateServerTlsPolicy, (NoAwaitTag, @@ -155,14 +230,28 @@ class MockNetworkSecurityConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateServerTlsPolicy(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateServerTlsPolicy, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateServerTlsPolicy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateServerTlsPolicy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateServerTlsPolicy(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateServerTlsPolicy, @@ -170,6 +259,12 @@ class MockNetworkSecurityConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateServerTlsPolicy(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateServerTlsPolicy, (NoAwaitTag, @@ -177,14 +272,28 @@ class MockNetworkSecurityConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateServerTlsPolicy(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateServerTlsPolicy, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteServerTlsPolicy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteServerTlsPolicy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteServerTlsPolicy(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteServerTlsPolicy, @@ -192,6 +301,12 @@ class MockNetworkSecurityConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteServerTlsPolicy(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteServerTlsPolicy, (NoAwaitTag, @@ -199,6 +314,14 @@ class MockNetworkSecurityConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteServerTlsPolicy(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteServerTlsPolicy, (google::longrunning::Operation const& operation), @@ -218,9 +341,15 @@ class MockNetworkSecurityConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateClientTlsPolicy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateClientTlsPolicy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateClientTlsPolicy(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateClientTlsPolicy, @@ -228,6 +357,12 @@ class MockNetworkSecurityConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateClientTlsPolicy(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateClientTlsPolicy, (NoAwaitTag, @@ -235,14 +370,28 @@ class MockNetworkSecurityConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateClientTlsPolicy(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateClientTlsPolicy, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateClientTlsPolicy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateClientTlsPolicy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateClientTlsPolicy(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateClientTlsPolicy, @@ -250,6 +399,12 @@ class MockNetworkSecurityConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateClientTlsPolicy(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateClientTlsPolicy, (NoAwaitTag, @@ -257,14 +412,28 @@ class MockNetworkSecurityConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateClientTlsPolicy(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateClientTlsPolicy, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteClientTlsPolicy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteClientTlsPolicy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteClientTlsPolicy(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteClientTlsPolicy, @@ -272,6 +441,12 @@ class MockNetworkSecurityConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteClientTlsPolicy(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteClientTlsPolicy, (NoAwaitTag, @@ -279,6 +454,14 @@ class MockNetworkSecurityConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteClientTlsPolicy(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteClientTlsPolicy, (google::longrunning::Operation const& operation), diff --git a/google/cloud/networkservices/v1/mocks/mock_dep_connection.h b/google/cloud/networkservices/v1/mocks/mock_dep_connection.h index 49c52ffa12636..8ae0fc92e2ac0 100644 --- a/google/cloud/networkservices/v1/mocks/mock_dep_connection.h +++ b/google/cloud/networkservices/v1/mocks/mock_dep_connection.h @@ -61,9 +61,15 @@ class MockDepServiceConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateLbTrafficExtension)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateLbTrafficExtension(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateLbTrafficExtension(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateLbTrafficExtension, @@ -71,20 +77,41 @@ class MockDepServiceConnection CreateLbTrafficExtensionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateLbTrafficExtension(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateLbTrafficExtension, (NoAwaitTag, google::cloud::networkservices::v1:: CreateLbTrafficExtensionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateLbTrafficExtension(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateLbTrafficExtension, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateLbTrafficExtension)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateLbTrafficExtension(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateLbTrafficExtension(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateLbTrafficExtension, @@ -92,20 +119,41 @@ class MockDepServiceConnection UpdateLbTrafficExtensionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateLbTrafficExtension(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateLbTrafficExtension, (NoAwaitTag, google::cloud::networkservices::v1:: UpdateLbTrafficExtensionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateLbTrafficExtension(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateLbTrafficExtension, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteLbTrafficExtension)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteLbTrafficExtension(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteLbTrafficExtension(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteLbTrafficExtension, @@ -113,12 +161,27 @@ class MockDepServiceConnection DeleteLbTrafficExtensionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteLbTrafficExtension(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteLbTrafficExtension, (NoAwaitTag, google::cloud::networkservices::v1:: DeleteLbTrafficExtensionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteLbTrafficExtension(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteLbTrafficExtension, @@ -138,9 +201,15 @@ class MockDepServiceConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateLbRouteExtension)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateLbRouteExtension(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateLbRouteExtension(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateLbRouteExtension, @@ -148,6 +217,12 @@ class MockDepServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateLbRouteExtension(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateLbRouteExtension, (NoAwaitTag, @@ -155,14 +230,28 @@ class MockDepServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateLbRouteExtension(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateLbRouteExtension, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateLbRouteExtension)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateLbRouteExtension(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateLbRouteExtension(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateLbRouteExtension, @@ -170,6 +259,12 @@ class MockDepServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateLbRouteExtension(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateLbRouteExtension, (NoAwaitTag, @@ -177,14 +272,28 @@ class MockDepServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateLbRouteExtension(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateLbRouteExtension, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteLbRouteExtension)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteLbRouteExtension(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteLbRouteExtension(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteLbRouteExtension, @@ -192,6 +301,12 @@ class MockDepServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteLbRouteExtension(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteLbRouteExtension, (NoAwaitTag, @@ -199,6 +314,14 @@ class MockDepServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteLbRouteExtension(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteLbRouteExtension, (google::longrunning::Operation const& operation), diff --git a/google/cloud/networkservices/v1/mocks/mock_network_services_connection.h b/google/cloud/networkservices/v1/mocks/mock_network_services_connection.h index edeaa86b405dc..3098833883baa 100644 --- a/google/cloud/networkservices/v1/mocks/mock_network_services_connection.h +++ b/google/cloud/networkservices/v1/mocks/mock_network_services_connection.h @@ -60,9 +60,15 @@ class MockNetworkServicesConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateEndpointPolicy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateEndpointPolicy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateEndpointPolicy(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateEndpointPolicy, @@ -70,6 +76,12 @@ class MockNetworkServicesConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateEndpointPolicy(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateEndpointPolicy, (NoAwaitTag, @@ -77,14 +89,28 @@ class MockNetworkServicesConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateEndpointPolicy(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateEndpointPolicy, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateEndpointPolicy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateEndpointPolicy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateEndpointPolicy(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateEndpointPolicy, @@ -92,6 +118,12 @@ class MockNetworkServicesConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateEndpointPolicy(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateEndpointPolicy, (NoAwaitTag, @@ -99,14 +131,28 @@ class MockNetworkServicesConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateEndpointPolicy(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateEndpointPolicy, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteEndpointPolicy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteEndpointPolicy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteEndpointPolicy(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteEndpointPolicy, @@ -114,6 +160,12 @@ class MockNetworkServicesConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteEndpointPolicy(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteEndpointPolicy, (NoAwaitTag, @@ -121,6 +173,14 @@ class MockNetworkServicesConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteEndpointPolicy(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteEndpointPolicy, (google::longrunning::Operation const& operation), @@ -136,59 +196,119 @@ class MockNetworkServicesConnection (google::cloud::networkservices::v1::GetGatewayRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateGateway)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateGateway(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateGateway(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateGateway, (google::cloud::networkservices::v1::CreateGatewayRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateGateway(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateGateway, (NoAwaitTag, google::cloud::networkservices::v1::CreateGatewayRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateGateway(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateGateway, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateGateway)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateGateway(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateGateway(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateGateway, (google::cloud::networkservices::v1::UpdateGatewayRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateGateway(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateGateway, (NoAwaitTag, google::cloud::networkservices::v1::UpdateGatewayRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateGateway(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateGateway, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteGateway)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteGateway(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteGateway(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteGateway, (google::cloud::networkservices::v1::DeleteGatewayRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteGateway(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteGateway, (NoAwaitTag, google::cloud::networkservices::v1::DeleteGatewayRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteGateway(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteGateway, (google::longrunning::Operation const& operation), @@ -205,47 +325,93 @@ class MockNetworkServicesConnection (google::cloud::networkservices::v1::GetGrpcRouteRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateGrpcRoute)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateGrpcRoute(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateGrpcRoute(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateGrpcRoute, (google::cloud::networkservices::v1::CreateGrpcRouteRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateGrpcRoute(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateGrpcRoute, (NoAwaitTag, google::cloud::networkservices::v1::CreateGrpcRouteRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateGrpcRoute(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateGrpcRoute, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateGrpcRoute)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateGrpcRoute(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateGrpcRoute(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateGrpcRoute, (google::cloud::networkservices::v1::UpdateGrpcRouteRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateGrpcRoute(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateGrpcRoute, (NoAwaitTag, google::cloud::networkservices::v1::UpdateGrpcRouteRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateGrpcRoute(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateGrpcRoute, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteGrpcRoute)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteGrpcRoute(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteGrpcRoute(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteGrpcRoute, @@ -253,12 +419,26 @@ class MockNetworkServicesConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteGrpcRoute(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteGrpcRoute, (NoAwaitTag, google::cloud::networkservices::v1::DeleteGrpcRouteRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteGrpcRoute(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteGrpcRoute, (google::longrunning::Operation const& operation), @@ -275,47 +455,93 @@ class MockNetworkServicesConnection (google::cloud::networkservices::v1::GetHttpRouteRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateHttpRoute)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateHttpRoute(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateHttpRoute(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateHttpRoute, (google::cloud::networkservices::v1::CreateHttpRouteRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateHttpRoute(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateHttpRoute, (NoAwaitTag, google::cloud::networkservices::v1::CreateHttpRouteRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateHttpRoute(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateHttpRoute, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateHttpRoute)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateHttpRoute(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateHttpRoute(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateHttpRoute, (google::cloud::networkservices::v1::UpdateHttpRouteRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateHttpRoute(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateHttpRoute, (NoAwaitTag, google::cloud::networkservices::v1::UpdateHttpRouteRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateHttpRoute(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateHttpRoute, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteHttpRoute)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteHttpRoute(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteHttpRoute(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteHttpRoute, @@ -323,12 +549,26 @@ class MockNetworkServicesConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteHttpRoute(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteHttpRoute, (NoAwaitTag, google::cloud::networkservices::v1::DeleteHttpRouteRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteHttpRoute(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteHttpRoute, (google::longrunning::Operation const& operation), @@ -345,47 +585,93 @@ class MockNetworkServicesConnection (google::cloud::networkservices::v1::GetTcpRouteRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateTcpRoute)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateTcpRoute(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateTcpRoute(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateTcpRoute, (google::cloud::networkservices::v1::CreateTcpRouteRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateTcpRoute(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateTcpRoute, (NoAwaitTag, google::cloud::networkservices::v1::CreateTcpRouteRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateTcpRoute(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateTcpRoute, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateTcpRoute)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateTcpRoute(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateTcpRoute(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateTcpRoute, (google::cloud::networkservices::v1::UpdateTcpRouteRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateTcpRoute(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateTcpRoute, (NoAwaitTag, google::cloud::networkservices::v1::UpdateTcpRouteRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateTcpRoute(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateTcpRoute, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteTcpRoute)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteTcpRoute(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteTcpRoute(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteTcpRoute, @@ -393,12 +679,26 @@ class MockNetworkServicesConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteTcpRoute(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteTcpRoute, (NoAwaitTag, google::cloud::networkservices::v1::DeleteTcpRouteRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteTcpRoute(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteTcpRoute, (google::longrunning::Operation const& operation), @@ -415,47 +715,93 @@ class MockNetworkServicesConnection (google::cloud::networkservices::v1::GetTlsRouteRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateTlsRoute)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateTlsRoute(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateTlsRoute(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateTlsRoute, (google::cloud::networkservices::v1::CreateTlsRouteRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateTlsRoute(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateTlsRoute, (NoAwaitTag, google::cloud::networkservices::v1::CreateTlsRouteRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateTlsRoute(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateTlsRoute, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateTlsRoute)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateTlsRoute(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateTlsRoute(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateTlsRoute, (google::cloud::networkservices::v1::UpdateTlsRouteRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateTlsRoute(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateTlsRoute, (NoAwaitTag, google::cloud::networkservices::v1::UpdateTlsRouteRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateTlsRoute(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateTlsRoute, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteTlsRoute)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteTlsRoute(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteTlsRoute(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteTlsRoute, @@ -463,12 +809,26 @@ class MockNetworkServicesConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteTlsRoute(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteTlsRoute, (NoAwaitTag, google::cloud::networkservices::v1::DeleteTlsRouteRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteTlsRoute(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteTlsRoute, (google::longrunning::Operation const& operation), @@ -487,9 +847,15 @@ class MockNetworkServicesConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateServiceBinding)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateServiceBinding(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateServiceBinding(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateServiceBinding, @@ -497,6 +863,12 @@ class MockNetworkServicesConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateServiceBinding(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateServiceBinding, (NoAwaitTag, @@ -504,14 +876,28 @@ class MockNetworkServicesConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateServiceBinding(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateServiceBinding, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteServiceBinding)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteServiceBinding(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteServiceBinding(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteServiceBinding, @@ -519,6 +905,12 @@ class MockNetworkServicesConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteServiceBinding(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteServiceBinding, (NoAwaitTag, @@ -526,6 +918,14 @@ class MockNetworkServicesConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteServiceBinding(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteServiceBinding, (google::longrunning::Operation const& operation), @@ -541,57 +941,117 @@ class MockNetworkServicesConnection (google::cloud::networkservices::v1::GetMeshRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateMesh)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateMesh(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateMesh(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateMesh, (google::cloud::networkservices::v1::CreateMeshRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateMesh(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateMesh, (NoAwaitTag, google::cloud::networkservices::v1::CreateMeshRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateMesh(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateMesh, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateMesh)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateMesh(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateMesh(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateMesh, (google::cloud::networkservices::v1::UpdateMeshRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateMesh(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateMesh, (NoAwaitTag, google::cloud::networkservices::v1::UpdateMeshRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateMesh(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateMesh, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteMesh)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteMesh(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteMesh(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteMesh, (google::cloud::networkservices::v1::DeleteMeshRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteMesh(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteMesh, (NoAwaitTag, google::cloud::networkservices::v1::DeleteMeshRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteMesh(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteMesh, (google::longrunning::Operation const& operation), diff --git a/google/cloud/notebooks/v1/mocks/mock_managed_notebook_connection.h b/google/cloud/notebooks/v1/mocks/mock_managed_notebook_connection.h index b4e155e32b217..fad7fa8add286 100644 --- a/google/cloud/notebooks/v1/mocks/mock_managed_notebook_connection.h +++ b/google/cloud/notebooks/v1/mocks/mock_managed_notebook_connection.h @@ -56,165 +56,345 @@ class MockManagedNotebookServiceConnection (google::cloud::notebooks::v1::GetRuntimeRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateRuntime)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateRuntime(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateRuntime(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateRuntime, (google::cloud::notebooks::v1::CreateRuntimeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateRuntime(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateRuntime, (NoAwaitTag, google::cloud::notebooks::v1::CreateRuntimeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateRuntime(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateRuntime, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateRuntime)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateRuntime(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateRuntime(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateRuntime, (google::cloud::notebooks::v1::UpdateRuntimeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateRuntime(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateRuntime, (NoAwaitTag, google::cloud::notebooks::v1::UpdateRuntimeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateRuntime(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateRuntime, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteRuntime)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteRuntime(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteRuntime(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteRuntime, (google::cloud::notebooks::v1::DeleteRuntimeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteRuntime(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteRuntime, (NoAwaitTag, google::cloud::notebooks::v1::DeleteRuntimeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteRuntime(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteRuntime, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, StartRuntime)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, StartRuntime(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// StartRuntime(Matcher(_))) + /// @endcode MOCK_METHOD( future>, StartRuntime, (google::cloud::notebooks::v1::StartRuntimeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, StartRuntime(_, _)) + /// @endcode MOCK_METHOD( StatusOr, StartRuntime, (NoAwaitTag, google::cloud::notebooks::v1::StartRuntimeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, StartRuntime(Matcher(_))) + /// @endcode MOCK_METHOD(future>, StartRuntime, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, StopRuntime)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, StopRuntime(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// StopRuntime(Matcher(_))) + /// @endcode MOCK_METHOD(future>, StopRuntime, (google::cloud::notebooks::v1::StopRuntimeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, StopRuntime(_, _)) + /// @endcode MOCK_METHOD(StatusOr, StopRuntime, (NoAwaitTag, google::cloud::notebooks::v1::StopRuntimeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, StopRuntime(Matcher(_))) + /// @endcode MOCK_METHOD(future>, StopRuntime, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SwitchRuntime)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SwitchRuntime(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SwitchRuntime(Matcher(_))) + /// @endcode MOCK_METHOD( future>, SwitchRuntime, (google::cloud::notebooks::v1::SwitchRuntimeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SwitchRuntime(_, _)) + /// @endcode MOCK_METHOD( StatusOr, SwitchRuntime, (NoAwaitTag, google::cloud::notebooks::v1::SwitchRuntimeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, SwitchRuntime(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SwitchRuntime, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ResetRuntime)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ResetRuntime(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ResetRuntime(Matcher(_))) + /// @endcode MOCK_METHOD( future>, ResetRuntime, (google::cloud::notebooks::v1::ResetRuntimeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ResetRuntime(_, _)) + /// @endcode MOCK_METHOD( StatusOr, ResetRuntime, (NoAwaitTag, google::cloud::notebooks::v1::ResetRuntimeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, ResetRuntime(Matcher(_))) + /// @endcode MOCK_METHOD(future>, ResetRuntime, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpgradeRuntime)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpgradeRuntime(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpgradeRuntime(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpgradeRuntime, (google::cloud::notebooks::v1::UpgradeRuntimeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpgradeRuntime(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpgradeRuntime, (NoAwaitTag, google::cloud::notebooks::v1::UpgradeRuntimeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpgradeRuntime(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpgradeRuntime, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ReportRuntimeEvent)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ReportRuntimeEvent(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ReportRuntimeEvent(Matcher(_))) + /// @endcode MOCK_METHOD( future>, ReportRuntimeEvent, (google::cloud::notebooks::v1::ReportRuntimeEventRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ReportRuntimeEvent(_, _)) + /// @endcode MOCK_METHOD( StatusOr, ReportRuntimeEvent, (NoAwaitTag, google::cloud::notebooks::v1::ReportRuntimeEventRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ReportRuntimeEvent(Matcher(_))) + /// @endcode MOCK_METHOD(future>, ReportRuntimeEvent, (google::longrunning::Operation const& operation), (override)); @@ -227,20 +407,40 @@ class MockManagedNotebookServiceConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DiagnoseRuntime)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DiagnoseRuntime(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DiagnoseRuntime(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DiagnoseRuntime, (google::cloud::notebooks::v1::DiagnoseRuntimeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DiagnoseRuntime(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DiagnoseRuntime, (NoAwaitTag, google::cloud::notebooks::v1::DiagnoseRuntimeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DiagnoseRuntime(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DiagnoseRuntime, (google::longrunning::Operation const& operation), (override)); diff --git a/google/cloud/notebooks/v1/mocks/mock_notebook_connection.h b/google/cloud/notebooks/v1/mocks/mock_notebook_connection.h index 2cd26553124b2..586ebfcc8b57b 100644 --- a/google/cloud/notebooks/v1/mocks/mock_notebook_connection.h +++ b/google/cloud/notebooks/v1/mocks/mock_notebook_connection.h @@ -56,46 +56,92 @@ class MockNotebookServiceConnection (google::cloud::notebooks::v1::GetInstanceRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateInstance)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateInstance(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateInstance(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateInstance, (google::cloud::notebooks::v1::CreateInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateInstance(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateInstance, (NoAwaitTag, google::cloud::notebooks::v1::CreateInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateInstance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateInstance, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, RegisterInstance)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, RegisterInstance(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RegisterInstance(Matcher(_))) + /// @endcode MOCK_METHOD( future>, RegisterInstance, (google::cloud::notebooks::v1::RegisterInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, RegisterInstance(_, _)) + /// @endcode MOCK_METHOD( StatusOr, RegisterInstance, (NoAwaitTag, google::cloud::notebooks::v1::RegisterInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, RegisterInstance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, RegisterInstance, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SetInstanceAccelerator)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SetInstanceAccelerator(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetInstanceAccelerator(Matcher(_))) + /// @endcode MOCK_METHOD( future>, SetInstanceAccelerator, @@ -103,6 +149,12 @@ class MockNotebookServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SetInstanceAccelerator(_, _)) + /// @endcode MOCK_METHOD( StatusOr, SetInstanceAccelerator, (NoAwaitTag, @@ -110,13 +162,27 @@ class MockNotebookServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetInstanceAccelerator(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetInstanceAccelerator, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SetInstanceMachineType)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SetInstanceMachineType(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetInstanceMachineType(Matcher(_))) + /// @endcode MOCK_METHOD( future>, SetInstanceMachineType, @@ -124,6 +190,12 @@ class MockNotebookServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SetInstanceMachineType(_, _)) + /// @endcode MOCK_METHOD( StatusOr, SetInstanceMachineType, (NoAwaitTag, @@ -131,32 +203,66 @@ class MockNotebookServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetInstanceMachineType(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetInstanceMachineType, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateInstanceConfig)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateInstanceConfig(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateInstanceConfig(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateInstanceConfig, (google::cloud::notebooks::v1::UpdateInstanceConfigRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateInstanceConfig(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateInstanceConfig, (NoAwaitTag, google::cloud::notebooks::v1::UpdateInstanceConfigRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateInstanceConfig(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateInstanceConfig, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateShieldedInstanceConfig)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateShieldedInstanceConfig(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateShieldedInstanceConfig(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateShieldedInstanceConfig, @@ -164,6 +270,12 @@ class MockNotebookServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateShieldedInstanceConfig(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateShieldedInstanceConfig, (NoAwaitTag, @@ -171,25 +283,54 @@ class MockNotebookServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateShieldedInstanceConfig(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateShieldedInstanceConfig, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SetInstanceLabels)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SetInstanceLabels(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetInstanceLabels(Matcher(_))) + /// @endcode MOCK_METHOD( future>, SetInstanceLabels, (google::cloud::notebooks::v1::SetInstanceLabelsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SetInstanceLabels(_, _)) + /// @endcode MOCK_METHOD( StatusOr, SetInstanceLabels, (NoAwaitTag, google::cloud::notebooks::v1::SetInstanceLabelsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetInstanceLabels(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetInstanceLabels, (google::longrunning::Operation const& operation), (override)); @@ -202,94 +343,194 @@ class MockNotebookServiceConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteInstance)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteInstance(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteInstance(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteInstance, (google::cloud::notebooks::v1::DeleteInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteInstance(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteInstance, (NoAwaitTag, google::cloud::notebooks::v1::DeleteInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteInstance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteInstance, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, StartInstance)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, StartInstance(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// StartInstance(Matcher(_))) + /// @endcode MOCK_METHOD( future>, StartInstance, (google::cloud::notebooks::v1::StartInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, StartInstance(_, _)) + /// @endcode MOCK_METHOD( StatusOr, StartInstance, (NoAwaitTag, google::cloud::notebooks::v1::StartInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, StartInstance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, StartInstance, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, StopInstance)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, StopInstance(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// StopInstance(Matcher(_))) + /// @endcode MOCK_METHOD( future>, StopInstance, (google::cloud::notebooks::v1::StopInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, StopInstance(_, _)) + /// @endcode MOCK_METHOD( StatusOr, StopInstance, (NoAwaitTag, google::cloud::notebooks::v1::StopInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, StopInstance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, StopInstance, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ResetInstance)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ResetInstance(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ResetInstance(Matcher(_))) + /// @endcode MOCK_METHOD( future>, ResetInstance, (google::cloud::notebooks::v1::ResetInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ResetInstance(_, _)) + /// @endcode MOCK_METHOD( StatusOr, ResetInstance, (NoAwaitTag, google::cloud::notebooks::v1::ResetInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, ResetInstance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, ResetInstance, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ReportInstanceInfo)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ReportInstanceInfo(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ReportInstanceInfo(Matcher(_))) + /// @endcode MOCK_METHOD( future>, ReportInstanceInfo, (google::cloud::notebooks::v1::ReportInstanceInfoRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ReportInstanceInfo(_, _)) + /// @endcode MOCK_METHOD( StatusOr, ReportInstanceInfo, (NoAwaitTag, google::cloud::notebooks::v1::ReportInstanceInfoRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ReportInstanceInfo(Matcher(_))) + /// @endcode MOCK_METHOD(future>, ReportInstanceInfo, (google::longrunning::Operation const& operation), (override)); @@ -307,65 +548,131 @@ class MockNotebookServiceConnection (google::cloud::notebooks::v1::GetInstanceHealthRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpgradeInstance)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpgradeInstance(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpgradeInstance(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpgradeInstance, (google::cloud::notebooks::v1::UpgradeInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpgradeInstance(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpgradeInstance, (NoAwaitTag, google::cloud::notebooks::v1::UpgradeInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpgradeInstance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpgradeInstance, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, RollbackInstance)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, RollbackInstance(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RollbackInstance(Matcher(_))) + /// @endcode MOCK_METHOD( future>, RollbackInstance, (google::cloud::notebooks::v1::RollbackInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, RollbackInstance(_, _)) + /// @endcode MOCK_METHOD( StatusOr, RollbackInstance, (NoAwaitTag, google::cloud::notebooks::v1::RollbackInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, RollbackInstance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, RollbackInstance, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DiagnoseInstance)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DiagnoseInstance(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DiagnoseInstance(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DiagnoseInstance, (google::cloud::notebooks::v1::DiagnoseInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DiagnoseInstance(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DiagnoseInstance, (NoAwaitTag, google::cloud::notebooks::v1::DiagnoseInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DiagnoseInstance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DiagnoseInstance, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpgradeInstanceInternal)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpgradeInstanceInternal(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpgradeInstanceInternal(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpgradeInstanceInternal, @@ -373,6 +680,12 @@ class MockNotebookServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpgradeInstanceInternal(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpgradeInstanceInternal, (NoAwaitTag, @@ -380,6 +693,15 @@ class MockNotebookServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpgradeInstanceInternal(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpgradeInstanceInternal, (google::longrunning::Operation const& operation), (override)); @@ -394,40 +716,80 @@ class MockNotebookServiceConnection (google::cloud::notebooks::v1::GetEnvironmentRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateEnvironment)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateEnvironment(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateEnvironment(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateEnvironment, (google::cloud::notebooks::v1::CreateEnvironmentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateEnvironment(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateEnvironment, (NoAwaitTag, google::cloud::notebooks::v1::CreateEnvironmentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateEnvironment(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateEnvironment, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteEnvironment)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteEnvironment(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteEnvironment(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteEnvironment, (google::cloud::notebooks::v1::DeleteEnvironmentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteEnvironment(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteEnvironment, (NoAwaitTag, google::cloud::notebooks::v1::DeleteEnvironmentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteEnvironment(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteEnvironment, (google::longrunning::Operation const& operation), (override)); @@ -441,57 +803,117 @@ class MockNotebookServiceConnection (google::cloud::notebooks::v1::GetScheduleRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteSchedule)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteSchedule(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteSchedule(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteSchedule, (google::cloud::notebooks::v1::DeleteScheduleRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteSchedule(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteSchedule, (NoAwaitTag, google::cloud::notebooks::v1::DeleteScheduleRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteSchedule(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteSchedule, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateSchedule)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateSchedule(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateSchedule(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateSchedule, (google::cloud::notebooks::v1::CreateScheduleRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateSchedule(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateSchedule, (NoAwaitTag, google::cloud::notebooks::v1::CreateScheduleRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateSchedule(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateSchedule, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, TriggerSchedule)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, TriggerSchedule(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// TriggerSchedule(Matcher(_))) + /// @endcode MOCK_METHOD( future>, TriggerSchedule, (google::cloud::notebooks::v1::TriggerScheduleRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, TriggerSchedule(_, _)) + /// @endcode MOCK_METHOD( StatusOr, TriggerSchedule, (NoAwaitTag, google::cloud::notebooks::v1::TriggerScheduleRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, TriggerSchedule(Matcher(_))) + /// @endcode MOCK_METHOD(future>, TriggerSchedule, (google::longrunning::Operation const& operation), (override)); @@ -506,40 +928,80 @@ class MockNotebookServiceConnection (google::cloud::notebooks::v1::GetExecutionRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteExecution)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteExecution(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteExecution(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteExecution, (google::cloud::notebooks::v1::DeleteExecutionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteExecution(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteExecution, (NoAwaitTag, google::cloud::notebooks::v1::DeleteExecutionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteExecution(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteExecution, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateExecution)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateExecution(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateExecution(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateExecution, (google::cloud::notebooks::v1::CreateExecutionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateExecution(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateExecution, (NoAwaitTag, google::cloud::notebooks::v1::CreateExecutionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateExecution(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateExecution, (google::longrunning::Operation const& operation), (override)); diff --git a/google/cloud/notebooks/v2/mocks/mock_notebook_connection.h b/google/cloud/notebooks/v2/mocks/mock_notebook_connection.h index e0b6a05797e75..61120b7ca7431 100644 --- a/google/cloud/notebooks/v2/mocks/mock_notebook_connection.h +++ b/google/cloud/notebooks/v2/mocks/mock_notebook_connection.h @@ -56,111 +56,231 @@ class MockNotebookServiceConnection (google::cloud::notebooks::v2::GetInstanceRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateInstance)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateInstance(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateInstance(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateInstance, (google::cloud::notebooks::v2::CreateInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateInstance(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateInstance, (NoAwaitTag, google::cloud::notebooks::v2::CreateInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateInstance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateInstance, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateInstance)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateInstance(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateInstance(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateInstance, (google::cloud::notebooks::v2::UpdateInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateInstance(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateInstance, (NoAwaitTag, google::cloud::notebooks::v2::UpdateInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateInstance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateInstance, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteInstance)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteInstance(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteInstance(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteInstance, (google::cloud::notebooks::v2::DeleteInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteInstance(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteInstance, (NoAwaitTag, google::cloud::notebooks::v2::DeleteInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteInstance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteInstance, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, StartInstance)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, StartInstance(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// StartInstance(Matcher(_))) + /// @endcode MOCK_METHOD( future>, StartInstance, (google::cloud::notebooks::v2::StartInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, StartInstance(_, _)) + /// @endcode MOCK_METHOD( StatusOr, StartInstance, (NoAwaitTag, google::cloud::notebooks::v2::StartInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, StartInstance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, StartInstance, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, StopInstance)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, StopInstance(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// StopInstance(Matcher(_))) + /// @endcode MOCK_METHOD( future>, StopInstance, (google::cloud::notebooks::v2::StopInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, StopInstance(_, _)) + /// @endcode MOCK_METHOD( StatusOr, StopInstance, (NoAwaitTag, google::cloud::notebooks::v2::StopInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, StopInstance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, StopInstance, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ResetInstance)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ResetInstance(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ResetInstance(Matcher(_))) + /// @endcode MOCK_METHOD( future>, ResetInstance, (google::cloud::notebooks::v2::ResetInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ResetInstance(_, _)) + /// @endcode MOCK_METHOD( StatusOr, ResetInstance, (NoAwaitTag, google::cloud::notebooks::v2::ResetInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, ResetInstance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, ResetInstance, (google::longrunning::Operation const& operation), (override)); @@ -173,58 +293,118 @@ class MockNotebookServiceConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpgradeInstance)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpgradeInstance(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpgradeInstance(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpgradeInstance, (google::cloud::notebooks::v2::UpgradeInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpgradeInstance(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpgradeInstance, (NoAwaitTag, google::cloud::notebooks::v2::UpgradeInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpgradeInstance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpgradeInstance, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, RollbackInstance)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, RollbackInstance(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RollbackInstance(Matcher(_))) + /// @endcode MOCK_METHOD( future>, RollbackInstance, (google::cloud::notebooks::v2::RollbackInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, RollbackInstance(_, _)) + /// @endcode MOCK_METHOD( StatusOr, RollbackInstance, (NoAwaitTag, google::cloud::notebooks::v2::RollbackInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, RollbackInstance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, RollbackInstance, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DiagnoseInstance)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DiagnoseInstance(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DiagnoseInstance(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DiagnoseInstance, (google::cloud::notebooks::v2::DiagnoseInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DiagnoseInstance(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DiagnoseInstance, (NoAwaitTag, google::cloud::notebooks::v2::DiagnoseInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DiagnoseInstance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DiagnoseInstance, (google::longrunning::Operation const& operation), (override)); diff --git a/google/cloud/optimization/v1/mocks/mock_fleet_routing_connection.h b/google/cloud/optimization/v1/mocks/mock_fleet_routing_connection.h index f183f5147d92a..fb2631b788334 100644 --- a/google/cloud/optimization/v1/mocks/mock_fleet_routing_connection.h +++ b/google/cloud/optimization/v1/mocks/mock_fleet_routing_connection.h @@ -53,9 +53,15 @@ class MockFleetRoutingConnection (google::cloud::optimization::v1::OptimizeToursRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, BatchOptimizeTours)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, BatchOptimizeTours(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// BatchOptimizeTours(Matcher(_))) + /// @endcode MOCK_METHOD(future>, BatchOptimizeTours, @@ -63,12 +69,26 @@ class MockFleetRoutingConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, BatchOptimizeTours(_, _)) + /// @endcode MOCK_METHOD(StatusOr, BatchOptimizeTours, (NoAwaitTag, google::cloud::optimization::v1::BatchOptimizeToursRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// BatchOptimizeTours(Matcher(_))) + /// @endcode MOCK_METHOD(future>, BatchOptimizeTours, diff --git a/google/cloud/osconfig/v1/mocks/mock_os_config_zonal_connection.h b/google/cloud/osconfig/v1/mocks/mock_os_config_zonal_connection.h index 9692abe5116cf..1bcd9b9fabc10 100644 --- a/google/cloud/osconfig/v1/mocks/mock_os_config_zonal_connection.h +++ b/google/cloud/osconfig/v1/mocks/mock_os_config_zonal_connection.h @@ -47,9 +47,15 @@ class MockOsConfigZonalServiceConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateOSPolicyAssignment)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateOSPolicyAssignment(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateOSPolicyAssignment(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateOSPolicyAssignment, @@ -57,6 +63,12 @@ class MockOsConfigZonalServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateOSPolicyAssignment(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateOSPolicyAssignment, (NoAwaitTag, @@ -64,13 +76,28 @@ class MockOsConfigZonalServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateOSPolicyAssignment(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateOSPolicyAssignment, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateOSPolicyAssignment)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateOSPolicyAssignment(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateOSPolicyAssignment(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateOSPolicyAssignment, @@ -78,6 +105,12 @@ class MockOsConfigZonalServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateOSPolicyAssignment(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateOSPolicyAssignment, (NoAwaitTag, @@ -85,6 +118,15 @@ class MockOsConfigZonalServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateOSPolicyAssignment(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateOSPolicyAssignment, (google::longrunning::Operation const& operation), (override)); @@ -108,9 +150,15 @@ class MockOsConfigZonalServiceConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteOSPolicyAssignment)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteOSPolicyAssignment(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteOSPolicyAssignment(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -119,6 +167,12 @@ class MockOsConfigZonalServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteOSPolicyAssignment(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteOSPolicyAssignment, (NoAwaitTag, @@ -126,6 +180,15 @@ class MockOsConfigZonalServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteOSPolicyAssignment(Matcher(_))) + /// @endcode MOCK_METHOD( future>, diff --git a/google/cloud/policysimulator/v1/mocks/mock_simulator_connection.h b/google/cloud/policysimulator/v1/mocks/mock_simulator_connection.h index 3af031bc39eda..4165cb8ab0b62 100644 --- a/google/cloud/policysimulator/v1/mocks/mock_simulator_connection.h +++ b/google/cloud/policysimulator/v1/mocks/mock_simulator_connection.h @@ -51,21 +51,41 @@ class MockSimulatorConnection : public policysimulator_v1::SimulatorConnection { (google::cloud::policysimulator::v1::GetReplayRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateReplay)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateReplay(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateReplay(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateReplay, (google::cloud::policysimulator::v1::CreateReplayRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateReplay(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateReplay, (NoAwaitTag, google::cloud::policysimulator::v1::CreateReplayRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateReplay(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateReplay, (google::longrunning::Operation const& operation), (override)); diff --git a/google/cloud/privateca/v1/mocks/mock_certificate_authority_connection.h b/google/cloud/privateca/v1/mocks/mock_certificate_authority_connection.h index 7c19086eede88..99c5d8abecddb 100644 --- a/google/cloud/privateca/v1/mocks/mock_certificate_authority_connection.h +++ b/google/cloud/privateca/v1/mocks/mock_certificate_authority_connection.h @@ -81,9 +81,15 @@ class MockCertificateAuthorityServiceConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ActivateCertificateAuthority)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ActivateCertificateAuthority(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ActivateCertificateAuthority(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -92,6 +98,12 @@ class MockCertificateAuthorityServiceConnection ActivateCertificateAuthorityRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ActivateCertificateAuthority(_, _)) + /// @endcode MOCK_METHOD(StatusOr, ActivateCertificateAuthority, (NoAwaitTag, @@ -99,15 +111,30 @@ class MockCertificateAuthorityServiceConnection ActivateCertificateAuthorityRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ActivateCertificateAuthority(Matcher(_))) + /// @endcode MOCK_METHOD( future>, ActivateCertificateAuthority, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateCertificateAuthority)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateCertificateAuthority(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateCertificateAuthority(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -116,6 +143,12 @@ class MockCertificateAuthorityServiceConnection CreateCertificateAuthorityRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateCertificateAuthority(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateCertificateAuthority, (NoAwaitTag, @@ -123,15 +156,30 @@ class MockCertificateAuthorityServiceConnection CreateCertificateAuthorityRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateCertificateAuthority(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateCertificateAuthority, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DisableCertificateAuthority)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DisableCertificateAuthority(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DisableCertificateAuthority(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -140,6 +188,12 @@ class MockCertificateAuthorityServiceConnection DisableCertificateAuthorityRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DisableCertificateAuthority(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DisableCertificateAuthority, (NoAwaitTag, @@ -147,15 +201,30 @@ class MockCertificateAuthorityServiceConnection DisableCertificateAuthorityRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DisableCertificateAuthority(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DisableCertificateAuthority, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, EnableCertificateAuthority)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, EnableCertificateAuthority(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// EnableCertificateAuthority(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -164,6 +233,12 @@ class MockCertificateAuthorityServiceConnection EnableCertificateAuthorityRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, EnableCertificateAuthority(_, _)) + /// @endcode MOCK_METHOD(StatusOr, EnableCertificateAuthority, (NoAwaitTag, @@ -171,6 +246,15 @@ class MockCertificateAuthorityServiceConnection EnableCertificateAuthorityRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// EnableCertificateAuthority(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -199,9 +283,15 @@ class MockCertificateAuthorityServiceConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UndeleteCertificateAuthority)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UndeleteCertificateAuthority(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UndeleteCertificateAuthority(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -210,6 +300,12 @@ class MockCertificateAuthorityServiceConnection UndeleteCertificateAuthorityRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UndeleteCertificateAuthority(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UndeleteCertificateAuthority, (NoAwaitTag, @@ -217,15 +313,30 @@ class MockCertificateAuthorityServiceConnection UndeleteCertificateAuthorityRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UndeleteCertificateAuthority(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UndeleteCertificateAuthority, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteCertificateAuthority)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteCertificateAuthority(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteCertificateAuthority(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -234,6 +345,12 @@ class MockCertificateAuthorityServiceConnection DeleteCertificateAuthorityRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteCertificateAuthority(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteCertificateAuthority, (NoAwaitTag, @@ -241,15 +358,30 @@ class MockCertificateAuthorityServiceConnection DeleteCertificateAuthorityRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteCertificateAuthority(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteCertificateAuthority, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateCertificateAuthority)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateCertificateAuthority(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateCertificateAuthority(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -258,6 +390,12 @@ class MockCertificateAuthorityServiceConnection UpdateCertificateAuthorityRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateCertificateAuthority(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateCertificateAuthority, (NoAwaitTag, @@ -265,15 +403,30 @@ class MockCertificateAuthorityServiceConnection UpdateCertificateAuthorityRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateCertificateAuthority(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateCertificateAuthority, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateCaPool)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateCaPool(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateCaPool(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateCaPool, @@ -281,6 +434,12 @@ class MockCertificateAuthorityServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateCaPool(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateCaPool, (NoAwaitTag, @@ -288,13 +447,27 @@ class MockCertificateAuthorityServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateCaPool(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateCaPool, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateCaPool)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateCaPool(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateCaPool(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateCaPool, @@ -302,6 +475,12 @@ class MockCertificateAuthorityServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateCaPool(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateCaPool, (NoAwaitTag, @@ -309,6 +488,14 @@ class MockCertificateAuthorityServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateCaPool(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateCaPool, (google::longrunning::Operation const& operation), (override)); @@ -324,9 +511,15 @@ class MockCertificateAuthorityServiceConnection (google::cloud::security::privateca::v1::ListCaPoolsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteCaPool)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteCaPool(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteCaPool(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, @@ -335,6 +528,12 @@ class MockCertificateAuthorityServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteCaPool(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteCaPool, (NoAwaitTag, @@ -342,6 +541,14 @@ class MockCertificateAuthorityServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteCaPool(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, @@ -371,10 +578,15 @@ class MockCertificateAuthorityServiceConnection ListCertificateRevocationListsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateCertificateRevocationList)` is now ambiguous. - /// Use `EXPECT_CALL(*mock, UpdateCertificateRevocationList(::testing::_))` - /// instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateCertificateRevocationList(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -383,6 +595,12 @@ class MockCertificateAuthorityServiceConnection UpdateCertificateRevocationListRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateCertificateRevocationList(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateCertificateRevocationList, (NoAwaitTag, @@ -390,15 +608,30 @@ class MockCertificateAuthorityServiceConnection UpdateCertificateRevocationListRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateCertificateRevocationList(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateCertificateRevocationList, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateCertificateTemplate)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateCertificateTemplate(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateCertificateTemplate(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateCertificateTemplate, @@ -406,20 +639,41 @@ class MockCertificateAuthorityServiceConnection CreateCertificateTemplateRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateCertificateTemplate(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateCertificateTemplate, (NoAwaitTag, google::cloud::security::privateca::v1:: CreateCertificateTemplateRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateCertificateTemplate(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateCertificateTemplate, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteCertificateTemplate)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteCertificateTemplate(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteCertificateTemplate(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, @@ -428,12 +682,27 @@ class MockCertificateAuthorityServiceConnection DeleteCertificateTemplateRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteCertificateTemplate(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteCertificateTemplate, (NoAwaitTag, google::cloud::security::privateca::v1:: DeleteCertificateTemplateRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteCertificateTemplate(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, @@ -455,9 +724,15 @@ class MockCertificateAuthorityServiceConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateCertificateTemplate)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateCertificateTemplate(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateCertificateTemplate(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateCertificateTemplate, @@ -465,12 +740,27 @@ class MockCertificateAuthorityServiceConnection UpdateCertificateTemplateRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateCertificateTemplate(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateCertificateTemplate, (NoAwaitTag, google::cloud::security::privateca::v1:: UpdateCertificateTemplateRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateCertificateTemplate(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateCertificateTemplate, diff --git a/google/cloud/privilegedaccessmanager/v1/mocks/mock_privileged_access_manager_connection.h b/google/cloud/privilegedaccessmanager/v1/mocks/mock_privileged_access_manager_connection.h index 8adc477931acb..5f0c523a4663f 100644 --- a/google/cloud/privilegedaccessmanager/v1/mocks/mock_privileged_access_manager_connection.h +++ b/google/cloud/privilegedaccessmanager/v1/mocks/mock_privileged_access_manager_connection.h @@ -75,9 +75,15 @@ class MockPrivilegedAccessManagerConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateEntitlement)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateEntitlement(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateEntitlement(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateEntitlement, @@ -85,19 +91,39 @@ class MockPrivilegedAccessManagerConnection CreateEntitlementRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateEntitlement(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateEntitlement, (NoAwaitTag, google::cloud::privilegedaccessmanager::v1:: CreateEntitlementRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateEntitlement(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateEntitlement, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteEntitlement)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteEntitlement(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteEntitlement(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteEntitlement, @@ -105,19 +131,39 @@ class MockPrivilegedAccessManagerConnection DeleteEntitlementRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteEntitlement(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteEntitlement, (NoAwaitTag, google::cloud::privilegedaccessmanager::v1:: DeleteEntitlementRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteEntitlement(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteEntitlement, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateEntitlement)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateEntitlement(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateEntitlement(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateEntitlement, @@ -125,11 +171,25 @@ class MockPrivilegedAccessManagerConnection UpdateEntitlementRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateEntitlement(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateEntitlement, (NoAwaitTag, google::cloud::privilegedaccessmanager::v1:: UpdateEntitlementRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateEntitlement(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateEntitlement, (google::longrunning::Operation const& operation), @@ -171,9 +231,15 @@ class MockPrivilegedAccessManagerConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, RevokeGrant)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, RevokeGrant(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RevokeGrant(Matcher(_))) + /// @endcode MOCK_METHOD( future>, RevokeGrant, @@ -181,6 +247,12 @@ class MockPrivilegedAccessManagerConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, RevokeGrant(_, _)) + /// @endcode MOCK_METHOD( StatusOr, RevokeGrant, (NoAwaitTag, @@ -188,6 +260,14 @@ class MockPrivilegedAccessManagerConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, RevokeGrant(Matcher(_))) + /// @endcode MOCK_METHOD( future>, RevokeGrant, (google::longrunning::Operation const& operation), diff --git a/google/cloud/pubsublite/mocks/mock_admin_connection.h b/google/cloud/pubsublite/mocks/mock_admin_connection.h index 23a079c21fe93..5fe5f210d47ea 100644 --- a/google/cloud/pubsublite/mocks/mock_admin_connection.h +++ b/google/cloud/pubsublite/mocks/mock_admin_connection.h @@ -105,21 +105,41 @@ class MockAdminServiceConnection : public pubsublite::AdminServiceConnection { (google::cloud::pubsublite::v1::DeleteSubscriptionRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SeekSubscription)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SeekSubscription(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SeekSubscription(Matcher(_))) + /// @endcode MOCK_METHOD( future>, SeekSubscription, (google::cloud::pubsublite::v1::SeekSubscriptionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SeekSubscription(_, _)) + /// @endcode MOCK_METHOD( StatusOr, SeekSubscription, (NoAwaitTag, google::cloud::pubsublite::v1::SeekSubscriptionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, SeekSubscription(Matcher(_))) + /// @endcode MOCK_METHOD( future>, SeekSubscription, (google::longrunning::Operation const& operation), diff --git a/google/cloud/rapidmigrationassessment/v1/mocks/mock_rapid_migration_assessment_connection.h b/google/cloud/rapidmigrationassessment/v1/mocks/mock_rapid_migration_assessment_connection.h index 1d1fd7e132be8..e050b5f1c617a 100644 --- a/google/cloud/rapidmigrationassessment/v1/mocks/mock_rapid_migration_assessment_connection.h +++ b/google/cloud/rapidmigrationassessment/v1/mocks/mock_rapid_migration_assessment_connection.h @@ -48,9 +48,15 @@ class MockRapidMigrationAssessmentConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateCollector)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateCollector(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateCollector(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateCollector, @@ -58,19 +64,39 @@ class MockRapidMigrationAssessmentConnection CreateCollectorRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateCollector(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateCollector, (NoAwaitTag, google::cloud::rapidmigrationassessment::v1:: CreateCollectorRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateCollector(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateCollector, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateAnnotation)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateAnnotation(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateAnnotation(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateAnnotation, @@ -78,11 +104,25 @@ class MockRapidMigrationAssessmentConnection CreateAnnotationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateAnnotation(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateAnnotation, (NoAwaitTag, google::cloud::rapidmigrationassessment::v1:: CreateAnnotationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateAnnotation(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateAnnotation, (google::longrunning::Operation const& operation), @@ -109,9 +149,15 @@ class MockRapidMigrationAssessmentConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateCollector)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateCollector(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateCollector(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateCollector, @@ -119,19 +165,39 @@ class MockRapidMigrationAssessmentConnection UpdateCollectorRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateCollector(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateCollector, (NoAwaitTag, google::cloud::rapidmigrationassessment::v1:: UpdateCollectorRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateCollector(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateCollector, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteCollector)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteCollector(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteCollector(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteCollector, @@ -139,19 +205,39 @@ class MockRapidMigrationAssessmentConnection DeleteCollectorRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteCollector(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteCollector, (NoAwaitTag, google::cloud::rapidmigrationassessment::v1:: DeleteCollectorRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteCollector(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteCollector, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ResumeCollector)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ResumeCollector(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ResumeCollector(Matcher(_))) + /// @endcode MOCK_METHOD( future>, ResumeCollector, @@ -159,19 +245,39 @@ class MockRapidMigrationAssessmentConnection ResumeCollectorRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ResumeCollector(_, _)) + /// @endcode MOCK_METHOD(StatusOr, ResumeCollector, (NoAwaitTag, google::cloud::rapidmigrationassessment::v1:: ResumeCollectorRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, ResumeCollector(Matcher(_))) + /// @endcode MOCK_METHOD( future>, ResumeCollector, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, RegisterCollector)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, RegisterCollector(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RegisterCollector(Matcher(_))) + /// @endcode MOCK_METHOD( future>, RegisterCollector, @@ -179,19 +285,39 @@ class MockRapidMigrationAssessmentConnection RegisterCollectorRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, RegisterCollector(_, _)) + /// @endcode MOCK_METHOD(StatusOr, RegisterCollector, (NoAwaitTag, google::cloud::rapidmigrationassessment::v1:: RegisterCollectorRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RegisterCollector(Matcher(_))) + /// @endcode MOCK_METHOD( future>, RegisterCollector, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, PauseCollector)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, PauseCollector(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PauseCollector(Matcher(_))) + /// @endcode MOCK_METHOD( future>, PauseCollector, @@ -199,6 +325,12 @@ class MockRapidMigrationAssessmentConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, PauseCollector(_, _)) + /// @endcode MOCK_METHOD( StatusOr, PauseCollector, (NoAwaitTag, @@ -206,6 +338,14 @@ class MockRapidMigrationAssessmentConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, PauseCollector(Matcher(_))) + /// @endcode MOCK_METHOD( future>, PauseCollector, (google::longrunning::Operation const& operation), diff --git a/google/cloud/redis/cluster/v1/mocks/mock_cloud_redis_cluster_connection.h b/google/cloud/redis/cluster/v1/mocks/mock_cloud_redis_cluster_connection.h index a4d758c285102..3150a3f1f7bea 100644 --- a/google/cloud/redis/cluster/v1/mocks/mock_cloud_redis_cluster_connection.h +++ b/google/cloud/redis/cluster/v1/mocks/mock_cloud_redis_cluster_connection.h @@ -57,57 +57,117 @@ class MockCloudRedisClusterConnection (google::cloud::redis::cluster::v1::GetClusterRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateCluster)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateCluster(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateCluster(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateCluster, (google::cloud::redis::cluster::v1::UpdateClusterRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateCluster(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateCluster, (NoAwaitTag, google::cloud::redis::cluster::v1::UpdateClusterRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateCluster(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateCluster, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteCluster)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteCluster(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteCluster(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteCluster, (google::cloud::redis::cluster::v1::DeleteClusterRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteCluster(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteCluster, (NoAwaitTag, google::cloud::redis::cluster::v1::DeleteClusterRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteCluster(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteCluster, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateCluster)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateCluster(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateCluster(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateCluster, (google::cloud::redis::cluster::v1::CreateClusterRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateCluster(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateCluster, (NoAwaitTag, google::cloud::redis::cluster::v1::CreateClusterRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateCluster(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateCluster, (google::longrunning::Operation const& operation), (override)); diff --git a/google/cloud/redis/v1/mocks/mock_cloud_redis_connection.h b/google/cloud/redis/v1/mocks/mock_cloud_redis_connection.h index 95831adf55d5b..5a1506f3abb43 100644 --- a/google/cloud/redis/v1/mocks/mock_cloud_redis_connection.h +++ b/google/cloud/redis/v1/mocks/mock_cloud_redis_connection.h @@ -60,141 +60,301 @@ class MockCloudRedisConnection : public redis_v1::CloudRedisConnection { (google::cloud::redis::v1::GetInstanceAuthStringRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateInstance)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateInstance(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateInstance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateInstance, (google::cloud::redis::v1::CreateInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateInstance(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateInstance, (NoAwaitTag, google::cloud::redis::v1::CreateInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateInstance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateInstance, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateInstance)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateInstance(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateInstance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateInstance, (google::cloud::redis::v1::UpdateInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateInstance(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateInstance, (NoAwaitTag, google::cloud::redis::v1::UpdateInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateInstance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateInstance, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpgradeInstance)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpgradeInstance(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpgradeInstance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpgradeInstance, (google::cloud::redis::v1::UpgradeInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpgradeInstance(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpgradeInstance, (NoAwaitTag, google::cloud::redis::v1::UpgradeInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpgradeInstance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpgradeInstance, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ImportInstance)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ImportInstance(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ImportInstance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, ImportInstance, (google::cloud::redis::v1::ImportInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ImportInstance(_, _)) + /// @endcode MOCK_METHOD(StatusOr, ImportInstance, (NoAwaitTag, google::cloud::redis::v1::ImportInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, ImportInstance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, ImportInstance, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ExportInstance)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ExportInstance(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ExportInstance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, ExportInstance, (google::cloud::redis::v1::ExportInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ExportInstance(_, _)) + /// @endcode MOCK_METHOD(StatusOr, ExportInstance, (NoAwaitTag, google::cloud::redis::v1::ExportInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, ExportInstance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, ExportInstance, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, FailoverInstance)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, FailoverInstance(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// FailoverInstance(Matcher(_))) + /// @endcode MOCK_METHOD( future>, FailoverInstance, (google::cloud::redis::v1::FailoverInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, FailoverInstance(_, _)) + /// @endcode MOCK_METHOD( StatusOr, FailoverInstance, (NoAwaitTag, google::cloud::redis::v1::FailoverInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, FailoverInstance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, FailoverInstance, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteInstance)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteInstance(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteInstance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteInstance, (google::cloud::redis::v1::DeleteInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteInstance(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteInstance, (NoAwaitTag, google::cloud::redis::v1::DeleteInstanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteInstance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteInstance, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, RescheduleMaintenance)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, RescheduleMaintenance(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RescheduleMaintenance(Matcher(_))) + /// @endcode MOCK_METHOD( future>, RescheduleMaintenance, (google::cloud::redis::v1::RescheduleMaintenanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, RescheduleMaintenance(_, _)) + /// @endcode MOCK_METHOD( StatusOr, RescheduleMaintenance, (NoAwaitTag, google::cloud::redis::v1::RescheduleMaintenanceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RescheduleMaintenance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, RescheduleMaintenance, (google::longrunning::Operation const& operation), (override)); diff --git a/google/cloud/resourcemanager/v3/mocks/mock_folders_connection.h b/google/cloud/resourcemanager/v3/mocks/mock_folders_connection.h index adc857488afbf..6aed8fc7dcf81 100644 --- a/google/cloud/resourcemanager/v3/mocks/mock_folders_connection.h +++ b/google/cloud/resourcemanager/v3/mocks/mock_folders_connection.h @@ -61,96 +61,196 @@ class MockFoldersConnection : public resourcemanager_v3::FoldersConnection { (google::cloud::resourcemanager::v3::SearchFoldersRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateFolder)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateFolder(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateFolder(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateFolder, (google::cloud::resourcemanager::v3::CreateFolderRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateFolder(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateFolder, (NoAwaitTag, google::cloud::resourcemanager::v3::CreateFolderRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateFolder(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateFolder, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateFolder)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateFolder(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateFolder(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateFolder, (google::cloud::resourcemanager::v3::UpdateFolderRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateFolder(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateFolder, (NoAwaitTag, google::cloud::resourcemanager::v3::UpdateFolderRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateFolder(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateFolder, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, MoveFolder)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, MoveFolder(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// MoveFolder(Matcher(_))) + /// @endcode MOCK_METHOD( future>, MoveFolder, (google::cloud::resourcemanager::v3::MoveFolderRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, MoveFolder(_, _)) + /// @endcode MOCK_METHOD( StatusOr, MoveFolder, (NoAwaitTag, google::cloud::resourcemanager::v3::MoveFolderRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, MoveFolder(Matcher(_))) + /// @endcode MOCK_METHOD(future>, MoveFolder, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteFolder)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteFolder(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteFolder(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteFolder, (google::cloud::resourcemanager::v3::DeleteFolderRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteFolder(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteFolder, (NoAwaitTag, google::cloud::resourcemanager::v3::DeleteFolderRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteFolder(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteFolder, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UndeleteFolder)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UndeleteFolder(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UndeleteFolder(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UndeleteFolder, (google::cloud::resourcemanager::v3::UndeleteFolderRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UndeleteFolder(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UndeleteFolder, (NoAwaitTag, google::cloud::resourcemanager::v3::UndeleteFolderRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UndeleteFolder(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UndeleteFolder, (google::longrunning::Operation const& operation), (override)); diff --git a/google/cloud/resourcemanager/v3/mocks/mock_projects_connection.h b/google/cloud/resourcemanager/v3/mocks/mock_projects_connection.h index 9aab2b1a93b34..24ef3dfb3eb03 100644 --- a/google/cloud/resourcemanager/v3/mocks/mock_projects_connection.h +++ b/google/cloud/resourcemanager/v3/mocks/mock_projects_connection.h @@ -62,97 +62,197 @@ class MockProjectsConnection : public resourcemanager_v3::ProjectsConnection { (google::cloud::resourcemanager::v3::SearchProjectsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateProject)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateProject(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateProject(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateProject, (google::cloud::resourcemanager::v3::CreateProjectRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateProject(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateProject, (NoAwaitTag, google::cloud::resourcemanager::v3::CreateProjectRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateProject(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateProject, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateProject)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateProject(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateProject(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateProject, (google::cloud::resourcemanager::v3::UpdateProjectRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateProject(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateProject, (NoAwaitTag, google::cloud::resourcemanager::v3::UpdateProjectRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateProject(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateProject, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, MoveProject)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, MoveProject(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// MoveProject(Matcher(_))) + /// @endcode MOCK_METHOD( future>, MoveProject, (google::cloud::resourcemanager::v3::MoveProjectRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, MoveProject(_, _)) + /// @endcode MOCK_METHOD( StatusOr, MoveProject, (NoAwaitTag, google::cloud::resourcemanager::v3::MoveProjectRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, MoveProject(Matcher(_))) + /// @endcode MOCK_METHOD(future>, MoveProject, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteProject)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteProject(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteProject(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteProject, (google::cloud::resourcemanager::v3::DeleteProjectRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteProject(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteProject, (NoAwaitTag, google::cloud::resourcemanager::v3::DeleteProjectRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteProject(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteProject, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UndeleteProject)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UndeleteProject(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UndeleteProject(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UndeleteProject, (google::cloud::resourcemanager::v3::UndeleteProjectRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UndeleteProject(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UndeleteProject, (NoAwaitTag, google::cloud::resourcemanager::v3::UndeleteProjectRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UndeleteProject(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UndeleteProject, (google::longrunning::Operation const& operation), (override)); diff --git a/google/cloud/resourcemanager/v3/mocks/mock_tag_bindings_connection.h b/google/cloud/resourcemanager/v3/mocks/mock_tag_bindings_connection.h index e32843ab54c0f..62a81053b07b4 100644 --- a/google/cloud/resourcemanager/v3/mocks/mock_tag_bindings_connection.h +++ b/google/cloud/resourcemanager/v3/mocks/mock_tag_bindings_connection.h @@ -53,9 +53,15 @@ class MockTagBindingsConnection (google::cloud::resourcemanager::v3::ListTagBindingsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateTagBinding)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateTagBinding(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateTagBinding(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateTagBinding, @@ -63,6 +69,12 @@ class MockTagBindingsConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateTagBinding(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateTagBinding, (NoAwaitTag, @@ -70,13 +82,27 @@ class MockTagBindingsConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateTagBinding(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateTagBinding, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteTagBinding)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteTagBinding(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteTagBinding(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -85,6 +111,12 @@ class MockTagBindingsConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteTagBinding(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteTagBinding, (NoAwaitTag, @@ -92,6 +124,14 @@ class MockTagBindingsConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteTagBinding(Matcher(_))) + /// @endcode MOCK_METHOD( future>, diff --git a/google/cloud/resourcemanager/v3/mocks/mock_tag_holds_connection.h b/google/cloud/resourcemanager/v3/mocks/mock_tag_holds_connection.h index 8fd3ec6335839..7cc61e7e7aabc 100644 --- a/google/cloud/resourcemanager/v3/mocks/mock_tag_holds_connection.h +++ b/google/cloud/resourcemanager/v3/mocks/mock_tag_holds_connection.h @@ -46,28 +46,54 @@ class MockTagHoldsConnection : public resourcemanager_v3::TagHoldsConnection { public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateTagHold)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateTagHold(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateTagHold(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateTagHold, (google::cloud::resourcemanager::v3::CreateTagHoldRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateTagHold(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateTagHold, (NoAwaitTag, google::cloud::resourcemanager::v3::CreateTagHoldRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateTagHold(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateTagHold, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteTagHold)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteTagHold(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteTagHold(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, @@ -75,12 +101,26 @@ class MockTagHoldsConnection : public resourcemanager_v3::TagHoldsConnection { (google::cloud::resourcemanager::v3::DeleteTagHoldRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteTagHold(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteTagHold, (NoAwaitTag, google::cloud::resourcemanager::v3::DeleteTagHoldRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteTagHold(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, diff --git a/google/cloud/resourcemanager/v3/mocks/mock_tag_keys_connection.h b/google/cloud/resourcemanager/v3/mocks/mock_tag_keys_connection.h index 027b236bc9c03..050f5a040dec2 100644 --- a/google/cloud/resourcemanager/v3/mocks/mock_tag_keys_connection.h +++ b/google/cloud/resourcemanager/v3/mocks/mock_tag_keys_connection.h @@ -62,59 +62,119 @@ class MockTagKeysConnection : public resourcemanager_v3::TagKeysConnection { request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateTagKey)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateTagKey(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateTagKey(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateTagKey, (google::cloud::resourcemanager::v3::CreateTagKeyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateTagKey(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateTagKey, (NoAwaitTag, google::cloud::resourcemanager::v3::CreateTagKeyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateTagKey(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateTagKey, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateTagKey)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateTagKey(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateTagKey(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateTagKey, (google::cloud::resourcemanager::v3::UpdateTagKeyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateTagKey(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateTagKey, (NoAwaitTag, google::cloud::resourcemanager::v3::UpdateTagKeyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateTagKey(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateTagKey, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteTagKey)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteTagKey(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteTagKey(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteTagKey, (google::cloud::resourcemanager::v3::DeleteTagKeyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteTagKey(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteTagKey, (NoAwaitTag, google::cloud::resourcemanager::v3::DeleteTagKeyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteTagKey(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteTagKey, (google::longrunning::Operation const& operation), (override)); diff --git a/google/cloud/resourcemanager/v3/mocks/mock_tag_values_connection.h b/google/cloud/resourcemanager/v3/mocks/mock_tag_values_connection.h index f663e961b5790..8f01aa7906c91 100644 --- a/google/cloud/resourcemanager/v3/mocks/mock_tag_values_connection.h +++ b/google/cloud/resourcemanager/v3/mocks/mock_tag_values_connection.h @@ -64,59 +64,119 @@ class MockTagValuesConnection : public resourcemanager_v3::TagValuesConnection { request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateTagValue)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateTagValue(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateTagValue(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateTagValue, (google::cloud::resourcemanager::v3::CreateTagValueRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateTagValue(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateTagValue, (NoAwaitTag, google::cloud::resourcemanager::v3::CreateTagValueRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateTagValue(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateTagValue, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateTagValue)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateTagValue(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateTagValue(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateTagValue, (google::cloud::resourcemanager::v3::UpdateTagValueRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateTagValue(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateTagValue, (NoAwaitTag, google::cloud::resourcemanager::v3::UpdateTagValueRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateTagValue(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateTagValue, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteTagValue)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteTagValue(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteTagValue(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteTagValue, (google::cloud::resourcemanager::v3::DeleteTagValueRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteTagValue(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteTagValue, (NoAwaitTag, google::cloud::resourcemanager::v3::DeleteTagValueRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteTagValue(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteTagValue, (google::longrunning::Operation const& operation), (override)); diff --git a/google/cloud/retail/v2/mocks/mock_analytics_connection.h b/google/cloud/retail/v2/mocks/mock_analytics_connection.h index 435b791017cdf..e87bf47a2863b 100644 --- a/google/cloud/retail/v2/mocks/mock_analytics_connection.h +++ b/google/cloud/retail/v2/mocks/mock_analytics_connection.h @@ -47,9 +47,15 @@ class MockAnalyticsServiceConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ExportAnalyticsMetrics)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ExportAnalyticsMetrics(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ExportAnalyticsMetrics(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, @@ -57,12 +63,26 @@ class MockAnalyticsServiceConnection (google::cloud::retail::v2::ExportAnalyticsMetricsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ExportAnalyticsMetrics(_, _)) + /// @endcode MOCK_METHOD( StatusOr, ExportAnalyticsMetrics, (NoAwaitTag, google::cloud::retail::v2::ExportAnalyticsMetricsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ExportAnalyticsMetrics(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, diff --git a/google/cloud/retail/v2/mocks/mock_completion_connection.h b/google/cloud/retail/v2/mocks/mock_completion_connection.h index e92cd30801220..cca3193bf88fb 100644 --- a/google/cloud/retail/v2/mocks/mock_completion_connection.h +++ b/google/cloud/retail/v2/mocks/mock_completion_connection.h @@ -52,21 +52,41 @@ class MockCompletionServiceConnection (google::cloud::retail::v2::CompleteQueryRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ImportCompletionData)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ImportCompletionData(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ImportCompletionData(Matcher(_))) + /// @endcode MOCK_METHOD( future>, ImportCompletionData, (google::cloud::retail::v2::ImportCompletionDataRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ImportCompletionData(_, _)) + /// @endcode MOCK_METHOD( StatusOr, ImportCompletionData, (NoAwaitTag, google::cloud::retail::v2::ImportCompletionDataRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ImportCompletionData(Matcher(_))) + /// @endcode MOCK_METHOD( future>, ImportCompletionData, (google::longrunning::Operation const& operation), diff --git a/google/cloud/retail/v2/mocks/mock_model_connection.h b/google/cloud/retail/v2/mocks/mock_model_connection.h index 0d104c4a5ba5f..066a2bf46c48a 100644 --- a/google/cloud/retail/v2/mocks/mock_model_connection.h +++ b/google/cloud/retail/v2/mocks/mock_model_connection.h @@ -46,18 +46,38 @@ class MockModelServiceConnection : public retail_v2::ModelServiceConnection { public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateModel)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateModel(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateModel(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateModel, (google::cloud::retail::v2::CreateModelRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateModel(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateModel, (NoAwaitTag, google::cloud::retail::v2::CreateModelRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateModel(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateModel, (google::longrunning::Operation const& operation), (override)); @@ -85,19 +105,38 @@ class MockModelServiceConnection : public retail_v2::ModelServiceConnection { (google::cloud::retail::v2::UpdateModelRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, TuneModel)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, TuneModel(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// TuneModel(Matcher(_))) + /// @endcode MOCK_METHOD(future>, TuneModel, (google::cloud::retail::v2::TuneModelRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, TuneModel(_, _)) + /// @endcode MOCK_METHOD(StatusOr, TuneModel, (NoAwaitTag, google::cloud::retail::v2::TuneModelRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, TuneModel(Matcher(_))) + /// @endcode MOCK_METHOD(future>, TuneModel, (google::longrunning::Operation const& operation), (override)); diff --git a/google/cloud/retail/v2/mocks/mock_product_connection.h b/google/cloud/retail/v2/mocks/mock_product_connection.h index 994618d2f128a..1d385a94129a7 100644 --- a/google/cloud/retail/v2/mocks/mock_product_connection.h +++ b/google/cloud/retail/v2/mocks/mock_product_connection.h @@ -67,84 +67,170 @@ class MockProductServiceConnection (google::cloud::retail::v2::DeleteProductRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, PurgeProducts)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, PurgeProducts(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PurgeProducts(Matcher(_))) + /// @endcode MOCK_METHOD( future>, PurgeProducts, (google::cloud::retail::v2::PurgeProductsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, PurgeProducts(_, _)) + /// @endcode MOCK_METHOD(StatusOr, PurgeProducts, (NoAwaitTag, google::cloud::retail::v2::PurgeProductsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, PurgeProducts(Matcher(_))) + /// @endcode MOCK_METHOD( future>, PurgeProducts, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ImportProducts)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ImportProducts(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ImportProducts(Matcher(_))) + /// @endcode MOCK_METHOD( future>, ImportProducts, (google::cloud::retail::v2::ImportProductsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ImportProducts(_, _)) + /// @endcode MOCK_METHOD(StatusOr, ImportProducts, (NoAwaitTag, google::cloud::retail::v2::ImportProductsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, ImportProducts(Matcher(_))) + /// @endcode MOCK_METHOD( future>, ImportProducts, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SetInventory)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SetInventory(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SetInventory(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetInventory, (google::cloud::retail::v2::SetInventoryRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SetInventory(_, _)) + /// @endcode MOCK_METHOD(StatusOr, SetInventory, (NoAwaitTag, google::cloud::retail::v2::SetInventoryRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, SetInventory(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SetInventory, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, AddFulfillmentPlaces)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, AddFulfillmentPlaces(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// AddFulfillmentPlaces(Matcher(_))) + /// @endcode MOCK_METHOD( future>, AddFulfillmentPlaces, (google::cloud::retail::v2::AddFulfillmentPlacesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, AddFulfillmentPlaces(_, _)) + /// @endcode MOCK_METHOD( StatusOr, AddFulfillmentPlaces, (NoAwaitTag, google::cloud::retail::v2::AddFulfillmentPlacesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// AddFulfillmentPlaces(Matcher(_))) + /// @endcode MOCK_METHOD( future>, AddFulfillmentPlaces, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, RemoveFulfillmentPlaces)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, RemoveFulfillmentPlaces(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RemoveFulfillmentPlaces(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, @@ -153,41 +239,82 @@ class MockProductServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, RemoveFulfillmentPlaces(_, _)) + /// @endcode MOCK_METHOD(StatusOr, RemoveFulfillmentPlaces, (NoAwaitTag, google::cloud::retail::v2::RemoveFulfillmentPlacesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RemoveFulfillmentPlaces(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, RemoveFulfillmentPlaces, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, AddLocalInventories)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, AddLocalInventories(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// AddLocalInventories(Matcher(_))) + /// @endcode MOCK_METHOD( future>, AddLocalInventories, (google::cloud::retail::v2::AddLocalInventoriesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, AddLocalInventories(_, _)) + /// @endcode MOCK_METHOD( StatusOr, AddLocalInventories, (NoAwaitTag, google::cloud::retail::v2::AddLocalInventoriesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// AddLocalInventories(Matcher(_))) + /// @endcode MOCK_METHOD( future>, AddLocalInventories, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, RemoveLocalInventories)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, RemoveLocalInventories(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RemoveLocalInventories(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, @@ -195,12 +322,26 @@ class MockProductServiceConnection (google::cloud::retail::v2::RemoveLocalInventoriesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, RemoveLocalInventories(_, _)) + /// @endcode MOCK_METHOD( StatusOr, RemoveLocalInventories, (NoAwaitTag, google::cloud::retail::v2::RemoveLocalInventoriesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RemoveLocalInventories(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, diff --git a/google/cloud/retail/v2/mocks/mock_user_event_connection.h b/google/cloud/retail/v2/mocks/mock_user_event_connection.h index 241a8440ea87b..4a213580334f8 100644 --- a/google/cloud/retail/v2/mocks/mock_user_event_connection.h +++ b/google/cloud/retail/v2/mocks/mock_user_event_connection.h @@ -56,61 +56,121 @@ class MockUserEventServiceConnection (google::cloud::retail::v2::CollectUserEventRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, PurgeUserEvents)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, PurgeUserEvents(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PurgeUserEvents(Matcher(_))) + /// @endcode MOCK_METHOD( future>, PurgeUserEvents, (google::cloud::retail::v2::PurgeUserEventsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, PurgeUserEvents(_, _)) + /// @endcode MOCK_METHOD( StatusOr, PurgeUserEvents, (NoAwaitTag, google::cloud::retail::v2::PurgeUserEventsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, PurgeUserEvents(Matcher(_))) + /// @endcode MOCK_METHOD( future>, PurgeUserEvents, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ImportUserEvents)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ImportUserEvents(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ImportUserEvents(Matcher(_))) + /// @endcode MOCK_METHOD( future>, ImportUserEvents, (google::cloud::retail::v2::ImportUserEventsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ImportUserEvents(_, _)) + /// @endcode MOCK_METHOD( StatusOr, ImportUserEvents, (NoAwaitTag, google::cloud::retail::v2::ImportUserEventsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, ImportUserEvents(Matcher(_))) + /// @endcode MOCK_METHOD( future>, ImportUserEvents, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, RejoinUserEvents)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, RejoinUserEvents(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RejoinUserEvents(Matcher(_))) + /// @endcode MOCK_METHOD( future>, RejoinUserEvents, (google::cloud::retail::v2::RejoinUserEventsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, RejoinUserEvents(_, _)) + /// @endcode MOCK_METHOD( StatusOr, RejoinUserEvents, (NoAwaitTag, google::cloud::retail::v2::RejoinUserEventsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, RejoinUserEvents(Matcher(_))) + /// @endcode MOCK_METHOD( future>, RejoinUserEvents, (google::longrunning::Operation const& operation), diff --git a/google/cloud/run/v2/mocks/mock_executions_connection.h b/google/cloud/run/v2/mocks/mock_executions_connection.h index 9ba5928c95211..d2fe8df5f350a 100644 --- a/google/cloud/run/v2/mocks/mock_executions_connection.h +++ b/google/cloud/run/v2/mocks/mock_executions_connection.h @@ -54,36 +54,76 @@ class MockExecutionsConnection : public run_v2::ExecutionsConnection { (google::cloud::run::v2::ListExecutionsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteExecution)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteExecution(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteExecution(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteExecution, (google::cloud::run::v2::DeleteExecutionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteExecution(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteExecution, (NoAwaitTag, google::cloud::run::v2::DeleteExecutionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteExecution(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteExecution, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CancelExecution)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CancelExecution(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CancelExecution(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CancelExecution, (google::cloud::run::v2::CancelExecutionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CancelExecution(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CancelExecution, (NoAwaitTag, google::cloud::run::v2::CancelExecutionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CancelExecution(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CancelExecution, (google::longrunning::Operation const& operation), (override)); diff --git a/google/cloud/run/v2/mocks/mock_jobs_connection.h b/google/cloud/run/v2/mocks/mock_jobs_connection.h index eb8163ed1a54b..437d822f1c2fb 100644 --- a/google/cloud/run/v2/mocks/mock_jobs_connection.h +++ b/google/cloud/run/v2/mocks/mock_jobs_connection.h @@ -46,18 +46,37 @@ class MockJobsConnection : public run_v2::JobsConnection { public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateJob)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateJob(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateJob(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateJob, (google::cloud::run::v2::CreateJobRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateJob(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateJob, (NoAwaitTag, google::cloud::run::v2::CreateJobRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateJob(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateJob, (google::longrunning::Operation const& operation), (override)); @@ -68,48 +87,105 @@ class MockJobsConnection : public run_v2::JobsConnection { MOCK_METHOD((StreamRange), ListJobs, (google::cloud::run::v2::ListJobsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateJob)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateJob(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateJob(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateJob, (google::cloud::run::v2::UpdateJobRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateJob(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateJob, (NoAwaitTag, google::cloud::run::v2::UpdateJobRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateJob(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateJob, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteJob)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteJob(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteJob(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteJob, (google::cloud::run::v2::DeleteJobRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteJob(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteJob, (NoAwaitTag, google::cloud::run::v2::DeleteJobRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteJob(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteJob, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, RunJob)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, RunJob(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, RunJob(Matcher(_))) + /// @endcode MOCK_METHOD(future>, RunJob, (google::cloud::run::v2::RunJobRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, RunJob(_, _)) + /// @endcode MOCK_METHOD(StatusOr, RunJob, (NoAwaitTag, google::cloud::run::v2::RunJobRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, RunJob(Matcher(_))) + /// @endcode MOCK_METHOD(future>, RunJob, (google::longrunning::Operation const& operation), (override)); diff --git a/google/cloud/run/v2/mocks/mock_revisions_connection.h b/google/cloud/run/v2/mocks/mock_revisions_connection.h index 7100d14a50883..ad76389d2b4b9 100644 --- a/google/cloud/run/v2/mocks/mock_revisions_connection.h +++ b/google/cloud/run/v2/mocks/mock_revisions_connection.h @@ -54,19 +54,39 @@ class MockRevisionsConnection : public run_v2::RevisionsConnection { (google::cloud::run::v2::ListRevisionsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteRevision)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteRevision(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteRevision(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteRevision, (google::cloud::run::v2::DeleteRevisionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteRevision(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteRevision, (NoAwaitTag, google::cloud::run::v2::DeleteRevisionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteRevision(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteRevision, (google::longrunning::Operation const& operation), (override)); diff --git a/google/cloud/run/v2/mocks/mock_services_connection.h b/google/cloud/run/v2/mocks/mock_services_connection.h index 1fa911c298fb7..071584771684c 100644 --- a/google/cloud/run/v2/mocks/mock_services_connection.h +++ b/google/cloud/run/v2/mocks/mock_services_connection.h @@ -46,18 +46,38 @@ class MockServicesConnection : public run_v2::ServicesConnection { public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateService)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateService(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateService(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateService, (google::cloud::run::v2::CreateServiceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateService(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateService, (NoAwaitTag, google::cloud::run::v2::CreateServiceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateService(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateService, (google::longrunning::Operation const& operation), (override)); @@ -69,33 +89,73 @@ class MockServicesConnection : public run_v2::ServicesConnection { (google::cloud::run::v2::ListServicesRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateService)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateService(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateService(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateService, (google::cloud::run::v2::UpdateServiceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateService(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateService, (NoAwaitTag, google::cloud::run::v2::UpdateServiceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateService(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateService, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteService)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteService(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteService(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteService, (google::cloud::run::v2::DeleteServiceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteService(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteService, (NoAwaitTag, google::cloud::run::v2::DeleteServiceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteService(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteService, (google::longrunning::Operation const& operation), (override)); diff --git a/google/cloud/securesourcemanager/v1/mocks/mock_secure_source_manager_connection.h b/google/cloud/securesourcemanager/v1/mocks/mock_secure_source_manager_connection.h index 742558251e9a2..fe792781a73db 100644 --- a/google/cloud/securesourcemanager/v1/mocks/mock_secure_source_manager_connection.h +++ b/google/cloud/securesourcemanager/v1/mocks/mock_secure_source_manager_connection.h @@ -59,9 +59,15 @@ class MockSecureSourceManagerConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateInstance)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateInstance(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateInstance(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateInstance, @@ -69,6 +75,12 @@ class MockSecureSourceManagerConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateInstance(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateInstance, (NoAwaitTag, @@ -76,14 +88,28 @@ class MockSecureSourceManagerConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateInstance(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateInstance, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteInstance)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteInstance(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteInstance(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, @@ -92,6 +118,12 @@ class MockSecureSourceManagerConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteInstance(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteInstance, (NoAwaitTag, @@ -99,6 +131,14 @@ class MockSecureSourceManagerConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteInstance(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, @@ -118,9 +158,15 @@ class MockSecureSourceManagerConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateRepository)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateRepository(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateRepository(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateRepository, @@ -128,6 +174,12 @@ class MockSecureSourceManagerConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateRepository(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateRepository, (NoAwaitTag, @@ -135,14 +187,28 @@ class MockSecureSourceManagerConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateRepository(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateRepository, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteRepository)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteRepository(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteRepository(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, @@ -151,6 +217,12 @@ class MockSecureSourceManagerConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteRepository(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteRepository, (NoAwaitTag, @@ -158,6 +230,14 @@ class MockSecureSourceManagerConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteRepository(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, diff --git a/google/cloud/securitycenter/v1/mocks/mock_security_center_connection.h b/google/cloud/securitycenter/v1/mocks/mock_security_center_connection.h index 8f74653520096..2065da0bd1267 100644 --- a/google/cloud/securitycenter/v1/mocks/mock_security_center_connection.h +++ b/google/cloud/securitycenter/v1/mocks/mock_security_center_connection.h @@ -47,9 +47,15 @@ class MockSecurityCenterConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, BulkMuteFindings)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, BulkMuteFindings(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// BulkMuteFindings(Matcher(_))) + /// @endcode MOCK_METHOD(future>, BulkMuteFindings, @@ -57,12 +63,26 @@ class MockSecurityCenterConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, BulkMuteFindings(_, _)) + /// @endcode MOCK_METHOD(StatusOr, BulkMuteFindings, (NoAwaitTag, google::cloud::securitycenter::v1::BulkMuteFindingsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, BulkMuteFindings(Matcher(_))) + /// @endcode MOCK_METHOD(future>, BulkMuteFindings, @@ -242,9 +262,15 @@ class MockSecurityCenterConnection (google::cloud::securitycenter::v1::ListSourcesRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, RunAssetDiscovery)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, RunAssetDiscovery(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RunAssetDiscovery(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -253,6 +279,12 @@ class MockSecurityCenterConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, RunAssetDiscovery(_, _)) + /// @endcode MOCK_METHOD( StatusOr, RunAssetDiscovery, (NoAwaitTag, @@ -260,6 +292,14 @@ class MockSecurityCenterConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RunAssetDiscovery(Matcher(_))) + /// @endcode MOCK_METHOD( future>, diff --git a/google/cloud/securitycenter/v2/mocks/mock_security_center_connection.h b/google/cloud/securitycenter/v2/mocks/mock_security_center_connection.h index 61a5a62bbd2d4..e35cfb36c1142 100644 --- a/google/cloud/securitycenter/v2/mocks/mock_security_center_connection.h +++ b/google/cloud/securitycenter/v2/mocks/mock_security_center_connection.h @@ -54,9 +54,15 @@ class MockSecurityCenterConnection BatchCreateResourceValueConfigsRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, BulkMuteFindings)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, BulkMuteFindings(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// BulkMuteFindings(Matcher(_))) + /// @endcode MOCK_METHOD(future>, BulkMuteFindings, @@ -64,12 +70,26 @@ class MockSecurityCenterConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, BulkMuteFindings(_, _)) + /// @endcode MOCK_METHOD(StatusOr, BulkMuteFindings, (NoAwaitTag, google::cloud::securitycenter::v2::BulkMuteFindingsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, BulkMuteFindings(Matcher(_))) + /// @endcode MOCK_METHOD(future>, BulkMuteFindings, diff --git a/google/cloud/servicemanagement/v1/mocks/mock_service_manager_connection.h b/google/cloud/servicemanagement/v1/mocks/mock_service_manager_connection.h index bd686fa6878da..0a9da69776019 100644 --- a/google/cloud/servicemanagement/v1/mocks/mock_service_manager_connection.h +++ b/google/cloud/servicemanagement/v1/mocks/mock_service_manager_connection.h @@ -57,49 +57,95 @@ class MockServiceManagerConnection (google::api::servicemanagement::v1::GetServiceRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateService)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateService(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateService(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateService, (google::api::servicemanagement::v1::CreateServiceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateService(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateService, (NoAwaitTag, google::api::servicemanagement::v1::CreateServiceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateService(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateService, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteService)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteService(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteService(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteService, (google::api::servicemanagement::v1::DeleteServiceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteService(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteService, (NoAwaitTag, google::api::servicemanagement::v1::DeleteServiceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteService(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteService, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UndeleteService)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UndeleteService(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UndeleteService(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UndeleteService, @@ -107,12 +153,26 @@ class MockServiceManagerConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UndeleteService(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UndeleteService, (NoAwaitTag, google::api::servicemanagement::v1::UndeleteServiceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UndeleteService(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UndeleteService, @@ -135,9 +195,15 @@ class MockServiceManagerConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SubmitConfigSource)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SubmitConfigSource(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SubmitConfigSource(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -146,6 +212,12 @@ class MockServiceManagerConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SubmitConfigSource(_, _)) + /// @endcode MOCK_METHOD( StatusOr, SubmitConfigSource, (NoAwaitTag, @@ -153,6 +225,14 @@ class MockServiceManagerConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SubmitConfigSource(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -171,9 +251,15 @@ class MockServiceManagerConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateServiceRollout)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateServiceRollout(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateServiceRollout(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateServiceRollout, @@ -181,6 +267,12 @@ class MockServiceManagerConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateServiceRollout(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateServiceRollout, (NoAwaitTag, @@ -188,6 +280,14 @@ class MockServiceManagerConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateServiceRollout(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateServiceRollout, (google::longrunning::Operation const& operation), (override)); diff --git a/google/cloud/serviceusage/v1/mocks/mock_service_usage_connection.h b/google/cloud/serviceusage/v1/mocks/mock_service_usage_connection.h index e4e463e7af47c..42055bd190c79 100644 --- a/google/cloud/serviceusage/v1/mocks/mock_service_usage_connection.h +++ b/google/cloud/serviceusage/v1/mocks/mock_service_usage_connection.h @@ -47,41 +47,81 @@ class MockServiceUsageConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, EnableService)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, EnableService(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// EnableService(Matcher(_))) + /// @endcode MOCK_METHOD( future>, EnableService, (google::api::serviceusage::v1::EnableServiceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, EnableService(_, _)) + /// @endcode MOCK_METHOD( StatusOr, EnableService, (NoAwaitTag, google::api::serviceusage::v1::EnableServiceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, EnableService(Matcher(_))) + /// @endcode MOCK_METHOD( future>, EnableService, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DisableService)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DisableService(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DisableService(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DisableService, (google::api::serviceusage::v1::DisableServiceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DisableService(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DisableService, (NoAwaitTag, google::api::serviceusage::v1::DisableServiceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DisableService(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DisableService, (google::longrunning::Operation const& operation), @@ -96,9 +136,15 @@ class MockServiceUsageConnection (google::api::serviceusage::v1::ListServicesRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, BatchEnableServices)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, BatchEnableServices(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// BatchEnableServices(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, @@ -107,12 +153,26 @@ class MockServiceUsageConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, BatchEnableServices(_, _)) + /// @endcode MOCK_METHOD(StatusOr, BatchEnableServices, (NoAwaitTag, google::api::serviceusage::v1::BatchEnableServicesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// BatchEnableServices(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, diff --git a/google/cloud/shell/v1/mocks/mock_cloud_shell_connection.h b/google/cloud/shell/v1/mocks/mock_cloud_shell_connection.h index 74b6b241bee88..a3b2aaf00cf16 100644 --- a/google/cloud/shell/v1/mocks/mock_cloud_shell_connection.h +++ b/google/cloud/shell/v1/mocks/mock_cloud_shell_connection.h @@ -51,77 +51,157 @@ class MockCloudShellServiceConnection (google::cloud::shell::v1::GetEnvironmentRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, StartEnvironment)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, StartEnvironment(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// StartEnvironment(Matcher(_))) + /// @endcode MOCK_METHOD( future>, StartEnvironment, (google::cloud::shell::v1::StartEnvironmentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, StartEnvironment(_, _)) + /// @endcode MOCK_METHOD( StatusOr, StartEnvironment, (NoAwaitTag, google::cloud::shell::v1::StartEnvironmentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, StartEnvironment(Matcher(_))) + /// @endcode MOCK_METHOD( future>, StartEnvironment, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, AuthorizeEnvironment)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, AuthorizeEnvironment(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// AuthorizeEnvironment(Matcher(_))) + /// @endcode MOCK_METHOD( future>, AuthorizeEnvironment, (google::cloud::shell::v1::AuthorizeEnvironmentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, AuthorizeEnvironment(_, _)) + /// @endcode MOCK_METHOD( StatusOr, AuthorizeEnvironment, (NoAwaitTag, google::cloud::shell::v1::AuthorizeEnvironmentRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// AuthorizeEnvironment(Matcher(_))) + /// @endcode MOCK_METHOD( future>, AuthorizeEnvironment, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, AddPublicKey)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, AddPublicKey(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// AddPublicKey(Matcher(_))) + /// @endcode MOCK_METHOD(future>, AddPublicKey, (google::cloud::shell::v1::AddPublicKeyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, AddPublicKey(_, _)) + /// @endcode MOCK_METHOD(StatusOr, AddPublicKey, (NoAwaitTag, google::cloud::shell::v1::AddPublicKeyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, AddPublicKey(Matcher(_))) + /// @endcode MOCK_METHOD(future>, AddPublicKey, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, RemovePublicKey)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, RemovePublicKey(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RemovePublicKey(Matcher(_))) + /// @endcode MOCK_METHOD( future>, RemovePublicKey, (google::cloud::shell::v1::RemovePublicKeyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, RemovePublicKey(_, _)) + /// @endcode MOCK_METHOD(StatusOr, RemovePublicKey, (NoAwaitTag, google::cloud::shell::v1::RemovePublicKeyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, RemovePublicKey(Matcher(_))) + /// @endcode MOCK_METHOD( future>, RemovePublicKey, (google::longrunning::Operation const& operation), diff --git a/google/cloud/spanner/admin/mocks/mock_database_admin_connection.h b/google/cloud/spanner/admin/mocks/mock_database_admin_connection.h index db0eaf6ad3bc2..5edfef31aeeba 100644 --- a/google/cloud/spanner/admin/mocks/mock_database_admin_connection.h +++ b/google/cloud/spanner/admin/mocks/mock_database_admin_connection.h @@ -53,9 +53,15 @@ class MockDatabaseAdminConnection (google::spanner::admin::database::v1::ListDatabasesRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateDatabase)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateDatabase(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateDatabase(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateDatabase, @@ -63,6 +69,12 @@ class MockDatabaseAdminConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateDatabase(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateDatabase, (NoAwaitTag, @@ -70,6 +82,14 @@ class MockDatabaseAdminConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateDatabase(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateDatabase, (google::longrunning::Operation const& operation), (override)); @@ -79,9 +99,15 @@ class MockDatabaseAdminConnection (google::spanner::admin::database::v1::GetDatabaseRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateDatabase)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateDatabase(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateDatabase(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateDatabase, @@ -89,6 +115,12 @@ class MockDatabaseAdminConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateDatabase(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateDatabase, (NoAwaitTag, @@ -96,13 +128,27 @@ class MockDatabaseAdminConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateDatabase(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateDatabase, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateDatabaseDdl)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateDatabaseDdl(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateDatabaseDdl(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -111,6 +157,12 @@ class MockDatabaseAdminConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateDatabaseDdl(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateDatabaseDdl, (NoAwaitTag, @@ -118,6 +170,14 @@ class MockDatabaseAdminConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateDatabaseDdl(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -149,40 +209,80 @@ class MockDatabaseAdminConnection (google::iam::v1::TestIamPermissionsRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateBackup)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateBackup(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateBackup(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateBackup, (google::spanner::admin::database::v1::CreateBackupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateBackup(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateBackup, (NoAwaitTag, google::spanner::admin::database::v1::CreateBackupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateBackup(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateBackup, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CopyBackup)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CopyBackup(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CopyBackup(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CopyBackup, (google::spanner::admin::database::v1::CopyBackupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CopyBackup(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CopyBackup, (NoAwaitTag, google::spanner::admin::database::v1::CopyBackupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CopyBackup(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CopyBackup, (google::longrunning::Operation const& operation), (override)); @@ -208,9 +308,15 @@ class MockDatabaseAdminConnection (google::spanner::admin::database::v1::ListBackupsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, RestoreDatabase)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, RestoreDatabase(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RestoreDatabase(Matcher(_))) + /// @endcode MOCK_METHOD( future>, RestoreDatabase, @@ -218,6 +324,12 @@ class MockDatabaseAdminConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, RestoreDatabase(_, _)) + /// @endcode MOCK_METHOD( StatusOr, RestoreDatabase, (NoAwaitTag, @@ -225,6 +337,14 @@ class MockDatabaseAdminConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, RestoreDatabase(Matcher(_))) + /// @endcode MOCK_METHOD(future>, RestoreDatabase, (google::longrunning::Operation const& operation), (override)); diff --git a/google/cloud/spanner/admin/mocks/mock_instance_admin_connection.h b/google/cloud/spanner/admin/mocks/mock_instance_admin_connection.h index 921f942448f4a..979c1aea624fc 100644 --- a/google/cloud/spanner/admin/mocks/mock_instance_admin_connection.h +++ b/google/cloud/spanner/admin/mocks/mock_instance_admin_connection.h @@ -61,9 +61,15 @@ class MockInstanceAdminConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateInstanceConfig)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateInstanceConfig(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateInstanceConfig(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateInstanceConfig, @@ -71,6 +77,12 @@ class MockInstanceAdminConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateInstanceConfig(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateInstanceConfig, (NoAwaitTag, @@ -78,14 +90,28 @@ class MockInstanceAdminConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateInstanceConfig(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateInstanceConfig, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateInstanceConfig)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateInstanceConfig(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateInstanceConfig(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateInstanceConfig, @@ -93,6 +119,12 @@ class MockInstanceAdminConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateInstanceConfig(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateInstanceConfig, (NoAwaitTag, @@ -100,6 +132,14 @@ class MockInstanceAdminConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateInstanceConfig(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateInstanceConfig, (google::longrunning::Operation const& operation), @@ -136,9 +176,15 @@ class MockInstanceAdminConnection (google::spanner::admin::instance::v1::GetInstanceRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateInstance)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateInstance(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateInstance(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateInstance, @@ -146,6 +192,12 @@ class MockInstanceAdminConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateInstance(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateInstance, (NoAwaitTag, @@ -153,13 +205,27 @@ class MockInstanceAdminConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateInstance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateInstance, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateInstance)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateInstance(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateInstance(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateInstance, @@ -167,6 +233,12 @@ class MockInstanceAdminConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateInstance(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateInstance, (NoAwaitTag, @@ -174,6 +246,14 @@ class MockInstanceAdminConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateInstance(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateInstance, (google::longrunning::Operation const& operation), (override)); @@ -204,9 +284,15 @@ class MockInstanceAdminConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateInstancePartition)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateInstancePartition(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateInstancePartition(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateInstancePartition, @@ -214,11 +300,26 @@ class MockInstanceAdminConnection CreateInstancePartitionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateInstancePartition(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateInstancePartition, (NoAwaitTag, google::spanner::admin::instance::v1:: CreateInstancePartitionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateInstancePartition(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateInstancePartition, @@ -229,9 +330,15 @@ class MockInstanceAdminConnection DeleteInstancePartitionRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateInstancePartition)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateInstancePartition(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateInstancePartition(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateInstancePartition, @@ -239,11 +346,26 @@ class MockInstanceAdminConnection UpdateInstancePartitionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateInstancePartition(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateInstancePartition, (NoAwaitTag, google::spanner::admin::instance::v1:: UpdateInstancePartitionRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateInstancePartition(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateInstancePartition, diff --git a/google/cloud/speech/v1/mocks/mock_speech_connection.h b/google/cloud/speech/v1/mocks/mock_speech_connection.h index 96b88be1f0426..4cdc15d253e63 100644 --- a/google/cloud/speech/v1/mocks/mock_speech_connection.h +++ b/google/cloud/speech/v1/mocks/mock_speech_connection.h @@ -50,21 +50,41 @@ class MockSpeechConnection : public speech_v1::SpeechConnection { (google::cloud::speech::v1::RecognizeRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, LongRunningRecognize)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, LongRunningRecognize(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// LongRunningRecognize(Matcher(_))) + /// @endcode MOCK_METHOD( future>, LongRunningRecognize, (google::cloud::speech::v1::LongRunningRecognizeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, LongRunningRecognize(_, _)) + /// @endcode MOCK_METHOD( StatusOr, LongRunningRecognize, (NoAwaitTag, google::cloud::speech::v1::LongRunningRecognizeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// LongRunningRecognize(Matcher(_))) + /// @endcode MOCK_METHOD( future>, LongRunningRecognize, (google::longrunning::Operation const& operation), diff --git a/google/cloud/speech/v2/mocks/mock_speech_connection.h b/google/cloud/speech/v2/mocks/mock_speech_connection.h index de01acf4f13c9..087649bf15ec1 100644 --- a/google/cloud/speech/v2/mocks/mock_speech_connection.h +++ b/google/cloud/speech/v2/mocks/mock_speech_connection.h @@ -46,20 +46,40 @@ class MockSpeechConnection : public speech_v2::SpeechConnection { public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateRecognizer)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateRecognizer(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateRecognizer(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateRecognizer, (google::cloud::speech::v2::CreateRecognizerRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateRecognizer(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateRecognizer, (NoAwaitTag, google::cloud::speech::v2::CreateRecognizerRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateRecognizer(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateRecognizer, (google::longrunning::Operation const& operation), (override)); @@ -73,57 +93,117 @@ class MockSpeechConnection : public speech_v2::SpeechConnection { (google::cloud::speech::v2::GetRecognizerRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateRecognizer)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateRecognizer(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateRecognizer(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateRecognizer, (google::cloud::speech::v2::UpdateRecognizerRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateRecognizer(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateRecognizer, (NoAwaitTag, google::cloud::speech::v2::UpdateRecognizerRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateRecognizer(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateRecognizer, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteRecognizer)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteRecognizer(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteRecognizer(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteRecognizer, (google::cloud::speech::v2::DeleteRecognizerRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteRecognizer(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteRecognizer, (NoAwaitTag, google::cloud::speech::v2::DeleteRecognizerRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteRecognizer(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteRecognizer, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UndeleteRecognizer)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UndeleteRecognizer(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UndeleteRecognizer(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UndeleteRecognizer, (google::cloud::speech::v2::UndeleteRecognizerRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UndeleteRecognizer(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UndeleteRecognizer, (NoAwaitTag, google::cloud::speech::v2::UndeleteRecognizerRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UndeleteRecognizer(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UndeleteRecognizer, (google::longrunning::Operation const& operation), (override)); @@ -137,20 +217,40 @@ class MockSpeechConnection : public speech_v2::SpeechConnection { google::cloud::speech::v2::StreamingRecognizeResponse>>), AsyncStreamingRecognize, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, BatchRecognize)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, BatchRecognize(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// BatchRecognize(Matcher(_))) + /// @endcode MOCK_METHOD( future>, BatchRecognize, (google::cloud::speech::v2::BatchRecognizeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, BatchRecognize(_, _)) + /// @endcode MOCK_METHOD(StatusOr, BatchRecognize, (NoAwaitTag, google::cloud::speech::v2::BatchRecognizeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, BatchRecognize(Matcher(_))) + /// @endcode MOCK_METHOD( future>, BatchRecognize, (google::longrunning::Operation const& operation), @@ -164,21 +264,41 @@ class MockSpeechConnection : public speech_v2::SpeechConnection { (google::cloud::speech::v2::UpdateConfigRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateCustomClass)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateCustomClass(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateCustomClass(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateCustomClass, (google::cloud::speech::v2::CreateCustomClassRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateCustomClass(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateCustomClass, (NoAwaitTag, google::cloud::speech::v2::CreateCustomClassRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateCustomClass(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateCustomClass, (google::longrunning::Operation const& operation), (override)); @@ -192,77 +312,157 @@ class MockSpeechConnection : public speech_v2::SpeechConnection { (google::cloud::speech::v2::GetCustomClassRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateCustomClass)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateCustomClass(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateCustomClass(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateCustomClass, (google::cloud::speech::v2::UpdateCustomClassRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateCustomClass(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateCustomClass, (NoAwaitTag, google::cloud::speech::v2::UpdateCustomClassRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateCustomClass(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateCustomClass, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteCustomClass)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteCustomClass(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteCustomClass(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteCustomClass, (google::cloud::speech::v2::DeleteCustomClassRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteCustomClass(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteCustomClass, (NoAwaitTag, google::cloud::speech::v2::DeleteCustomClassRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteCustomClass(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteCustomClass, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UndeleteCustomClass)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UndeleteCustomClass(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UndeleteCustomClass(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UndeleteCustomClass, (google::cloud::speech::v2::UndeleteCustomClassRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UndeleteCustomClass(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UndeleteCustomClass, (NoAwaitTag, google::cloud::speech::v2::UndeleteCustomClassRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UndeleteCustomClass(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UndeleteCustomClass, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreatePhraseSet)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreatePhraseSet(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreatePhraseSet(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreatePhraseSet, (google::cloud::speech::v2::CreatePhraseSetRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreatePhraseSet(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreatePhraseSet, (NoAwaitTag, google::cloud::speech::v2::CreatePhraseSetRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreatePhraseSet(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreatePhraseSet, (google::longrunning::Operation const& operation), (override)); @@ -276,56 +476,116 @@ class MockSpeechConnection : public speech_v2::SpeechConnection { (google::cloud::speech::v2::GetPhraseSetRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdatePhraseSet)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdatePhraseSet(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdatePhraseSet(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdatePhraseSet, (google::cloud::speech::v2::UpdatePhraseSetRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdatePhraseSet(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdatePhraseSet, (NoAwaitTag, google::cloud::speech::v2::UpdatePhraseSetRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdatePhraseSet(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdatePhraseSet, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeletePhraseSet)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeletePhraseSet(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeletePhraseSet(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeletePhraseSet, (google::cloud::speech::v2::DeletePhraseSetRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeletePhraseSet(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeletePhraseSet, (NoAwaitTag, google::cloud::speech::v2::DeletePhraseSetRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeletePhraseSet(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeletePhraseSet, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UndeletePhraseSet)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UndeletePhraseSet(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UndeletePhraseSet(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UndeletePhraseSet, (google::cloud::speech::v2::UndeletePhraseSetRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UndeletePhraseSet(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UndeletePhraseSet, (NoAwaitTag, google::cloud::speech::v2::UndeletePhraseSetRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UndeletePhraseSet(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UndeletePhraseSet, (google::longrunning::Operation const& operation), (override)); diff --git a/google/cloud/storagecontrol/v2/mocks/mock_storage_control_connection.h b/google/cloud/storagecontrol/v2/mocks/mock_storage_control_connection.h index 8b52e41c5f95a..9476edaf5ffa5 100644 --- a/google/cloud/storagecontrol/v2/mocks/mock_storage_control_connection.h +++ b/google/cloud/storagecontrol/v2/mocks/mock_storage_control_connection.h @@ -65,20 +65,40 @@ class MockStorageControlConnection (google::storage::control::v2::ListFoldersRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, RenameFolder)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, RenameFolder(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RenameFolder(Matcher(_))) + /// @endcode MOCK_METHOD( future>, RenameFolder, (google::storage::control::v2::RenameFolderRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, RenameFolder(_, _)) + /// @endcode MOCK_METHOD( StatusOr, RenameFolder, (NoAwaitTag, google::storage::control::v2::RenameFolderRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, RenameFolder(Matcher(_))) + /// @endcode MOCK_METHOD(future>, RenameFolder, (google::longrunning::Operation const& operation), (override)); diff --git a/google/cloud/storagetransfer/v1/mocks/mock_storage_transfer_connection.h b/google/cloud/storagetransfer/v1/mocks/mock_storage_transfer_connection.h index 402e90714e582..c2f7b035d4f34 100644 --- a/google/cloud/storagetransfer/v1/mocks/mock_storage_transfer_connection.h +++ b/google/cloud/storagetransfer/v1/mocks/mock_storage_transfer_connection.h @@ -85,21 +85,41 @@ class MockStorageTransferServiceConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, RunTransferJob)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, RunTransferJob(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RunTransferJob(Matcher(_))) + /// @endcode MOCK_METHOD( future>, RunTransferJob, (google::storagetransfer::v1::RunTransferJobRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, RunTransferJob(_, _)) + /// @endcode MOCK_METHOD( StatusOr, RunTransferJob, (NoAwaitTag, google::storagetransfer::v1::RunTransferJobRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, RunTransferJob(Matcher(_))) + /// @endcode MOCK_METHOD(future>, RunTransferJob, (google::longrunning::Operation const& operation), (override)); diff --git a/google/cloud/talent/v4/mocks/mock_job_connection.h b/google/cloud/talent/v4/mocks/mock_job_connection.h index cd1743b367411..21b8be10df8ee 100644 --- a/google/cloud/talent/v4/mocks/mock_job_connection.h +++ b/google/cloud/talent/v4/mocks/mock_job_connection.h @@ -50,21 +50,41 @@ class MockJobServiceConnection : public talent_v4::JobServiceConnection { (google::cloud::talent::v4::CreateJobRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, BatchCreateJobs)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, BatchCreateJobs(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// BatchCreateJobs(Matcher(_))) + /// @endcode MOCK_METHOD( future>, BatchCreateJobs, (google::cloud::talent::v4::BatchCreateJobsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, BatchCreateJobs(_, _)) + /// @endcode MOCK_METHOD( StatusOr, BatchCreateJobs, (NoAwaitTag, google::cloud::talent::v4::BatchCreateJobsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, BatchCreateJobs(Matcher(_))) + /// @endcode MOCK_METHOD( future>, BatchCreateJobs, (google::longrunning::Operation const& operation), @@ -78,21 +98,41 @@ class MockJobServiceConnection : public talent_v4::JobServiceConnection { (google::cloud::talent::v4::UpdateJobRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, BatchUpdateJobs)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, BatchUpdateJobs(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// BatchUpdateJobs(Matcher(_))) + /// @endcode MOCK_METHOD( future>, BatchUpdateJobs, (google::cloud::talent::v4::BatchUpdateJobsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, BatchUpdateJobs(_, _)) + /// @endcode MOCK_METHOD( StatusOr, BatchUpdateJobs, (NoAwaitTag, google::cloud::talent::v4::BatchUpdateJobsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, BatchUpdateJobs(Matcher(_))) + /// @endcode MOCK_METHOD( future>, BatchUpdateJobs, (google::longrunning::Operation const& operation), @@ -102,21 +142,41 @@ class MockJobServiceConnection : public talent_v4::JobServiceConnection { (google::cloud::talent::v4::DeleteJobRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, BatchDeleteJobs)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, BatchDeleteJobs(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// BatchDeleteJobs(Matcher(_))) + /// @endcode MOCK_METHOD( future>, BatchDeleteJobs, (google::cloud::talent::v4::BatchDeleteJobsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, BatchDeleteJobs(_, _)) + /// @endcode MOCK_METHOD( StatusOr, BatchDeleteJobs, (NoAwaitTag, google::cloud::talent::v4::BatchDeleteJobsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, BatchDeleteJobs(Matcher(_))) + /// @endcode MOCK_METHOD( future>, BatchDeleteJobs, (google::longrunning::Operation const& operation), diff --git a/google/cloud/telcoautomation/v1/mocks/mock_telco_automation_connection.h b/google/cloud/telcoautomation/v1/mocks/mock_telco_automation_connection.h index 3d6dabdbf2bb9..6ee170017629f 100644 --- a/google/cloud/telcoautomation/v1/mocks/mock_telco_automation_connection.h +++ b/google/cloud/telcoautomation/v1/mocks/mock_telco_automation_connection.h @@ -61,9 +61,15 @@ class MockTelcoAutomationConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateOrchestrationCluster)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateOrchestrationCluster(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateOrchestrationCluster(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, @@ -72,6 +78,12 @@ class MockTelcoAutomationConnection CreateOrchestrationClusterRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateOrchestrationCluster(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateOrchestrationCluster, (NoAwaitTag, @@ -79,15 +91,30 @@ class MockTelcoAutomationConnection CreateOrchestrationClusterRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateOrchestrationCluster(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, CreateOrchestrationCluster, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteOrchestrationCluster)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteOrchestrationCluster(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteOrchestrationCluster(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteOrchestrationCluster, @@ -95,6 +122,12 @@ class MockTelcoAutomationConnection DeleteOrchestrationClusterRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteOrchestrationCluster(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteOrchestrationCluster, (NoAwaitTag, @@ -102,6 +135,15 @@ class MockTelcoAutomationConnection DeleteOrchestrationClusterRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteOrchestrationCluster(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteOrchestrationCluster, @@ -117,40 +159,80 @@ class MockTelcoAutomationConnection (google::cloud::telcoautomation::v1::GetEdgeSlmRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateEdgeSlm)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateEdgeSlm(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateEdgeSlm(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateEdgeSlm, (google::cloud::telcoautomation::v1::CreateEdgeSlmRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateEdgeSlm(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateEdgeSlm, (NoAwaitTag, google::cloud::telcoautomation::v1::CreateEdgeSlmRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateEdgeSlm(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateEdgeSlm, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteEdgeSlm)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteEdgeSlm(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteEdgeSlm(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteEdgeSlm, (google::cloud::telcoautomation::v1::DeleteEdgeSlmRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteEdgeSlm(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteEdgeSlm, (NoAwaitTag, google::cloud::telcoautomation::v1::DeleteEdgeSlmRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteEdgeSlm(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteEdgeSlm, (google::longrunning::Operation const& operation), diff --git a/google/cloud/tpu/v1/mocks/mock_tpu_connection.h b/google/cloud/tpu/v1/mocks/mock_tpu_connection.h index 566b82642f5a4..810c163875b7d 100644 --- a/google/cloud/tpu/v1/mocks/mock_tpu_connection.h +++ b/google/cloud/tpu/v1/mocks/mock_tpu_connection.h @@ -53,78 +53,174 @@ class MockTpuConnection : public tpu_v1::TpuConnection { (google::cloud::tpu::v1::GetNodeRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateNode)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateNode(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateNode(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateNode, (google::cloud::tpu::v1::CreateNodeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateNode(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateNode, (NoAwaitTag, google::cloud::tpu::v1::CreateNodeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateNode(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateNode, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteNode)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteNode(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteNode(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteNode, (google::cloud::tpu::v1::DeleteNodeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteNode(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteNode, (NoAwaitTag, google::cloud::tpu::v1::DeleteNodeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteNode(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteNode, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ReimageNode)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ReimageNode(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ReimageNode(Matcher(_))) + /// @endcode MOCK_METHOD(future>, ReimageNode, (google::cloud::tpu::v1::ReimageNodeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ReimageNode(_, _)) + /// @endcode MOCK_METHOD(StatusOr, ReimageNode, (NoAwaitTag, google::cloud::tpu::v1::ReimageNodeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, ReimageNode(Matcher(_))) + /// @endcode MOCK_METHOD(future>, ReimageNode, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, StopNode)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, StopNode(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// StopNode(Matcher(_))) + /// @endcode MOCK_METHOD(future>, StopNode, (google::cloud::tpu::v1::StopNodeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, StopNode(_, _)) + /// @endcode MOCK_METHOD(StatusOr, StopNode, (NoAwaitTag, google::cloud::tpu::v1::StopNodeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, StopNode(Matcher(_))) + /// @endcode MOCK_METHOD(future>, StopNode, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, StartNode)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, StartNode(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// StartNode(Matcher(_))) + /// @endcode MOCK_METHOD(future>, StartNode, (google::cloud::tpu::v1::StartNodeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, StartNode(_, _)) + /// @endcode MOCK_METHOD(StatusOr, StartNode, (NoAwaitTag, google::cloud::tpu::v1::StartNodeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, StartNode(Matcher(_))) + /// @endcode MOCK_METHOD(future>, StartNode, (google::longrunning::Operation const& operation), (override)); diff --git a/google/cloud/tpu/v2/mocks/mock_tpu_connection.h b/google/cloud/tpu/v2/mocks/mock_tpu_connection.h index 48af66ae98515..e08cd0b49bd8c 100644 --- a/google/cloud/tpu/v2/mocks/mock_tpu_connection.h +++ b/google/cloud/tpu/v2/mocks/mock_tpu_connection.h @@ -53,80 +53,175 @@ class MockTpuConnection : public tpu_v2::TpuConnection { (google::cloud::tpu::v2::GetNodeRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateNode)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateNode(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateNode(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateNode, (google::cloud::tpu::v2::CreateNodeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateNode(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateNode, (NoAwaitTag, google::cloud::tpu::v2::CreateNodeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateNode(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateNode, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteNode)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteNode(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteNode(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteNode, (google::cloud::tpu::v2::DeleteNodeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteNode(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteNode, (NoAwaitTag, google::cloud::tpu::v2::DeleteNodeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteNode(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteNode, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, StopNode)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, StopNode(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// StopNode(Matcher(_))) + /// @endcode MOCK_METHOD(future>, StopNode, (google::cloud::tpu::v2::StopNodeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, StopNode(_, _)) + /// @endcode MOCK_METHOD(StatusOr, StopNode, (NoAwaitTag, google::cloud::tpu::v2::StopNodeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, StopNode(Matcher(_))) + /// @endcode MOCK_METHOD(future>, StopNode, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, StartNode)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, StartNode(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// StartNode(Matcher(_))) + /// @endcode MOCK_METHOD(future>, StartNode, (google::cloud::tpu::v2::StartNodeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, StartNode(_, _)) + /// @endcode MOCK_METHOD(StatusOr, StartNode, (NoAwaitTag, google::cloud::tpu::v2::StartNodeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, StartNode(Matcher(_))) + /// @endcode MOCK_METHOD(future>, StartNode, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateNode)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateNode(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateNode(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateNode, (google::cloud::tpu::v2::UpdateNodeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateNode(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateNode, (NoAwaitTag, google::cloud::tpu::v2::UpdateNodeRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateNode(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateNode, (google::longrunning::Operation const& operation), (override)); diff --git a/google/cloud/translate/v3/mocks/mock_translation_connection.h b/google/cloud/translate/v3/mocks/mock_translation_connection.h index e7b0f136bdf4a..76047f0b9d893 100644 --- a/google/cloud/translate/v3/mocks/mock_translation_connection.h +++ b/google/cloud/translate/v3/mocks/mock_translation_connection.h @@ -72,9 +72,15 @@ class MockTranslationServiceConnection (google::cloud::translation::v3::TranslateDocumentRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, BatchTranslateText)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, BatchTranslateText(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// BatchTranslateText(Matcher(_))) + /// @endcode MOCK_METHOD( future>, BatchTranslateText, @@ -82,20 +88,40 @@ class MockTranslationServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, BatchTranslateText(_, _)) + /// @endcode MOCK_METHOD(StatusOr, BatchTranslateText, (NoAwaitTag, google::cloud::translation::v3::BatchTranslateTextRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// BatchTranslateText(Matcher(_))) + /// @endcode MOCK_METHOD( future>, BatchTranslateText, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, BatchTranslateDocument)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, BatchTranslateDocument(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// BatchTranslateDocument(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -104,6 +130,12 @@ class MockTranslationServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, BatchTranslateDocument(_, _)) + /// @endcode MOCK_METHOD( StatusOr, BatchTranslateDocument, (NoAwaitTag, @@ -111,27 +143,55 @@ class MockTranslationServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// BatchTranslateDocument(Matcher(_))) + /// @endcode MOCK_METHOD( future>, BatchTranslateDocument, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateGlossary)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateGlossary(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateGlossary(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateGlossary, (google::cloud::translation::v3::CreateGlossaryRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateGlossary(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateGlossary, (NoAwaitTag, google::cloud::translation::v3::CreateGlossaryRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateGlossary(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateGlossary, (google::longrunning::Operation const& operation), (override)); @@ -146,21 +206,41 @@ class MockTranslationServiceConnection (google::cloud::translation::v3::GetGlossaryRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteGlossary)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteGlossary(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteGlossary(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteGlossary, (google::cloud::translation::v3::DeleteGlossaryRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteGlossary(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteGlossary, (NoAwaitTag, google::cloud::translation::v3::DeleteGlossaryRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteGlossary(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteGlossary, (google::longrunning::Operation const& operation), diff --git a/google/cloud/video/livestream/v1/mocks/mock_livestream_connection.h b/google/cloud/video/livestream/v1/mocks/mock_livestream_connection.h index dd84a600412f6..5c620a097b5ac 100644 --- a/google/cloud/video/livestream/v1/mocks/mock_livestream_connection.h +++ b/google/cloud/video/livestream/v1/mocks/mock_livestream_connection.h @@ -47,21 +47,41 @@ class MockLivestreamServiceConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateChannel)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateChannel(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateChannel(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateChannel, (google::cloud::video::livestream::v1::CreateChannelRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateChannel(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateChannel, (NoAwaitTag, google::cloud::video::livestream::v1::CreateChannelRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateChannel(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateChannel, (google::longrunning::Operation const& operation), (override)); @@ -77,9 +97,15 @@ class MockLivestreamServiceConnection (google::cloud::video::livestream::v1::GetChannelRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteChannel)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteChannel(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteChannel(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteChannel, @@ -87,39 +113,79 @@ class MockLivestreamServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteChannel(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteChannel, (NoAwaitTag, google::cloud::video::livestream::v1::DeleteChannelRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteChannel(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteChannel, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateChannel)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateChannel(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateChannel(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateChannel, (google::cloud::video::livestream::v1::UpdateChannelRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateChannel(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateChannel, (NoAwaitTag, google::cloud::video::livestream::v1::UpdateChannelRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateChannel(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateChannel, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, StartChannel)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, StartChannel(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// StartChannel(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -128,21 +194,41 @@ class MockLivestreamServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, StartChannel(_, _)) + /// @endcode MOCK_METHOD(StatusOr, StartChannel, (NoAwaitTag, google::cloud::video::livestream::v1::StartChannelRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, StartChannel(Matcher(_))) + /// @endcode MOCK_METHOD( future>, StartChannel, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, StopChannel)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, StopChannel(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// StopChannel(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -150,33 +236,67 @@ class MockLivestreamServiceConnection (google::cloud::video::livestream::v1::StopChannelRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, StopChannel(_, _)) + /// @endcode MOCK_METHOD( StatusOr, StopChannel, (NoAwaitTag, google::cloud::video::livestream::v1::StopChannelRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, StopChannel(Matcher(_))) + /// @endcode MOCK_METHOD( future>, StopChannel, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateInput)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateInput(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateInput(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateInput, (google::cloud::video::livestream::v1::CreateInputRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateInput(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateInput, (NoAwaitTag, google::cloud::video::livestream::v1::CreateInputRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateInput(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateInput, (google::longrunning::Operation const& operation), (override)); @@ -191,41 +311,81 @@ class MockLivestreamServiceConnection (google::cloud::video::livestream::v1::GetInputRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteInput)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteInput(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteInput(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteInput, (google::cloud::video::livestream::v1::DeleteInputRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteInput(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteInput, (NoAwaitTag, google::cloud::video::livestream::v1::DeleteInputRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteInput(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteInput, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateInput)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateInput(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateInput(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateInput, (google::cloud::video::livestream::v1::UpdateInputRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateInput(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateInput, (NoAwaitTag, google::cloud::video::livestream::v1::UpdateInputRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateInput(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateInput, (google::longrunning::Operation const& operation), (override)); @@ -260,78 +420,158 @@ class MockLivestreamServiceConnection (google::cloud::video::livestream::v1::GetClipRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateClip)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateClip(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateClip(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateClip, (google::cloud::video::livestream::v1::CreateClipRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateClip(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateClip, (NoAwaitTag, google::cloud::video::livestream::v1::CreateClipRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateClip(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateClip, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteClip)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteClip(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteClip(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteClip, (google::cloud::video::livestream::v1::DeleteClipRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteClip(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteClip, (NoAwaitTag, google::cloud::video::livestream::v1::DeleteClipRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteClip(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteClip, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateAsset)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateAsset(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateAsset(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateAsset, (google::cloud::video::livestream::v1::CreateAssetRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateAsset(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateAsset, (NoAwaitTag, google::cloud::video::livestream::v1::CreateAssetRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateAsset(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateAsset, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteAsset)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteAsset(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteAsset(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteAsset, (google::cloud::video::livestream::v1::DeleteAssetRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteAsset(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteAsset, (NoAwaitTag, google::cloud::video::livestream::v1::DeleteAssetRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteAsset(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteAsset, (google::longrunning::Operation const& operation), @@ -352,20 +592,40 @@ class MockLivestreamServiceConnection (google::cloud::video::livestream::v1::GetPoolRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdatePool)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdatePool(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdatePool(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdatePool, (google::cloud::video::livestream::v1::UpdatePoolRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdatePool(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdatePool, (NoAwaitTag, google::cloud::video::livestream::v1::UpdatePoolRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdatePool(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdatePool, (google::longrunning::Operation const& operation), (override)); diff --git a/google/cloud/video/stitcher/v1/mocks/mock_video_stitcher_connection.h b/google/cloud/video/stitcher/v1/mocks/mock_video_stitcher_connection.h index 912fc11070152..232ee35132f98 100644 --- a/google/cloud/video/stitcher/v1/mocks/mock_video_stitcher_connection.h +++ b/google/cloud/video/stitcher/v1/mocks/mock_video_stitcher_connection.h @@ -47,21 +47,41 @@ class MockVideoStitcherServiceConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateCdnKey)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateCdnKey(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateCdnKey(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateCdnKey, (google::cloud::video::stitcher::v1::CreateCdnKeyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateCdnKey(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateCdnKey, (NoAwaitTag, google::cloud::video::stitcher::v1::CreateCdnKeyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateCdnKey(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateCdnKey, (google::longrunning::Operation const& operation), (override)); @@ -76,41 +96,81 @@ class MockVideoStitcherServiceConnection (google::cloud::video::stitcher::v1::GetCdnKeyRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteCdnKey)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteCdnKey(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteCdnKey(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteCdnKey, (google::cloud::video::stitcher::v1::DeleteCdnKeyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteCdnKey(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteCdnKey, (NoAwaitTag, google::cloud::video::stitcher::v1::DeleteCdnKeyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteCdnKey(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteCdnKey, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateCdnKey)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateCdnKey(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateCdnKey(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateCdnKey, (google::cloud::video::stitcher::v1::UpdateCdnKeyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateCdnKey(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateCdnKey, (NoAwaitTag, google::cloud::video::stitcher::v1::UpdateCdnKeyRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateCdnKey(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateCdnKey, (google::longrunning::Operation const& operation), (override)); @@ -166,20 +226,40 @@ class MockVideoStitcherServiceConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateSlate)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateSlate(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateSlate(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateSlate, (google::cloud::video::stitcher::v1::CreateSlateRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateSlate(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateSlate, (NoAwaitTag, google::cloud::video::stitcher::v1::CreateSlateRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateSlate(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateSlate, (google::longrunning::Operation const& operation), (override)); @@ -194,39 +274,79 @@ class MockVideoStitcherServiceConnection (google::cloud::video::stitcher::v1::GetSlateRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateSlate)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateSlate(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateSlate(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateSlate, (google::cloud::video::stitcher::v1::UpdateSlateRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateSlate(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateSlate, (NoAwaitTag, google::cloud::video::stitcher::v1::UpdateSlateRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateSlate(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateSlate, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteSlate)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteSlate(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteSlate(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteSlate, (google::cloud::video::stitcher::v1::DeleteSlateRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteSlate(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteSlate, (NoAwaitTag, google::cloud::video::stitcher::v1::DeleteSlateRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteSlate(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteSlate, (google::longrunning::Operation const& operation), @@ -245,9 +365,15 @@ class MockVideoStitcherServiceConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateLiveConfig)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateLiveConfig(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateLiveConfig(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateLiveConfig, @@ -255,6 +381,12 @@ class MockVideoStitcherServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateLiveConfig(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateLiveConfig, (NoAwaitTag, @@ -262,6 +394,14 @@ class MockVideoStitcherServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateLiveConfig(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateLiveConfig, (google::longrunning::Operation const& operation), (override)); @@ -277,9 +417,15 @@ class MockVideoStitcherServiceConnection (google::cloud::video::stitcher::v1::GetLiveConfigRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteLiveConfig)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteLiveConfig(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteLiveConfig(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteLiveConfig, @@ -287,6 +433,12 @@ class MockVideoStitcherServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteLiveConfig(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteLiveConfig, (NoAwaitTag, @@ -294,14 +446,28 @@ class MockVideoStitcherServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteLiveConfig(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteLiveConfig, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateLiveConfig)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateLiveConfig(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateLiveConfig(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateLiveConfig, @@ -309,6 +475,12 @@ class MockVideoStitcherServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateLiveConfig(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateLiveConfig, (NoAwaitTag, @@ -316,25 +488,53 @@ class MockVideoStitcherServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateLiveConfig(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateLiveConfig, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateVodConfig)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateVodConfig(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateVodConfig(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateVodConfig, (google::cloud::video::stitcher::v1::CreateVodConfigRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateVodConfig(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateVodConfig, (NoAwaitTag, google::cloud::video::stitcher::v1::CreateVodConfigRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateVodConfig(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateVodConfig, (google::longrunning::Operation const& operation), (override)); @@ -350,9 +550,15 @@ class MockVideoStitcherServiceConnection (google::cloud::video::stitcher::v1::GetVodConfigRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteVodConfig)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteVodConfig(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteVodConfig(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteVodConfig, @@ -360,32 +566,66 @@ class MockVideoStitcherServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteVodConfig(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteVodConfig, (NoAwaitTag, google::cloud::video::stitcher::v1::DeleteVodConfigRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteVodConfig(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteVodConfig, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateVodConfig)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateVodConfig(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateVodConfig(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateVodConfig, (google::cloud::video::stitcher::v1::UpdateVodConfigRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateVodConfig(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateVodConfig, (NoAwaitTag, google::cloud::video::stitcher::v1::UpdateVodConfigRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateVodConfig(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateVodConfig, (google::longrunning::Operation const& operation), (override)); diff --git a/google/cloud/videointelligence/v1/mocks/mock_video_intelligence_connection.h b/google/cloud/videointelligence/v1/mocks/mock_video_intelligence_connection.h index abe58c851f9bc..d78b73e82dc0f 100644 --- a/google/cloud/videointelligence/v1/mocks/mock_video_intelligence_connection.h +++ b/google/cloud/videointelligence/v1/mocks/mock_video_intelligence_connection.h @@ -47,9 +47,15 @@ class MockVideoIntelligenceServiceConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, AnnotateVideo)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, AnnotateVideo(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// AnnotateVideo(Matcher(_))) + /// @endcode MOCK_METHOD(future>, AnnotateVideo, @@ -57,12 +63,26 @@ class MockVideoIntelligenceServiceConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, AnnotateVideo(_, _)) + /// @endcode MOCK_METHOD(StatusOr, AnnotateVideo, (NoAwaitTag, google::cloud::videointelligence::v1::AnnotateVideoRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, AnnotateVideo(Matcher(_))) + /// @endcode MOCK_METHOD(future>, AnnotateVideo, (google::longrunning::Operation const& operation), diff --git a/google/cloud/vision/v1/mocks/mock_image_annotator_connection.h b/google/cloud/vision/v1/mocks/mock_image_annotator_connection.h index 8f485cf36f940..c1212e7f4169a 100644 --- a/google/cloud/vision/v1/mocks/mock_image_annotator_connection.h +++ b/google/cloud/vision/v1/mocks/mock_image_annotator_connection.h @@ -59,9 +59,15 @@ class MockImageAnnotatorConnection (google::cloud::vision::v1::BatchAnnotateFilesRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, AsyncBatchAnnotateImages)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, AsyncBatchAnnotateImages(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// AsyncBatchAnnotateImages(Matcher(_))) + /// @endcode MOCK_METHOD(future>, AsyncBatchAnnotateImages, @@ -69,6 +75,12 @@ class MockImageAnnotatorConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, AsyncBatchAnnotateImages(_, _)) + /// @endcode MOCK_METHOD(StatusOr, AsyncBatchAnnotateImages, (NoAwaitTag, @@ -76,14 +88,29 @@ class MockImageAnnotatorConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// AsyncBatchAnnotateImages(Matcher(_))) + /// @endcode MOCK_METHOD(future>, AsyncBatchAnnotateImages, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, AsyncBatchAnnotateFiles)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, AsyncBatchAnnotateFiles(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// AsyncBatchAnnotateFiles(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, @@ -92,12 +119,27 @@ class MockImageAnnotatorConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, AsyncBatchAnnotateFiles(_, _)) + /// @endcode MOCK_METHOD(StatusOr, AsyncBatchAnnotateFiles, (NoAwaitTag, google::cloud::vision::v1::AsyncBatchAnnotateFilesRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// AsyncBatchAnnotateFiles(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, diff --git a/google/cloud/vision/v1/mocks/mock_product_search_connection.h b/google/cloud/vision/v1/mocks/mock_product_search_connection.h index 2a129f188f6b2..8ee27c974973b 100644 --- a/google/cloud/vision/v1/mocks/mock_product_search_connection.h +++ b/google/cloud/vision/v1/mocks/mock_product_search_connection.h @@ -127,40 +127,80 @@ class MockProductSearchConnection : public vision_v1::ProductSearchConnection { (google::cloud::vision::v1::ListProductsInProductSetRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ImportProductSets)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ImportProductSets(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ImportProductSets(Matcher(_))) + /// @endcode MOCK_METHOD( future>, ImportProductSets, (google::cloud::vision::v1::ImportProductSetsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ImportProductSets(_, _)) + /// @endcode MOCK_METHOD( StatusOr, ImportProductSets, (NoAwaitTag, google::cloud::vision::v1::ImportProductSetsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ImportProductSets(Matcher(_))) + /// @endcode MOCK_METHOD( future>, ImportProductSets, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, PurgeProducts)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, PurgeProducts(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PurgeProducts(Matcher(_))) + /// @endcode MOCK_METHOD( future>, PurgeProducts, (google::cloud::vision::v1::PurgeProductsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, PurgeProducts(_, _)) + /// @endcode MOCK_METHOD(StatusOr, PurgeProducts, (NoAwaitTag, google::cloud::vision::v1::PurgeProductsRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, PurgeProducts(Matcher(_))) + /// @endcode MOCK_METHOD( future>, PurgeProducts, (google::longrunning::Operation const& operation), diff --git a/google/cloud/vmmigration/v1/mocks/mock_vm_migration_connection.h b/google/cloud/vmmigration/v1/mocks/mock_vm_migration_connection.h index 61adefa4e032d..23a95c51de9e4 100644 --- a/google/cloud/vmmigration/v1/mocks/mock_vm_migration_connection.h +++ b/google/cloud/vmmigration/v1/mocks/mock_vm_migration_connection.h @@ -55,57 +55,117 @@ class MockVmMigrationConnection : public vmmigration_v1::VmMigrationConnection { (google::cloud::vmmigration::v1::GetSourceRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateSource)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateSource(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateSource(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateSource, (google::cloud::vmmigration::v1::CreateSourceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateSource(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateSource, (NoAwaitTag, google::cloud::vmmigration::v1::CreateSourceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateSource(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateSource, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateSource)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateSource(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateSource(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateSource, (google::cloud::vmmigration::v1::UpdateSourceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateSource(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateSource, (NoAwaitTag, google::cloud::vmmigration::v1::UpdateSourceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateSource(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateSource, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteSource)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteSource(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteSource(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteSource, (google::cloud::vmmigration::v1::DeleteSourceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteSource(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteSource, (NoAwaitTag, google::cloud::vmmigration::v1::DeleteSourceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteSource(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteSource, (google::longrunning::Operation const& operation), @@ -130,9 +190,15 @@ class MockVmMigrationConnection : public vmmigration_v1::VmMigrationConnection { request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateUtilizationReport)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateUtilizationReport(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateUtilizationReport(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateUtilizationReport, @@ -140,6 +206,12 @@ class MockVmMigrationConnection : public vmmigration_v1::VmMigrationConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateUtilizationReport(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateUtilizationReport, (NoAwaitTag, @@ -147,14 +219,29 @@ class MockVmMigrationConnection : public vmmigration_v1::VmMigrationConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateUtilizationReport(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateUtilizationReport, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteUtilizationReport)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteUtilizationReport(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteUtilizationReport(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteUtilizationReport, @@ -162,6 +249,12 @@ class MockVmMigrationConnection : public vmmigration_v1::VmMigrationConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteUtilizationReport(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteUtilizationReport, (NoAwaitTag, @@ -169,6 +262,15 @@ class MockVmMigrationConnection : public vmmigration_v1::VmMigrationConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteUtilizationReport(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteUtilizationReport, @@ -187,9 +289,15 @@ class MockVmMigrationConnection : public vmmigration_v1::VmMigrationConnection { request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateDatacenterConnector)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateDatacenterConnector(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateDatacenterConnector(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateDatacenterConnector, @@ -197,6 +305,12 @@ class MockVmMigrationConnection : public vmmigration_v1::VmMigrationConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateDatacenterConnector(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateDatacenterConnector, (NoAwaitTag, @@ -204,14 +318,29 @@ class MockVmMigrationConnection : public vmmigration_v1::VmMigrationConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateDatacenterConnector(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateDatacenterConnector, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteDatacenterConnector)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteDatacenterConnector(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteDatacenterConnector(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteDatacenterConnector, @@ -219,6 +348,12 @@ class MockVmMigrationConnection : public vmmigration_v1::VmMigrationConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteDatacenterConnector(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteDatacenterConnector, (NoAwaitTag, @@ -226,14 +361,29 @@ class MockVmMigrationConnection : public vmmigration_v1::VmMigrationConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteDatacenterConnector(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteDatacenterConnector, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpgradeAppliance)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpgradeAppliance(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpgradeAppliance(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, @@ -241,33 +391,67 @@ class MockVmMigrationConnection : public vmmigration_v1::VmMigrationConnection { (google::cloud::vmmigration::v1::UpgradeApplianceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpgradeAppliance(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpgradeAppliance, (NoAwaitTag, google::cloud::vmmigration::v1::UpgradeApplianceRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpgradeAppliance(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, UpgradeAppliance, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateMigratingVm)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateMigratingVm(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateMigratingVm(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateMigratingVm, (google::cloud::vmmigration::v1::CreateMigratingVmRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateMigratingVm(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateMigratingVm, (NoAwaitTag, google::cloud::vmmigration::v1::CreateMigratingVmRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateMigratingVm(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateMigratingVm, (google::longrunning::Operation const& operation), (override)); @@ -282,108 +466,214 @@ class MockVmMigrationConnection : public vmmigration_v1::VmMigrationConnection { (google::cloud::vmmigration::v1::GetMigratingVmRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateMigratingVm)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateMigratingVm(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateMigratingVm(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateMigratingVm, (google::cloud::vmmigration::v1::UpdateMigratingVmRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateMigratingVm(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateMigratingVm, (NoAwaitTag, google::cloud::vmmigration::v1::UpdateMigratingVmRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateMigratingVm(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateMigratingVm, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteMigratingVm)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteMigratingVm(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteMigratingVm(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteMigratingVm, (google::cloud::vmmigration::v1::DeleteMigratingVmRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteMigratingVm(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteMigratingVm, (NoAwaitTag, google::cloud::vmmigration::v1::DeleteMigratingVmRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteMigratingVm(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteMigratingVm, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, StartMigration)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, StartMigration(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// StartMigration(Matcher(_))) + /// @endcode MOCK_METHOD( future>, StartMigration, (google::cloud::vmmigration::v1::StartMigrationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, StartMigration(_, _)) + /// @endcode MOCK_METHOD( StatusOr, StartMigration, (NoAwaitTag, google::cloud::vmmigration::v1::StartMigrationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, StartMigration(Matcher(_))) + /// @endcode MOCK_METHOD( future>, StartMigration, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ResumeMigration)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ResumeMigration(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ResumeMigration(Matcher(_))) + /// @endcode MOCK_METHOD( future>, ResumeMigration, (google::cloud::vmmigration::v1::ResumeMigrationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ResumeMigration(_, _)) + /// @endcode MOCK_METHOD( StatusOr, ResumeMigration, (NoAwaitTag, google::cloud::vmmigration::v1::ResumeMigrationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, ResumeMigration(Matcher(_))) + /// @endcode MOCK_METHOD( future>, ResumeMigration, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, PauseMigration)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, PauseMigration(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// PauseMigration(Matcher(_))) + /// @endcode MOCK_METHOD( future>, PauseMigration, (google::cloud::vmmigration::v1::PauseMigrationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, PauseMigration(_, _)) + /// @endcode MOCK_METHOD( StatusOr, PauseMigration, (NoAwaitTag, google::cloud::vmmigration::v1::PauseMigrationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, PauseMigration(Matcher(_))) + /// @endcode MOCK_METHOD( future>, PauseMigration, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, FinalizeMigration)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, FinalizeMigration(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// FinalizeMigration(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, @@ -391,52 +681,106 @@ class MockVmMigrationConnection : public vmmigration_v1::VmMigrationConnection { (google::cloud::vmmigration::v1::FinalizeMigrationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, FinalizeMigration(_, _)) + /// @endcode MOCK_METHOD( StatusOr, FinalizeMigration, (NoAwaitTag, google::cloud::vmmigration::v1::FinalizeMigrationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// FinalizeMigration(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, FinalizeMigration, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateCloneJob)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateCloneJob(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateCloneJob(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateCloneJob, (google::cloud::vmmigration::v1::CreateCloneJobRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateCloneJob(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateCloneJob, (NoAwaitTag, google::cloud::vmmigration::v1::CreateCloneJobRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateCloneJob(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateCloneJob, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CancelCloneJob)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CancelCloneJob(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CancelCloneJob(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CancelCloneJob, (google::cloud::vmmigration::v1::CancelCloneJobRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CancelCloneJob(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CancelCloneJob, (NoAwaitTag, google::cloud::vmmigration::v1::CancelCloneJobRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CancelCloneJob(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CancelCloneJob, (google::longrunning::Operation const& operation), @@ -452,28 +796,54 @@ class MockVmMigrationConnection : public vmmigration_v1::VmMigrationConnection { (google::cloud::vmmigration::v1::GetCloneJobRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateCutoverJob)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateCutoverJob(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateCutoverJob(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateCutoverJob, (google::cloud::vmmigration::v1::CreateCutoverJobRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateCutoverJob(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateCutoverJob, (NoAwaitTag, google::cloud::vmmigration::v1::CreateCutoverJobRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateCutoverJob(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateCutoverJob, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CancelCutoverJob)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CancelCutoverJob(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CancelCutoverJob(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, @@ -481,12 +851,26 @@ class MockVmMigrationConnection : public vmmigration_v1::VmMigrationConnection { (google::cloud::vmmigration::v1::CancelCutoverJobRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CancelCutoverJob(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CancelCutoverJob, (NoAwaitTag, google::cloud::vmmigration::v1::CancelCutoverJobRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CancelCutoverJob(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, @@ -511,65 +895,131 @@ class MockVmMigrationConnection : public vmmigration_v1::VmMigrationConnection { (google::cloud::vmmigration::v1::GetGroupRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateGroup)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateGroup(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateGroup(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateGroup, (google::cloud::vmmigration::v1::CreateGroupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateGroup(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateGroup, (NoAwaitTag, google::cloud::vmmigration::v1::CreateGroupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateGroup(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateGroup, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateGroup)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateGroup(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateGroup(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateGroup, (google::cloud::vmmigration::v1::UpdateGroupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateGroup(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateGroup, (NoAwaitTag, google::cloud::vmmigration::v1::UpdateGroupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateGroup(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateGroup, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteGroup)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteGroup(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteGroup(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteGroup, (google::cloud::vmmigration::v1::DeleteGroupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteGroup(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteGroup, (NoAwaitTag, google::cloud::vmmigration::v1::DeleteGroupRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteGroup(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteGroup, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, AddGroupMigration)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, AddGroupMigration(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// AddGroupMigration(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, @@ -577,21 +1027,41 @@ class MockVmMigrationConnection : public vmmigration_v1::VmMigrationConnection { (google::cloud::vmmigration::v1::AddGroupMigrationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, AddGroupMigration(_, _)) + /// @endcode MOCK_METHOD( StatusOr, AddGroupMigration, (NoAwaitTag, google::cloud::vmmigration::v1::AddGroupMigrationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// AddGroupMigration(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, AddGroupMigration, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, RemoveGroupMigration)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, RemoveGroupMigration(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RemoveGroupMigration(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -600,6 +1070,12 @@ class MockVmMigrationConnection : public vmmigration_v1::VmMigrationConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, RemoveGroupMigration(_, _)) + /// @endcode MOCK_METHOD( StatusOr, RemoveGroupMigration, (NoAwaitTag, @@ -607,6 +1083,14 @@ class MockVmMigrationConnection : public vmmigration_v1::VmMigrationConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RemoveGroupMigration(Matcher(_))) + /// @endcode MOCK_METHOD( future>, @@ -624,47 +1108,93 @@ class MockVmMigrationConnection : public vmmigration_v1::VmMigrationConnection { (google::cloud::vmmigration::v1::GetTargetProjectRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateTargetProject)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateTargetProject(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateTargetProject(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateTargetProject, (google::cloud::vmmigration::v1::CreateTargetProjectRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateTargetProject(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateTargetProject, (NoAwaitTag, google::cloud::vmmigration::v1::CreateTargetProjectRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateTargetProject(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateTargetProject, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateTargetProject)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateTargetProject(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateTargetProject(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateTargetProject, (google::cloud::vmmigration::v1::UpdateTargetProjectRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateTargetProject(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateTargetProject, (NoAwaitTag, google::cloud::vmmigration::v1::UpdateTargetProjectRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateTargetProject(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateTargetProject, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteTargetProject)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteTargetProject(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteTargetProject(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteTargetProject, @@ -672,12 +1202,26 @@ class MockVmMigrationConnection : public vmmigration_v1::VmMigrationConnection { request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteTargetProject(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteTargetProject, (NoAwaitTag, google::cloud::vmmigration::v1::DeleteTargetProjectRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteTargetProject(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteTargetProject, (google::longrunning::Operation const& operation), diff --git a/google/cloud/vmwareengine/v1/mocks/mock_vmware_engine_connection.h b/google/cloud/vmwareengine/v1/mocks/mock_vmware_engine_connection.h index c6d04dfb7db27..d88194d94b94f 100644 --- a/google/cloud/vmwareengine/v1/mocks/mock_vmware_engine_connection.h +++ b/google/cloud/vmwareengine/v1/mocks/mock_vmware_engine_connection.h @@ -58,66 +58,132 @@ class MockVmwareEngineConnection (google::cloud::vmwareengine::v1::GetPrivateCloudRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreatePrivateCloud)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreatePrivateCloud(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreatePrivateCloud(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreatePrivateCloud, (google::cloud::vmwareengine::v1::CreatePrivateCloudRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreatePrivateCloud(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreatePrivateCloud, (NoAwaitTag, google::cloud::vmwareengine::v1::CreatePrivateCloudRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreatePrivateCloud(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreatePrivateCloud, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdatePrivateCloud)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdatePrivateCloud(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdatePrivateCloud(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdatePrivateCloud, (google::cloud::vmwareengine::v1::UpdatePrivateCloudRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdatePrivateCloud(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdatePrivateCloud, (NoAwaitTag, google::cloud::vmwareengine::v1::UpdatePrivateCloudRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdatePrivateCloud(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdatePrivateCloud, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeletePrivateCloud)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeletePrivateCloud(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeletePrivateCloud(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeletePrivateCloud, (google::cloud::vmwareengine::v1::DeletePrivateCloudRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeletePrivateCloud(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeletePrivateCloud, (NoAwaitTag, google::cloud::vmwareengine::v1::DeletePrivateCloudRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeletePrivateCloud(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeletePrivateCloud, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UndeletePrivateCloud)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UndeletePrivateCloud(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UndeletePrivateCloud(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UndeletePrivateCloud, @@ -125,6 +191,12 @@ class MockVmwareEngineConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UndeletePrivateCloud(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UndeletePrivateCloud, (NoAwaitTag, @@ -132,6 +204,14 @@ class MockVmwareEngineConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UndeletePrivateCloud(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UndeletePrivateCloud, (google::longrunning::Operation const& operation), (override)); @@ -146,57 +226,117 @@ class MockVmwareEngineConnection (google::cloud::vmwareengine::v1::GetClusterRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateCluster)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateCluster(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateCluster(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateCluster, (google::cloud::vmwareengine::v1::CreateClusterRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateCluster(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateCluster, (NoAwaitTag, google::cloud::vmwareengine::v1::CreateClusterRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateCluster(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateCluster, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateCluster)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateCluster(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateCluster(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateCluster, (google::cloud::vmwareengine::v1::UpdateClusterRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateCluster(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateCluster, (NoAwaitTag, google::cloud::vmwareengine::v1::UpdateClusterRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateCluster(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateCluster, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteCluster)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteCluster(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteCluster(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteCluster, (google::cloud::vmwareengine::v1::DeleteClusterRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteCluster(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteCluster, (NoAwaitTag, google::cloud::vmwareengine::v1::DeleteClusterRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteCluster(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteCluster, (google::longrunning::Operation const& operation), @@ -228,9 +368,15 @@ class MockVmwareEngineConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateExternalAddress)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateExternalAddress(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateExternalAddress(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateExternalAddress, @@ -238,6 +384,12 @@ class MockVmwareEngineConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateExternalAddress(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateExternalAddress, (NoAwaitTag, @@ -245,14 +397,28 @@ class MockVmwareEngineConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateExternalAddress(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateExternalAddress, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateExternalAddress)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateExternalAddress(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateExternalAddress(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateExternalAddress, @@ -260,6 +426,12 @@ class MockVmwareEngineConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateExternalAddress(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateExternalAddress, (NoAwaitTag, @@ -267,14 +439,28 @@ class MockVmwareEngineConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateExternalAddress(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateExternalAddress, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteExternalAddress)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteExternalAddress(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteExternalAddress(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteExternalAddress, @@ -282,6 +468,12 @@ class MockVmwareEngineConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteExternalAddress(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteExternalAddress, (NoAwaitTag, @@ -289,6 +481,14 @@ class MockVmwareEngineConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteExternalAddress(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteExternalAddress, (google::longrunning::Operation const& operation), @@ -304,20 +504,40 @@ class MockVmwareEngineConnection (google::cloud::vmwareengine::v1::GetSubnetRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateSubnet)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateSubnet(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateSubnet(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateSubnet, (google::cloud::vmwareengine::v1::UpdateSubnetRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateSubnet(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateSubnet, (NoAwaitTag, google::cloud::vmwareengine::v1::UpdateSubnetRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateSubnet(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateSubnet, (google::longrunning::Operation const& operation), (override)); @@ -335,9 +555,15 @@ class MockVmwareEngineConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateExternalAccessRule)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateExternalAccessRule(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateExternalAccessRule(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateExternalAccessRule, @@ -345,6 +571,12 @@ class MockVmwareEngineConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateExternalAccessRule(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateExternalAccessRule, (NoAwaitTag, @@ -352,14 +584,29 @@ class MockVmwareEngineConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateExternalAccessRule(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateExternalAccessRule, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateExternalAccessRule)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateExternalAccessRule(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateExternalAccessRule(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateExternalAccessRule, @@ -367,6 +614,12 @@ class MockVmwareEngineConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateExternalAccessRule(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateExternalAccessRule, (NoAwaitTag, @@ -374,14 +627,29 @@ class MockVmwareEngineConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateExternalAccessRule(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateExternalAccessRule, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteExternalAccessRule)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteExternalAccessRule(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteExternalAccessRule(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteExternalAccessRule, @@ -389,6 +657,12 @@ class MockVmwareEngineConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteExternalAccessRule(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteExternalAccessRule, (NoAwaitTag, @@ -396,6 +670,15 @@ class MockVmwareEngineConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteExternalAccessRule(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteExternalAccessRule, @@ -413,9 +696,15 @@ class MockVmwareEngineConnection (google::cloud::vmwareengine::v1::GetLoggingServerRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateLoggingServer)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateLoggingServer(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateLoggingServer(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateLoggingServer, @@ -423,6 +712,12 @@ class MockVmwareEngineConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateLoggingServer(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateLoggingServer, (NoAwaitTag, @@ -430,13 +725,27 @@ class MockVmwareEngineConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateLoggingServer(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateLoggingServer, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateLoggingServer)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateLoggingServer(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateLoggingServer(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateLoggingServer, @@ -444,6 +753,12 @@ class MockVmwareEngineConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateLoggingServer(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateLoggingServer, (NoAwaitTag, @@ -451,13 +766,27 @@ class MockVmwareEngineConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateLoggingServer(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateLoggingServer, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteLoggingServer)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteLoggingServer(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteLoggingServer(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteLoggingServer, @@ -465,6 +794,12 @@ class MockVmwareEngineConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteLoggingServer(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteLoggingServer, (NoAwaitTag, @@ -472,6 +807,14 @@ class MockVmwareEngineConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteLoggingServer(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteLoggingServer, (google::longrunning::Operation const& operation), @@ -500,9 +843,15 @@ class MockVmwareEngineConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ResetNsxCredentials)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ResetNsxCredentials(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ResetNsxCredentials(Matcher(_))) + /// @endcode MOCK_METHOD( future>, ResetNsxCredentials, @@ -510,6 +859,12 @@ class MockVmwareEngineConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ResetNsxCredentials(_, _)) + /// @endcode MOCK_METHOD( StatusOr, ResetNsxCredentials, (NoAwaitTag, @@ -517,13 +872,27 @@ class MockVmwareEngineConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ResetNsxCredentials(Matcher(_))) + /// @endcode MOCK_METHOD(future>, ResetNsxCredentials, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, ResetVcenterCredentials)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, ResetVcenterCredentials(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ResetVcenterCredentials(Matcher(_))) + /// @endcode MOCK_METHOD( future>, ResetVcenterCredentials, @@ -531,6 +900,12 @@ class MockVmwareEngineConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, ResetVcenterCredentials(_, _)) + /// @endcode MOCK_METHOD( StatusOr, ResetVcenterCredentials, (NoAwaitTag, @@ -538,6 +913,15 @@ class MockVmwareEngineConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// ResetVcenterCredentials(Matcher(_))) + /// @endcode MOCK_METHOD(future>, ResetVcenterCredentials, (google::longrunning::Operation const& operation), (override)); @@ -548,9 +932,15 @@ class MockVmwareEngineConnection (google::cloud::vmwareengine::v1::GetDnsForwardingRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateDnsForwarding)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateDnsForwarding(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateDnsForwarding(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateDnsForwarding, @@ -558,6 +948,12 @@ class MockVmwareEngineConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateDnsForwarding(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateDnsForwarding, (NoAwaitTag, @@ -565,6 +961,14 @@ class MockVmwareEngineConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateDnsForwarding(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateDnsForwarding, (google::longrunning::Operation const& operation), (override)); @@ -581,9 +985,15 @@ class MockVmwareEngineConnection (google::cloud::vmwareengine::v1::ListNetworkPeeringsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateNetworkPeering)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateNetworkPeering(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateNetworkPeering(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateNetworkPeering, @@ -591,6 +1001,12 @@ class MockVmwareEngineConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateNetworkPeering(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateNetworkPeering, (NoAwaitTag, @@ -598,13 +1014,27 @@ class MockVmwareEngineConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateNetworkPeering(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateNetworkPeering, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteNetworkPeering)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteNetworkPeering(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteNetworkPeering(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteNetworkPeering, @@ -612,6 +1042,12 @@ class MockVmwareEngineConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteNetworkPeering(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteNetworkPeering, (NoAwaitTag, @@ -619,14 +1055,28 @@ class MockVmwareEngineConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteNetworkPeering(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteNetworkPeering, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateNetworkPeering)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateNetworkPeering(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateNetworkPeering(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateNetworkPeering, @@ -634,6 +1084,12 @@ class MockVmwareEngineConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateNetworkPeering(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateNetworkPeering, (NoAwaitTag, @@ -641,6 +1097,14 @@ class MockVmwareEngineConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateNetworkPeering(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateNetworkPeering, (google::longrunning::Operation const& operation), (override)); @@ -651,9 +1115,15 @@ class MockVmwareEngineConnection (google::cloud::vmwareengine::v1::ListPeeringRoutesRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateHcxActivationKey)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateHcxActivationKey(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateHcxActivationKey(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateHcxActivationKey, @@ -661,6 +1131,12 @@ class MockVmwareEngineConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateHcxActivationKey(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateHcxActivationKey, (NoAwaitTag, @@ -668,6 +1144,14 @@ class MockVmwareEngineConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateHcxActivationKey(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateHcxActivationKey, (google::longrunning::Operation const& operation), @@ -698,9 +1182,15 @@ class MockVmwareEngineConnection (google::cloud::vmwareengine::v1::ListNetworkPoliciesRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateNetworkPolicy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateNetworkPolicy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateNetworkPolicy(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateNetworkPolicy, @@ -708,6 +1198,12 @@ class MockVmwareEngineConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateNetworkPolicy(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateNetworkPolicy, (NoAwaitTag, @@ -715,13 +1211,27 @@ class MockVmwareEngineConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateNetworkPolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateNetworkPolicy, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateNetworkPolicy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateNetworkPolicy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateNetworkPolicy(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateNetworkPolicy, @@ -729,6 +1239,12 @@ class MockVmwareEngineConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateNetworkPolicy(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateNetworkPolicy, (NoAwaitTag, @@ -736,13 +1252,27 @@ class MockVmwareEngineConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateNetworkPolicy(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateNetworkPolicy, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteNetworkPolicy)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteNetworkPolicy(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteNetworkPolicy(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteNetworkPolicy, @@ -750,6 +1280,12 @@ class MockVmwareEngineConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteNetworkPolicy(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteNetworkPolicy, (NoAwaitTag, @@ -757,6 +1293,14 @@ class MockVmwareEngineConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteNetworkPolicy(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteNetworkPolicy, (google::longrunning::Operation const& operation), @@ -776,10 +1320,15 @@ class MockVmwareEngineConnection GetManagementDnsZoneBindingRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateManagementDnsZoneBinding)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateManagementDnsZoneBinding(::testing::_))` - /// instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateManagementDnsZoneBinding(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, @@ -788,6 +1337,12 @@ class MockVmwareEngineConnection CreateManagementDnsZoneBindingRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateManagementDnsZoneBinding(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateManagementDnsZoneBinding, (NoAwaitTag, @@ -795,16 +1350,30 @@ class MockVmwareEngineConnection CreateManagementDnsZoneBindingRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateManagementDnsZoneBinding(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, CreateManagementDnsZoneBinding, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateManagementDnsZoneBinding)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateManagementDnsZoneBinding(::testing::_))` - /// instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateManagementDnsZoneBinding(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, @@ -813,6 +1382,12 @@ class MockVmwareEngineConnection UpdateManagementDnsZoneBindingRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateManagementDnsZoneBinding(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateManagementDnsZoneBinding, (NoAwaitTag, @@ -820,16 +1395,30 @@ class MockVmwareEngineConnection UpdateManagementDnsZoneBindingRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateManagementDnsZoneBinding(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, UpdateManagementDnsZoneBinding, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteManagementDnsZoneBinding)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteManagementDnsZoneBinding(::testing::_))` - /// instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteManagementDnsZoneBinding(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteManagementDnsZoneBinding, @@ -837,6 +1426,12 @@ class MockVmwareEngineConnection DeleteManagementDnsZoneBindingRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteManagementDnsZoneBinding(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteManagementDnsZoneBinding, (NoAwaitTag, @@ -844,15 +1439,29 @@ class MockVmwareEngineConnection DeleteManagementDnsZoneBindingRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteManagementDnsZoneBinding(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteManagementDnsZoneBinding, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, RepairManagementDnsZoneBinding)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, RepairManagementDnsZoneBinding(::testing::_))` - /// instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RepairManagementDnsZoneBinding(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, @@ -861,6 +1470,12 @@ class MockVmwareEngineConnection RepairManagementDnsZoneBindingRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, RepairManagementDnsZoneBinding(_, _)) + /// @endcode MOCK_METHOD(StatusOr, RepairManagementDnsZoneBinding, (NoAwaitTag, @@ -868,15 +1483,30 @@ class MockVmwareEngineConnection RepairManagementDnsZoneBindingRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RepairManagementDnsZoneBinding(Matcher(_))) + /// @endcode MOCK_METHOD( future< StatusOr>, RepairManagementDnsZoneBinding, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateVmwareEngineNetwork)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateVmwareEngineNetwork(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateVmwareEngineNetwork(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateVmwareEngineNetwork, @@ -884,6 +1514,12 @@ class MockVmwareEngineConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateVmwareEngineNetwork(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateVmwareEngineNetwork, (NoAwaitTag, @@ -891,14 +1527,29 @@ class MockVmwareEngineConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateVmwareEngineNetwork(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateVmwareEngineNetwork, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateVmwareEngineNetwork)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateVmwareEngineNetwork(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateVmwareEngineNetwork(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateVmwareEngineNetwork, @@ -906,6 +1557,12 @@ class MockVmwareEngineConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateVmwareEngineNetwork(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateVmwareEngineNetwork, (NoAwaitTag, @@ -913,14 +1570,29 @@ class MockVmwareEngineConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateVmwareEngineNetwork(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateVmwareEngineNetwork, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteVmwareEngineNetwork)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteVmwareEngineNetwork(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteVmwareEngineNetwork(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteVmwareEngineNetwork, @@ -928,6 +1600,12 @@ class MockVmwareEngineConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteVmwareEngineNetwork(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteVmwareEngineNetwork, (NoAwaitTag, @@ -935,6 +1613,15 @@ class MockVmwareEngineConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteVmwareEngineNetwork(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteVmwareEngineNetwork, @@ -954,9 +1641,15 @@ class MockVmwareEngineConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreatePrivateConnection)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreatePrivateConnection(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreatePrivateConnection(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreatePrivateConnection, @@ -964,6 +1657,12 @@ class MockVmwareEngineConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreatePrivateConnection(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreatePrivateConnection, (NoAwaitTag, @@ -971,6 +1670,15 @@ class MockVmwareEngineConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreatePrivateConnection(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreatePrivateConnection, @@ -989,9 +1697,15 @@ class MockVmwareEngineConnection (google::cloud::vmwareengine::v1::ListPrivateConnectionsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdatePrivateConnection)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdatePrivateConnection(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdatePrivateConnection(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdatePrivateConnection, @@ -999,6 +1713,12 @@ class MockVmwareEngineConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdatePrivateConnection(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdatePrivateConnection, (NoAwaitTag, @@ -1006,14 +1726,29 @@ class MockVmwareEngineConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdatePrivateConnection(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdatePrivateConnection, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeletePrivateConnection)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeletePrivateConnection(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeletePrivateConnection(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeletePrivateConnection, @@ -1021,6 +1756,12 @@ class MockVmwareEngineConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeletePrivateConnection(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeletePrivateConnection, (NoAwaitTag, @@ -1028,6 +1769,15 @@ class MockVmwareEngineConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeletePrivateConnection(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeletePrivateConnection, @@ -1039,9 +1789,15 @@ class MockVmwareEngineConnection ListPrivateConnectionPeeringRoutesRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, GrantDnsBindPermission)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, GrantDnsBindPermission(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// GrantDnsBindPermission(Matcher(_))) + /// @endcode MOCK_METHOD( future>, GrantDnsBindPermission, @@ -1049,6 +1805,12 @@ class MockVmwareEngineConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, GrantDnsBindPermission(_, _)) + /// @endcode MOCK_METHOD( StatusOr, GrantDnsBindPermission, (NoAwaitTag, @@ -1056,6 +1818,14 @@ class MockVmwareEngineConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// GrantDnsBindPermission(Matcher(_))) + /// @endcode MOCK_METHOD( future>, GrantDnsBindPermission, (google::longrunning::Operation const& operation), @@ -1068,9 +1838,15 @@ class MockVmwareEngineConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, RevokeDnsBindPermission)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, RevokeDnsBindPermission(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RevokeDnsBindPermission(Matcher(_))) + /// @endcode MOCK_METHOD( future>, RevokeDnsBindPermission, @@ -1078,6 +1854,12 @@ class MockVmwareEngineConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, RevokeDnsBindPermission(_, _)) + /// @endcode MOCK_METHOD( StatusOr, RevokeDnsBindPermission, (NoAwaitTag, @@ -1085,6 +1867,15 @@ class MockVmwareEngineConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// RevokeDnsBindPermission(Matcher(_))) + /// @endcode MOCK_METHOD( future>, RevokeDnsBindPermission, diff --git a/google/cloud/vpcaccess/v1/mocks/mock_vpc_access_connection.h b/google/cloud/vpcaccess/v1/mocks/mock_vpc_access_connection.h index 7ff87e1ab1706..b798635b9a749 100644 --- a/google/cloud/vpcaccess/v1/mocks/mock_vpc_access_connection.h +++ b/google/cloud/vpcaccess/v1/mocks/mock_vpc_access_connection.h @@ -47,21 +47,41 @@ class MockVpcAccessServiceConnection public: MOCK_METHOD(Options, options, (), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateConnector)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateConnector(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateConnector(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateConnector, (google::cloud::vpcaccess::v1::CreateConnectorRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateConnector(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateConnector, (NoAwaitTag, google::cloud::vpcaccess::v1::CreateConnectorRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateConnector(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateConnector, (google::longrunning::Operation const& operation), (override)); @@ -76,21 +96,41 @@ class MockVpcAccessServiceConnection (google::cloud::vpcaccess::v1::ListConnectorsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteConnector)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteConnector(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteConnector(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteConnector, (google::cloud::vpcaccess::v1::DeleteConnectorRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteConnector(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteConnector, (NoAwaitTag, google::cloud::vpcaccess::v1::DeleteConnectorRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteConnector(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteConnector, (google::longrunning::Operation const& operation), (override)); diff --git a/google/cloud/webrisk/v1/mocks/mock_web_risk_connection.h b/google/cloud/webrisk/v1/mocks/mock_web_risk_connection.h index ac8d203e8037f..9670c695b6b35 100644 --- a/google/cloud/webrisk/v1/mocks/mock_web_risk_connection.h +++ b/google/cloud/webrisk/v1/mocks/mock_web_risk_connection.h @@ -68,19 +68,39 @@ class MockWebRiskServiceConnection (google::cloud::webrisk::v1::CreateSubmissionRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, SubmitUri)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, SubmitUri(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// SubmitUri(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SubmitUri, (google::cloud::webrisk::v1::SubmitUriRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, SubmitUri(_, _)) + /// @endcode MOCK_METHOD(StatusOr, SubmitUri, (NoAwaitTag, google::cloud::webrisk::v1::SubmitUriRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, SubmitUri(Matcher(_))) + /// @endcode MOCK_METHOD(future>, SubmitUri, (google::longrunning::Operation const& operation), (override)); diff --git a/google/cloud/workflows/v1/mocks/mock_workflows_connection.h b/google/cloud/workflows/v1/mocks/mock_workflows_connection.h index 33ed098096fe9..c45dd1f2b345b 100644 --- a/google/cloud/workflows/v1/mocks/mock_workflows_connection.h +++ b/google/cloud/workflows/v1/mocks/mock_workflows_connection.h @@ -55,57 +55,117 @@ class MockWorkflowsConnection : public workflows_v1::WorkflowsConnection { (google::cloud::workflows::v1::GetWorkflowRequest const& request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateWorkflow)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateWorkflow(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateWorkflow(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateWorkflow, (google::cloud::workflows::v1::CreateWorkflowRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateWorkflow(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateWorkflow, (NoAwaitTag, google::cloud::workflows::v1::CreateWorkflowRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, CreateWorkflow(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateWorkflow, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteWorkflow)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteWorkflow(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteWorkflow(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteWorkflow, (google::cloud::workflows::v1::DeleteWorkflowRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteWorkflow(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteWorkflow, (NoAwaitTag, google::cloud::workflows::v1::DeleteWorkflowRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, DeleteWorkflow(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteWorkflow, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateWorkflow)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateWorkflow(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateWorkflow(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateWorkflow, (google::cloud::workflows::v1::UpdateWorkflowRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateWorkflow(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateWorkflow, (NoAwaitTag, google::cloud::workflows::v1::UpdateWorkflowRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, UpdateWorkflow(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateWorkflow, (google::longrunning::Operation const& operation), (override)); diff --git a/google/cloud/workstations/v1/mocks/mock_workstations_connection.h b/google/cloud/workstations/v1/mocks/mock_workstations_connection.h index 38a78c481d039..cdaac1c8d95ed 100644 --- a/google/cloud/workstations/v1/mocks/mock_workstations_connection.h +++ b/google/cloud/workstations/v1/mocks/mock_workstations_connection.h @@ -60,9 +60,15 @@ class MockWorkstationsConnection (google::cloud::workstations::v1::ListWorkstationClustersRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateWorkstationCluster)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateWorkstationCluster(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateWorkstationCluster(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateWorkstationCluster, @@ -70,6 +76,12 @@ class MockWorkstationsConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateWorkstationCluster(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateWorkstationCluster, (NoAwaitTag, @@ -77,14 +89,29 @@ class MockWorkstationsConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateWorkstationCluster(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateWorkstationCluster, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateWorkstationCluster)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateWorkstationCluster(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateWorkstationCluster(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateWorkstationCluster, @@ -92,6 +119,12 @@ class MockWorkstationsConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateWorkstationCluster(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateWorkstationCluster, (NoAwaitTag, @@ -99,14 +132,29 @@ class MockWorkstationsConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateWorkstationCluster(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateWorkstationCluster, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteWorkstationCluster)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteWorkstationCluster(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteWorkstationCluster(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteWorkstationCluster, @@ -114,6 +162,12 @@ class MockWorkstationsConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteWorkstationCluster(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteWorkstationCluster, (NoAwaitTag, @@ -121,6 +175,15 @@ class MockWorkstationsConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteWorkstationCluster(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteWorkstationCluster, @@ -146,9 +209,15 @@ class MockWorkstationsConnection request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateWorkstationConfig)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateWorkstationConfig(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateWorkstationConfig(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateWorkstationConfig, @@ -156,6 +225,12 @@ class MockWorkstationsConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateWorkstationConfig(_, _)) + /// @endcode MOCK_METHOD( StatusOr, CreateWorkstationConfig, (NoAwaitTag, @@ -163,14 +238,29 @@ class MockWorkstationsConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateWorkstationConfig(Matcher(_))) + /// @endcode MOCK_METHOD( future>, CreateWorkstationConfig, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateWorkstationConfig)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateWorkstationConfig(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateWorkstationConfig(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateWorkstationConfig, @@ -178,6 +268,12 @@ class MockWorkstationsConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateWorkstationConfig(_, _)) + /// @endcode MOCK_METHOD( StatusOr, UpdateWorkstationConfig, (NoAwaitTag, @@ -185,14 +281,29 @@ class MockWorkstationsConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateWorkstationConfig(Matcher(_))) + /// @endcode MOCK_METHOD( future>, UpdateWorkstationConfig, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteWorkstationConfig)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteWorkstationConfig(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteWorkstationConfig(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteWorkstationConfig, @@ -200,6 +311,12 @@ class MockWorkstationsConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteWorkstationConfig(_, _)) + /// @endcode MOCK_METHOD( StatusOr, DeleteWorkstationConfig, (NoAwaitTag, @@ -207,6 +324,15 @@ class MockWorkstationsConnection request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteWorkstationConfig(Matcher(_))) + /// @endcode MOCK_METHOD( future>, DeleteWorkstationConfig, @@ -229,97 +355,197 @@ class MockWorkstationsConnection (google::cloud::workstations::v1::ListUsableWorkstationsRequest request), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, CreateWorkstation)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, CreateWorkstation(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateWorkstation(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateWorkstation, (google::cloud::workstations::v1::CreateWorkstationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, CreateWorkstation(_, _)) + /// @endcode MOCK_METHOD(StatusOr, CreateWorkstation, (NoAwaitTag, google::cloud::workstations::v1::CreateWorkstationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// CreateWorkstation(Matcher(_))) + /// @endcode MOCK_METHOD(future>, CreateWorkstation, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, UpdateWorkstation)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, UpdateWorkstation(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateWorkstation(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateWorkstation, (google::cloud::workstations::v1::UpdateWorkstationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, UpdateWorkstation(_, _)) + /// @endcode MOCK_METHOD(StatusOr, UpdateWorkstation, (NoAwaitTag, google::cloud::workstations::v1::UpdateWorkstationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// UpdateWorkstation(Matcher(_))) + /// @endcode MOCK_METHOD(future>, UpdateWorkstation, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, DeleteWorkstation)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, DeleteWorkstation(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteWorkstation(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteWorkstation, (google::cloud::workstations::v1::DeleteWorkstationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, DeleteWorkstation(_, _)) + /// @endcode MOCK_METHOD(StatusOr, DeleteWorkstation, (NoAwaitTag, google::cloud::workstations::v1::DeleteWorkstationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// DeleteWorkstation(Matcher(_))) + /// @endcode MOCK_METHOD(future>, DeleteWorkstation, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, StartWorkstation)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, StartWorkstation(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// StartWorkstation(Matcher(_))) + /// @endcode MOCK_METHOD( future>, StartWorkstation, (google::cloud::workstations::v1::StartWorkstationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, StartWorkstation(_, _)) + /// @endcode MOCK_METHOD( StatusOr, StartWorkstation, (NoAwaitTag, google::cloud::workstations::v1::StartWorkstationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, StartWorkstation(Matcher(_))) + /// @endcode MOCK_METHOD(future>, StartWorkstation, (google::longrunning::Operation const& operation), (override)); - /// Due to additional overloads for this method - /// `EXPECT_CALL(*mock, StopWorkstation)` is now ambiguous. Use - /// `EXPECT_CALL(*mock, StopWorkstation(::testing::_))` instead. + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, + /// StopWorkstation(Matcher(_))) + /// @endcode MOCK_METHOD( future>, StopWorkstation, (google::cloud::workstations::v1::StopWorkstationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// EXPECT_CALL(*mock, StopWorkstation(_, _)) + /// @endcode MOCK_METHOD( StatusOr, StopWorkstation, (NoAwaitTag, google::cloud::workstations::v1::StopWorkstationRequest const& request), (override)); + /// To disambiguate calls, use: + /// + /// @code + /// using ::testing::_; + /// using ::testing::Matcher; + /// EXPECT_CALL(*mock, StopWorkstation(Matcher(_))) + /// @endcode MOCK_METHOD(future>, StopWorkstation, (google::longrunning::Operation const& operation), (override));