mw/com: disambiguate proxy field test ctor with WithTestTag

KrishaDeshkool · KrishaDeshkool · commit 5e6e75a52a3d · 2026-05-06T16:34:43.000+02:00
diff --git a/score/mw/com/impl/field_tags.h b/score/mw/com/impl/field_tags.h
@@ -49,6 +49,12 @@ struct is_tag_enabled : std::conjunction<contains_type<TargetTag, Tags...>, std:
 {
 };
 
+/// \brief Marker used as a disambiguator on test-only ctors to keep them distinct from production overloads.
+/// Lives in detail to signal "not part of the public API"; tests reach into the detail namespace knowingly.
+struct WithTestTag
+{
+};
+
 }  // namespace detail
 
 }  // namespace score::mw::com::impl
diff --git a/score/mw/com/impl/mocking/proxy_event_mock_test.cpp b/score/mw/com/impl/mocking/proxy_event_mock_test.cpp
@@ -45,15 +45,27 @@ class ProxyEventFieldMockFixture : public ::testing::Test
     using ProxyEventFieldMock = typename T::ProxyEventFieldMock;
 
     ProxyEventFieldMockFixture()
+        : unit_{[this] {
+              if constexpr (detail::is_proxy_field_v<ProxyEventField>)
+              {
+                  return ProxyEventField{proxy_base_,
+                                         kDummyEventFieldName,
+                                         detail::WithTestTag{},
+                                         std::unique_ptr<ProxyEventBinding<TestSampleType>>{nullptr}};
+              }
+              else
+              {
+                  return ProxyEventField{
+                      proxy_base_, kDummyEventFieldName, std::unique_ptr<ProxyEventBinding<TestSampleType>>{nullptr}};
+              }
+          }()}
     {
         unit_.InjectMock(proxy_service_element_mock_);
     }
 
     ProxyEventFieldMock proxy_service_element_mock_{};
     ProxyBase proxy_base_{nullptr, MakeFakeHandle(1U)};
-    ProxyEventField unit_{proxy_base_,
-                          kDummyEventFieldName,
-                          std::unique_ptr<ProxyEventBinding<TestSampleType>>{nullptr}};
+    ProxyEventField unit_;
 };
 
 struct ProxyEventStruct
diff --git a/score/mw/com/impl/proxy_event_base_test.cpp b/score/mw/com/impl/proxy_event_base_test.cpp
@@ -40,6 +40,21 @@ using namespace ::testing;
 
 using TestEventOrFieldType = std::uint16_t;
 
+/// Constructs a service element (ProxyEvent / GenericProxyEvent / ProxyField) for testing, inserting the
+/// detail::WithTestTag disambiguator when the target type is a ProxyField.
+template <typename ServiceElementType, typename ProxyT, typename Binding>
+auto MakeServiceElementForTest(ProxyT& proxy, const char* name, Binding binding)
+{
+    if constexpr (detail::is_proxy_field_v<ServiceElementType>)
+    {
+        return std::make_unique<ServiceElementType>(proxy, name, detail::WithTestTag{}, std::move(binding));
+    }
+    else
+    {
+        return std::make_unique<ServiceElementType>(proxy, name, std::move(binding));
+    }
+}
+
 const ServiceTypeDeployment kEmptyTypeDeployment{score::cpp::blank{}};
 const ServiceIdentifierType kFooservice{make_ServiceIdentifierType("foo")};
 const auto kInstanceSpecifier = InstanceSpecifier::Create(std::string{"/dummy_instance_specifier"}).value();
@@ -73,8 +88,8 @@ class ProxyEventBaseFixture : public ::testing::Test
         auto mock_service_element_binding_ptr = std::make_unique<MockServiceElementType>();
         mock_service_element_binding_ = mock_service_element_binding_ptr.get();
 
-        service_element_ =
-            std::make_unique<ServiceElementType>(empty_proxy_, kEventName, std::move(mock_service_element_binding_ptr));
+        service_element_ = MakeServiceElementForTest<ServiceElementType>(
+            empty_proxy_, kEventName, std::move(mock_service_element_binding_ptr));
 
         ON_CALL(*mock_service_element_binding_, SetReceiveHandler(_)).WillByDefault(Return(score::Result<void>{}));
     }
@@ -164,8 +179,9 @@ TYPED_TEST(ProxyEventBaseCreationFixture, CreatingServiceElementWithValidEventBi
                            make_HandleType(make_InstanceIdentifier(kEmptyInstanceDeployment, kEmptyTypeDeployment)));
 
     // When creating a ProxyEvent with a valid binding
-    auto service_element = std::make_unique<typename ProxyEventBaseCreationFixture<TypeParam>::ServiceElementType>(
-        dummy_proxy, kEventName, std::move(valid_proxy_event_binding));
+    auto service_element =
+        MakeServiceElementForTest<typename ProxyEventBaseCreationFixture<TypeParam>::ServiceElementType>(
+            dummy_proxy, kEventName, std::move(valid_proxy_event_binding));
 
     // Then the proxy should report that all bindings are valid
     EXPECT_TRUE(dummy_proxy.AreBindingsValid());
