Consolidate redundant test-only Timed Request code per Boris's feedback:

- Remove redundant WriteClient constructor taking only bool parameter
- Merge pychip_WriteClient_TestOnlyWriteAttributesTimedRequestNoTimedAction
  and pychip_WriteClient_TestOnlyWriteAttributesTimedActionNoTimedRequestFlag
  into single pychip_WriteClient_TestOnlyWriteAttributesWithMismatchedTimedRequestField
- Update Python bindings and tests to use unified API

The single test function now takes both timedRequestTimeoutMs and timedRequestFieldValue parameters,
allowing callers to specify exactly what combination they need for each test scenario.

Author: j-ororke

src/app/WriteClient.h

@@ -144,9 +144,13 @@ class WriteClient : public Messaging::ExchangeDelegate
         assertChipStackLockedByCurrentThread();
     }
 
+    // Tag type to distinguish the test constructor from the normal constructor
+    struct TestOnlyOverrideTimedRequestFieldTag
+    {
+    };
+
     /**
-     * TestOnly constructor that allows setting the TimedRequest field in the WriteRequest without performing
-     * a Timed Request action (i.e., without actually sending a TimedRequest message first).
+     * TestOnly constructor that decouples the Timed Request action from the TimedRequest field value.
      *
      * IMPORTANT: Understanding the distinction between two concepts:
      * 1. TIMED REQUEST ACTION: A preceding TimedRequest protocol message sent before the actual Write Request.
@@ -161,41 +165,16 @@ class WriteClient : public Messaging::ExchangeDelegate
      *   - A Timed Request action is sent (controlled by mTimedWriteTimeoutMs)
      *   - The TimedRequest field in WriteRequest is set to true (mTimedRequestFieldValue = true)
      *
-     * This test constructor allows you to decouple these for testing edge cases:
-     *   - aTimedRequestFieldValue = false: No Timed Request action AND TimedRequest field is false (normal non-timed write)
-     *   - aTimedRequestFieldValue = true:  No Timed Request action BUT TimedRequest field is true
-     *                            (This is invalid behavior that should be rejected by the server, used for negative testing)
-     *
-     * @param[in] aTimedRequestFieldValue If true, sets the TimedRequest field in WriteRequest to true without actually
-     *                          performing a Timed Request action. This creates a mismatch that should be rejected
-     *                          by a compliant server.
-     */
-    WriteClient(Messaging::ExchangeManager * apExchangeMgr, Callback * apCallback, bool aTimedRequestFieldValue) :
-        mpExchangeMgr(apExchangeMgr), mExchangeCtx(*this), mpCallback(apCallback), mTimedRequestFieldValue(aTimedRequestFieldValue)
-    {
-        assertChipStackLockedByCurrentThread();
-    }
-
-    // Tag type to distinguish the test constructor from the normal constructor
-    struct TestOnlyOverrideTimedRequestFieldTag
-    {
-    };
-
-    /**
-     * TestOnly constructor that allows performing a Timed Request action while setting the TimedRequest field
-     * in the WriteRequest to false (i.e., sending a TimedRequest message first, but then lying about it in the WriteRequest).
-     *
-     * This tests the third edge case: Timed Request action IS performed, but the TimedRequest field is set to false.
+     * This test constructor allows you to decouple these for testing all edge cases:
      *
-     * Test scenarios enabled by WriteClient constructors:
-     * 1. Normal write (both false):              Action = No,  Field = False  [Standard constructor with no timeout]
-     * 2. Normal timed write (both true):         Action = Yes, Field = True   [Standard constructor with timeout]
-     * 3. Field true, no action (invalid):        Action = No,  Field = True   [Test constructor taking bool
-     * aTimedRequestFieldValue]
-     * 4. Action present, field false (invalid):  Action = Yes, Field = False  [THIS constructor]
+     * Test scenarios enabled by this constructor:
+     * 1. Normal write (both false):              Action = No,  Field = False  [aTimedWriteTimeoutMs = Missing, aTimedRequestFieldValue = false]
+     * 2. Normal timed write (both true):         Action = Yes, Field = True   [aTimedWriteTimeoutMs = value, aTimedRequestFieldValue = true]
+     * 3. Field true, no action (invalid):        Action = No,  Field = True   [aTimedWriteTimeoutMs = Missing, aTimedRequestFieldValue = true]
+     * 4. Action present, field false (invalid):  Action = Yes, Field = False  [aTimedWriteTimeoutMs = value, aTimedRequestFieldValue = false]
      *
-     * @param[in] aTimedWriteTimeoutMs The timeout for the Timed Request action (WILL be sent)
-     * @param[in] aTimedRequestFieldValue If false, the TimedRequest field in WriteRequest will be false despite the action
+     * @param[in] aTimedWriteTimeoutMs The timeout for the Timed Request action (if provided, action WILL be sent)
+     * @param[in] aTimedRequestFieldValue The value of the TimedRequest field in WriteRequest (can mismatch the action for testing)
      */
     WriteClient(Messaging::ExchangeManager * apExchangeMgr, Callback * apCallback, const Optional<uint16_t> & aTimedWriteTimeoutMs,
                 bool aTimedRequestFieldValue, TestOnlyOverrideTimedRequestFieldTag) :

