src/setup_payload/tests/TestQRCodeTLV.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 #include "TestHelpers.h"
  18
  19 #include <nlbyteorder.h>
  20 #include <nlunit-test.h>
  21
  22 #include <support/UnitTestRegistration.h>
  23
  24 using namespace chip;
  25 using namespace std;
  26
  27 namespace {
  28
  29 void TestOptionalDataAddRemove(nlTestSuite * inSuite, void * inContext)
  30 {
  31     SetupPayload payload = GetDefaultPayload();
  32     vector<OptionalQRCodeInfo> optionalData;
  33     CHIP_ERROR err;
  34
  35     optionalData = payload.getAllOptionalVendorData();
  36     NL_TEST_ASSERT(inSuite, optionalData.empty());
  37
  38     err = payload.addOptionalVendorData(kOptionalDefaultStringTag, kOptionalDefaultStringValue);
  39     NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
  40
  41     optionalData = payload.getAllOptionalVendorData();
  42     NL_TEST_ASSERT(inSuite, optionalData.size() == 1);
  43
  44     err = payload.addOptionalVendorData(kOptionalDefaultIntTag, kOptionalDefaultIntValue);
  45     NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
  46
  47     optionalData = payload.getAllOptionalVendorData();
  48     NL_TEST_ASSERT(inSuite, optionalData.size() == 2);
  49
  50     err = payload.removeOptionalVendorData(kOptionalDefaultStringTag);
  51     NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
  52
  53     optionalData = payload.getAllOptionalVendorData();
  54     NL_TEST_ASSERT(inSuite, optionalData.size() == 1);
  55
  56     payload.removeOptionalVendorData(kOptionalDefaultIntTag);
  57     NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
  58
  59     optionalData = payload.getAllOptionalVendorData();
  60     NL_TEST_ASSERT(inSuite, optionalData.empty());
  61
  62     err = payload.removeOptionalVendorData(kOptionalDefaultStringTag);
  63     NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_KEY_NOT_FOUND);
  64
  65     optionalData = payload.getAllOptionalVendorData();
  66     NL_TEST_ASSERT(inSuite, optionalData.empty());
  67
  68     err = payload.removeOptionalVendorData(kOptionalDefaultIntTag);
  69     NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_KEY_NOT_FOUND);
  70
  71     optionalData = payload.getAllOptionalVendorData();
  72     NL_TEST_ASSERT(inSuite, optionalData.empty());
  73 }
  74
  75 void TestSimpleWrite(nlTestSuite * inSuite, void * inContext)
  76 {
  77     SetupPayload inPayload = GetDefaultPayload();
  78
  79     QRCodeSetupPayloadGenerator generator(inPayload);
  80     string result;
  81     CHIP_ERROR err = generator.payloadBase41Representation(result);
  82     NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
  83 }
  84
  85 void TestSimpleRead(nlTestSuite * inSuite, void * inContext)
  86 {
  87     SetupPayload inPayload = GetDefaultPayload();
  88     SetupPayload outPayload;
  89
  90     QRCodeSetupPayloadGenerator generator(inPayload);
  91     string result;
  92     CHIP_ERROR err = generator.payloadBase41Representation(result);
  93     NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
  94
  95     QRCodeSetupPayloadParser parser = QRCodeSetupPayloadParser(result);
  96     err                             = parser.populatePayload(outPayload);
  97     NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
  98
  99     NL_TEST_ASSERT(inSuite, inPayload == outPayload);
 100 }
 101
 102 void TestOptionalTagValues(nlTestSuite * inSuite, void * inContext)
 103 {
 104     SetupPayload payload = GetDefaultPayload();
 105     CHIP_ERROR err;
 106
 107     err = payload.addOptionalVendorData(kOptionalDefaultStringTag, kOptionalDefaultStringValue);
 108     NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
 109
 110     err = payload.addOptionalVendorData(0, kOptionalDefaultStringValue);
 111     NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
 112
 113     err = payload.addOptionalVendorData(127, kOptionalDefaultStringValue);
 114     NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
 115
 116     err = payload.addOptionalVendorData(128, kOptionalDefaultStringValue);
 117     NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_INVALID_ARGUMENT);
 118
 119     err = payload.addOptionalVendorData(255, kOptionalDefaultStringValue);
 120     NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_INVALID_ARGUMENT);
 121 }
 122
 123 void TestSerialNumberAddRemove(nlTestSuite * inSuite, void * inContext)
 124 {
 125     SetupPayload inPayload = GetDefaultPayload();
 126
 127     string sn;
 128     NL_TEST_ASSERT(inSuite, inPayload.getSerialNumber(sn) == CHIP_ERROR_KEY_NOT_FOUND);
 129     NL_TEST_ASSERT(inSuite, inPayload.removeSerialNumber() == CHIP_ERROR_KEY_NOT_FOUND);
 130
 131     NL_TEST_ASSERT(inSuite, inPayload.addSerialNumber(kSerialNumberDefaultStringValue) == CHIP_NO_ERROR);
 132     NL_TEST_ASSERT(inSuite, inPayload.getSerialNumber(sn) == CHIP_NO_ERROR);
 133     NL_TEST_ASSERT(inSuite, sn == kSerialNumberDefaultStringValue);
 134
 135     NL_TEST_ASSERT(inSuite, inPayload.addSerialNumber(kSerialNumberDefaultUInt32Value) == CHIP_NO_ERROR);
 136     NL_TEST_ASSERT(inSuite, inPayload.getSerialNumber(sn) == CHIP_NO_ERROR);
 137     NL_TEST_ASSERT(inSuite, sn == to_string(kSerialNumberDefaultUInt32Value));
 138
 139     NL_TEST_ASSERT(inSuite, inPayload.removeSerialNumber() == CHIP_NO_ERROR);
 140     NL_TEST_ASSERT(inSuite, inPayload.getSerialNumber(sn) == CHIP_ERROR_KEY_NOT_FOUND);
 141     NL_TEST_ASSERT(inSuite, inPayload.removeSerialNumber() == CHIP_ERROR_KEY_NOT_FOUND);
 142 }
 143
 144 void TestOptionalDataWriteSerial(nlTestSuite * inSuite, void * inContext)
 145 {
 146     CHIP_ERROR err         = CHIP_NO_ERROR;
 147     SetupPayload inPayload = GetDefaultPayload();
 148     err                    = inPayload.addSerialNumber("1");
 149     NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
 150
 151     QRCodeSetupPayloadGenerator generator(inPayload);
 152     string result;
 153     err = generator.payloadBase41Representation(result);
 154     NL_TEST_ASSERT(inSuite, err != CHIP_NO_ERROR);
 155
 156     uint8_t optionalInfo[kDefaultBufferSizeInBytes];
 157     err = generator.payloadBase41Representation(result, optionalInfo, sizeof(optionalInfo));
 158     NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
 159 }
 160
 161 void TestOptionalDataWrite(nlTestSuite * inSuite, void * inContext)
 162 {
 163     SetupPayload inPayload = GetDefaultPayloadWithOptionalDefaults();
 164
 165     QRCodeSetupPayloadGenerator generator(inPayload);
 166     string result;
 167     uint8_t optionalInfo[kDefaultBufferSizeInBytes];
 168     CHIP_ERROR err = generator.payloadBase41Representation(result, optionalInfo, sizeof(optionalInfo));
 169     NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
 170 }
 171
 172 void TestOptionalDataReadSerial(nlTestSuite * inSuite, void * inContext)
 173 {
 174     SetupPayload inPayload = GetDefaultPayload();
 175
 176     inPayload.addSerialNumber(kSerialNumberDefaultStringValue);
 177     NL_TEST_ASSERT(inSuite, CheckWriteRead(inPayload));
 178
 179     inPayload.addSerialNumber(kSerialNumberDefaultUInt32Value);
 180     NL_TEST_ASSERT(inSuite, CheckWriteRead(inPayload));
 181 }
 182
 183 void TestOptionalDataReadVendorInt(nlTestSuite * inSuite, void * inContext)
 184 {
 185     SetupPayload inPayload = GetDefaultPayload();
 186     inPayload.addOptionalVendorData(kOptionalDefaultIntTag, kOptionalDefaultIntValue);
 187
 188     NL_TEST_ASSERT(inSuite, CheckWriteRead(inPayload));
 189 }
 190
 191 void TestOptionalDataReadVendorString(nlTestSuite * inSuite, void * inContext)
 192 {
 193     SetupPayload inPayload = GetDefaultPayload();
 194     inPayload.addOptionalVendorData(kOptionalDefaultStringTag, kOptionalDefaultStringValue);
 195
 196     NL_TEST_ASSERT(inSuite, CheckWriteRead(inPayload));
 197 }
 198
 199 void TestOptionalDataRead(nlTestSuite * inSuite, void * inContext)
 200 {
 201     SetupPayload inPayload = GetDefaultPayloadWithOptionalDefaults();
 202
 203     NL_TEST_ASSERT(inSuite, CheckWriteRead(inPayload));
 204 }
 205
 206 void TestOptionalDataWriteNoBuffer(nlTestSuite * inSuite, void * inContext)
 207 {
 208     SetupPayload inPayload = GetDefaultPayloadWithOptionalDefaults();
 209
 210     QRCodeSetupPayloadGenerator generator(inPayload);
 211     string result;
 212     CHIP_ERROR err = generator.payloadBase41Representation(result);
 213     NL_TEST_ASSERT(inSuite, err != CHIP_NO_ERROR);
 214 }
 215
 216 void TestOptionalDataWriteSmallBuffer(nlTestSuite * inSuite, void * inContext)
 217 {
 218     SetupPayload inPayload = GetDefaultPayloadWithOptionalDefaults();
 219
 220     QRCodeSetupPayloadGenerator generator(inPayload);
 221     string result;
 222     uint8_t optionalInfo[kSmallBufferSizeInBytes];
 223     CHIP_ERROR err = generator.payloadBase41Representation(result, optionalInfo, sizeof(optionalInfo));
 224     NL_TEST_ASSERT(inSuite, err != CHIP_NO_ERROR);
 225 }
 226
 227 // Test Suite
 228
 229 /**
 230  *  Test Suite that lists all the test functions.
 231  */
 232 // clang-format off
 233 const nlTest sTests[] =
 234 {
 235     NL_TEST_DEF("Test Simple Write",                TestSimpleWrite),
 236     NL_TEST_DEF("Test Simple Read",                 TestSimpleRead),
 237     NL_TEST_DEF("Test Optional Add Remove",         TestOptionalDataAddRemove),
 238     NL_TEST_DEF("Test Serial Number Add Remove",    TestSerialNumberAddRemove),
 239     NL_TEST_DEF("Test Optional Write",              TestOptionalDataWrite),
 240     NL_TEST_DEF("Test Optional Write Serial",       TestOptionalDataWriteSerial),
 241     NL_TEST_DEF("Test Optional Write No Buffer",    TestOptionalDataWriteNoBuffer),
 242     NL_TEST_DEF("Test Optional Write Small Buffer", TestOptionalDataWriteSmallBuffer),
 243     NL_TEST_DEF("Test Optional Read Serial",        TestOptionalDataReadSerial),
 244     NL_TEST_DEF("Test Optional Read Vendor String", TestOptionalDataReadVendorString),
 245     NL_TEST_DEF("Test Optional Read Vendor Int",    TestOptionalDataReadVendorInt),
 246     NL_TEST_DEF("Test Optional Read",               TestOptionalDataRead),
 247     NL_TEST_DEF("Test Optional Tag Values",         TestOptionalTagValues),
 248
 249     NL_TEST_SENTINEL()
 250 };
 251 // clang-format on
 252
 253 struct TestContext
 254 {
 255     nlTestSuite * mSuite;
 256 };
 257
 258 /**
 259  *  Set up the test suite.
 260  */
 261 int TestQRCodeTLV_Setup(void * inContext)
 262 {
 263     CHIP_ERROR error = chip::Platform::MemoryInit();
 264     if (error != CHIP_NO_ERROR)
 265         return FAILURE;
 266     return SUCCESS;
 267 }
 268
 269 /**
 270  *  Tear down the test suite.
 271  */
 272 int TestQRCodeTLV_Teardown(void * inContext)
 273 {
 274     chip::Platform::MemoryShutdown();
 275     return SUCCESS;
 276 }
 277
 278 } // namespace
 279
 280 /**
 281  *  Main
 282  */
 283 int TestQRCodeTLV()
 284 {
 285     // clang-format off
 286     nlTestSuite theSuite =
 287     {
 288         "chip-qrcode-optional-info-tests",
 289         &sTests[0],
 290         TestQRCodeTLV_Setup,
 291         TestQRCodeTLV_Teardown
 292     };
 293     // clang-format on
 294     TestContext context;
 295
 296     context.mSuite = &theSuite;
 297
 298     // Generate machine-readable, comma-separated value (CSV) output.
 299     nl_test_set_output_style(OUTPUT_CSV);
 300
 301     // Run test suit against one context
 302     nlTestRunner(&theSuite, &context);
 303
 304     return nlTestRunnerStats(&theSuite);
 305 }
 306
 307 CHIP_REGISTER_TEST_SUITE(TestQRCodeTLV);