@@ -178,10 +194,11 @@ TYPED_TEST(ProxyEventBaseCreationFixture, CreatingServiceElementWithInvalidEvent
                            make_HandleType(make_InstanceIdentifier(kEmptyInstanceDeployment, kEmptyTypeDeployment)));
 
     // When creating a ProxyEvent with an invalid binding
-    auto service_element = std::make_unique<typename ProxyEventBaseCreationFixture<TypeParam>::ServiceElementType>(
-        dummy_proxy,
-        kEventName,
-        std::unique_ptr<typename ProxyEventBaseCreationFixture<TypeParam>::MockServiceElementType>(nullptr));
+    auto service_element =
+        MakeServiceElementForTest<typename ProxyEventBaseCreationFixture<TypeParam>::ServiceElementType>(
+            dummy_proxy,
+            kEventName,
+            std::unique_ptr<typename ProxyEventBaseCreationFixture<TypeParam>::MockServiceElementType>(nullptr));
 
     // Then the proxy should report that all bindings are not valid
     EXPECT_FALSE(dummy_proxy.AreBindingsValid());
@@ -197,8 +214,9 @@ TYPED_TEST(ProxyEventBaseCreationFixture, CreatingServiceElementWithInvalidProxy
                            make_HandleType(make_InstanceIdentifier(kEmptyInstanceDeployment, kEmptyTypeDeployment)));
 
     // When creating a ProxyEvent with a valid binding
-    auto service_element = std::make_unique<typename ProxyEventBaseCreationFixture<TypeParam>::ServiceElementType>(
-        dummy_proxy, kEventName, std::move(valid_proxy_event_binding));
+    auto service_element =
+        MakeServiceElementForTest<typename ProxyEventBaseCreationFixture<TypeParam>::ServiceElementType>(
+            dummy_proxy, kEventName, std::move(valid_proxy_event_binding));
 
     // Then the proxy should report that all bindings are not valid
     EXPECT_FALSE(dummy_proxy.AreBindingsValid());
@@ -223,8 +241,9 @@ TYPED_TEST(ProxyEventBaseCreationFixture,
                            make_HandleType(make_InstanceIdentifier(kEmptyInstanceDeployment, kEmptyTypeDeployment)));
 
     // When creating a ProxyEvent with a valid binding
-    auto service_element = std::make_unique<typename ProxyEventBaseCreationFixture<TypeParam>::ServiceElementType>(
-        dummy_proxy, kEventName, std::move(valid_proxy_event_binding));
+    auto service_element =
+        MakeServiceElementForTest<typename ProxyEventBaseCreationFixture<TypeParam>::ServiceElementType>(
+            dummy_proxy, kEventName, std::move(valid_proxy_event_binding));
 }
 
 TYPED_TEST(ProxyEventBaseCreationFixture,
@@ -243,10 +262,10 @@ TYPED_TEST(ProxyEventBaseCreationFixture,
                            make_HandleType(make_InstanceIdentifier(kEmptyInstanceDeployment, kEmptyTypeDeployment)));
 
     // When creating a ProxyEvent with an invalid binding
-    auto service_element = std::make_unique<typename ProxyEventBaseCreationFixture<TypeParam>::ServiceElementType>(
-        dummy_proxy,
-        kEventName,
-        std::unique_ptr<typename ProxyEventBaseCreationFixture<TypeParam>::MockServiceElementType>(nullptr));
+    using ServiceElementType = typename ProxyEventBaseCreationFixture<TypeParam>::ServiceElementType;
+    using MockServiceElementType = typename ProxyEventBaseCreationFixture<TypeParam>::MockServiceElementType;
+    auto service_element = MakeServiceElementForTest<ServiceElementType>(
+        dummy_proxy, kEventName, std::unique_ptr<MockServiceElementType>(nullptr));
 }
 
 TYPED_TEST(ProxyEventBaseUnsubscribeFixture, CallingUnsubscribeWhileSubscribedCallsUnsubscribeOnBinding)
@@ -357,8 +376,8 @@ class AServiceElement : public ::testing::Test
         auto mock_service_element_binding_ptr = std::make_unique<MockServiceElementType>();
         mock_service_element_binding_ = mock_service_element_binding_ptr.get();
 
-        service_element_ =
-            std::make_unique<ServiceElementType>(empty_proxy_, kEventName, std::move(mock_service_element_binding_ptr));
+        service_element_ = MakeServiceElementForTest<ServiceElementType>(
+            empty_proxy_, kEventName, std::move(mock_service_element_binding_ptr));
         ASSERT_NE(service_element_, nullptr);
 
         ON_CALL(*mock_service_element_binding_, SetReceiveHandler(_)).WillByDefault(Return(score::Result<void>{}));
diff --git a/score/mw/com/impl/proxy_event_test.cpp b/score/mw/com/impl/proxy_event_test.cpp
@@ -106,7 +106,17 @@ class ProxyEventFixture : public ::testing::Test
                        make_HandleType(make_InstanceIdentifier(kEmptyInstanceDeployment, kEmptyTypeDeployment))},
           mock_proxy_event_ptr_{std::make_unique<MockProxyEventType>()},
           mock_proxy_event_{*mock_proxy_event_ptr_},
