Add unit tests for TimeSnapshot command in GeneralDiagnosticsCluster (#41291)

* Add unit tests for `TimeSnapshot` command in `GeneralDiagnosticsCluster`

- Introduced a mock CommandHandler and a NullProvider for testing.
- Implemented tests for TimeSnapshot command, including scenarios with and without POSIX time support.
- Verified response values and ensured correct handling of command invocations.
- Added helper methods for setting up TLV readers and buffers for command testing.

* Refactor `TestGeneralDiagnosticsCluster` to improve command invocation testing

- Moved command invocation logic into a helper method  for better code reuse and clarity.

* Handle status responses in `ClusterTester` when `InvokeCommand` returns `nullopt`

When InvokeCommand returns nullopt, check for both data responses and
status responses in the mock handler. Previously only data responses
were checked. Now if a status response exists, use the last status
from the handler.

* Handle status responses and unexpected states in ClusterTester

When InvokeCommand returns nullopt, check for both data responses
and status responses. If a status response exists, use the last
status from the handler. Also handle the unexpected case where
neither response nor status is provided by setting an error status
and logging a warning.

* Refactor `TestGeneralDiagnosticsCluster` to improve command invocation and response handling

- Moved the `InvokeTimeSnapshotAndGetResponse` method outside the test struct for better organization and clarity.
- Simplified the command invocation process by ensuring `ClusterTester` is instantiated within each test case.
- Enhanced readability by removing redundant code and ensuring consistent error handling during command execution.

* Refactor `InvokeTimeSnapshotAndGetResponse` to use `ClusterTester` directly in tests

- Updated the `InvokeTimeSnapshotAndGetResponse` function to accept `ClusterTester` instead of `GeneralDiagnosticsCluster` for improved clarity and consistency in test cases.
- Adjusted all relevant test cases to reflect this change, ensuring proper command invocation and response handling.

* Enhance error handling in `InvokeTimeSnapshotAndGetResponse` for improved robustness

- Updated the InvokeTimeSnapshotAndGetResponse function to return appropriate error codes for various failure scenarios, ensuring better error handling during command execution.
- Adjusted test cases to assert the return value of the function, enhancing the reliability of the tests and ensuring that errors are properly captured and reported.

* Fix test helper to properly propagate errors

Changed InvokeTimeSnapshotAndGetResponse() to return CHIP_ERROR instead
of void. ASSERT macros inside void helper functions only return from the
helper, not from the test itself, which can lead to tests continuing with
uninitialized data and undefined behavior.

Author: LyudmilaKostanyan

src/app/clusters/general-diagnostics-server/CodegenIntegration.cpp

@@ -61,12 +61,12 @@ class IntegrationDelegate : public CodegenClusterIntegration::Delegate
 #if defined(ZCL_USING_TIME_SYNCHRONIZATION_CLUSTER_SERVER)
             .enablePosixTime = true,
 #else
-            .enablePosixTime      = false,
+            .enablePosixTime       = false,
 #endif
 #if defined(GENERAL_DIAGNOSTICS_ENABLE_PAYLOAD_TEST_REQUEST_CMD)
-            .enablePayloadSnaphot = true,
+            .enablePayloadSnapshot = true,
 #else
-            .enablePayloadSnaphot = false,
+            .enablePayloadSnapshot = false,
 #endif
         };
         gServer.Create(optionalAttributeSet, functionsConfig);

src/app/clusters/general-diagnostics-server/general-diagnostics-cluster.cpp

