Switch YAML tests to using templated ReadAttribute.

This will let us handle reading nullables (and structs once we can
have struct-typed attributes) propely.

examples/chip-tool/templates/partials/test_cluster.zapt

@@ -61,12 +61,14 @@ class {{filename}}: public TestCommand
     {{#unless isWait}}
     {{#unless isCommand}}
     {{#unless isWriteAttribute}}
+    {{#unless isReadAttribute}}
     chip::Callback::Callback<void (*) ({{>failureArguments}})> {{>failureCallback}} { {{>failureResponse}}, this };
     chip::Callback::Callback<void (*) ({{>successArguments}})> {{>successCallback}} { {{>successResponse}}, this };
     {{/unless}}
     {{/unless}}
     {{/unless}}
     {{/unless}}
+    {{/unless}}
     {{/chip_tests_items}}
 
     {{#chip_tests_items}}
@@ -78,6 +80,11 @@ class {{filename}}: public TestCommand
     {
         (static_cast<{{filename}} *>(context))->OnFailureResponse_{{index}}(chip::to_underlying(status));
     }
+    {{else if isReadAttribute}}
+    static void {{>failureResponse}}(void * context, EmberAfStatus status)
+    {
+        (static_cast<{{filename}} *>(context))->OnFailureResponse_{{index}}(chip::to_underlying(status));
+    }
     {{else}}
     static void {{>failureResponse}}({{> failureArguments}})
     {
@@ -160,6 +167,10 @@ class {{filename}}: public TestCommand
           {{#*inline "failureResponse"}}OnFailureCallback_{{index}}{{/inline}}
           {{#*inline "successResponse"}}OnSuccessCallback_{{index}}{{/inline}}
           {{#if async}}ReturnErrorOnFailure({{else}}return {{/if}}cluster.WriteAttribute<chip::app::Clusters::{{asUpperCamelCase cluster}}::Attributes::{{asUpperCamelCase attribute}}::TypeInfo>({{#chip_tests_item_parameters}}{{asLowerCamelCase name}}Argument, {{/chip_tests_item_parameters}}this, {{>successResponse}}, {{>failureResponse}}){{#if async}}){{/if}};
+        {{else if isReadAttribute}}
+          {{#*inline "failureResponse"}}OnFailureCallback_{{index}}{{/inline}}
+          {{#*inline "successResponse"}}OnSuccessCallback_{{index}}{{/inline}}
+          {{#if async}}ReturnErrorOnFailure({{else}}return {{/if}}cluster.ReadAttribute<chip::app::Clusters::{{asUpperCamelCase cluster}}::Attributes::{{asUpperCamelCase attribute}}::TypeInfo>({{#chip_tests_item_parameters}}{{asLowerCamelCase name}}Argument, {{/chip_tests_item_parameters}}this, {{>successResponse}}, {{>failureResponse}}){{#if async}}){{/if}};
         {{else}}
           {{~#*inline "commandName"}}{{asUpperCamelCase commandName}}{{#if isAttribute}}Attribute{{asUpperCamelCase attribute}}{{/if}}{{/inline}}
           {{#if async}}ReturnErrorOnFailure({{else}}return {{/if}}cluster.{{>commandName}}({{>successCallback}}.Cancel(){{#unless isWaitForReport}}, {{>failureCallback}}.Cancel(){{/unless}}{{#chip_tests_item_parameters}}, {{asLowerCamelCase name}}Argument{{/chip_tests_item_parameters}}){{#if async}}){{/if}};

src/app/tests/suites/TestDescriptorCluster.yaml

@@ -23,7 +23,7 @@ tests:
       command: "readAttribute"
       attribute: "Device List"
       response:
-          value: [{ deviceTypeId: 1, revision: 1 }]
+          value: [{ type: 0, revision: 1 }]
 
     - label: "Read attribute Server list"
       command: "readAttribute"

src/app/zap-templates/templates/app/cluster-objects.zapt

@@ -139,9 +139,11 @@ namespace {{asUpperCamelCase label}} {
     {{#if entryType}}
         using Type = {{zapTypeToEncodableClusterObjectType entryType forceNotOptional=true}};
         using DecodableType = {{zapTypeToDecodableClusterObjectType entryType forceNotOptional=true}};
+        using DecodableArgType = {{zapTypeToDecodableClusterObjectType entryType forceNotOptional=true isArgument=true}};
     {{else}}
         using Type = {{zapTypeToEncodableClusterObjectType type forceNotOptional=true}};
         using DecodableType = {{zapTypeToDecodableClusterObjectType type forceNotOptional=true}};
+        using DecodableArgType = {{zapTypeToDecodableClusterObjectType type forceNotOptional=true isArgument=true}};
     {{/if}}
 
         static constexpr ClusterId GetClusterId() { return Clusters::{{asUpperCamelCase parent.name}}::Id; }

src/controller/CHIPCluster.h

@@ -30,6 +30,7 @@
 #include <app/DeviceProxy.h>
 #include <app/util/error-mapping.h>
 #include <controller/InvokeInteraction.h>
+#include <controller/ReadInteraction.h>
 #include <controller/WriteInteraction.h>
 
 namespace chip {
@@ -40,6 +41,9 @@ using CommandResponseSuccessCallback = void(void * context, const T & responseOb
 using CommandResponseFailureCallback = void(void * context, EmberAfStatus status);
 using WriteResponseSuccessCallback   = void (*)(void * context);
 using WriteResponseFailureCallback   = void (*)(void * context, EmberAfStatus status);
+template <typename T>
+using ReadResponseSuccessCallback = void (*)(void * context, T responseData);
+using ReadResponseFailureCallback = void (*)(void * context, EmberAfStatus status);
 
 class DLL_EXPORT ClusterBase
 {
@@ -102,6 +106,42 @@ class DLL_EXPORT ClusterBase
                               failureCb);
     }
 
+    /**
+     * Read an attribute and get a type-safe callback with the attribute value.
+     */
+    template <typename AttributeInfo>
+    CHIP_ERROR ReadAttribute(void * context, ReadResponseSuccessCallback<typename AttributeInfo::DecodableArgType> successCb,
+                             ReadResponseFailureCallback failureCb)
+    {
+        return ReadAttribute<typename AttributeInfo::DecodableType, typename AttributeInfo::DecodableArgType>(
+            context, AttributeInfo::GetClusterId(), AttributeInfo::GetAttributeId(), successCb, failureCb);
+    }
+
+    template <typename DecodableType, typename DecodableArgType>
+    CHIP_ERROR ReadAttribute(void * context, ClusterId clusterId, AttributeId attributeId,
+                             ReadResponseSuccessCallback<DecodableArgType> successCb, ReadResponseFailureCallback failureCb)
+    {
+        VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
+
+        auto onSuccessCb = [context, successCb](const app::ConcreteAttributePath & commandPath, const DecodableType & aData) {
+            if (successCb != nullptr)
+            {
+                successCb(context, aData);
+            }
+        };
+
+        auto onFailureCb = [context, failureCb](const app::ConcreteAttributePath * commandPath, app::StatusIB status,
+                                                CHIP_ERROR aError) {
+            if (failureCb != nullptr)
+            {
+                failureCb(context, app::ToEmberAfStatus(status.mStatus));
+            }
+        };
+
+        return Controller::ReadAttribute<DecodableType>(mDevice->GetExchangeManager(), mDevice->GetSecureSession().Value(),
+                                                        mEndpoint, clusterId, attributeId, onSuccessCb, onFailureCb);
+    }
+
 protected:
     ClusterBase(uint16_t cluster) : mClusterId(cluster) {}
 

src/controller/ReadInteraction.h

@@ -36,12 +36,18 @@ namespace Controller {
  * GetAttributeId() methods is expected to work.
  *
  */
-template <typename AttributeTypeInfo>
+
+/**
+ * To avoid instantiating all the complicated code on a per-attribute basis, we
+ * have a helper that's just templated on the type.
+ */
+template <typename DecodableAttributeType>
 CHIP_ERROR ReadAttribute(Messaging::ExchangeManager * aExchangeMgr, const SessionHandle sessionHandle, EndpointId endpointId,
-                         typename TypedReadCallback<AttributeTypeInfo>::OnSuccessCallbackType onSuccessCb,
-                         typename TypedReadCallback<AttributeTypeInfo>::OnErrorCallbackType onErrorCb)
+                         ClusterId clusterId, AttributeId attributeId,
+                         typename TypedReadCallback<DecodableAttributeType>::OnSuccessCallbackType onSuccessCb,
+                         typename TypedReadCallback<DecodableAttributeType>::OnErrorCallbackType onErrorCb)
 {
-    app::AttributePathParams attributePath(endpointId, AttributeTypeInfo::GetClusterId(), AttributeTypeInfo::GetAttributeId());
+    app::AttributePathParams attributePath(endpointId, clusterId, attributeId);
     app::ReadPrepareParams readParams(sessionHandle);
     app::ReadClient * readClient         = nullptr;
     app::InteractionModelEngine * engine = app::InteractionModelEngine::GetInstance();
@@ -50,11 +56,12 @@ CHIP_ERROR ReadAttribute(Messaging::ExchangeManager * aExchangeMgr, const Sessio
     readParams.mpAttributePathParamsList    = &attributePath;
     readParams.mAttributePathParamsListSize = 1;
 
-    auto onDone = [](app::ReadClient * apReadClient, TypedReadCallback<AttributeTypeInfo> * callback) {
+    auto onDone = [](app::ReadClient * apReadClient, TypedReadCallback<DecodableAttributeType> * callback) {
         chip::Platform::Delete(callback);
     };
 
-    auto callback = chip::Platform::MakeUnique<TypedReadCallback<AttributeTypeInfo>>(onSuccessCb, onErrorCb, onDone);
+    auto callback = chip::Platform::MakeUnique<TypedReadCallback<DecodableAttributeType>>(clusterId, attributeId, onSuccessCb,
+                                                                                          onErrorCb, onDone);
     VerifyOrReturnError(callback != nullptr, CHIP_ERROR_NO_MEMORY);
 
     ReturnErrorOnFailure(engine->NewReadClient(&readClient, app::ReadClient::InteractionType::Read, callback.get()));
@@ -75,5 +82,15 @@ CHIP_ERROR ReadAttribute(Messaging::ExchangeManager * aExchangeMgr, const Sessio
     return err;
 }
 
+template <typename AttributeTypeInfo>
+CHIP_ERROR ReadAttribute(Messaging::ExchangeManager * aExchangeMgr, const SessionHandle sessionHandle, EndpointId endpointId,
+                         typename TypedReadCallback<typename AttributeTypeInfo::DecodableType>::OnSuccessCallbackType onSuccessCb,
+                         typename TypedReadCallback<typename AttributeTypeInfo::DecodableType>::OnErrorCallbackType onErrorCb)
+{
+    return ReadAttribute<typename AttributeTypeInfo::DecodableType>(aExchangeMgr, sessionHandle, endpointId,
+                                                                    AttributeTypeInfo::GetClusterId(),
+                                                                    AttributeTypeInfo::GetAttributeId(), onSuccessCb, onErrorCb);
+}
+
 } // namespace Controller
 } // namespace chip

src/controller/TypedReadCallback.h

@@ -35,31 +35,31 @@ namespace Controller {
  *  2. Automatic decoding of attribute data provided in the TLVReader by InteractionModelDelegate::OnReportData into a decoded
  *     cluster object.
  */
-template <typename AttributeTypeInfo>
+template <typename DecodableAttributeType>
 class TypedReadCallback final : public app::ReadClient::Callback
 {
 public:
     using OnSuccessCallbackType =
-        std::function<void(const app::ConcreteAttributePath & aPath, const typename AttributeTypeInfo::DecodableType & aData)>;
+        std::function<void(const app::ConcreteAttributePath & aPath, const DecodableAttributeType & aData)>;
     using OnErrorCallbackType = std::function<void(const app::ConcreteAttributePath * aPath,
                                                    Protocols::InteractionModel::Status aIMStatus, CHIP_ERROR aError)>;
     using OnDoneCallbackType  = std::function<void(app::ReadClient * client, TypedReadCallback * callback)>;
 
-    TypedReadCallback(OnSuccessCallbackType aOnSuccess, OnErrorCallbackType aOnError, OnDoneCallbackType aOnDone) :
-        mOnSuccess(aOnSuccess), mOnError(aOnError), mOnDone(aOnDone)
+    TypedReadCallback(ClusterId aClusterId, AttributeId aAttributeId, OnSuccessCallbackType aOnSuccess,
+                      OnErrorCallbackType aOnError, OnDoneCallbackType aOnDone) :
+        mClusterId(aClusterId),
+        mAttributeId(aAttributeId), mOnSuccess(aOnSuccess), mOnError(aOnError), mOnDone(aOnDone)
     {}
 
 private:
     void OnAttributeData(const app::ReadClient * apReadClient, const app::ConcreteAttributePath & aPath, TLV::TLVReader * apData,
                          const app::StatusIB & status) override
     {
         CHIP_ERROR err = CHIP_NO_ERROR;
-        typename AttributeTypeInfo::DecodableType value;
+        DecodableAttributeType value;
 
         VerifyOrExit(status.mStatus == Protocols::InteractionModel::Status::Success, err = CHIP_ERROR_IM_STATUS_CODE_RECEIVED);
-        VerifyOrExit(aPath.mClusterId == AttributeTypeInfo::GetClusterId() &&
-                         aPath.mAttributeId == AttributeTypeInfo::GetAttributeId(),
-                     CHIP_ERROR_SCHEMA_MISMATCH);
+        VerifyOrExit(aPath.mClusterId == mClusterId && aPath.mAttributeId == mAttributeId, err = CHIP_ERROR_SCHEMA_MISMATCH);
         VerifyOrExit(apData != nullptr, err = CHIP_ERROR_INVALID_ARGUMENT);
 
         err = app::DataModel::Decode(*apData, value);
@@ -90,6 +90,8 @@ class TypedReadCallback final : public app::ReadClient::Callback
 
     void OnDone(app::ReadClient * apReadClient) override { mOnDone(apReadClient, this); }
 
+    ClusterId mClusterId;
+    AttributeId mAttributeId;
     OnSuccessCallbackType mOnSuccess;
     OnErrorCallbackType mOnError;
     OnDoneCallbackType mOnDone;