src/app/tests/TestMessageDef.cpp

   1 /*
   2  *
   3  *    Copyright (c) 2020-2021 Project CHIP Authors
   4  *    All rights reserved.
   5  *
   6  *    Licensed under the Apache License, Version 2.0 (the "License");
   7  *    you may not use this file except in compliance with the License.
   8  *    You may obtain a copy of the License at
   9  *
  10  *        http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  *    Unless required by applicable law or agreed to in writing, software
  13  *    distributed under the License is distributed on an "AS IS" BASIS,
  14  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  *    See the License for the specific language governing permissions and
  16  *    limitations under the License.
  17  */
  18
  19 /**
  20  *    @file
  21  *      This file implements a test for  CHIP Interaction Model Message Def
  22  *
  23  */
  24
  25 #include <app/MessageDef/CommandDataElement.h>
  26 #include <app/MessageDef/CommandList.h>
  27 #include <app/MessageDef/InvokeCommand.h>
  28 #include <app/MessageDef/ReadRequest.h>
  29 #include <app/MessageDef/ReportData.h>
  30 #include <core/CHIPTLVDebug.hpp>
  31 #include <support/CHIPMem.h>
  32 #include <support/UnitTestRegistration.h>
  33 #include <system/TLVPacketBufferBackingStore.h>
  34
  35 #include <nlunit-test.h>
  36
  37 namespace {
  38
  39 using namespace chip::app;
  40
  41 void TLVPrettyPrinter(const char * aFormat, ...)
  42 {
  43     va_list args;
  44
  45     va_start(args, aFormat);
  46
  47     vprintf(aFormat, args);
  48
  49     va_end(args);
  50 }
  51
  52 CHIP_ERROR DebugPrettyPrint(const chip::System::PacketBufferHandle & aMsgBuf)
  53 {
  54     CHIP_ERROR err = CHIP_NO_ERROR;
  55     chip::System::PacketBufferTLVReader reader;
  56     reader.Init(aMsgBuf.Retain());
  57     err = reader.Next();
  58     chip::TLV::Debug::Dump(reader, TLVPrettyPrinter);
  59
  60     if (CHIP_NO_ERROR != err)
  61     {
  62         ChipLogProgress(DataManagement, "DebugPrettyPrint fails with err %d", err);
  63     }
  64
  65     return err;
  66 }
  67
  68 void BuildAttributePath(nlTestSuite * apSuite, AttributePath::Builder & aAttributePathBuilder)
  69 {
  70     CHIP_ERROR err = CHIP_NO_ERROR;
  71     aAttributePathBuilder.NodeId(1).EndpointId(2).ClusterId(3).FieldId(4).ListIndex(5).EndOfAttributePath();
  72     err = aAttributePathBuilder.GetError();
  73     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
  74 }
  75
  76 void ParseAttributePath(nlTestSuite * apSuite, chip::TLV::TLVReader & aReader)
  77 {
  78     AttributePath::Parser attributePathParser;
  79     CHIP_ERROR err              = CHIP_NO_ERROR;
  80     chip::NodeId nodeId         = 1;
  81     chip::EndpointId endpointId = 2;
  82     chip::ClusterId clusterId   = 3;
  83     uint8_t fieldId             = 4;
  84     uint16_t listIndex          = 5;
  85
  86     err = attributePathParser.Init(aReader);
  87     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
  88
  89     err = attributePathParser.CheckSchemaValidity();
  90     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
  91
  92     err = attributePathParser.GetNodeId(&nodeId);
  93     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR && nodeId == 1);
  94
  95     err = attributePathParser.GetEndpointId(&endpointId);
  96     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR && endpointId == 2);
  97
  98     err = attributePathParser.GetClusterId(&clusterId);
  99     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR && clusterId == 3);
 100
 101     err = attributePathParser.GetFieldId(&fieldId);
 102     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR && fieldId == 4);
 103
 104     err = attributePathParser.GetListIndex(&listIndex);
 105     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR && listIndex == 5);
 106 }
 107
 108 void BuildAttributePathList(nlTestSuite * apSuite, AttributePathList::Builder & aAttributePathListBuilder)
 109 {
 110     AttributePath::Builder attributePathBuilder = aAttributePathListBuilder.CreateAttributePathBuilder();
 111     NL_TEST_ASSERT(apSuite, attributePathBuilder.GetError() == CHIP_NO_ERROR);
 112     BuildAttributePath(apSuite, attributePathBuilder);
 113
 114     aAttributePathListBuilder.EndOfAttributePathList();
 115     NL_TEST_ASSERT(apSuite, aAttributePathListBuilder.GetError() == CHIP_NO_ERROR);
 116 }
 117
 118 void ParseAttributePathList(nlTestSuite * apSuite, chip::TLV::TLVReader & aReader)
 119 {
 120     CHIP_ERROR err = CHIP_NO_ERROR;
 121     AttributePathList::Parser attributePathListParser;
 122     AttributePath::Parser attributePathParser;
 123
 124     err = attributePathListParser.Init(aReader);
 125     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 126
 127     err = attributePathListParser.CheckSchemaValidity();
 128     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 129 }
 130
 131 void BuildEventPath(nlTestSuite * apSuite, EventPath::Builder & aEventPathBuilder)
 132 {
 133     CHIP_ERROR err = CHIP_NO_ERROR;
 134     aEventPathBuilder.NodeId(1).EndpointId(2).ClusterId(3).EventId(4).EndOfEventPath();
 135     err = aEventPathBuilder.GetError();
 136     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 137 }
 138
 139 void ParseEventPath(nlTestSuite * apSuite, EventPath::Parser & aEventPathParser)
 140 {
 141     CHIP_ERROR err              = CHIP_NO_ERROR;
 142     chip::NodeId nodeId         = 1;
 143     chip::EndpointId endpointId = 2;
 144     chip::ClusterId clusterId   = 3;
 145     chip::EventId eventId       = 4;
 146
 147     err = aEventPathParser.CheckSchemaValidity();
 148     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 149
 150     err = aEventPathParser.GetNodeId(&nodeId);
 151     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR && nodeId == 1);
 152
 153     err = aEventPathParser.GetEndpointId(&endpointId);
 154     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR && endpointId == 2);
 155
 156     err = aEventPathParser.GetClusterId(&clusterId);
 157     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR && clusterId == 3);
 158
 159     err = aEventPathParser.GetEventId(&eventId);
 160     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR && eventId == 4);
 161 }
 162
 163 void BuildEventPathList(nlTestSuite * apSuite, EventPathList::Builder & aEventPathListBuilder)
 164 {
 165     EventPath::Builder eventPathBuilder = aEventPathListBuilder.CreateEventPathBuilder();
 166     NL_TEST_ASSERT(apSuite, eventPathBuilder.GetError() == CHIP_NO_ERROR);
 167     BuildEventPath(apSuite, eventPathBuilder);
 168
 169     aEventPathListBuilder.EndOfEventPathList();
 170     NL_TEST_ASSERT(apSuite, aEventPathListBuilder.GetError() == CHIP_NO_ERROR);
 171 }
 172
 173 void ParseEventPathList(nlTestSuite * apSuite, chip::TLV::TLVReader & aReader)
 174 {
 175     CHIP_ERROR err = CHIP_NO_ERROR;
 176     EventPathList::Parser eventPathListParser;
 177
 178     err = eventPathListParser.Init(aReader);
 179     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 180
 181     err = eventPathListParser.CheckSchemaValidity();
 182     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 183 }
 184
 185 void BuildCommandPath(nlTestSuite * apSuite, CommandPath::Builder & aCommandPathBuilder)
 186 {
 187     aCommandPathBuilder.EndpointId(1).ClusterId(3).CommandId(4).EndOfCommandPath();
 188     NL_TEST_ASSERT(apSuite, aCommandPathBuilder.GetError() == CHIP_NO_ERROR);
 189 }
 190
 191 void ParseCommandPath(nlTestSuite * apSuite, chip::TLV::TLVReader & aReader)
 192 {
 193     CHIP_ERROR err = CHIP_NO_ERROR;
 194     CommandPath::Parser commandPathParser;
 195     chip::EndpointId endpointId = 0;
 196     chip::ClusterId clusterId   = 0;
 197     chip::CommandId commandId   = 0;
 198
 199     err = commandPathParser.Init(aReader);
 200     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 201
 202     err = commandPathParser.CheckSchemaValidity();
 203     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 204
 205     err = commandPathParser.GetEndpointId(&endpointId);
 206     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR && endpointId == 1);
 207
 208     err = commandPathParser.GetClusterId(&clusterId);
 209     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR && clusterId == 3);
 210
 211     err = commandPathParser.GetCommandId(&commandId);
 212     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR && commandId == 4);
 213 }
 214
 215 void BuildEventDataElement(nlTestSuite * apSuite, EventDataElement::Builder & aEventDataElementBuilder)
 216 {
 217     CHIP_ERROR err = CHIP_NO_ERROR;
 218
 219     EventPath::Builder eventPathBuilder = aEventDataElementBuilder.CreateEventPathBuilder();
 220     NL_TEST_ASSERT(apSuite, eventPathBuilder.GetError() == CHIP_NO_ERROR);
 221     BuildEventPath(apSuite, eventPathBuilder);
 222
 223     aEventDataElementBuilder.PriorityLevel(2)
 224         .Number(3)
 225         .UTCTimestamp(4)
 226         .SystemTimestamp(5)
 227         .DeltaUTCTimestamp(6)
 228         .DeltaSystemTimestamp(7);
 229     err = aEventDataElementBuilder.GetError();
 230     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 231     // Construct test event data
 232     {
 233         chip::TLV::TLVWriter * pWriter = aEventDataElementBuilder.GetWriter();
 234         chip::TLV::TLVType dummyType   = chip::TLV::kTLVType_NotSpecified;
 235         err =
 236             pWriter->StartContainer(chip::TLV::ContextTag(EventDataElement::kCsTag_Data), chip::TLV::kTLVType_Structure, dummyType);
 237         NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 238
 239         err = pWriter->PutBoolean(chip::TLV::ContextTag(1), true);
 240         NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 241
 242         err = pWriter->EndContainer(dummyType);
 243         NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 244     }
 245
 246     aEventDataElementBuilder.EndOfEventDataElement();
 247 }
 248
 249 void ParseEventDataElement(nlTestSuite * apSuite, EventDataElement::Parser & aEventDataElementParser)
 250 {
 251     CHIP_ERROR err                = CHIP_NO_ERROR;
 252     uint8_t importanceLevel       = 0;
 253     uint64_t number               = 0;
 254     uint64_t uTCTimestamp         = 0;
 255     uint64_t systemTimestamp      = 0;
 256     uint64_t deltaUTCTimestamp    = 0;
 257     uint64_t deltaSystemTimestamp = 0;
 258
 259     err = aEventDataElementParser.CheckSchemaValidity();
 260     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 261
 262     {
 263         {
 264             EventPath::Parser eventPath;
 265             err = aEventDataElementParser.GetEventPath(&eventPath);
 266             NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 267         }
 268         err = aEventDataElementParser.GetPriorityLevel(&importanceLevel);
 269         NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR && importanceLevel == 2);
 270         err = aEventDataElementParser.GetNumber(&number);
 271         NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR && number == 3);
 272         err = aEventDataElementParser.GetUTCTimestamp(&uTCTimestamp);
 273         NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR && uTCTimestamp == 4);
 274         err = aEventDataElementParser.GetSystemTimestamp(&systemTimestamp);
 275         NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR && systemTimestamp == 5);
 276         err = aEventDataElementParser.GetDeltaUTCTimestamp(&deltaUTCTimestamp);
 277         NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR && deltaUTCTimestamp == 6);
 278         err = aEventDataElementParser.GetDeltaSystemTimestamp(&deltaSystemTimestamp);
 279         NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR && deltaSystemTimestamp == 7);
 280
 281         {
 282             chip::TLV::TLVReader reader;
 283             bool val = false;
 284             chip::TLV::TLVType container;
 285             aEventDataElementParser.GetData(&reader);
 286             err = reader.EnterContainer(container);
 287             NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 288
 289             err = reader.Next();
 290             NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 291
 292             err = reader.Get(val);
 293             NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR && val);
 294
 295             err = reader.ExitContainer(container);
 296             NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 297         }
 298     }
 299 }
 300
 301 void BuildEventList(nlTestSuite * apSuite, EventList::Builder & aEventListBuilder)
 302 {
 303     EventDataElement::Builder eventDataElementBuilder = aEventListBuilder.CreateEventBuilder();
 304     NL_TEST_ASSERT(apSuite, eventDataElementBuilder.GetError() == CHIP_NO_ERROR);
 305     BuildEventDataElement(apSuite, eventDataElementBuilder);
 306
 307     aEventListBuilder.EndOfEventList();
 308     NL_TEST_ASSERT(apSuite, aEventListBuilder.GetError() == CHIP_NO_ERROR);
 309 }
 310
 311 void ParseEventList(nlTestSuite * apSuite, chip::TLV::TLVReader & aReader)
 312 {
 313     CHIP_ERROR err = CHIP_NO_ERROR;
 314     EventList::Parser eventListParser;
 315
 316     err = eventListParser.Init(aReader);
 317     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 318
 319     err = eventListParser.CheckSchemaValidity();
 320     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 321 }
 322
 323 void BuildStatusElement(nlTestSuite * apSuite, StatusElement::Builder & aStatusElementBuilder)
 324 {
 325     CHIP_ERROR err = CHIP_NO_ERROR;
 326
 327     aStatusElementBuilder.EncodeStatusElement(chip::Protocols::SecureChannel::GeneralStatusCode::kFailure, 2, 3)
 328         .EndOfStatusElement();
 329     err = aStatusElementBuilder.GetError();
 330     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 331 }
 332
 333 void ParseStatusElement(nlTestSuite * apSuite, StatusElement::Parser & aStatusElementParser)
 334 {
 335     CHIP_ERROR err = CHIP_NO_ERROR;
 336     StatusElement::Parser StatusElementParser;
 337
 338     chip::Protocols::SecureChannel::GeneralStatusCode generalCode = chip::Protocols::SecureChannel::GeneralStatusCode::kFailure;
 339     uint32_t protocolId                                           = 0;
 340     uint16_t protocolCode                                         = 0;
 341
 342     err = aStatusElementParser.CheckSchemaValidity();
 343     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 344
 345     err = aStatusElementParser.DecodeStatusElement(&generalCode, &protocolId, &protocolCode);
 346     NL_TEST_ASSERT(apSuite,
 347                    err == CHIP_NO_ERROR &&
 348                        static_cast<uint16_t>(generalCode) ==
 349                            static_cast<uint16_t>(chip::Protocols::SecureChannel::GeneralStatusCode::kFailure) &&
 350                        protocolId == 2 && protocolCode == 3);
 351 }
 352
 353 void BuildAttributeStatusElement(nlTestSuite * apSuite, AttributeStatusElement::Builder & aAttributeStatusElementBuilder)
 354 {
 355     AttributePath::Builder attributePathBuilder = aAttributeStatusElementBuilder.CreateAttributePathBuilder();
 356     NL_TEST_ASSERT(apSuite, attributePathBuilder.GetError() == CHIP_NO_ERROR);
 357     BuildAttributePath(apSuite, attributePathBuilder);
 358
 359     StatusElement::Builder statusElementBuilder = aAttributeStatusElementBuilder.CreateStatusElementBuilder();
 360     NL_TEST_ASSERT(apSuite, statusElementBuilder.GetError() == CHIP_NO_ERROR);
 361     BuildStatusElement(apSuite, statusElementBuilder);
 362
 363     aAttributeStatusElementBuilder.EndOfAttributeStatusElement();
 364     NL_TEST_ASSERT(apSuite, aAttributeStatusElementBuilder.GetError() == CHIP_NO_ERROR);
 365 }
 366
 367 void ParseAttributeStatusElement(nlTestSuite * apSuite, AttributeStatusElement::Parser & aAttributeStatusElementParser)
 368 {
 369     CHIP_ERROR err = CHIP_NO_ERROR;
 370     AttributePath::Parser attributePathParser;
 371     StatusElement::Parser statusElementParser;
 372
 373     err = aAttributeStatusElementParser.CheckSchemaValidity();
 374     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 375
 376     err = aAttributeStatusElementParser.GetAttributePath(&attributePathParser);
 377     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 378
 379     err = aAttributeStatusElementParser.GetStatusElement(&statusElementParser);
 380     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 381 }
 382
 383 void BuildAttributeStatusList(nlTestSuite * apSuite, AttributeStatusList::Builder & aAttributeStatusListBuilder)
 384 {
 385     AttributeStatusElement::Builder aAttributeStatusElementBuilder = aAttributeStatusListBuilder.CreateAttributeStatusBuilder();
 386     NL_TEST_ASSERT(apSuite, aAttributeStatusListBuilder.GetError() == CHIP_NO_ERROR);
 387     BuildAttributeStatusElement(apSuite, aAttributeStatusElementBuilder);
 388
 389     aAttributeStatusListBuilder.EndOfAttributeStatusList();
 390     NL_TEST_ASSERT(apSuite, aAttributeStatusListBuilder.GetError() == CHIP_NO_ERROR);
 391 }
 392
 393 void ParseAttributeStatusList(nlTestSuite * apSuite, chip::TLV::TLVReader & aReader)
 394 {
 395     CHIP_ERROR err = CHIP_NO_ERROR;
 396     AttributeStatusList::Parser attributeStatusParser;
 397
 398     err = attributeStatusParser.Init(aReader);
 399     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 400
 401     err = attributeStatusParser.CheckSchemaValidity();
 402     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 403 }
 404
 405 void BuildAttributeDataElement(nlTestSuite * apSuite, AttributeDataElement::Builder & aAttributeDataElementBuilder)
 406 {
 407     CHIP_ERROR err = CHIP_NO_ERROR;
 408
 409     AttributePath::Builder attributePathBuilder = aAttributeDataElementBuilder.CreateAttributePathBuilder();
 410     NL_TEST_ASSERT(apSuite, aAttributeDataElementBuilder.GetError() == CHIP_NO_ERROR);
 411     BuildAttributePath(apSuite, attributePathBuilder);
 412
 413     aAttributeDataElementBuilder.DataVersion(2);
 414     err = aAttributeDataElementBuilder.GetError();
 415     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 416
 417     // Construct attribute data
 418     {
 419         chip::TLV::TLVWriter * pWriter = aAttributeDataElementBuilder.GetWriter();
 420         chip::TLV::TLVType dummyType   = chip::TLV::kTLVType_NotSpecified;
 421         err = pWriter->StartContainer(chip::TLV::ContextTag(AttributeDataElement::kCsTag_Data), chip::TLV::kTLVType_Structure,
 422                                       dummyType);
 423         NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 424
 425         err = pWriter->PutBoolean(chip::TLV::ContextTag(1), true);
 426         NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 427
 428         err = pWriter->EndContainer(dummyType);
 429         NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 430     }
 431
 432     aAttributeDataElementBuilder.MoreClusterData(true);
 433     err = aAttributeDataElementBuilder.GetError();
 434     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 435
 436     aAttributeDataElementBuilder.EndOfAttributeDataElement();
 437     NL_TEST_ASSERT(apSuite, aAttributeDataElementBuilder.GetError() == CHIP_NO_ERROR);
 438 }
 439
 440 void ParseAttributeDataElement(nlTestSuite * apSuite, AttributeDataElement::Parser & aAttributeDataElementParser)
 441 {
 442     CHIP_ERROR err = CHIP_NO_ERROR;
 443     AttributePath::Parser attributePathParser;
 444     StatusElement::Parser statusElementParser;
 445     chip::DataVersion version = 0;
 446     bool moreClusterDataFlag  = false;
 447
 448     err = aAttributeDataElementParser.CheckSchemaValidity();
 449     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 450
 451     err = aAttributeDataElementParser.GetAttributePath(&attributePathParser);
 452     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 453
 454     err = aAttributeDataElementParser.GetDataVersion(&version);
 455     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR && version == 2);
 456
 457     {
 458         chip::TLV::TLVReader reader;
 459         bool val = false;
 460         chip::TLV::TLVType container;
 461         aAttributeDataElementParser.GetData(&reader);
 462         err = reader.EnterContainer(container);
 463         NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 464
 465         err = reader.Next();
 466         NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 467
 468         err = reader.Get(val);
 469         NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR && val);
 470
 471         err = reader.ExitContainer(container);
 472         NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 473     }
 474
 475     err = aAttributeDataElementParser.GetMoreClusterDataFlag(&moreClusterDataFlag);
 476     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR && moreClusterDataFlag);
 477 }
 478
 479 void BuildAttributeDataList(nlTestSuite * apSuite, AttributeDataList::Builder & aAttributeDataListBuilder)
 480 {
 481     AttributeDataElement::Builder attributeDataElementBuilder = aAttributeDataListBuilder.CreateAttributeDataElementBuilder();
 482     NL_TEST_ASSERT(apSuite, aAttributeDataListBuilder.GetError() == CHIP_NO_ERROR);
 483     BuildAttributeDataElement(apSuite, attributeDataElementBuilder);
 484
 485     aAttributeDataListBuilder.EndOfAttributeDataList();
 486     NL_TEST_ASSERT(apSuite, aAttributeDataListBuilder.GetError() == CHIP_NO_ERROR);
 487 }
 488
 489 void ParseAttributeDataList(nlTestSuite * apSuite, chip::TLV::TLVReader & aReader)
 490 {
 491     CHIP_ERROR err = CHIP_NO_ERROR;
 492     AttributeDataList::Parser attributeDataListParser;
 493
 494     err = attributeDataListParser.Init(aReader);
 495     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 496
 497     err = attributeDataListParser.CheckSchemaValidity();
 498     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 499 }
 500
 501 void BuildAttributeDataVersionList(nlTestSuite * apSuite, AttributeDataVersionList::Builder & aAttributeDataVersionListBuilder)
 502 {
 503     aAttributeDataVersionListBuilder.AddVersion(1);
 504
 505     aAttributeDataVersionListBuilder.EndOfAttributeDataVersionList();
 506     NL_TEST_ASSERT(apSuite, aAttributeDataVersionListBuilder.GetError() == CHIP_NO_ERROR);
 507 }
 508
 509 void ParseAttributeDataVersionList(nlTestSuite * apSuite, chip::TLV::TLVReader & aReader)
 510 {
 511     CHIP_ERROR err = CHIP_NO_ERROR;
 512     chip::DataVersion version;
 513     AttributeDataVersionList::Parser attributeDataVersionListParser;
 514
 515     err = attributeDataVersionListParser.Init(aReader);
 516     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 517
 518     err = attributeDataVersionListParser.CheckSchemaValidity();
 519     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 520
 521     attributeDataVersionListParser.GetVersion(&version);
 522 }
 523
 524 void BuildCommandDataElement(nlTestSuite * apSuite, CommandDataElement::Builder & aCommandDataElementBuilder)
 525 {
 526     CHIP_ERROR err = CHIP_NO_ERROR;
 527
 528     CommandPath::Builder commandPathBuilder = aCommandDataElementBuilder.CreateCommandPathBuilder();
 529     NL_TEST_ASSERT(apSuite, aCommandDataElementBuilder.GetError() == CHIP_NO_ERROR);
 530     BuildCommandPath(apSuite, commandPathBuilder);
 531
 532     // Construct command data
 533     {
 534         chip::TLV::TLVWriter * pWriter = aCommandDataElementBuilder.GetWriter();
 535         chip::TLV::TLVType dummyType   = chip::TLV::kTLVType_NotSpecified;
 536         err = pWriter->StartContainer(chip::TLV::ContextTag(CommandDataElement::kCsTag_Data), chip::TLV::kTLVType_Structure,
 537                                       dummyType);
 538         NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 539
 540         err = pWriter->PutBoolean(chip::TLV::ContextTag(1), true);
 541         NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 542
 543         err = pWriter->EndContainer(dummyType);
 544         NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 545     }
 546
 547     aCommandDataElementBuilder.EndOfCommandDataElement();
 548     NL_TEST_ASSERT(apSuite, aCommandDataElementBuilder.GetError() == CHIP_NO_ERROR);
 549 }
 550
 551 void ParseCommandDataElement(nlTestSuite * apSuite, CommandDataElement::Parser & aCommandDataElementParser)
 552 {
 553     CHIP_ERROR err = CHIP_NO_ERROR;
 554     CommandPath::Parser commandPathParser;
 555
 556     err = aCommandDataElementParser.CheckSchemaValidity();
 557     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 558
 559     err = aCommandDataElementParser.GetCommandPath(&commandPathParser);
 560     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 561
 562     {
 563         chip::TLV::TLVReader reader;
 564         bool val = false;
 565         chip::TLV::TLVType container;
 566         aCommandDataElementParser.GetData(&reader);
 567         err = reader.EnterContainer(container);
 568         NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 569
 570         err = reader.Next();
 571         NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 572
 573         err = reader.Get(val);
 574         NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR && val);
 575
 576         err = reader.ExitContainer(container);
 577         NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 578     }
 579 }
 580
 581 void BuildCommandDataElementWithStatusCode(nlTestSuite * apSuite, CommandDataElement::Builder & aCommandDataElementBuilder)
 582 {
 583     CommandPath::Builder commandPathBuilder = aCommandDataElementBuilder.CreateCommandPathBuilder();
 584     NL_TEST_ASSERT(apSuite, aCommandDataElementBuilder.GetError() == CHIP_NO_ERROR);
 585     BuildCommandPath(apSuite, commandPathBuilder);
 586
 587     StatusElement::Builder statusElementBuilder = aCommandDataElementBuilder.CreateStatusElementBuilder();
 588     NL_TEST_ASSERT(apSuite, statusElementBuilder.GetError() == CHIP_NO_ERROR);
 589     BuildStatusElement(apSuite, statusElementBuilder);
 590
 591     aCommandDataElementBuilder.EndOfCommandDataElement();
 592     NL_TEST_ASSERT(apSuite, aCommandDataElementBuilder.GetError() == CHIP_NO_ERROR);
 593 }
 594
 595 void ParseCommandDataElementWithStatusCode(nlTestSuite * apSuite, CommandDataElement::Parser & aCommandDataElementParser)
 596 {
 597     CHIP_ERROR err = CHIP_NO_ERROR;
 598     CommandPath::Parser commandPathParser;
 599     StatusElement::Parser statusElementParser;
 600     err = aCommandDataElementParser.CheckSchemaValidity();
 601     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 602
 603     err = aCommandDataElementParser.GetCommandPath(&commandPathParser);
 604     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 605
 606     err = aCommandDataElementParser.GetStatusElement(&statusElementParser);
 607     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 608 }
 609
 610 void BuildCommandList(nlTestSuite * apSuite, CommandList::Builder & aCommandListBuilder)
 611 {
 612     CommandDataElement::Builder commandDataElementBuilder = aCommandListBuilder.CreateCommandDataElementBuilder();
 613     NL_TEST_ASSERT(apSuite, aCommandListBuilder.GetError() == CHIP_NO_ERROR);
 614     BuildCommandDataElement(apSuite, commandDataElementBuilder);
 615
 616     aCommandListBuilder.EndOfCommandList();
 617     NL_TEST_ASSERT(apSuite, aCommandListBuilder.GetError() == CHIP_NO_ERROR);
 618 }
 619
 620 void ParseCommandList(nlTestSuite * apSuite, chip::TLV::TLVReader & aReader)
 621 {
 622     CHIP_ERROR err = CHIP_NO_ERROR;
 623     CommandList::Parser commandListParser;
 624     commandListParser.Init(aReader);
 625     err = commandListParser.CheckSchemaValidity();
 626     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 627 }
 628
 629 void BuildReportData(nlTestSuite * apSuite, chip::TLV::TLVWriter & aWriter)
 630 {
 631     CHIP_ERROR err = CHIP_NO_ERROR;
 632     ReportData::Builder reportDataBuilder;
 633
 634     err = reportDataBuilder.Init(&aWriter);
 635     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 636
 637     reportDataBuilder.SuppressResponse(true).SubscriptionId(2);
 638     NL_TEST_ASSERT(apSuite, reportDataBuilder.GetError() == CHIP_NO_ERROR);
 639
 640     AttributeStatusList::Builder attributeStatusList = reportDataBuilder.CreateAttributeStatusListBuilder();
 641     NL_TEST_ASSERT(apSuite, reportDataBuilder.GetError() == CHIP_NO_ERROR);
 642     BuildAttributeStatusList(apSuite, attributeStatusList);
 643
 644     AttributeDataList::Builder attributeDataList = reportDataBuilder.CreateAttributeDataListBuilder();
 645     NL_TEST_ASSERT(apSuite, reportDataBuilder.GetError() == CHIP_NO_ERROR);
 646     BuildAttributeDataList(apSuite, attributeDataList);
 647
 648     EventList::Builder eventList = reportDataBuilder.CreateEventDataListBuilder();
 649     NL_TEST_ASSERT(apSuite, reportDataBuilder.GetError() == CHIP_NO_ERROR);
 650     BuildEventList(apSuite, eventList);
 651
 652     reportDataBuilder.MoreChunkedMessages(true);
 653     NL_TEST_ASSERT(apSuite, reportDataBuilder.GetError() == CHIP_NO_ERROR);
 654
 655     reportDataBuilder.EndOfReportData();
 656     NL_TEST_ASSERT(apSuite, reportDataBuilder.GetError() == CHIP_NO_ERROR);
 657 }
 658
 659 void ParseReportData(nlTestSuite * apSuite, chip::TLV::TLVReader & aReader)
 660 {
 661     CHIP_ERROR err = CHIP_NO_ERROR;
 662     ReportData::Parser reportDataParser;
 663
 664     bool suppressResponse   = false;
 665     uint64_t subscriptionId = 0;
 666     AttributeStatusList::Parser attributeStatusListParser;
 667     AttributeDataList::Parser attributeDataListParser;
 668     EventList::Parser eventListParser;
 669     bool moreChunkedMessages = false;
 670     reportDataParser.Init(aReader);
 671
 672     err = reportDataParser.CheckSchemaValidity();
 673     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 674
 675     err = reportDataParser.GetSuppressResponse(&suppressResponse);
 676     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR && suppressResponse);
 677
 678     err = reportDataParser.GetSubscriptionId(&subscriptionId);
 679     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR && subscriptionId == 2);
 680
 681     err = reportDataParser.GetAttributeStatusList(&attributeStatusListParser);
 682     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 683
 684     err = reportDataParser.GetAttributeDataList(&attributeDataListParser);
 685     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 686
 687     err = reportDataParser.GetEventDataList(&eventListParser);
 688     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 689
 690     err = reportDataParser.GetMoreChunkedMessages(&moreChunkedMessages);
 691     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR && moreChunkedMessages);
 692 }
 693
 694 void BuildInvokeCommand(nlTestSuite * apSuite, chip::TLV::TLVWriter & aWriter)
 695 {
 696     CHIP_ERROR err = CHIP_NO_ERROR;
 697     InvokeCommand::Builder invokeCommandBuilder;
 698
 699     err = invokeCommandBuilder.Init(&aWriter);
 700     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 701
 702     CommandList::Builder commandList = invokeCommandBuilder.CreateCommandListBuilder();
 703     NL_TEST_ASSERT(apSuite, invokeCommandBuilder.GetError() == CHIP_NO_ERROR);
 704     BuildCommandList(apSuite, commandList);
 705
 706     invokeCommandBuilder.EndOfInvokeCommand();
 707     NL_TEST_ASSERT(apSuite, invokeCommandBuilder.GetError() == CHIP_NO_ERROR);
 708 }
 709
 710 void ParseInvokeCommand(nlTestSuite * apSuite, chip::TLV::TLVReader & aReader)
 711 {
 712     CHIP_ERROR err = CHIP_NO_ERROR;
 713
 714     InvokeCommand::Parser invokeCommandParser;
 715     CommandList::Parser commandListParser;
 716
 717     err = invokeCommandParser.Init(aReader);
 718     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 719
 720     err = invokeCommandParser.CheckSchemaValidity();
 721     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 722
 723     err = invokeCommandParser.GetCommandList(&commandListParser);
 724     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 725 }
 726
 727 void BuildReadRequest(nlTestSuite * apSuite, chip::TLV::TLVWriter & aWriter)
 728 {
 729     CHIP_ERROR err = CHIP_NO_ERROR;
 730     ReadRequest::Builder readRequestBuilder;
 731
 732     err = readRequestBuilder.Init(&aWriter);
 733     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 734
 735     AttributePathList::Builder attributePathList = readRequestBuilder.CreateAttributePathListBuilder();
 736     NL_TEST_ASSERT(apSuite, readRequestBuilder.GetError() == CHIP_NO_ERROR);
 737     BuildAttributePathList(apSuite, attributePathList);
 738
 739     EventPathList::Builder eventPathList = readRequestBuilder.CreateEventPathListBuilder();
 740     NL_TEST_ASSERT(apSuite, readRequestBuilder.GetError() == CHIP_NO_ERROR);
 741     BuildEventPathList(apSuite, eventPathList);
 742
 743     AttributeDataVersionList::Builder attributeDataVersionList = readRequestBuilder.CreateAttributeDataVersionListBuilder();
 744     NL_TEST_ASSERT(apSuite, readRequestBuilder.GetError() == CHIP_NO_ERROR);
 745     BuildAttributeDataVersionList(apSuite, attributeDataVersionList);
 746
 747     readRequestBuilder.EventNumber(1);
 748     NL_TEST_ASSERT(apSuite, readRequestBuilder.GetError() == CHIP_NO_ERROR);
 749
 750     readRequestBuilder.EndOfReadRequest();
 751     NL_TEST_ASSERT(apSuite, readRequestBuilder.GetError() == CHIP_NO_ERROR);
 752 }
 753
 754 void ParseReadRequest(nlTestSuite * apSuite, chip::TLV::TLVReader & aReader)
 755 {
 756     CHIP_ERROR err = CHIP_NO_ERROR;
 757
 758     ReadRequest::Parser readRequestParser;
 759     AttributePathList::Parser attributePathListParser;
 760     EventPathList::Parser eventPathListParser;
 761     AttributeDataVersionList::Parser attributeDataVersionListParser;
 762     uint64_t eventNumber;
 763
 764     err = readRequestParser.Init(aReader);
 765     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 766
 767     err = readRequestParser.CheckSchemaValidity();
 768     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 769
 770     err = readRequestParser.GetAttributePathList(&attributePathListParser);
 771     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 772
 773     err = readRequestParser.GetEventPathList(&eventPathListParser);
 774     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 775
 776     err = readRequestParser.GetAttributeDataVersionList(&attributeDataVersionListParser);
 777     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 778
 779     err = readRequestParser.GetEventNumber(&eventNumber);
 780     NL_TEST_ASSERT(apSuite, eventNumber == 1 && err == CHIP_NO_ERROR);
 781 }
 782
 783 void AttributePathTest(nlTestSuite * apSuite, void * apContext)
 784 {
 785     CHIP_ERROR err = CHIP_NO_ERROR;
 786     AttributePath::Builder attributePathBuilder;
 787     chip::System::PacketBufferTLVWriter writer;
 788     chip::System::PacketBufferTLVReader reader;
 789     writer.Init(chip::System::PacketBufferHandle::New(chip::System::PacketBuffer::kMaxSize));
 790     attributePathBuilder.Init(&writer);
 791     BuildAttributePath(apSuite, attributePathBuilder);
 792     chip::System::PacketBufferHandle buf;
 793     err = writer.Finalize(&buf);
 794     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 795
 796     DebugPrettyPrint(buf);
 797
 798     reader.Init(std::move(buf));
 799     err = reader.Next();
 800     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 801
 802     ParseAttributePath(apSuite, reader);
 803 }
 804
 805 void AttributePathListTest(nlTestSuite * apSuite, void * apContext)
 806 {
 807     CHIP_ERROR err = CHIP_NO_ERROR;
 808     chip::System::PacketBufferTLVWriter writer;
 809     chip::System::PacketBufferTLVReader reader;
 810     AttributePathList::Builder attributePathListBuilder;
 811
 812     writer.Init(chip::System::PacketBufferHandle::New(chip::System::PacketBuffer::kMaxSize));
 813
 814     err = attributePathListBuilder.Init(&writer);
 815     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 816
 817     BuildAttributePathList(apSuite, attributePathListBuilder);
 818     chip::System::PacketBufferHandle buf;
 819     err = writer.Finalize(&buf);
 820     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 821
 822     DebugPrettyPrint(buf);
 823
 824     reader.Init(std::move(buf));
 825     err = reader.Next();
 826     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 827     ParseAttributePathList(apSuite, reader);
 828 }
 829
 830 void EventPathTest(nlTestSuite * apSuite, void * apContext)
 831 {
 832     CHIP_ERROR err = CHIP_NO_ERROR;
 833     EventPath::Parser eventPathParser;
 834     EventPath::Builder eventPathBuilder;
 835     chip::System::PacketBufferTLVWriter writer;
 836     chip::System::PacketBufferTLVReader reader;
 837     writer.Init(chip::System::PacketBufferHandle::New(chip::System::PacketBuffer::kMaxSize));
 838     eventPathBuilder.Init(&writer);
 839     BuildEventPath(apSuite, eventPathBuilder);
 840     chip::System::PacketBufferHandle buf;
 841     err = writer.Finalize(&buf);
 842     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 843
 844     DebugPrettyPrint(buf);
 845
 846     reader.Init(std::move(buf));
 847     err = reader.Next();
 848     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 849
 850     eventPathParser.Init(reader);
 851     ParseEventPath(apSuite, eventPathParser);
 852 }
 853
 854 void EventPathListTest(nlTestSuite * apSuite, void * apContext)
 855 {
 856     CHIP_ERROR err = CHIP_NO_ERROR;
 857     chip::System::PacketBufferTLVWriter writer;
 858     chip::System::PacketBufferTLVReader reader;
 859     EventPathList::Builder eventPathListBuilder;
 860
 861     writer.Init(chip::System::PacketBufferHandle::New(chip::System::PacketBuffer::kMaxSize));
 862
 863     err = eventPathListBuilder.Init(&writer);
 864     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 865
 866     BuildEventPathList(apSuite, eventPathListBuilder);
 867     chip::System::PacketBufferHandle buf;
 868     err = writer.Finalize(&buf);
 869     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 870
 871     DebugPrettyPrint(buf);
 872
 873     reader.Init(std::move(buf));
 874     err = reader.Next();
 875     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 876     ParseEventPathList(apSuite, reader);
 877 }
 878
 879 void CommandPathTest(nlTestSuite * apSuite, void * apContext)
 880 {
 881     CHIP_ERROR err = CHIP_NO_ERROR;
 882     chip::System::PacketBufferTLVWriter writer;
 883     chip::System::PacketBufferTLVReader reader;
 884     CommandPath::Builder commandPathBuilder;
 885     writer.Init(chip::System::PacketBufferHandle::New(chip::System::PacketBuffer::kMaxSize));
 886     err = commandPathBuilder.Init(&writer);
 887     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 888
 889     BuildCommandPath(apSuite, commandPathBuilder);
 890
 891     chip::System::PacketBufferHandle buf;
 892     err = writer.Finalize(&buf);
 893     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 894
 895     DebugPrettyPrint(buf);
 896
 897     reader.Init(std::move(buf));
 898     err = reader.Next();
 899     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 900
 901     ParseCommandPath(apSuite, reader);
 902 }
 903
 904 void EventDataElementTest(nlTestSuite * apSuite, void * apContext)
 905 {
 906     CHIP_ERROR err = CHIP_NO_ERROR;
 907     EventDataElement::Builder eventDataElementBuilder;
 908     EventDataElement::Parser eventDataElementParser;
 909     chip::System::PacketBufferTLVWriter writer;
 910     chip::System::PacketBufferTLVReader reader;
 911     writer.Init(chip::System::PacketBufferHandle::New(chip::System::PacketBuffer::kMaxSize));
 912     eventDataElementBuilder.Init(&writer);
 913     BuildEventDataElement(apSuite, eventDataElementBuilder);
 914     chip::System::PacketBufferHandle buf;
 915     err = writer.Finalize(&buf);
 916     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 917
 918     DebugPrettyPrint(buf);
 919
 920     reader.Init(std::move(buf));
 921     err = reader.Next();
 922     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 923
 924     eventDataElementParser.Init(reader);
 925     ParseEventDataElement(apSuite, eventDataElementParser);
 926 }
 927
 928 void EventListTest(nlTestSuite * apSuite, void * apContext)
 929 {
 930     CHIP_ERROR err = CHIP_NO_ERROR;
 931     chip::System::PacketBufferTLVWriter writer;
 932     chip::System::PacketBufferTLVReader reader;
 933     EventList::Builder eventListBuilder;
 934     writer.Init(chip::System::PacketBufferHandle::New(chip::System::PacketBuffer::kMaxSize));
 935     eventListBuilder.Init(&writer);
 936     BuildEventList(apSuite, eventListBuilder);
 937     chip::System::PacketBufferHandle buf;
 938     err = writer.Finalize(&buf);
 939     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 940
 941     DebugPrettyPrint(buf);
 942
 943     reader.Init(std::move(buf));
 944     err = reader.Next();
 945     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 946     ParseEventList(apSuite, reader);
 947 }
 948
 949 void StatusElementTest(nlTestSuite * apSuite, void * apContext)
 950 {
 951     CHIP_ERROR err = CHIP_NO_ERROR;
 952     StatusElement::Builder statusElementBuilder;
 953     StatusElement::Parser statusElementParser;
 954     chip::System::PacketBufferTLVWriter writer;
 955     chip::System::PacketBufferTLVReader reader;
 956     writer.Init(chip::System::PacketBufferHandle::New(chip::System::PacketBuffer::kMaxSize));
 957     statusElementBuilder.Init(&writer);
 958     BuildStatusElement(apSuite, statusElementBuilder);
 959     chip::System::PacketBufferHandle buf;
 960     err = writer.Finalize(&buf);
 961     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 962
 963     DebugPrettyPrint(buf);
 964
 965     reader.Init(std::move(buf));
 966     err = reader.Next();
 967     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 968
 969     statusElementParser.Init(reader);
 970     ParseStatusElement(apSuite, statusElementParser);
 971 }
 972
 973 void AttributeStatusElementTest(nlTestSuite * apSuite, void * apContext)
 974 {
 975     CHIP_ERROR err = CHIP_NO_ERROR;
 976     AttributeStatusElement::Builder attributeStatusElementBuilder;
 977     AttributeStatusElement::Parser attributeStatusElementParser;
 978     chip::System::PacketBufferTLVWriter writer;
 979     chip::System::PacketBufferTLVReader reader;
 980     writer.Init(chip::System::PacketBufferHandle::New(chip::System::PacketBuffer::kMaxSize));
 981     attributeStatusElementBuilder.Init(&writer);
 982     BuildAttributeStatusElement(apSuite, attributeStatusElementBuilder);
 983     chip::System::PacketBufferHandle buf;
 984     err = writer.Finalize(&buf);
 985     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 986
 987     DebugPrettyPrint(buf);
 988
 989     reader.Init(std::move(buf));
 990     err = reader.Next();
 991     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
 992
 993     attributeStatusElementParser.Init(reader);
 994     ParseAttributeStatusElement(apSuite, attributeStatusElementParser);
 995 }
 996
 997 void AttributeStatusListTest(nlTestSuite * apSuite, void * apContext)
 998 {
 999     CHIP_ERROR err = CHIP_NO_ERROR;
1000     chip::System::PacketBufferTLVWriter writer;
1001     chip::System::PacketBufferTLVReader reader;
1002     writer.Init(chip::System::PacketBufferHandle::New(chip::System::PacketBuffer::kMaxSize));
1003     AttributeStatusList::Builder attributeStatusListBuilder;
1004     err = attributeStatusListBuilder.Init(&writer);
1005     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
1006     BuildAttributeStatusList(apSuite, attributeStatusListBuilder);
1007     chip::System::PacketBufferHandle buf;
1008     err = writer.Finalize(&buf);
1009     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
1010
1011     DebugPrettyPrint(buf);
1012
1013     reader.Init(std::move(buf));
1014     err = reader.Next();
1015     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
1016     ParseAttributeStatusList(apSuite, reader);
1017 }
1018
1019 void AttributeDataElementTest(nlTestSuite * apSuite, void * apContext)
1020 {
1021     CHIP_ERROR err = CHIP_NO_ERROR;
1022     AttributeDataElement::Builder attributeDataElementBuilder;
1023     AttributeDataElement::Parser attributeDataElementParser;
1024     chip::System::PacketBufferTLVWriter writer;
1025     chip::System::PacketBufferTLVReader reader;
1026     writer.Init(chip::System::PacketBufferHandle::New(chip::System::PacketBuffer::kMaxSize));
1027     attributeDataElementBuilder.Init(&writer);
1028     BuildAttributeDataElement(apSuite, attributeDataElementBuilder);
1029     chip::System::PacketBufferHandle buf;
1030     err = writer.Finalize(&buf);
1031     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
1032
1033     DebugPrettyPrint(buf);
1034
1035     reader.Init(std::move(buf));
1036     err = reader.Next();
1037     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
1038
1039     attributeDataElementParser.Init(reader);
1040     ParseAttributeDataElement(apSuite, attributeDataElementParser);
1041 }
1042
1043 void AttributeDataListTest(nlTestSuite * apSuite, void * apContext)
1044 {
1045     CHIP_ERROR err = CHIP_NO_ERROR;
1046     chip::System::PacketBufferTLVWriter writer;
1047     chip::System::PacketBufferTLVReader reader;
1048     writer.Init(chip::System::PacketBufferHandle::New(chip::System::PacketBuffer::kMaxSize));
1049     AttributeDataList::Builder attributeDataListBuilder;
1050     attributeDataListBuilder.Init(&writer);
1051     BuildAttributeDataList(apSuite, attributeDataListBuilder);
1052     chip::System::PacketBufferHandle buf;
1053     err = writer.Finalize(&buf);
1054     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
1055
1056     DebugPrettyPrint(buf);
1057
1058     reader.Init(std::move(buf));
1059     err = reader.Next();
1060     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
1061     ParseAttributeDataList(apSuite, reader);
1062 }
1063
1064 void AttributeDataVersionListTest(nlTestSuite * apSuite, void * apContext)
1065 {
1066     CHIP_ERROR err = CHIP_NO_ERROR;
1067     chip::System::PacketBufferTLVWriter writer;
1068     chip::System::PacketBufferTLVReader reader;
1069     writer.Init(chip::System::PacketBufferHandle::New(chip::System::PacketBuffer::kMaxSize));
1070     AttributeDataVersionList::Builder attributeDataVersionListBuilder;
1071     attributeDataVersionListBuilder.Init(&writer);
1072     BuildAttributeDataVersionList(apSuite, attributeDataVersionListBuilder);
1073     chip::System::PacketBufferHandle buf;
1074     err = writer.Finalize(&buf);
1075     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
1076
1077     DebugPrettyPrint(buf);
1078
1079     reader.Init(std::move(buf));
1080     err = reader.Next();
1081     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
1082     ParseAttributeDataVersionList(apSuite, reader);
1083 }
1084
1085 void CommandDataElementTest(nlTestSuite * apSuite, void * apContext)
1086 {
1087     CHIP_ERROR err = CHIP_NO_ERROR;
1088     CommandDataElement::Builder commandDataElementBuilder;
1089     CommandDataElement::Parser commandDataElementParser;
1090     chip::System::PacketBufferTLVWriter writer;
1091     chip::System::PacketBufferTLVReader reader;
1092     writer.Init(chip::System::PacketBufferHandle::New(chip::System::PacketBuffer::kMaxSize));
1093     commandDataElementBuilder.Init(&writer);
1094     BuildCommandDataElement(apSuite, commandDataElementBuilder);
1095     chip::System::PacketBufferHandle buf;
1096     err = writer.Finalize(&buf);
1097     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
1098
1099     DebugPrettyPrint(buf);
1100
1101     reader.Init(std::move(buf));
1102     err = reader.Next();
1103     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
1104
1105     commandDataElementParser.Init(reader);
1106     ParseCommandDataElement(apSuite, commandDataElementParser);
1107 }
1108
1109 void CommandDataElementWithStatusCodeTest(nlTestSuite * apSuite, void * apContext)
1110 {
1111     CHIP_ERROR err = CHIP_NO_ERROR;
1112     CommandDataElement::Builder commandDataElementBuilder;
1113     CommandDataElement::Parser commandDataElementParser;
1114     chip::System::PacketBufferTLVWriter writer;
1115     chip::System::PacketBufferTLVReader reader;
1116     writer.Init(chip::System::PacketBufferHandle::New(chip::System::PacketBuffer::kMaxSize));
1117     commandDataElementBuilder.Init(&writer);
1118     BuildCommandDataElementWithStatusCode(apSuite, commandDataElementBuilder);
1119     chip::System::PacketBufferHandle buf;
1120     err = writer.Finalize(&buf);
1121     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
1122
1123     DebugPrettyPrint(buf);
1124
1125     reader.Init(std::move(buf));
1126     err = reader.Next();
1127     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
1128
1129     commandDataElementParser.Init(reader);
1130     ParseCommandDataElementWithStatusCode(apSuite, commandDataElementParser);
1131 }
1132
1133 void CommandListTest(nlTestSuite * apSuite, void * apContext)
1134 {
1135     CHIP_ERROR err = CHIP_NO_ERROR;
1136     chip::System::PacketBufferTLVWriter writer;
1137     chip::System::PacketBufferTLVReader reader;
1138     CommandList::Builder commandListBuilder;
1139     writer.Init(chip::System::PacketBufferHandle::New(chip::System::PacketBuffer::kMaxSize));
1140     commandListBuilder.Init(&writer);
1141     BuildCommandList(apSuite, commandListBuilder);
1142     chip::System::PacketBufferHandle buf;
1143     err = writer.Finalize(&buf);
1144     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
1145
1146     DebugPrettyPrint(buf);
1147
1148     reader.Init(std::move(buf));
1149     err = reader.Next();
1150     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
1151     ParseCommandList(apSuite, reader);
1152 }
1153
1154 void ReportDataTest(nlTestSuite * apSuite, void * apContext)
1155 {
1156     CHIP_ERROR err = CHIP_NO_ERROR;
1157     chip::System::PacketBufferTLVWriter writer;
1158     chip::System::PacketBufferTLVReader reader;
1159     writer.Init(chip::System::PacketBufferHandle::New(chip::System::PacketBuffer::kMaxSize));
1160     BuildReportData(apSuite, writer);
1161     chip::System::PacketBufferHandle buf;
1162     err = writer.Finalize(&buf);
1163     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
1164
1165     DebugPrettyPrint(buf);
1166
1167     reader.Init(std::move(buf));
1168     err = reader.Next();
1169     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
1170     ParseReportData(apSuite, reader);
1171 }
1172
1173 void InvokeCommandTest(nlTestSuite * apSuite, void * apContext)
1174 {
1175     CHIP_ERROR err = CHIP_NO_ERROR;
1176     chip::System::PacketBufferTLVWriter writer;
1177     chip::System::PacketBufferTLVReader reader;
1178     writer.Init(chip::System::PacketBufferHandle::New(chip::System::PacketBuffer::kMaxSize));
1179     BuildInvokeCommand(apSuite, writer);
1180     chip::System::PacketBufferHandle buf;
1181     err = writer.Finalize(&buf);
1182     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
1183
1184     DebugPrettyPrint(buf);
1185
1186     reader.Init(std::move(buf));
1187     err = reader.Next();
1188     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
1189     ParseInvokeCommand(apSuite, reader);
1190 }
1191
1192 void ReadRequestTest(nlTestSuite * apSuite, void * apContext)
1193 {
1194     CHIP_ERROR err = CHIP_NO_ERROR;
1195     chip::System::PacketBufferTLVWriter writer;
1196     chip::System::PacketBufferTLVReader reader;
1197     writer.Init(chip::System::PacketBufferHandle::New(chip::System::PacketBuffer::kMaxSize));
1198     BuildReadRequest(apSuite, writer);
1199     chip::System::PacketBufferHandle buf;
1200     err = writer.Finalize(&buf);
1201     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
1202
1203     DebugPrettyPrint(buf);
1204
1205     reader.Init(std::move(buf));
1206     err = reader.Next();
1207     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
1208     ParseReadRequest(apSuite, reader);
1209 }
1210
1211 void CheckPointRollbackTest(nlTestSuite * apSuite, void * apContext)
1212 {
1213     CHIP_ERROR err        = CHIP_NO_ERROR;
1214     size_t NumDataElement = 0;
1215     chip::System::PacketBufferTLVWriter writer;
1216     chip::System::PacketBufferTLVReader reader;
1217     AttributeDataList::Parser attributeDataListParser;
1218     chip::TLV::TLVWriter checkpoint;
1219     writer.Init(chip::System::PacketBufferHandle::New(chip::System::PacketBuffer::kMaxSize));
1220     AttributeDataList::Builder attributeDataListBuilder;
1221     attributeDataListBuilder.Init(&writer);
1222
1223     // encode one attribute element
1224     AttributeDataElement::Builder attributeDataElementBuilder1 = attributeDataListBuilder.CreateAttributeDataElementBuilder();
1225     NL_TEST_ASSERT(apSuite, attributeDataListBuilder.GetError() == CHIP_NO_ERROR);
1226     BuildAttributeDataElement(apSuite, attributeDataElementBuilder1);
1227     // checkpoint
1228     attributeDataListBuilder.Checkpoint(checkpoint);
1229     // encode another attribute element
1230     AttributeDataElement::Builder attributeDataElementBuilder2 = attributeDataListBuilder.CreateAttributeDataElementBuilder();
1231     NL_TEST_ASSERT(apSuite, attributeDataListBuilder.GetError() == CHIP_NO_ERROR);
1232     BuildAttributeDataElement(apSuite, attributeDataElementBuilder2);
1233     // rollback to previous checkpoint
1234     attributeDataListBuilder.Rollback(checkpoint);
1235
1236     attributeDataListBuilder.EndOfAttributeDataList();
1237     NL_TEST_ASSERT(apSuite, attributeDataListBuilder.GetError() == CHIP_NO_ERROR);
1238
1239     chip::System::PacketBufferHandle buf;
1240     err = writer.Finalize(&buf);
1241     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
1242
1243     DebugPrettyPrint(buf);
1244
1245     reader.Init(std::move(buf));
1246     err = reader.Next();
1247     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
1248
1249     err = attributeDataListParser.Init(reader);
1250     NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR);
1251     attributeDataListParser.CheckSchemaValidity();
1252
1253     while (CHIP_NO_ERROR == (err = attributeDataListParser.Next()))
1254     {
1255         ++NumDataElement;
1256     }
1257
1258     NL_TEST_ASSERT(apSuite, NumDataElement == 1);
1259 }
1260
1261 /**
1262  *   Test Suite. It lists all the test functions.
1263  */
1264
1265 // clang-format off
1266 const nlTest sTests[] =
1267         {
1268                 NL_TEST_DEF("AttributePathTest", AttributePathTest),
1269                 NL_TEST_DEF("AttributePathListTest", AttributePathListTest),
1270                 NL_TEST_DEF("EventPathTest", EventPathTest),
1271                 NL_TEST_DEF("EventPathListTest", EventPathListTest),
1272                 NL_TEST_DEF("CommandPathTest", CommandPathTest),
1273                 NL_TEST_DEF("EventDataElementTest", EventDataElementTest),
1274                 NL_TEST_DEF("EventListTest", EventListTest),
1275                 NL_TEST_DEF("StatusElementTest", StatusElementTest),
1276                 NL_TEST_DEF("AttributeStatusElementTest", AttributeStatusElementTest),
1277                 NL_TEST_DEF("AttributeStatusListTest", AttributeStatusListTest),
1278                 NL_TEST_DEF("AttributeDataElementTest", AttributeDataElementTest),
1279                 NL_TEST_DEF("AttributeDataListTest", AttributeDataListTest),
1280                 NL_TEST_DEF("AttributeDataVersionListTest", AttributeDataVersionListTest),
1281                 NL_TEST_DEF("CommandDataElementTest", CommandDataElementTest),
1282                 NL_TEST_DEF("CommandDataElementWithStatusCodeTest", CommandDataElementWithStatusCodeTest),
1283                 NL_TEST_DEF("CommandListTest", CommandListTest),
1284                 NL_TEST_DEF("ReportDataTest", ReportDataTest),
1285                 NL_TEST_DEF("InvokeCommandTest", InvokeCommandTest),
1286                 NL_TEST_DEF("ReadRequestTest", ReadRequestTest),
1287                 NL_TEST_DEF("CheckPointRollbackTest", CheckPointRollbackTest),
1288                 NL_TEST_SENTINEL()
1289         };
1290 // clang-format on
1291 } // namespace
1292
1293 /**
1294  *  Set up the test suite.
1295  */
1296 static int TestSetup(void * inContext)
1297 {
1298     CHIP_ERROR error = chip::Platform::MemoryInit();
1299     if (error != CHIP_NO_ERROR)
1300         return FAILURE;
1301     return SUCCESS;
1302 }
1303
1304 /**
1305  *  Tear down the test suite.
1306  */
1307 static int TestTeardown(void * inContext)
1308 {
1309     chip::Platform::MemoryShutdown();
1310     return SUCCESS;
1311 }
1312
1313 int TestMessageDef()
1314 {
1315     // clang-format off
1316     nlTestSuite theSuite =
1317         {
1318         "MessageDef",
1319         &sTests[0],
1320         TestSetup,
1321         TestTeardown,
1322     };
1323     // clang-format on
1324
1325     nlTestRunner(&theSuite, nullptr);
1326
1327     return (nlTestRunnerStats(&theSuite));
1328 }
1329
1330 CHIP_REGISTER_TEST_SUITE(TestMessageDef)