-          proxy_event_{empty_proxy_, kEventName, std::move(mock_proxy_event_ptr_)}
+          proxy_event_{[this] {
+              if constexpr (detail::is_proxy_field_v<ProxyEventType>)
+              {
+                  return ProxyEventType{
+                      empty_proxy_, kEventName, detail::WithTestTag{}, std::move(mock_proxy_event_ptr_)};
+              }
+              else
+              {
+                  return ProxyEventType{empty_proxy_, kEventName, std::move(mock_proxy_event_ptr_)};
+              }
+          }()}
     {
     }
 
diff --git a/score/mw/com/impl/proxy_field.h b/score/mw/com/impl/proxy_field.h
@@ -43,6 +43,25 @@ namespace score::mw::com::impl
 template <typename FieldType, typename... Tags>
 class ProxyFieldAttorney;
 
+template <typename SampleDataType, typename... Tags>
+class ProxyField;
+
+namespace detail
+{
+
+template <typename T>
+struct is_proxy_field : std::false_type
+{
+};
+template <typename FieldType, typename... Tags>
+struct is_proxy_field<ProxyField<FieldType, Tags...>> : std::true_type
+{
+};
+template <typename T>
+constexpr bool is_proxy_field_v = is_proxy_field<T>::value;
+
+}  // namespace detail
+
 /// \brief This is the user-visible class of a field that is part of a proxy. It delegates all functionality to
 /// ProxyEvent.
 ///
@@ -67,11 +86,11 @@ class ProxyField final : public ProxyFieldBase
   public:
     using FieldType = SampleDataType;
 
-    /// Testing ctor: bindings are passed in directly (used with mock bindings). The event binding is required
-    /// (no default) to disambiguate this overload from the production ctors when called as `{proxy, field_name}`.
-    /// Method bindings default to nullptr; passing nullptr means the corresponding ProxyMethod is not built.
+    /// Testing ctor: bindings are passed in directly (used with mock bindings). Disambiguated from the production
+    /// ctors via the detail::WithTestTag marker, required as the 3rd argument. Bindings default to nullptr;
     ProxyField(ProxyBase& proxy_base,
                const std::string_view field_name,
+               detail::WithTestTag,
                std::unique_ptr<ProxyEventBinding<FieldType>> event_binding = nullptr,
                std::unique_ptr<ProxyMethodBinding> get_method_binding = nullptr,
                std::unique_ptr<ProxyMethodBinding> set_method_binding = nullptr)
diff --git a/score/mw/com/impl/proxy_field_base.h b/score/mw/com/impl/proxy_field_base.h
@@ -30,10 +30,10 @@ namespace score::mw::com::impl
 class ProxyFieldBase
 {
   public:
+    /// \param proxy_event_base_dispatch May be nullptr when the field has no notifier tag.
     ProxyFieldBase(ProxyBase& proxy_base, std::string_view field_name, ProxyEventBase* proxy_event_base_dispatch)
         : proxy_base_{proxy_base}, proxy_event_base_dispatch_{proxy_event_base_dispatch}, field_name_{field_name}
     {
-        SCORE_LANGUAGE_FUTURECPP_ASSERT_PRD(proxy_event_base_dispatch != nullptr);
     }
 
     /// \brief A ProxyFieldBase shall not be copyable
diff --git a/score/mw/com/test/common_test_resources/test_interface.h b/score/mw/com/test/common_test_resources/test_interface.h
@@ -28,11 +28,7 @@ class TestInterface : public T::Base
   public:
     using T::Base::Base;
 
-    typename T::template Field<std::int32_t,
-                               score::mw::com::WithGetter,
-                               score::mw::com::WithSetter,
-                               score::mw::com::WithNotifier>
-        test_field{*this, "test_field"};
+    typename T::template Field<std::int32_t, score::mw::com::WithNotifier> test_field{*this, "test_field"};
 };
 
 }  // namespace score::mw::com::test

Original file line number	Diff line number	Diff line change
`@@ -30,10 +30,10 @@ namespace score::mw::com::impl`
`30`	`30`	`class ProxyFieldBase`
`31`	`31`	`{`
`32`	`32`	`public:`
	`33`	`+ /// \param proxy_event_base_dispatch May be nullptr when the field has no notifier tag.`
`33`	`34`	`ProxyFieldBase(ProxyBase& proxy_base, std::string_view field_name, ProxyEventBase* proxy_event_base_dispatch)`
`34`	`35`	`: proxy_base_{proxy_base}, proxy_event_base_dispatch_{proxy_event_base_dispatch}, field_name_{field_name}`
`35`	`36`	`{`
`36`		`- SCORE_LANGUAGE_FUTURECPP_ASSERT_PRD(proxy_event_base_dispatch != nullptr);`
`37`	`37`	`}`
`38`	`38`
`39`	`39`	`/// \brief A ProxyFieldBase shall not be copyable`