src/setup_payload/tests/TestManualCode.cpp

   1 /*
   2  *
   3  *    Copyright (c) 2020 Project CHIP Authors
   4  *
   5  *    Licensed under the Apache License, Version 2.0 (the "License");
   6  *    you may not use this file except in compliance with the License.
   7  *    You may obtain a copy of the License at
   8  *
   9  *        http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  *    Unless required by applicable law or agreed to in writing, software
  12  *    distributed under the License is distributed on an "AS IS" BASIS,
  13  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  *    See the License for the specific language governing permissions and
  15  *    limitations under the License.
  16  */
  17
  18 /**
  19  *    @file
  20  *      This file implements a unit test suite for the manual setup
  21  *      code functionality.
  22  *
  23  */
  24
  25 #include <nlunit-test.h>
  26 #include <stdio.h>
  27
  28 #include "ManualSetupPayloadGenerator.cpp"
  29 #include "ManualSetupPayloadParser.cpp"
  30 #include "SetupPayload.cpp"
  31 #include "SetupPayload.h"
  32
  33 #include <support/UnitTestRegistration.h>
  34 #include <support/verhoeff/Verhoeff.h>
  35
  36 using namespace chip;
  37
  38 namespace {
  39
  40 bool CheckGenerator(const SetupPayload & payload, std::string expectedResult)
  41 {
  42     std::string result;
  43     ManualSetupPayloadGenerator generator(payload);
  44     generator.payloadDecimalStringRepresentation(result);
  45
  46     if (!expectedResult.empty())
  47     {
  48         expectedResult += Verhoeff10::ComputeCheckChar(expectedResult.c_str());
  49     }
  50
  51     bool same = result == expectedResult;
  52     if (!same)
  53     {
  54         printf("Actual result: %s\n", result.c_str());
  55         printf("Expected result: %s\n", expectedResult.c_str());
  56     }
  57
  58     return same;
  59 }
  60
  61 SetupPayload GetDefaultPayload()
  62 {
  63     SetupPayload payload;
  64     payload.setUpPINCode  = 123456780;
  65     payload.discriminator = 2560;
  66
  67     return payload;
  68 }
  69
  70 void TestDecimalRepresentation_PartialPayload(nlTestSuite * inSuite, void * inContext)
  71 {
  72     SetupPayload payload = GetDefaultPayload();
  73
  74     std::string expectedResult = "2361087535";
  75
  76     NL_TEST_ASSERT(inSuite, CheckGenerator(payload, expectedResult));
  77 }
  78
  79 void TestDecimalRepresentation_PartialPayload_RequiresCustomFlow(nlTestSuite * inSuite, void * inContext)
  80 {
  81     SetupPayload payload       = GetDefaultPayload();
  82     payload.requiresCustomFlow = true;
  83
  84     std::string expectedResult = "63610875350000000000";
  85
  86     NL_TEST_ASSERT(inSuite, CheckGenerator(payload, expectedResult));
  87 }
  88
  89 void TestDecimalRepresentation_FullPayloadWithZeros(nlTestSuite * inSuite, void * inContext)
  90 {
  91     SetupPayload payload       = GetDefaultPayload();
  92     payload.requiresCustomFlow = true;
  93     payload.vendorID           = 1;
  94     payload.productID          = 1;
  95
  96     std::string expectedResult = "63610875350000100001";
  97
  98     NL_TEST_ASSERT(inSuite, CheckGenerator(payload, expectedResult));
  99 }
 100
 101 void TestDecimalRepresentation_FullPayloadWithoutZeros(nlTestSuite * inSuite, void * inContext)
 102 {
 103     SetupPayload payload       = GetDefaultPayload();
 104     payload.requiresCustomFlow = true;
 105     payload.vendorID           = 45367;
 106     payload.productID          = 14526;
 107
 108     std::string expectedResult = "63610875354536714526";
 109
 110     NL_TEST_ASSERT(inSuite, CheckGenerator(payload, expectedResult));
 111 }
 112
 113 void TestDecimalRepresentation_FullPayloadWithoutZeros_DoesNotRequireCustomFlow(nlTestSuite * inSuite, void * inContext)
 114 {
 115     SetupPayload payload = GetDefaultPayload();
 116     payload.vendorID     = 45367;
 117     payload.productID    = 14526;
 118
 119     std::string expectedResult = "2361087535";
 120
 121     NL_TEST_ASSERT(inSuite, CheckGenerator(payload, expectedResult));
 122 }
 123
 124 void TestDecimalRepresentation_AllZeros(nlTestSuite * inSuite, void * inContext)
 125 {
 126     SetupPayload payload;
 127     payload.setUpPINCode  = 0;
 128     payload.discriminator = 0;
 129
 130     std::string expectedResult = "";
 131
 132     NL_TEST_ASSERT(inSuite, CheckGenerator(payload, expectedResult));
 133 }
 134
 135 void TestDecimalRepresentation_AllOnes(nlTestSuite * inSuite, void * inContext)
 136 {
 137     SetupPayload payload;
 138     payload.setUpPINCode       = 0x7FFFFFF;
 139     payload.discriminator      = 0xFFF;
 140     payload.requiresCustomFlow = true;
 141     payload.vendorID           = 65535;
 142     payload.productID          = 65535;
 143
 144     std::string expectedResult = "76553581916553565535";
 145
 146     NL_TEST_ASSERT(inSuite, CheckGenerator(payload, expectedResult));
 147 }
 148
 149 void TestDecimalRepresentation_InvalidPayload(nlTestSuite * inSuite, void * inContext)
 150 {
 151     SetupPayload payload  = GetDefaultPayload();
 152     payload.discriminator = 0x1f00;
 153
 154     ManualSetupPayloadGenerator generator(payload);
 155     std::string result;
 156     NL_TEST_ASSERT(inSuite, generator.payloadDecimalStringRepresentation(result) == CHIP_ERROR_INVALID_ARGUMENT);
 157 }
 158
 159 void assertPayloadValues(nlTestSuite * inSuite, CHIP_ERROR actualError, CHIP_ERROR expectedError, const SetupPayload & payload,
 160                          uint32_t pinCode, uint16_t discriminator, uint16_t vendorID, uint16_t productID)
 161 {
 162     NL_TEST_ASSERT(inSuite, actualError == expectedError);
 163     NL_TEST_ASSERT(inSuite, payload.setUpPINCode == pinCode);
 164     NL_TEST_ASSERT(inSuite, payload.discriminator == discriminator);
 165     NL_TEST_ASSERT(inSuite, payload.vendorID == vendorID);
 166     NL_TEST_ASSERT(inSuite, payload.productID == productID);
 167 }
 168
 169 void TestGenerateAndParser_ManualSetupCodeWithLongDiscriminator(nlTestSuite * inSuite, void * inContext)
 170 {
 171     SetupPayload payload       = GetDefaultPayload();
 172     payload.requiresCustomFlow = false;
 173     payload.discriminator      = 0xa1f;
 174
 175     {
 176         // Test short 11 digit code
 177         ManualSetupPayloadGenerator generator(payload);
 178         std::string result;
 179         NL_TEST_ASSERT(inSuite, generator.payloadDecimalStringRepresentation(result) == CHIP_NO_ERROR);
 180
 181         SetupPayload outPayload;
 182         CHIP_ERROR err = ManualSetupPayloadParser(result).populatePayload(outPayload);
 183         assertPayloadValues(inSuite, err, CHIP_NO_ERROR, outPayload, payload.setUpPINCode, 0xa00, payload.vendorID,
 184                             payload.productID);
 185     }
 186
 187     payload.vendorID           = 1;
 188     payload.productID          = 1;
 189     payload.requiresCustomFlow = true;
 190     payload.discriminator      = 0xb1f;
 191
 192     {
 193         // Test long 21 digit code
 194         ManualSetupPayloadGenerator generator(payload);
 195         std::string result;
 196         NL_TEST_ASSERT(inSuite, generator.payloadDecimalStringRepresentation(result) == CHIP_NO_ERROR);
 197
 198         SetupPayload outPayload;
 199         CHIP_ERROR err = ManualSetupPayloadParser(result).populatePayload(outPayload);
 200         assertPayloadValues(inSuite, err, CHIP_NO_ERROR, outPayload, payload.setUpPINCode, 0xb00, payload.vendorID,
 201                             payload.productID);
 202     }
 203 }
 204
 205 void assertEmptyPayloadWithError(nlTestSuite * inSuite, CHIP_ERROR actualError, CHIP_ERROR expectedError,
 206                                  const SetupPayload & payload)
 207 {
 208     NL_TEST_ASSERT(inSuite, actualError == expectedError);
 209     NL_TEST_ASSERT(inSuite,
 210                    payload.setUpPINCode == 0 && payload.discriminator == 0 && payload.productID == 0 && payload.vendorID == 0);
 211 }
 212
 213 void TestPayloadParser_FullPayload(nlTestSuite * inSuite, void * inContext)
 214 {
 215     SetupPayload payload;
 216     std::string decimalString;
 217
 218     decimalString = "63610875354536714526";
 219     decimalString += Verhoeff10::ComputeCheckChar(decimalString.c_str());
 220     CHIP_ERROR err = ManualSetupPayloadParser(decimalString).populatePayload(payload);
 221     assertPayloadValues(inSuite, err, CHIP_NO_ERROR, payload, 123456780, 2560, 45367, 14526);
 222
 223     decimalString = "52927623630456200032";
 224     decimalString += Verhoeff10::ComputeCheckChar(decimalString.c_str());
 225     err = ManualSetupPayloadParser(decimalString).populatePayload(payload);
 226     assertPayloadValues(inSuite, err, CHIP_NO_ERROR, payload, 38728284, 1280, 4562, 32);
 227
 228     decimalString = "40000100000000100001";
 229     decimalString += Verhoeff10::ComputeCheckChar(decimalString.c_str());
 230     err = ManualSetupPayloadParser(decimalString).populatePayload(payload);
 231     assertPayloadValues(inSuite, err, CHIP_NO_ERROR, payload, 1, 0, 1, 1);
 232 }
 233
 234 void TestGenerateAndParser_FullPayload(nlTestSuite * inSuite, void * inContext)
 235 {
 236     SetupPayload payload       = GetDefaultPayload();
 237     payload.vendorID           = 1;
 238     payload.productID          = 1;
 239     payload.requiresCustomFlow = true;
 240
 241     ManualSetupPayloadGenerator generator(payload);
 242     std::string result;
 243     NL_TEST_ASSERT(inSuite, generator.payloadDecimalStringRepresentation(result) == CHIP_NO_ERROR);
 244
 245     SetupPayload outPayload;
 246     CHIP_ERROR err = ManualSetupPayloadParser(result).populatePayload(outPayload);
 247     assertPayloadValues(inSuite, err, CHIP_NO_ERROR, outPayload, payload.setUpPINCode, payload.discriminator, payload.vendorID,
 248                         payload.productID);
 249 }
 250
 251 void TestGenerateAndParser_PartialPayload(nlTestSuite * inSuite, void * inContext)
 252 {
 253     SetupPayload payload = GetDefaultPayload();
 254
 255     ManualSetupPayloadGenerator generator(payload);
 256     std::string result;
 257     NL_TEST_ASSERT(inSuite, generator.payloadDecimalStringRepresentation(result) == CHIP_NO_ERROR);
 258
 259     SetupPayload outPayload;
 260     CHIP_ERROR err = ManualSetupPayloadParser(result).populatePayload(outPayload);
 261     assertPayloadValues(inSuite, err, CHIP_NO_ERROR, outPayload, payload.setUpPINCode, payload.discriminator, payload.vendorID,
 262                         payload.productID);
 263 }
 264
 265 void TestPayloadParser_PartialPayload(nlTestSuite * inSuite, void * inContext)
 266 {
 267     CHIP_ERROR err;
 268     SetupPayload payload;
 269     std::string decimalString;
 270
 271     decimalString = "2361087535";
 272     decimalString += Verhoeff10::ComputeCheckChar(decimalString.c_str());
 273     NL_TEST_ASSERT(inSuite, decimalString.length() == 11);
 274     err = ManualSetupPayloadParser(decimalString).populatePayload(payload);
 275     assertPayloadValues(inSuite, err, CHIP_NO_ERROR, payload, 123456780, 2560, 0, 0);
 276
 277     decimalString = "0000010000";
 278     decimalString += Verhoeff10::ComputeCheckChar(decimalString.c_str());
 279     NL_TEST_ASSERT(inSuite, decimalString.length() == 11);
 280     err = ManualSetupPayloadParser(decimalString).populatePayload(payload);
 281     assertPayloadValues(inSuite, err, CHIP_NO_ERROR, payload, 1, 0, 0, 0);
 282
 283     decimalString = "63610875350000000000";
 284     decimalString += Verhoeff10::ComputeCheckChar(decimalString.c_str());
 285     NL_TEST_ASSERT(inSuite, decimalString.length() == 21);
 286     err = ManualSetupPayloadParser(decimalString).populatePayload(payload);
 287     assertPayloadValues(inSuite, err, CHIP_NO_ERROR, payload, 123456780, 2560, 0, 0);
 288
 289     // no discriminator (= 0)
 290     decimalString = "0033407535";
 291     decimalString += Verhoeff10::ComputeCheckChar(decimalString.c_str());
 292     NL_TEST_ASSERT(inSuite, decimalString.length() == 11);
 293     err = ManualSetupPayloadParser(decimalString).populatePayload(payload);
 294     NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
 295
 296     // no vid (= 0)
 297     decimalString = "63610875350000014526";
 298     decimalString += Verhoeff10::ComputeCheckChar(decimalString.c_str());
 299     NL_TEST_ASSERT(inSuite, decimalString.length() == 21);
 300     err = ManualSetupPayloadParser(decimalString).populatePayload(payload);
 301     NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
 302
 303     // no pid (= 0)
 304     decimalString = "63610875354536700000";
 305     decimalString += Verhoeff10::ComputeCheckChar(decimalString.c_str());
 306     NL_TEST_ASSERT(inSuite, decimalString.length() == 21);
 307     err = ManualSetupPayloadParser(decimalString).populatePayload(payload);
 308     NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
 309 }
 310
 311 void TestShortCodeReadWrite(nlTestSuite * inSuite, void * context)
 312 {
 313     SetupPayload inPayload = GetDefaultPayload();
 314     SetupPayload outPayload;
 315
 316     std::string result;
 317     ManualSetupPayloadGenerator generator(inPayload);
 318     generator.payloadDecimalStringRepresentation(result);
 319     ManualSetupPayloadParser(result).populatePayload(outPayload);
 320
 321     NL_TEST_ASSERT(inSuite, inPayload == outPayload);
 322 }
 323
 324 void TestLongCodeReadWrite(nlTestSuite * inSuite, void * context)
 325 {
 326     SetupPayload inPayload       = GetDefaultPayload();
 327     inPayload.requiresCustomFlow = true;
 328     inPayload.vendorID           = 1;
 329     inPayload.productID          = 1;
 330     SetupPayload outPayload;
 331
 332     std::string result;
 333     ManualSetupPayloadGenerator generator(inPayload);
 334     generator.payloadDecimalStringRepresentation(result);
 335     ManualSetupPayloadParser(result).populatePayload(outPayload);
 336
 337     NL_TEST_ASSERT(inSuite, inPayload == outPayload);
 338 }
 339
 340 void TestPayloadParser_InvalidEntry(nlTestSuite * inSuite, void * inContext)
 341 {
 342     SetupPayload payload;
 343     std::string decimalString;
 344
 345     // Empty input
 346     decimalString = "";
 347     decimalString += Verhoeff10::ComputeCheckChar(decimalString.c_str());
 348     assertEmptyPayloadWithError(inSuite, ManualSetupPayloadParser(decimalString).populatePayload(payload),
 349                                 CHIP_ERROR_INVALID_STRING_LENGTH, payload);
 350
 351     // Invalid character
 352     decimalString = "24184.2196";
 353     decimalString += Verhoeff10::ComputeCheckChar(decimalString.c_str());
 354     assertEmptyPayloadWithError(inSuite, ManualSetupPayloadParser(decimalString).populatePayload(payload),
 355                                 CHIP_ERROR_INVALID_INTEGER_VALUE, payload);
 356
 357     // too short
 358     decimalString = "2456";
 359     decimalString += Verhoeff10::ComputeCheckChar(decimalString.c_str());
 360     assertEmptyPayloadWithError(inSuite, ManualSetupPayloadParser(decimalString).populatePayload(payload),
 361                                 CHIP_ERROR_INVALID_STRING_LENGTH, payload);
 362
 363     // too long for long code
 364     decimalString = "123456789123456785671";
 365     decimalString += Verhoeff10::ComputeCheckChar(decimalString.c_str());
 366     assertEmptyPayloadWithError(inSuite, ManualSetupPayloadParser(decimalString).populatePayload(payload),
 367                                 CHIP_ERROR_INVALID_STRING_LENGTH, payload);
 368
 369     // too long for short code
 370     decimalString = "12749875380";
 371     decimalString += Verhoeff10::ComputeCheckChar(decimalString.c_str());
 372     assertEmptyPayloadWithError(inSuite, ManualSetupPayloadParser(decimalString).populatePayload(payload),
 373                                 CHIP_ERROR_INVALID_STRING_LENGTH, payload);
 374
 375     // bit to indicate short code but long code length
 376     decimalString = "23456789123456785610";
 377     decimalString += Verhoeff10::ComputeCheckChar(decimalString.c_str());
 378     assertEmptyPayloadWithError(inSuite, ManualSetupPayloadParser(decimalString).populatePayload(payload),
 379                                 CHIP_ERROR_INVALID_STRING_LENGTH, payload);
 380     // no pin code (= 0)
 381     decimalString = "2327680000";
 382     decimalString += Verhoeff10::ComputeCheckChar(decimalString.c_str());
 383     assertEmptyPayloadWithError(inSuite, ManualSetupPayloadParser(decimalString).populatePayload(payload),
 384                                 CHIP_ERROR_INVALID_ARGUMENT, payload);
 385     // wrong check digit
 386     decimalString = "02684354589";
 387     assertEmptyPayloadWithError(inSuite, ManualSetupPayloadParser(decimalString).populatePayload(payload),
 388                                 CHIP_ERROR_INTEGRITY_CHECK_FAILED, payload);
 389 }
 390
 391 void TestCheckDecimalStringValidity(nlTestSuite * inSuite, void * inContext)
 392 {
 393     std::string outReprensation;
 394     char checkDigit;
 395     std::string representationWithoutCheckDigit;
 396     std::string decimalString;
 397
 398     representationWithoutCheckDigit = "";
 399     NL_TEST_ASSERT(
 400         inSuite, checkDecimalStringValidity(representationWithoutCheckDigit, outReprensation) == CHIP_ERROR_INVALID_STRING_LENGTH);
 401
 402     representationWithoutCheckDigit = "1";
 403     NL_TEST_ASSERT(
 404         inSuite, checkDecimalStringValidity(representationWithoutCheckDigit, outReprensation) == CHIP_ERROR_INVALID_STRING_LENGTH);
 405
 406     representationWithoutCheckDigit = "10109";
 407     checkDigit                      = Verhoeff10::ComputeCheckChar(representationWithoutCheckDigit.c_str());
 408     decimalString                   = representationWithoutCheckDigit + checkDigit;
 409     NL_TEST_ASSERT(inSuite, checkDecimalStringValidity(decimalString, outReprensation) == CHIP_NO_ERROR);
 410     NL_TEST_ASSERT(inSuite, outReprensation == representationWithoutCheckDigit);
 411
 412     representationWithoutCheckDigit = "0000";
 413     checkDigit                      = Verhoeff10::ComputeCheckChar(representationWithoutCheckDigit.c_str());
 414     decimalString                   = representationWithoutCheckDigit + checkDigit;
 415     NL_TEST_ASSERT(inSuite, checkDecimalStringValidity(decimalString, outReprensation) == CHIP_NO_ERROR);
 416     NL_TEST_ASSERT(inSuite, outReprensation == representationWithoutCheckDigit);
 417 }
 418
 419 void TestCheckCodeLengthValidity(nlTestSuite * inSuite, void * inContext)
 420 {
 421     NL_TEST_ASSERT(inSuite, checkCodeLengthValidity("01234567890123456789", true) == CHIP_NO_ERROR);
 422     NL_TEST_ASSERT(inSuite, checkCodeLengthValidity("0123456789", false) == CHIP_NO_ERROR);
 423
 424     NL_TEST_ASSERT(inSuite, checkCodeLengthValidity("01234567891", false) == CHIP_ERROR_INVALID_STRING_LENGTH);
 425     NL_TEST_ASSERT(inSuite, checkCodeLengthValidity("012345678", false) == CHIP_ERROR_INVALID_STRING_LENGTH);
 426     NL_TEST_ASSERT(inSuite, checkCodeLengthValidity("012345678901234567891", true) == CHIP_ERROR_INVALID_STRING_LENGTH);
 427     NL_TEST_ASSERT(inSuite, checkCodeLengthValidity("0123456789012345678", true) == CHIP_ERROR_INVALID_STRING_LENGTH);
 428 }
 429
 430 void TestDecimalStringToNumber(nlTestSuite * inSuite, void * inContext)
 431 {
 432     uint32_t number;
 433     NL_TEST_ASSERT(inSuite, toNumber("12345", number) == CHIP_NO_ERROR);
 434     NL_TEST_ASSERT(inSuite, number == 12345);
 435
 436     NL_TEST_ASSERT(inSuite, toNumber("01234567890", number) == CHIP_NO_ERROR);
 437     NL_TEST_ASSERT(inSuite, number == 1234567890);
 438
 439     NL_TEST_ASSERT(inSuite, toNumber("00000001", number) == CHIP_NO_ERROR);
 440     NL_TEST_ASSERT(inSuite, number == 1);
 441
 442     NL_TEST_ASSERT(inSuite, toNumber("0", number) == CHIP_NO_ERROR);
 443     NL_TEST_ASSERT(inSuite, number == 0);
 444
 445     NL_TEST_ASSERT(inSuite, toNumber("012345.123456789", number) == CHIP_ERROR_INVALID_INTEGER_VALUE);
 446     NL_TEST_ASSERT(inSuite, toNumber("/", number) == CHIP_ERROR_INVALID_INTEGER_VALUE);
 447 }
 448
 449 void TestReadCharsFromDecimalString(nlTestSuite * inSuite, void * inContext)
 450 {
 451     uint32_t number;
 452     size_t index = 3;
 453     NL_TEST_ASSERT(inSuite, readDigitsFromDecimalString("12345", index, number, 2) == CHIP_NO_ERROR);
 454     NL_TEST_ASSERT(inSuite, number == 45);
 455
 456     index = 2;
 457     NL_TEST_ASSERT(inSuite, readDigitsFromDecimalString("6256276377282", index, number, 7) == CHIP_NO_ERROR);
 458     NL_TEST_ASSERT(inSuite, number == 5627637);
 459
 460     index = 0;
 461     NL_TEST_ASSERT(inSuite, readDigitsFromDecimalString("10", index, number, 2) == CHIP_NO_ERROR);
 462     NL_TEST_ASSERT(inSuite, number == 10);
 463
 464     index = 0;
 465     NL_TEST_ASSERT(inSuite, readDigitsFromDecimalString("01", index, number, 2) == CHIP_NO_ERROR);
 466     NL_TEST_ASSERT(inSuite, number == 1);
 467
 468     index = 1;
 469     NL_TEST_ASSERT(inSuite, readDigitsFromDecimalString("11", index, number, 1) == CHIP_NO_ERROR);
 470     NL_TEST_ASSERT(inSuite, number == 1);
 471
 472     index = 2;
 473     NL_TEST_ASSERT(inSuite, readDigitsFromDecimalString("100001", index, number, 3) == CHIP_NO_ERROR);
 474
 475     index = 1;
 476     NL_TEST_ASSERT(inSuite, readDigitsFromDecimalString("12345", index, number, 5) == CHIP_ERROR_INVALID_STRING_LENGTH);
 477     NL_TEST_ASSERT(inSuite, readDigitsFromDecimalString("12", index, number, 5) == CHIP_ERROR_INVALID_STRING_LENGTH);
 478
 479     index = 200;
 480     NL_TEST_ASSERT(inSuite, readDigitsFromDecimalString("6256276377282", index, number, 1) == CHIP_ERROR_INVALID_STRING_LENGTH);
 481 }
 482
 483 void TestShortCodeCharLengths(nlTestSuite * inSuite, void * inContext)
 484 {
 485     size_t numBits                        = 1 + kSetupPINCodeFieldLengthInBits + kManualSetupDiscriminatorFieldLengthInBits;
 486     size_t manualSetupShortCodeCharLength = static_cast<size_t>(ceil(log10(pow(2, numBits))));
 487     NL_TEST_ASSERT(inSuite, manualSetupShortCodeCharLength == kManualSetupShortCodeCharLength);
 488
 489     size_t manualSetupVendorIdCharLength = static_cast<size_t>(ceil(log10(pow(2, kVendorIDFieldLengthInBits))));
 490     NL_TEST_ASSERT(inSuite, manualSetupVendorIdCharLength == kManualSetupVendorIdCharLength);
 491
 492     size_t manualSetupProductIdCharLength = static_cast<size_t>(ceil(log10(pow(2, kProductIDFieldLengthInBits))));
 493     NL_TEST_ASSERT(inSuite, manualSetupProductIdCharLength == kManualSetupProductIdCharLength);
 494
 495     size_t manualSetupLongCodeCharLength =
 496         kManualSetupShortCodeCharLength + kManualSetupVendorIdCharLength + kManualSetupProductIdCharLength;
 497     NL_TEST_ASSERT(inSuite, manualSetupLongCodeCharLength == kManualSetupLongCodeCharLength);
 498 }
 499
 500 /**
 501  *  Test Suite that lists all the Test functions.
 502  */
 503 // clang-format off
 504 const nlTest sTests[] =
 505 {
 506     NL_TEST_DEF("Generate Decimal Representation from Partial Payload",                 TestDecimalRepresentation_PartialPayload),
 507     NL_TEST_DEF("Generate Decimal Representation from Partial Payload (Custom Flow)",   TestDecimalRepresentation_PartialPayload_RequiresCustomFlow),
 508     NL_TEST_DEF("Generate Decimal Representation from Full Payload with Zeros",         TestDecimalRepresentation_FullPayloadWithZeros),
 509     NL_TEST_DEF("Decimal Representation from Full Payload without Zeros",               TestDecimalRepresentation_FullPayloadWithoutZeros_DoesNotRequireCustomFlow),
 510     NL_TEST_DEF("Decimal Representation from Full Payload without Zeros (Custom Flow)", TestDecimalRepresentation_FullPayloadWithoutZeros),
 511     NL_TEST_DEF("Test Decimal Representation - Invalid Payload",                        TestDecimalRepresentation_InvalidPayload),
 512     NL_TEST_DEF("Test 12 bit discriminator for manual setup code",                      TestGenerateAndParser_ManualSetupCodeWithLongDiscriminator),
 513     NL_TEST_DEF("Test Decimal Representation - All Zeros",                              TestDecimalRepresentation_AllZeros),
 514     NL_TEST_DEF("Test Decimal Representation - All Ones",                               TestDecimalRepresentation_AllOnes),
 515     NL_TEST_DEF("Parse from Partial Payload",                                           TestPayloadParser_PartialPayload),
 516     NL_TEST_DEF("Parse from Full Payload",                                              TestPayloadParser_FullPayload),
 517     NL_TEST_DEF("Test Invalid Entry To QR Code Parser",                                 TestPayloadParser_InvalidEntry),
 518     NL_TEST_DEF("Test Short Read Write",                                                TestShortCodeReadWrite),
 519     NL_TEST_DEF("Test Long Read Write",                                                 TestLongCodeReadWrite),
 520     NL_TEST_DEF("Check Decimal String Validity",                                        TestCheckDecimalStringValidity),
 521     NL_TEST_DEF("Check QR Code Length Validity",                                        TestCheckCodeLengthValidity),
 522     NL_TEST_DEF("Test Decimal String to Number",                                        TestDecimalStringToNumber),
 523     NL_TEST_DEF("Test Short Code Character Lengths",                                    TestShortCodeCharLengths),
 524     NL_TEST_DEF("Test Read Characters from Decimal String",                             TestReadCharsFromDecimalString),
 525     NL_TEST_DEF("Generate Full Payload and Parse it",                                   TestGenerateAndParser_FullPayload),
 526     NL_TEST_DEF("Generate Partial Payload and Parse it",                                TestGenerateAndParser_PartialPayload),
 527
 528     NL_TEST_SENTINEL()
 529 };
 530 // clang-format on
 531
 532 struct TestContext
 533 {
 534     nlTestSuite * mSuite;
 535 };
 536
 537 } // namespace
 538
 539 /**
 540  *  Main
 541  */
 542 int TestManualSetupCode()
 543 {
 544     // clang-format off
 545     nlTestSuite theSuite =
 546     {
 547         "chip-manual-code-general-Tests",
 548         &sTests[0],
 549         nullptr,
 550         nullptr
 551     };
 552     // clang-format on
 553     TestContext context;
 554
 555     context.mSuite = &theSuite;
 556
 557     // Generate machine-readable, comma-separated value (CSV) output.
 558     nl_test_set_output_style(OUTPUT_CSV);
 559
 560     // Run Test suit against one context
 561     nlTestRunner(&theSuite, &context);
 562
 563     return nlTestRunnerStats(&theSuite);
 564 }
 565
 566 CHIP_REGISTER_TEST_SUITE(TestManualSetupCode);