[Create Test] Creating IDM_3_2 python3 test module

src/app/WriteClient.cpp

@@ -171,7 +171,7 @@ CHIP_ERROR WriteClient::StartNewMessage()
         ReturnErrorOnFailure(FinalizeMessage(true));
     }
 
-    // Do not allow timed request with chunks.
+    // Per Matter specification: a Write Request that is part of a Timed Write Interaction SHALL NOT be chunked.
     VerifyOrReturnError(!(mTimedWriteTimeoutMs.HasValue() && !mChunks.IsNull()), CHIP_ERROR_NO_MEMORY);
 
     System::PacketBufferHandle packet = System::PacketBufferHandle::New(kMaxSecureSduLengthBytes);
@@ -201,7 +201,7 @@ CHIP_ERROR WriteClient::StartNewMessage()
 
     ReturnErrorOnFailure(mWriteRequestBuilder.Init(&mMessageWriter));
     mWriteRequestBuilder.SuppressResponse(mSuppressResponse);
-    mWriteRequestBuilder.TimedRequest(mTimedWriteTimeoutMs.HasValue());
+    mWriteRequestBuilder.TimedRequest(mTimedRequestFieldValue);
     ReturnErrorOnFailure(mWriteRequestBuilder.GetError());
     mWriteRequestBuilder.CreateWriteRequests();
     ReturnErrorOnFailure(mWriteRequestBuilder.GetError());

src/app/WriteClient.h

@@ -129,7 +129,7 @@ class WriteClient : public Messaging::ExchangeDelegate
                 bool aSuppressResponse = false) :
         mpExchangeMgr(apExchangeMgr),
         mExchangeCtx(*this), mpCallback(apCallback), mTimedWriteTimeoutMs(aTimedWriteTimeoutMs),
-        mSuppressResponse(aSuppressResponse)
+        mSuppressResponse(aSuppressResponse), mTimedRequestFieldValue(aTimedWriteTimeoutMs.HasValue())
     {
         assertChipStackLockedByCurrentThread();
     }
@@ -138,7 +138,70 @@ class WriteClient : public Messaging::ExchangeDelegate
     WriteClient(Messaging::ExchangeManager * apExchangeMgr, Callback * apCallback, const Optional<uint16_t> & aTimedWriteTimeoutMs,
                 uint16_t aReservedSize) :
         mpExchangeMgr(apExchangeMgr),
-        mExchangeCtx(*this), mpCallback(apCallback), mTimedWriteTimeoutMs(aTimedWriteTimeoutMs), mReservedSize(aReservedSize)
+        mExchangeCtx(*this), mpCallback(apCallback), mTimedWriteTimeoutMs(aTimedWriteTimeoutMs), mReservedSize(aReservedSize),
+        mTimedRequestFieldValue(aTimedWriteTimeoutMs.HasValue())
+    {
+        assertChipStackLockedByCurrentThread();
+    }
+
+    /**
+     * 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).
+     *
+     * IMPORTANT: Understanding the distinction between two concepts:
+     * 1. TIMED REQUEST ACTION: A preceding TimedRequest protocol message sent before the actual Write Request.
+     *                          This establishes a time window during which the server will accept the write.
+     *                          This is controlled by the mTimedWriteTimeoutMs field.
+     *
+     * 2. TIMEDREQUEST FIELD: A boolean field in the WriteRequest message itself that indicates whether
+     *                       the write was preceded by a Timed Request action.
+     *                       This is controlled by the mTimedRequestFieldValue field.
+     *
+     * Normal behavior: When you provide a timeout value to the standard constructor, both happen together:
+     *   - 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.
+     *
+     * 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]
+     *
+     * @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
+     */
+    WriteClient(Messaging::ExchangeManager * apExchangeMgr, Callback * apCallback, const Optional<uint16_t> & aTimedWriteTimeoutMs,
+                bool aTimedRequestFieldValue, TestOnlyOverrideTimedRequestFieldTag) :
+        mpExchangeMgr(apExchangeMgr),
+        mExchangeCtx(*this), mpCallback(apCallback), mTimedWriteTimeoutMs(aTimedWriteTimeoutMs),
+        mTimedRequestFieldValue(aTimedRequestFieldValue)
     {
         assertChipStackLockedByCurrentThread();
     }
@@ -525,6 +588,15 @@ class WriteClient : public Messaging::ExchangeDelegate
     uint16_t mReservedSize = 0;
     // #endif
 
+    /**
+     * The value of the TimedRequest field in the WriteRequest message.
+     *
+     * This tells the server whether this write was preceded by a Timed Request action.
+     * Normally this matches whether mTimedWriteTimeoutMs has a value, but test constructors
+     * can decouple these to test protocol mismatch scenarios.
+     */
+    bool mTimedRequestFieldValue = false;
+
     /**
      * Below we define several const variables for encoding overheads.
      * WriteRequestMessage =