src/controller/python/matter/ChipDeviceCtrl.py

@@ -1616,46 +1616,23 @@ def _prepare_write_attribute_requests(self, attributes: typing.List[typing.Tuple
                     v[0], v[1], v[2], 1, v[1].value))
         return attrs
 
-    async def TestOnlyWriteAttributeTimedRequestFlagWithNoTimedAction(self, nodeid: int,
-                                                                      attributes: typing.List[typing.Tuple[int, ClusterObjects.ClusterAttributeDescriptor]],
-                                                                      interactionTimeoutMs: typing.Optional[int] = None, busyWaitMs: typing.Optional[int] = None,
-                                                                      payloadCapability: int = TransportPayloadCapability.MRP_PAYLOAD):
+    async def TestOnlyWriteAttributeWithMismatchedTimedRequestField(self, nodeid: int,
+                                                                    attributes: typing.List[typing.Tuple[int, ClusterObjects.ClusterAttributeDescriptor]],
+                                                                    timedRequestTimeoutMs: int,
+                                                                    timedRequestFieldValue: bool,
+                                                                    interactionTimeoutMs: typing.Optional[int] = None, busyWaitMs: typing.Optional[int] = None,
+                                                                    payloadCapability: int = TransportPayloadCapability.MRP_PAYLOAD):
         '''
-        ONLY TO BE USED FOR TEST: Write attributes with TimedRequest flag but no TimedAction transaction.
-        This should result in TIMED_REQUEST_MISMATCH error.
+        ONLY TO BE USED FOR TEST: Write attributes with decoupled Timed Request action and TimedRequest field.
+        This allows testing TIMED_REQUEST_MISMATCH scenarios:
+        - timedRequestTimeoutMs=0, timedRequestFieldValue=True: No action, but field=true (MISMATCH)
+        - timedRequestTimeoutMs>0, timedRequestFieldValue=False: Action sent, but field=false (MISMATCH)
 
-        Please see WriteAttribute for description of parameters.
+        Please see WriteAttribute for description of common parameters.
 
-        Returns:
-            [AttributeStatus] (list - one for each path).
-
-        Raises:
-            InteractionModelError on error (expected: TIMED_REQUEST_MISMATCH)
-        '''
-        self.CheckIsActive()
-
-        eventLoop = asyncio.get_running_loop()
-        future = eventLoop.create_future()
-
-        device = await self.GetConnectedDevice(nodeid, timeoutMs=interactionTimeoutMs, payloadCapability=payloadCapability)
-
-        attrs = self._prepare_write_attribute_requests(attributes)
-
-        ClusterAttribute.TestOnlyWriteAttributeTimedRequestFlagWithNoTimedAction(
-            future, eventLoop, device.deviceProxy, attrs,
-            interactionTimeoutMs=interactionTimeoutMs, busyWaitMs=busyWaitMs).raise_on_error()
-        return await future
-
-    async def TestOnlyWriteAttributeTimedActionNoTimedRequestFlag(self, nodeid: int,
-                                                                  attributes: typing.List[typing.Tuple[int, ClusterObjects.ClusterAttributeDescriptor]],
-                                                                  timedRequestTimeoutMs: int,
-                                                                  interactionTimeoutMs: typing.Optional[int] = None, busyWaitMs: typing.Optional[int] = None,
-                                                                  payloadCapability: int = TransportPayloadCapability.MRP_PAYLOAD):
-        '''
-        ONLY TO BE USED FOR TEST: Write attributes with Timed Action performed but TimedRequest flag set to false.
-        This should result in TIMED_REQUEST_MISMATCH error.
-
-        Please see WriteAttribute for description of parameters.
+        Additional parameters:
+            timedRequestTimeoutMs: Timeout for the Timed Request action (0 means no action)
+            timedRequestFieldValue: Value of the TimedRequest field in WriteRequest
 
         Returns:
             [AttributeStatus] (list - one for each path).
@@ -1672,9 +1649,10 @@ async def TestOnlyWriteAttributeTimedActionNoTimedRequestFlag(self, nodeid: int,
 
         attrs = self._prepare_write_attribute_requests(attributes)
 
-        ClusterAttribute.TestOnlyWriteAttributeTimedActionNoTimedRequestFlag(
+        ClusterAttribute.TestOnlyWriteAttributeWithMismatchedTimedRequestField(
             future, eventLoop, device.deviceProxy, attrs,
             timedRequestTimeoutMs=timedRequestTimeoutMs,
+            timedRequestFieldValue=timedRequestFieldValue,
             interactionTimeoutMs=interactionTimeoutMs, busyWaitMs=busyWaitMs).raise_on_error()
         return await future
 

src/controller/python/matter/clusters/Attribute.py

@@ -1061,13 +1061,17 @@ def WriteAttributes(future: Future, eventLoop, device,
     return res
 
 
-def TestOnlyWriteAttributeTimedRequestFlagWithNoTimedAction(future: Future, eventLoop, device,
-                                                            attributes: List[AttributeWriteRequest],
-                                                            interactionTimeoutMs: Union[None, int] = None,
-                                                            busyWaitMs: Union[None, int] = None) -> PyChipError:
+def TestOnlyWriteAttributeWithMismatchedTimedRequestField(future: Future, eventLoop, device,
+                                                          attributes: List[AttributeWriteRequest],
+                                                          timedRequestTimeoutMs: int,
+                                                          timedRequestFieldValue: bool,
+                                                          interactionTimeoutMs: Union[None, int] = None,
+                                                          busyWaitMs: Union[None, int] = None) -> PyChipError:
     ''' 