@@ -462,7 +462,7 @@ GeneralDiagnosticsClusterFullConfigurable::InvokeCommand(const DataModel::Invoke
         return HandleTimeSnapshot(*handler, request.path, request_data);
     }
     case GeneralDiagnostics::Commands::PayloadTestRequest::Id: {
-        if (mFunctionConfig.enablePayloadSnaphot)
+        if (mFunctionConfig.enablePayloadSnapshot)
         {
             GeneralDiagnostics::Commands::PayloadTestRequest::DecodableType request_data;
             ReturnErrorOnFailure(request_data.Decode(input_arguments));

src/app/clusters/general-diagnostics-server/general-diagnostics-cluster.h

@@ -32,7 +32,7 @@ namespace Clusters {
 struct GeneralDiagnosticsFunctionsConfig
 {
     bool enablePosixTime : 1;
-    bool enablePayloadSnaphot : 1;
+    bool enablePayloadSnapshot : 1;
 };
 
 class GeneralDiagnosticsCluster : public DefaultServerCluster

src/app/clusters/general-diagnostics-server/tests/TestGeneralDiagnosticsCluster.cpp

@@ -15,26 +15,31 @@
  */
 #include <pw_unit_test/framework.h>
 
+#include <app-common/zap-generated/cluster-objects.h>
 #include <app/clusters/general-diagnostics-server/general-diagnostics-cluster.h>
 #include <app/clusters/testing/AttributeTesting.h>
+#include <app/clusters/testing/ClusterTester.h>
+#include <app/clusters/testing/ValidateGlobalAttributes.h>
 #include <app/data-model-provider/MetadataTypes.h>
 #include <app/server-cluster/DefaultServerCluster.h>
+#include <app/server-cluster/testing/TestServerClusterContext.h>
 #include <clusters/GeneralDiagnostics/Enums.h>
 #include <clusters/GeneralDiagnostics/Metadata.h>
 #include <lib/core/CHIPError.h>
 #include <lib/core/StringBuilderAdapters.h>
 #include <lib/support/ReadOnlyBuffer.h>
+#include <messaging/ExchangeContext.h>
 #include <platform/DiagnosticDataProvider.h>
 
-#include <cmath>
-
 namespace {
 
 using namespace chip;
 using namespace chip::app;
 using namespace chip::app::Clusters;
 using namespace chip::app::Clusters::GeneralDiagnostics::Attributes;
 using namespace chip::app::DataModel;
+using namespace chip::Test;
+using namespace chip::Testing;
 
 template <class T>
 class ScopedDiagnosticsProvider
@@ -57,10 +62,38 @@ class ScopedDiagnosticsProvider
     T mProvider;
 };
 
+// Mock DiagnosticDataProvider for testing
+class NullProvider : public DeviceLayer::DiagnosticDataProvider
+{
+};
+
+// Helper method to invoke TimeSnapshot command and decode response
+CHIP_ERROR InvokeTimeSnapshotAndGetResponse(ClusterTester & tester,
+                                            GeneralDiagnostics::Commands::TimeSnapshotResponse::DecodableType & response)
+{
+    GeneralDiagnostics::Commands::TimeSnapshot::Type request{};
+    auto result = tester.Invoke(GeneralDiagnostics::Commands::TimeSnapshot::Id, request);
+
+    if (!result.status.has_value())
+    {
+        return CHIP_ERROR_INTERNAL;
+    }
+
+    ReturnErrorOnFailure(result.status->GetUnderlyingError());
+
+    if (!result.response.has_value())
+    {
+        return CHIP_ERROR_INCORRECT_STATE;
+    }
+
+    response = result.response.value();
+    return CHIP_NO_ERROR;
+}
+
 struct TestGeneralDiagnosticsCluster : public ::testing::Test
 {
-    static void SetUpTestSuite() { ASSERT_EQ(chip::Platform::MemoryInit(), CHIP_NO_ERROR); }
-    static void TearDownTestSuite() { chip::Platform::MemoryShutdown(); }
+    static void SetUpTestSuite() { ASSERT_EQ(Platform::MemoryInit(), CHIP_NO_ERROR); }
+    static void TearDownTestSuite() { Platform::MemoryShutdown(); }
 };
 
 TEST_F(TestGeneralDiagnosticsCluster, CompileTest)
@@ -71,8 +104,8 @@ TEST_F(TestGeneralDiagnosticsCluster, CompileTest)
     ASSERT_EQ(cluster.GetClusterFlags({ kRootEndpointId, GeneralDiagnostics::Id }), BitFlags<ClusterQualityFlags>());
 
     const GeneralDiagnosticsFunctionsConfig functionsConfig{
-        .enablePosixTime      = true,
-        .enablePayloadSnaphot = true,
+        .enablePosixTime       = true,
+        .enablePayloadSnapshot = true,
     };
 
     GeneralDiagnosticsClusterFullConfigurable clusterWithTimeAndPayload(optionalAttributeSet, functionsConfig);
@@ -84,52 +117,31 @@ TEST_F(TestGeneralDiagnosticsCluster, AttributesTest)
 {
     {
         // everything returns empty here ..
-        class NullProvider : public DeviceLayer::DiagnosticDataProvider
-        {
-        };
         const GeneralDiagnosticsCluster::OptionalAttributeSet optionalAttributeSet;
         ScopedDiagnosticsProvider<NullProvider> nullProvider;
         GeneralDiagnosticsCluster cluster(optionalAttributeSet);
 
         // Check required accepted commands are present
-        ConcreteClusterPath generalDiagnosticsPath = ConcreteClusterPath(kRootEndpointId, GeneralDiagnostics::Id);
-
-        ReadOnlyBufferBuilder<DataModel::AcceptedCommandEntry> acceptedCommandsBuilder;
-        ASSERT_EQ(cluster.AcceptedCommands(generalDiagnosticsPath, acceptedCommandsBuilder), CHIP_NO_ERROR);
-        ReadOnlyBuffer<DataModel::AcceptedCommandEntry> acceptedCommands = acceptedCommandsBuilder.TakeBuffer();
-        ASSERT_EQ(acceptedCommands.size(), 2u);
-
-        ASSERT_EQ(acceptedCommands[0].commandId, GeneralDiagnostics::Commands::TestEventTrigger::Id);
-        ASSERT_EQ(acceptedCommands[0].GetInvokePrivilege(),
-                  GeneralDiagnostics::Commands::TestEventTrigger::kMetadataEntry.GetInvokePrivilege());
-
-        ASSERT_EQ(acceptedCommands[1].commandId, GeneralDiagnostics::Commands::TimeSnapshot::Id);
-        ASSERT_EQ(acceptedCommands[1].GetInvokePrivilege(),
-                  GeneralDiagnostics::Commands::TimeSnapshot::kMetadataEntry.GetInvokePrivilege());
+        ASSERT_TRUE(IsAcceptedCommandsListEqualTo(cluster,
+                                                  {
+                                                      GeneralDiagnostics::Commands::TestEventTrigger::kMetadataEntry,
+                                                      GeneralDiagnostics::Commands::TimeSnapshot::kMetadataEntry,
+                                                  }));
 
         // Check required generated commands are present
-        ReadOnlyBufferBuilder<chip::CommandId> generatedCommandsBuilder;
-        ASSERT_EQ(cluster.GeneratedCommands(generalDiagnosticsPath, generatedCommandsBuilder), CHIP_NO_ERROR);
-        ReadOnlyBuffer<chip::CommandId> generatedCommands = generatedCommandsBuilder.TakeBuffer();
-
-        ASSERT_EQ(generatedCommands.size(), 1u);
-        ASSERT_EQ(generatedCommands[0], GeneralDiagnostics::Commands::TimeSnapshotResponse::Id);
+        ASSERT_TRUE(IsGeneratedCommandsListEqualTo(cluster,
+                                                   {
+                                                       GeneralDiagnostics::Commands::TimeSnapshotResponse::Id,
+                                                   }));
 
         // Everything is unimplemented, so attributes are just the global and mandatory ones.
-        ReadOnlyBufferBuilder<DataModel::AttributeEntry> attributesBuilder;
-        ASSERT_EQ(cluster.Attributes(generalDiagnosticsPath, attributesBuilder), CHIP_NO_ERROR);
-
-        ReadOnlyBufferBuilder<DataModel::AttributeEntry> expectedBuilder;
-        ASSERT_EQ(expectedBuilder.ReferenceExisting(DefaultServerCluster::GlobalAttributes()), CHIP_NO_ERROR);
-        ASSERT_EQ(expectedBuilder.AppendElements({
-                      GeneralDiagnostics::Attributes::NetworkInterfaces::kMetadataEntry,
-                      GeneralDiagnostics::Attributes::RebootCount::kMetadataEntry,
-                      GeneralDiagnostics::Attributes::UpTime::kMetadataEntry,
-                      GeneralDiagnostics::Attributes::TestEventTriggersEnabled::kMetadataEntry,
-                  }),
-                  CHIP_NO_ERROR);
-
-        ASSERT_TRUE(Testing::EqualAttributeSets(attributesBuilder.TakeBuffer(), expectedBuilder.TakeBuffer()));
+        ASSERT_TRUE(IsAttributesListEqualTo(cluster,
+                                            {
+                                                GeneralDiagnostics::Attributes::NetworkInterfaces::kMetadataEntry,
+                                                GeneralDiagnostics::Attributes::RebootCount::kMetadataEntry,
+                                                GeneralDiagnostics::Attributes::UpTime::kMetadataEntry,
+                                                GeneralDiagnostics::Attributes::TestEventTriggersEnabled::kMetadataEntry,
+                                            }));
     }
 
     {
@@ -146,22 +158,22 @@ TEST_F(TestGeneralDiagnosticsCluster, AttributesTest)
                 totalOperationalHours = 456;
                 return CHIP_NO_ERROR;
             }
-            CHIP_ERROR GetBootReason(chip::app::Clusters::GeneralDiagnostics::BootReasonEnum & bootReason) override
+            CHIP_ERROR GetBootReason(app::Clusters::GeneralDiagnostics::BootReasonEnum & bootReason) override
             {
                 bootReason = GeneralDiagnostics::BootReasonEnum::kSoftwareReset;
                 return CHIP_NO_ERROR;
             }
             CHIP_ERROR
-            GetActiveHardwareFaults(chip::DeviceLayer::GeneralFaults<DeviceLayer::kMaxHardwareFaults> & hardwareFaults) override
+            GetActiveHardwareFaults(DeviceLayer::GeneralFaults<DeviceLayer::kMaxHardwareFaults> & hardwareFaults) override
             {
                 return CHIP_NO_ERROR;
             }
-            CHIP_ERROR GetActiveRadioFaults(chip::DeviceLayer::GeneralFaults<DeviceLayer::kMaxRadioFaults> & radioFaults) override
+            CHIP_ERROR GetActiveRadioFaults(DeviceLayer::GeneralFaults<DeviceLayer::kMaxRadioFaults> & radioFaults) override
             {
                 return CHIP_NO_ERROR;
             }
             CHIP_ERROR
-            GetActiveNetworkFaults(chip::DeviceLayer::GeneralFaults<DeviceLayer::kMaxNetworkFaults> & networkFaults) override
+            GetActiveNetworkFaults(DeviceLayer::GeneralFaults<DeviceLayer::kMaxNetworkFaults> & networkFaults) override
             {
                 return CHIP_NO_ERROR;
             }
@@ -180,49 +192,31 @@ TEST_F(TestGeneralDiagnosticsCluster, AttributesTest)
         GeneralDiagnosticsCluster cluster(optionalAttributeSet);
 
         // Check mandatory commands are present
-        ConcreteClusterPath generalDiagnosticsPath = ConcreteClusterPath(kRootEndpointId, GeneralDiagnostics::Id);
-
-        ReadOnlyBufferBuilder<DataModel::AcceptedCommandEntry> commandsBuilder;
-        ASSERT_EQ(cluster.AcceptedCommands(generalDiagnosticsPath, commandsBuilder), CHIP_NO_ERROR);
-        ReadOnlyBuffer<DataModel::AcceptedCommandEntry> commands = commandsBuilder.TakeBuffer();
-        ASSERT_EQ(commands.size(), 2u);
-
-        ASSERT_EQ(commands[0].commandId, GeneralDiagnostics::Commands::TestEventTrigger::Id);
-        ASSERT_EQ(commands[0].GetInvokePrivilege(),
-                  GeneralDiagnostics::Commands::TestEventTrigger::kMetadataEntry.GetInvokePrivilege());
-
-        ASSERT_EQ(commands[1].commandId, GeneralDiagnostics::Commands::TimeSnapshot::Id);
-        ASSERT_EQ(commands[1].GetInvokePrivilege(),
-                  GeneralDiagnostics::Commands::TimeSnapshot::kMetadataEntry.GetInvokePrivilege());
+        ASSERT_TRUE(IsAcceptedCommandsListEqualTo(cluster,
+                                                  {
+                                                      GeneralDiagnostics::Commands::TestEventTrigger::kMetadataEntry,
+                                                      GeneralDiagnostics::Commands::TimeSnapshot::kMetadataEntry,
+                                                  }));
 
         // Check required generated commands are present
-        ReadOnlyBufferBuilder<chip::CommandId> generatedCommandsBuilder;
-        ASSERT_EQ(cluster.GeneratedCommands(generalDiagnosticsPath, generatedCommandsBuilder), CHIP_NO_ERROR);
-        ReadOnlyBuffer<chip::CommandId> generatedCommands = generatedCommandsBuilder.TakeBuffer();
-
-        ASSERT_EQ(generatedCommands.size(), 1u);
-        ASSERT_EQ(generatedCommands[0], GeneralDiagnostics::Commands::TimeSnapshotResponse::Id);
+        ASSERT_TRUE(IsGeneratedCommandsListEqualTo(cluster,
+                                                   {
+                                                       GeneralDiagnostics::Commands::TimeSnapshotResponse::Id,
+                                                   }));
 
         // Everything is implemented, so attributes are the global ones and ALL optional ones as well.
-        ReadOnlyBufferBuilder<DataModel::AttributeEntry> attributesBuilder;
-        ASSERT_EQ(cluster.Attributes(generalDiagnosticsPath, attributesBuilder), CHIP_NO_ERROR);
-
-        ReadOnlyBufferBuilder<DataModel::AttributeEntry> expectedBuilder;
-        ASSERT_EQ(expectedBuilder.ReferenceExisting(DefaultServerCluster::GlobalAttributes()), CHIP_NO_ERROR);
-        ASSERT_EQ(expectedBuilder.AppendElements({
-                      GeneralDiagnostics::Attributes::NetworkInterfaces::kMetadataEntry,
-                      GeneralDiagnostics::Attributes::RebootCount::kMetadataEntry,
-                      GeneralDiagnostics::Attributes::UpTime::kMetadataEntry,
-                      GeneralDiagnostics::Attributes::TestEventTriggersEnabled::kMetadataEntry,
-                      GeneralDiagnostics::Attributes::TotalOperationalHours::kMetadataEntry,
-                      GeneralDiagnostics::Attributes::BootReason::kMetadataEntry,
-                      GeneralDiagnostics::Attributes::ActiveHardwareFaults::kMetadataEntry,
-                      GeneralDiagnostics::Attributes::ActiveRadioFaults::kMetadataEntry,
-                      GeneralDiagnostics::Attributes::ActiveNetworkFaults::kMetadataEntry,
-                  }),
-                  CHIP_NO_ERROR);
-
-        ASSERT_TRUE(Testing::EqualAttributeSets(attributesBuilder.TakeBuffer(), expectedBuilder.TakeBuffer()));
+        ASSERT_TRUE(IsAttributesListEqualTo(cluster,
+                                            {
+                                                GeneralDiagnostics::Attributes::NetworkInterfaces::kMetadataEntry,
+                                                GeneralDiagnostics::Attributes::RebootCount::kMetadataEntry,
+                                                GeneralDiagnostics::Attributes::UpTime::kMetadataEntry,
+                                                GeneralDiagnostics::Attributes::TestEventTriggersEnabled::kMetadataEntry,
+                                                GeneralDiagnostics::Attributes::TotalOperationalHours::kMetadataEntry,
+                                                GeneralDiagnostics::Attributes::BootReason::kMetadataEntry,
+                                                GeneralDiagnostics::Attributes::ActiveHardwareFaults::kMetadataEntry,
+                                                GeneralDiagnostics::Attributes::ActiveRadioFaults::kMetadataEntry,
+                                                GeneralDiagnostics::Attributes::ActiveNetworkFaults::kMetadataEntry,
+                                            }));
 
         // Check proper read/write of values and returns
         uint16_t rebootCount                               = 0;
@@ -247,4 +241,69 @@ TEST_F(TestGeneralDiagnosticsCluster, AttributesTest)
     }
 }
 
+TEST_F(TestGeneralDiagnosticsCluster, TimeSnapshotCommandTest)
+{
+    // Create a cluster with no optional attributes enabled
+    const GeneralDiagnosticsCluster::OptionalAttributeSet optionalAttributeSet;
+    ScopedDiagnosticsProvider<NullProvider> nullProvider;
+    GeneralDiagnosticsCluster cluster(optionalAttributeSet);
+
+    ClusterTester tester(cluster);
+    ASSERT_EQ(cluster.Startup(tester.GetServerClusterContext()), CHIP_NO_ERROR);
+
+    // Invoke TimeSnapshot command and get response
+    GeneralDiagnostics::Commands::TimeSnapshotResponse::DecodableType response;
+    ASSERT_EQ(InvokeTimeSnapshotAndGetResponse(tester, response), CHIP_NO_ERROR);
+
+    // Basic configuration excludes POSIX time
+    EXPECT_TRUE(response.posixTimeMs.IsNull());
+}
+
+TEST_F(TestGeneralDiagnosticsCluster, TimeSnapshotCommandWithPosixTimeTest)
+{
+    // Configure cluster with POSIX time support enabled and no optional attributes enabled
+    const GeneralDiagnosticsCluster::OptionalAttributeSet optionalAttributeSet;
+    ScopedDiagnosticsProvider<NullProvider> nullProvider;
+    const GeneralDiagnosticsFunctionsConfig functionsConfig{
+        .enablePosixTime       = true,
+        .enablePayloadSnapshot = false,
+    };
+    GeneralDiagnosticsClusterFullConfigurable cluster(optionalAttributeSet, functionsConfig);
+
+    ClusterTester tester(cluster);
+    ASSERT_EQ(cluster.Startup(tester.GetServerClusterContext()), CHIP_NO_ERROR);
+
+    // Invoke TimeSnapshot command and get response
+    GeneralDiagnostics::Commands::TimeSnapshotResponse::DecodableType response;
+    ASSERT_EQ(InvokeTimeSnapshotAndGetResponse(tester, response), CHIP_NO_ERROR);
+
+    // POSIX time is included when available (system dependent)
+    if (!response.posixTimeMs.IsNull())
+    {
+        EXPECT_GT(response.posixTimeMs.Value(), 0u);
+    }
+}
+
+TEST_F(TestGeneralDiagnosticsCluster, TimeSnapshotResponseValues)
+{
+    // Create a cluster with no optional attributes enabled
+    const GeneralDiagnosticsCluster::OptionalAttributeSet optionalAttributeSet;
+    ScopedDiagnosticsProvider<NullProvider> nullProvider;
+    GeneralDiagnosticsCluster cluster(optionalAttributeSet);
+
+    ClusterTester tester(cluster);
+    ASSERT_EQ(cluster.Startup(tester.GetServerClusterContext()), CHIP_NO_ERROR);
+
+    // First invocation. Capture initial timestamp
+    GeneralDiagnostics::Commands::TimeSnapshotResponse::DecodableType firstResponse;
+    ASSERT_EQ(InvokeTimeSnapshotAndGetResponse(tester, firstResponse), CHIP_NO_ERROR);
+
+    // Second invocation. Capture subsequent timestamp
+    GeneralDiagnostics::Commands::TimeSnapshotResponse::DecodableType secondResponse;
+    ASSERT_EQ(InvokeTimeSnapshotAndGetResponse(tester, secondResponse), CHIP_NO_ERROR);
+
+    // Verify second response is also valid and greater than or equal to first
+    EXPECT_GE(secondResponse.systemTimeMs, firstResponse.systemTimeMs);
+}
+
 } // namespace

src/app/clusters/testing/ClusterTester.h

@@ -175,6 +175,31 @@ class ClusterTester
 
         result.status = mCluster.InvokeCommand(invokeRequest, reader, &mHandler);
 
+        // If InvokeCommand returned nullopt, it means the command implementation handled the response.
+        // We need to check the mock handler for a data response or a status response.
+        if (!result.status.has_value())
+        {
+            if (mHandler.HasResponse())
+            {
+                // A data response was added, so the command is successful.
+                result.status = app::DataModel::ActionReturnStatus(CHIP_NO_ERROR);
+            }
+            else if (mHandler.HasStatus())
+            {
+                // A status response was added. Use the last one.
+                result.status = app::DataModel::ActionReturnStatus(mHandler.GetLastStatus().status);
+            }
+            else
+            {
+                // Neither response nor status was provided; this is unexpected.
+                // This would happen either in error (as mentioned here) or if the command is supposed
+                // to be handled asynchronously. ClusterTester does not support such asynchronous processing.
+                result.status = app::DataModel::ActionReturnStatus(CHIP_ERROR_INCORRECT_STATE);
+                ChipLogError(
+                    Test, "InvokeCommand returned nullopt, but neither HasResponse nor HasStatus is true. Setting error status.");
+            }
+        }
+
         // If command was successful and there's a response, decode it (skip for NullObjectType)
         if constexpr (!std::is_same_v<ResponseType, app::DataModel::NullObjectType>)
         {