-    ONLY TO BE USED FOR TEST: Writes attributes with TimedRequest flag but no TimedAction transaction
-    This should result in TIMED_REQUEST_MISMATCH error.
+    ONLY TO BE USED FOR TEST: Writes attributes with decoupled Timed Request action and TimedRequest field.
+    This allows testing TIMED_REQUEST_MISMATCH scenarios:
+    - timedRequestTimeoutMs=0, timedRequestFieldValue=True: No action, but field=true (MISMATCH)
+    - timedRequestTimeoutMs>0, timedRequestFieldValue=False: Action sent, but field=false (MISMATCH)
     '''
     handle = GetLibraryHandle()
 
@@ -1079,43 +1083,12 @@ def TestOnlyWriteAttributeTimedRequestFlagWithNoTimedAction(future: Future, even
     transaction = AsyncWriteTransaction(future, eventLoop)
     ctypes.pythonapi.Py_IncRef(ctypes.py_object(transaction))
 
-    # Call the TestOnly C++ function that sets TimedRequest=True but no timed transaction
+    # Call the TestOnly C++ function that decouples action and field
     res = builtins.chipStack.Call(
-        lambda: handle.pychip_WriteClient_TestOnlyWriteAttributesTimedRequestNoTimedAction(
-            ctypes.py_object(transaction), device,
-            ctypes.c_size_t(0 if interactionTimeoutMs is None else interactionTimeoutMs),
-            ctypes.c_size_t(0 if busyWaitMs is None else busyWaitMs),
-            pyWriteAttributes, ctypes.c_size_t(numberOfAttributes))
-    )
-    if not res.is_success:
-        ctypes.pythonapi.Py_DecRef(ctypes.py_object(transaction))
-    return res
-
-
-def TestOnlyWriteAttributeTimedActionNoTimedRequestFlag(future: Future, eventLoop, device,
-                                                        attributes: List[AttributeWriteRequest],
-                                                        timedRequestTimeoutMs: int,
-                                                        interactionTimeoutMs: Union[None, int] = None,
-                                                        busyWaitMs: Union[None, int] = None) -> PyChipError:
-    ''' 
-    ONLY TO BE USED FOR TEST: Writes attributes with Timed Action performed but TimedRequest flag set to false.
-    This should result in TIMED_REQUEST_MISMATCH error.
-    '''
-    handle = GetLibraryHandle()
-
-    # Note: We skip the timed write check here to allow testing the TIMED_REQUEST_MISMATCH scenario
-    # In normal WriteAttributes, this would check for must_use_timed_write
-    pyWriteAttributes, numberOfAttributes = _prepare_write_attributes_data(
-        attributes, must_use_timed_write_check=False)
-
-    transaction = AsyncWriteTransaction(future, eventLoop)
-    ctypes.pythonapi.Py_IncRef(ctypes.py_object(transaction))
-
-    # Call the TestOnly C++ function that performs TimedRequest action but sets flag=False
-    res = builtins.chipStack.Call(
-        lambda: handle.pychip_WriteClient_TestOnlyWriteAttributesTimedActionNoTimedRequestFlag(
+        lambda: handle.pychip_WriteClient_TestOnlyWriteAttributesWithMismatchedTimedRequestField(
             ctypes.py_object(transaction), device,
             ctypes.c_size_t(timedRequestTimeoutMs),
+            ctypes.c_bool(timedRequestFieldValue),
             ctypes.c_size_t(0 if interactionTimeoutMs is None else interactionTimeoutMs),
             ctypes.c_size_t(0 if busyWaitMs is None else busyWaitMs),
             pyWriteAttributes, ctypes.c_size_t(numberOfAttributes))
@@ -1295,12 +1268,9 @@ def Init():
 
         handle.pychip_WriteClient_WriteAttributes.restype = PyChipError
         handle.pychip_WriteClient_WriteGroupAttributes.restype = PyChipError
-        handle.pychip_WriteClient_TestOnlyWriteAttributesTimedRequestNoTimedAction.restype = PyChipError
-        handle.pychip_WriteClient_TestOnlyWriteAttributesTimedRequestNoTimedAction.argtypes = [py_object, c_void_p,
-                                                                                               c_size_t, c_size_t, POINTER(PyWriteAttributeData), c_size_t]
-        handle.pychip_WriteClient_TestOnlyWriteAttributesTimedActionNoTimedRequestFlag.restype = PyChipError
-        handle.pychip_WriteClient_TestOnlyWriteAttributesTimedActionNoTimedRequestFlag.argtypes = [py_object, c_void_p,
-                                                                                                   c_size_t, c_size_t, c_size_t, POINTER(PyWriteAttributeData), c_size_t]
+        handle.pychip_WriteClient_TestOnlyWriteAttributesWithMismatchedTimedRequestField.restype = PyChipError
+        handle.pychip_WriteClient_TestOnlyWriteAttributesWithMismatchedTimedRequestField.argtypes = [py_object, c_void_p,
+                                                                                                     c_size_t, c_bool, c_size_t, c_size_t, POINTER(PyWriteAttributeData), c_size_t]
 
         # Both WriteAttributes and WriteGroupAttributes are variadic functions. As per ctype documentation
         # https://docs.python.org/3/library/ctypes.html#calling-varadic-functions, it is critical that we