/*
 *
 *    Copyright (c) 2020 Project CHIP Authors
 *
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 *
 *        http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */

/**
 *    @file
 *      This file implements a unit test suite for the Quick Response
 *      code functionality.
 *
 */

#include "TestHelpers.h"

#include <nlbyteorder.h>
#include <nlunit-test.h>

#include <lib/support/Span.h>
#include <lib/support/UnitTestContext.h>
#include <lib/support/UnitTestRegistration.h>

using namespace chip;
using namespace std;

namespace {

void TestRendezvousFlags(nlTestSuite * inSuite, void * inContext)
{
    SetupPayload inPayload = GetDefaultPayload();

    // Not having a value in rendezvousInformation is not allowed for a QR code.
    inPayload.rendezvousInformation.SetValue(RendezvousInformationFlag::kNone);
    NL_TEST_ASSERT(inSuite, CheckWriteRead(inPayload));

    inPayload.rendezvousInformation.SetValue(RendezvousInformationFlag::kSoftAP);
    NL_TEST_ASSERT(inSuite, CheckWriteRead(inPayload));

    inPayload.rendezvousInformation.SetValue(RendezvousInformationFlag::kBLE);
    NL_TEST_ASSERT(inSuite, CheckWriteRead(inPayload));

    inPayload.rendezvousInformation.SetValue(RendezvousInformationFlag::kOnNetwork);
    NL_TEST_ASSERT(inSuite, CheckWriteRead(inPayload));

    inPayload.rendezvousInformation.SetValue(
        RendezvousInformationFlags(RendezvousInformationFlag::kSoftAP, RendezvousInformationFlag::kOnNetwork));
    NL_TEST_ASSERT(inSuite, CheckWriteRead(inPayload));

    inPayload.rendezvousInformation.SetValue(
        RendezvousInformationFlags(RendezvousInformationFlag::kBLE, RendezvousInformationFlag::kOnNetwork));
    NL_TEST_ASSERT(inSuite, CheckWriteRead(inPayload));

    inPayload.rendezvousInformation.SetValue(RendezvousInformationFlags(
        RendezvousInformationFlag::kBLE, RendezvousInformationFlag::kSoftAP, RendezvousInformationFlag::kOnNetwork));
    NL_TEST_ASSERT(inSuite, CheckWriteRead(inPayload));
}

void TestCommissioningFlow(nlTestSuite * inSuite, void * inContext)
{
    SetupPayload inPayload = GetDefaultPayload();

    inPayload.commissioningFlow = CommissioningFlow::kStandard;
    NL_TEST_ASSERT(inSuite, CheckWriteRead(inPayload));

    inPayload.commissioningFlow = CommissioningFlow::kUserActionRequired;
    NL_TEST_ASSERT(inSuite, CheckWriteRead(inPayload));

    inPayload.commissioningFlow = CommissioningFlow::kCustom;
    NL_TEST_ASSERT(inSuite, CheckWriteRead(inPayload));
}

void TestMaximumValues(nlTestSuite * inSuite, void * inContext)
{
    SetupPayload inPayload = GetDefaultPayload();

    inPayload.version           = static_cast<uint8_t>((1 << kVersionFieldLengthInBits) - 1);
    inPayload.vendorID          = 0xFFFF;
    inPayload.productID         = 0xFFFF;
    inPayload.commissioningFlow = CommissioningFlow::kCustom;
    inPayload.rendezvousInformation.SetValue(RendezvousInformationFlags(
        RendezvousInformationFlag::kBLE, RendezvousInformationFlag::kSoftAP, RendezvousInformationFlag::kOnNetwork));
    inPayload.discriminator.SetLongValue(static_cast<uint16_t>((1 << kPayloadDiscriminatorFieldLengthInBits) - 1));
    inPayload.setUpPINCode = static_cast<uint32_t>((1 << kSetupPINCodeFieldLengthInBits) - 1);

    NL_TEST_ASSERT(inSuite, CheckWriteRead(inPayload, /* allowInvalidPayload */ true));
}

void TestPayloadByteArrayRep(nlTestSuite * inSuite, void * inContext)
{
    SetupPayload payload = GetDefaultPayload();

    string expected = " 0000 000000000000000100000000000 000010000000 00000001 00 0000000000000001 0000000000001100 000";
    NL_TEST_ASSERT(inSuite, CompareBinary(payload, expected));
}

void TestPayloadBase38Rep(nlTestSuite * inSuite, void * inContext)
{
    SetupPayload payload = GetDefaultPayload();

    QRCodeSetupPayloadGenerator generator(payload);
    string result;
    CHIP_ERROR err  = generator.payloadBase38Representation(result);
    bool didSucceed = err == CHIP_NO_ERROR;
    NL_TEST_ASSERT(inSuite, didSucceed == true);

    NL_TEST_ASSERT(inSuite, result == kDefaultPayloadQRCode);
}

void TestBase38(nlTestSuite * inSuite, void * inContext)
{
    uint8_t input[3] = { 10, 10, 10 };
    char encodedBuf[64];
    MutableByteSpan inputSpan(input);
    MutableCharSpan encodedSpan(encodedBuf);

    // basic stuff
    base38Encode(inputSpan.SubSpan(0, 0), encodedSpan);
    NL_TEST_ASSERT(inSuite, strlen(encodedBuf) == 0);
    encodedSpan = MutableCharSpan(encodedBuf);
    base38Encode(inputSpan.SubSpan(0, 1), encodedSpan);
    NL_TEST_ASSERT(inSuite, strcmp(encodedBuf, "A0") == 0);
    encodedSpan = MutableCharSpan(encodedBuf);
    base38Encode(inputSpan.SubSpan(0, 2), encodedSpan);
    NL_TEST_ASSERT(inSuite, strcmp(encodedBuf, "OT10") == 0);
    encodedSpan = MutableCharSpan(encodedBuf);
    base38Encode(inputSpan, encodedSpan);
    NL_TEST_ASSERT(inSuite, strcmp(encodedBuf, "-N.B0") == 0);

    // test null termination of output buffer
    encodedSpan             = MutableCharSpan(encodedBuf);
    MutableCharSpan subSpan = encodedSpan.SubSpan(0, 2);
    NL_TEST_ASSERT(inSuite, base38Encode(inputSpan.SubSpan(0, 1), subSpan) == CHIP_ERROR_BUFFER_TOO_SMALL);
    // Force no nulls in output buffer
    memset(encodedSpan.data(), '?', encodedSpan.size());
    subSpan = encodedSpan.SubSpan(0, 3);
    base38Encode(inputSpan.SubSpan(0, 1), subSpan);
    size_t encodedLen = strnlen(encodedSpan.data(), ArraySize(encodedBuf));
    NL_TEST_ASSERT(inSuite, encodedLen == strlen("A0"));
    NL_TEST_ASSERT(inSuite, strcmp(encodedBuf, "A0") == 0);

    // passing empty parameters
    MutableCharSpan emptySpan;
    encodedSpan = MutableCharSpan(encodedBuf);
    NL_TEST_ASSERT(inSuite, base38Encode(inputSpan, emptySpan) == CHIP_ERROR_BUFFER_TOO_SMALL);
    base38Encode(MutableByteSpan(), encodedSpan);
    NL_TEST_ASSERT(inSuite, strcmp(encodedBuf, "") == 0);
    NL_TEST_ASSERT(inSuite, base38Encode(MutableByteSpan(), emptySpan) == CHIP_ERROR_BUFFER_TOO_SMALL);

    // test single odd byte corner conditions
    encodedSpan = MutableCharSpan(encodedBuf);
    input[2]    = 0;
    base38Encode(inputSpan, encodedSpan);
    NL_TEST_ASSERT(inSuite, strcmp(encodedBuf, "OT100") == 0);
    input[2]    = 40;
    encodedSpan = MutableCharSpan(encodedBuf);
    base38Encode(inputSpan, encodedSpan);
    NL_TEST_ASSERT(inSuite, strcmp(encodedBuf, "Y6V91") == 0);
    input[2]    = 41;
    encodedSpan = MutableCharSpan(encodedBuf);
    base38Encode(inputSpan, encodedSpan);
    NL_TEST_ASSERT(inSuite, strcmp(encodedBuf, "KL0B1") == 0);
    input[2]    = 255;
    encodedSpan = MutableCharSpan(encodedBuf);
    base38Encode(inputSpan, encodedSpan);
    NL_TEST_ASSERT(inSuite, strcmp(encodedBuf, "Q-M08") == 0);

    // verify chunks of 1,2 and 3 bytes result in fixed-length strings padded with '0'
    // for 1 byte we need always 2 characters
    input[0]    = 35;
    encodedSpan = MutableCharSpan(encodedBuf);
    base38Encode(inputSpan.SubSpan(0, 1), encodedSpan);
    NL_TEST_ASSERT(inSuite, strcmp(encodedBuf, "Z0") == 0);
    // for 2 bytes we need always 4 characters
    input[0]    = 255;
    input[1]    = 0;
    encodedSpan = MutableCharSpan(encodedBuf);
    base38Encode(inputSpan.SubSpan(0, 2), encodedSpan);
    NL_TEST_ASSERT(inSuite, strcmp(encodedBuf, "R600") == 0);
    // for 3 bytes we need always 5 characters
    input[0]    = 46;
    input[1]    = 0;
    input[2]    = 0;
    encodedSpan = MutableCharSpan(encodedBuf);
    base38Encode(inputSpan, encodedSpan);
    NL_TEST_ASSERT(inSuite, strcmp(encodedBuf, "81000") == 0);

    // verify maximum available values for each chunk size to check selecting proper characters number
    // for 1 byte we need 2 characters
    input[0]    = 255;
    encodedSpan = MutableCharSpan(encodedBuf);
    base38Encode(inputSpan.SubSpan(0, 1), encodedSpan);
    NL_TEST_ASSERT(inSuite, strcmp(encodedBuf, "R6") == 0);
    // for 2 bytes we need 4 characters
    input[0]    = 255;
    input[1]    = 255;
    encodedSpan = MutableCharSpan(encodedBuf);
    base38Encode(inputSpan.SubSpan(0, 2), encodedSpan);
    NL_TEST_ASSERT(inSuite, strcmp(encodedBuf, "NE71") == 0);
    // for 3 bytes we need 5 characters
    input[0]    = 255;
    input[1]    = 255;
    input[2]    = 255;
    encodedSpan = MutableCharSpan(encodedBuf);
    base38Encode(inputSpan, encodedSpan);
    NL_TEST_ASSERT(inSuite, strcmp(encodedBuf, "PLS18") == 0);

    // fun with strings
    encodedSpan = MutableCharSpan(encodedBuf);
    base38Encode(ByteSpan((uint8_t *) "Hello World!", sizeof("Hello World!") - 1), encodedSpan);
    NL_TEST_ASSERT(inSuite, strcmp(encodedBuf, "KKHF3W2S013OPM3EJX11") == 0);

    vector<uint8_t> decoded = vector<uint8_t>();
    NL_TEST_ASSERT(inSuite, base38Decode("KKHF3W2S013OPM3EJX11", decoded) == CHIP_NO_ERROR);

    string hello_world;
    for (uint8_t b : decoded)
    {
        hello_world += static_cast<char>(b);
    }
    NL_TEST_ASSERT(inSuite, hello_world == "Hello World!");

    // short input
    NL_TEST_ASSERT(inSuite, base38Decode("A0", decoded) == CHIP_NO_ERROR);
    NL_TEST_ASSERT(inSuite, decoded.size() == 1);
    NL_TEST_ASSERT(inSuite, decoded[0] == 10);

    // empty == empty
    NL_TEST_ASSERT(inSuite, base38Decode("", decoded) == CHIP_NO_ERROR);
    NL_TEST_ASSERT(inSuite, decoded.empty());

    // test invalid characters
    NL_TEST_ASSERT(inSuite, base38Decode("0\001", decoded) == CHIP_ERROR_INVALID_INTEGER_VALUE);
    NL_TEST_ASSERT(inSuite, base38Decode("\0010", decoded) == CHIP_ERROR_INVALID_INTEGER_VALUE);
    NL_TEST_ASSERT(inSuite, base38Decode("[0", decoded) == CHIP_ERROR_INVALID_INTEGER_VALUE);
    NL_TEST_ASSERT(inSuite, base38Decode("0[", decoded) == CHIP_ERROR_INVALID_INTEGER_VALUE);
    NL_TEST_ASSERT(inSuite, base38Decode(" 0", decoded) == CHIP_ERROR_INVALID_INTEGER_VALUE);
    NL_TEST_ASSERT(inSuite, base38Decode("!0", decoded) == CHIP_ERROR_INVALID_INTEGER_VALUE);
    NL_TEST_ASSERT(inSuite, base38Decode("\"0", decoded) == CHIP_ERROR_INVALID_INTEGER_VALUE);
    NL_TEST_ASSERT(inSuite, base38Decode("#0", decoded) == CHIP_ERROR_INVALID_INTEGER_VALUE);
    NL_TEST_ASSERT(inSuite, base38Decode("$0", decoded) == CHIP_ERROR_INVALID_INTEGER_VALUE);
    NL_TEST_ASSERT(inSuite, base38Decode("%0", decoded) == CHIP_ERROR_INVALID_INTEGER_VALUE);
    NL_TEST_ASSERT(inSuite, base38Decode("&0", decoded) == CHIP_ERROR_INVALID_INTEGER_VALUE);
    NL_TEST_ASSERT(inSuite, base38Decode("'0", decoded) == CHIP_ERROR_INVALID_INTEGER_VALUE);
    NL_TEST_ASSERT(inSuite, base38Decode("(0", decoded) == CHIP_ERROR_INVALID_INTEGER_VALUE);
    NL_TEST_ASSERT(inSuite, base38Decode(")0", decoded) == CHIP_ERROR_INVALID_INTEGER_VALUE);
    NL_TEST_ASSERT(inSuite, base38Decode("*0", decoded) == CHIP_ERROR_INVALID_INTEGER_VALUE);
    NL_TEST_ASSERT(inSuite, base38Decode("+0", decoded) == CHIP_ERROR_INVALID_INTEGER_VALUE);
    NL_TEST_ASSERT(inSuite, base38Decode(",0", decoded) == CHIP_ERROR_INVALID_INTEGER_VALUE);
    NL_TEST_ASSERT(inSuite, base38Decode(";0", decoded) == CHIP_ERROR_INVALID_INTEGER_VALUE);
    NL_TEST_ASSERT(inSuite, base38Decode("<0", decoded) == CHIP_ERROR_INVALID_INTEGER_VALUE);
    NL_TEST_ASSERT(inSuite, base38Decode("=0", decoded) == CHIP_ERROR_INVALID_INTEGER_VALUE);
    NL_TEST_ASSERT(inSuite, base38Decode(">0", decoded) == CHIP_ERROR_INVALID_INTEGER_VALUE);
    NL_TEST_ASSERT(inSuite, base38Decode("@0", decoded) == CHIP_ERROR_INVALID_INTEGER_VALUE);

    // test strings that encode maximum values
    NL_TEST_ASSERT(inSuite, base38Decode("R6", decoded) == CHIP_NO_ERROR); // this is 0xFF
    NL_TEST_ASSERT(inSuite, decoded == std::vector<uint8_t>({ 255 }));
    NL_TEST_ASSERT(inSuite, base38Decode("S6", decoded) == CHIP_ERROR_INVALID_ARGUMENT); // trying to encode 0xFF + 1 in 2 chars
    NL_TEST_ASSERT(inSuite, base38Decode("S600", decoded) == CHIP_NO_ERROR);             // this is 0xFF + 1, needs 4 chars
    NL_TEST_ASSERT(inSuite, decoded == std::vector<uint8_t>({ 0, 1 }));
    NL_TEST_ASSERT(inSuite, base38Decode("NE71", decoded) == CHIP_NO_ERROR); // this is 0xFFFF
    NL_TEST_ASSERT(inSuite, decoded == std::vector<uint8_t>({ 255, 255 }));
    NL_TEST_ASSERT(inSuite, base38Decode("OE71", decoded) == CHIP_ERROR_INVALID_ARGUMENT); // trying to encode 0xFFFF + 1 in 4 chars
    NL_TEST_ASSERT(inSuite, base38Decode("OE710", decoded) == CHIP_NO_ERROR);              // this is 0xFFFF + 1, needs 5 chars
    NL_TEST_ASSERT(inSuite, decoded == std::vector<uint8_t>({ 0, 0, 1 }));
    NL_TEST_ASSERT(inSuite, base38Decode("PLS18", decoded) == CHIP_NO_ERROR); // this is 0xFFFFFF
    NL_TEST_ASSERT(inSuite, decoded == std::vector<uint8_t>({ 255, 255, 255 }));
    NL_TEST_ASSERT(inSuite, base38Decode("QLS18", decoded) == CHIP_ERROR_INVALID_ARGUMENT); // trying to encode 0xFFFFFF + 1
}

void TestBitsetLen(nlTestSuite * inSuite, void * inContext)
{
    NL_TEST_ASSERT(inSuite, kTotalPayloadDataSizeInBits % 8 == 0);
}

void TestSetupPayloadVerify(nlTestSuite * inSuite, void * inContext)
{
    SetupPayload payload = GetDefaultPayload();
    NL_TEST_ASSERT(inSuite, payload.isValidQRCodePayload() == true);

    // test invalid commissioning flow
    SetupPayload test_payload      = payload;
    test_payload.commissioningFlow = CommissioningFlow::kCustom;
    NL_TEST_ASSERT(inSuite, test_payload.isValidQRCodePayload());

    test_payload.commissioningFlow = static_cast<CommissioningFlow>(1 << kCommissioningFlowFieldLengthInBits);
    NL_TEST_ASSERT(inSuite, test_payload.isValidQRCodePayload() == false);

    // test invalid version
    test_payload         = payload;
    test_payload.version = 1 << kVersionFieldLengthInBits;
    NL_TEST_ASSERT(inSuite, test_payload.isValidQRCodePayload() == false);

    // test invalid rendezvousInformation
    test_payload                       = payload;
    RendezvousInformationFlags invalid = RendezvousInformationFlags(
        RendezvousInformationFlag::kBLE, RendezvousInformationFlag::kSoftAP, RendezvousInformationFlag::kOnNetwork);
    invalid.SetRaw(static_cast<uint8_t>(invalid.Raw() + 1));
    test_payload.rendezvousInformation.SetValue(invalid);
    NL_TEST_ASSERT(inSuite, test_payload.isValidQRCodePayload() == false);

    // test invalid setup PIN
    test_payload              = payload;
    test_payload.setUpPINCode = 1 << kSetupPINCodeFieldLengthInBits;
    NL_TEST_ASSERT(inSuite, test_payload.isValidQRCodePayload() == false);
}

void TestInvalidQRCodePayload_WrongCharacterSet(nlTestSuite * inSuite, void * inContext)
{
    string invalidString = kDefaultPayloadQRCode;
    invalidString.back() = ' '; // space is not contained in the base38 alphabet

    QRCodeSetupPayloadParser parser = QRCodeSetupPayloadParser(invalidString);
    SetupPayload payload;
    CHIP_ERROR err = parser.populatePayload(payload);
    bool didFail   = err != CHIP_NO_ERROR;
    NL_TEST_ASSERT(inSuite, didFail == true);
    NL_TEST_ASSERT(inSuite, payload.isValidQRCodePayload() == false);
}

void TestInvalidQRCodePayload_WrongLength(nlTestSuite * inSuite, void * inContext)
{
    string invalidString = kDefaultPayloadQRCode;
    invalidString.pop_back();

    QRCodeSetupPayloadParser parser = QRCodeSetupPayloadParser(invalidString);
    SetupPayload payload;
    CHIP_ERROR err = parser.populatePayload(payload);
    bool didFail   = err != CHIP_NO_ERROR;
    NL_TEST_ASSERT(inSuite, didFail == true);
    NL_TEST_ASSERT(inSuite, payload.isValidQRCodePayload() == false);
}

void TestPayloadEquality(nlTestSuite * inSuite, void * inContext)
{
    SetupPayload payload      = GetDefaultPayload();
    SetupPayload equalPayload = GetDefaultPayload();

    NL_TEST_ASSERT(inSuite, payload == equalPayload);
}

void TestPayloadInEquality(nlTestSuite * inSuite, void * inContext)
{
    SetupPayload payload = GetDefaultPayload();

    SetupPayload unequalPayload = GetDefaultPayload();
    unequalPayload.discriminator.SetLongValue(28);
    unequalPayload.setUpPINCode = 121233;

    NL_TEST_ASSERT(inSuite, !(payload == unequalPayload));
}

void TestQRCodeToPayloadGeneration(nlTestSuite * inSuite, void * inContext)
{
    SetupPayload payload = GetDefaultPayload();

    QRCodeSetupPayloadGenerator generator(payload);
    string base38Rep;
    CHIP_ERROR err  = generator.payloadBase38Representation(base38Rep);
    bool didSucceed = err == CHIP_NO_ERROR;
    NL_TEST_ASSERT(inSuite, didSucceed == true);

    SetupPayload resultingPayload;
    QRCodeSetupPayloadParser parser(base38Rep);

    err        = parser.populatePayload(resultingPayload);
    didSucceed = err == CHIP_NO_ERROR;
    NL_TEST_ASSERT(inSuite, didSucceed == true);
    NL_TEST_ASSERT(inSuite, resultingPayload.isValidQRCodePayload() == true);

    bool result = payload == resultingPayload;
    NL_TEST_ASSERT(inSuite, result == true);
}

void TestExtractPayload(nlTestSuite * inSuite, void * inContext)
{
    NL_TEST_ASSERT(inSuite, QRCodeSetupPayloadParser::ExtractPayload(string("MT:ABC")) == string("ABC"));
    NL_TEST_ASSERT(inSuite, QRCodeSetupPayloadParser::ExtractPayload(string("MT:")) == string(""));
    NL_TEST_ASSERT(inSuite, QRCodeSetupPayloadParser::ExtractPayload(string("H:")) == string(""));
    NL_TEST_ASSERT(inSuite, QRCodeSetupPayloadParser::ExtractPayload(string("ASMT:")) == string(""));
    NL_TEST_ASSERT(inSuite, QRCodeSetupPayloadParser::ExtractPayload(string("Z%MT:ABC%")) == string("ABC"));
    NL_TEST_ASSERT(inSuite, QRCodeSetupPayloadParser::ExtractPayload(string("Z%MT:ABC")) == string("ABC"));
    NL_TEST_ASSERT(inSuite, QRCodeSetupPayloadParser::ExtractPayload(string("%Z%MT:ABC")) == string("ABC"));
    NL_TEST_ASSERT(inSuite, QRCodeSetupPayloadParser::ExtractPayload(string("%Z%MT:ABC%")) == string("ABC"));
    NL_TEST_ASSERT(inSuite, QRCodeSetupPayloadParser::ExtractPayload(string("%Z%MT:ABC%DDD")) == string("ABC"));
    NL_TEST_ASSERT(inSuite, QRCodeSetupPayloadParser::ExtractPayload(string("MT:ABC%DDD")) == string("ABC"));
    NL_TEST_ASSERT(inSuite, QRCodeSetupPayloadParser::ExtractPayload(string("MT:ABC%")) == string("ABC"));
    NL_TEST_ASSERT(inSuite, QRCodeSetupPayloadParser::ExtractPayload(string("%MT:")) == string(""));
    NL_TEST_ASSERT(inSuite, QRCodeSetupPayloadParser::ExtractPayload(string("%MT:%")) == string(""));
    NL_TEST_ASSERT(inSuite, QRCodeSetupPayloadParser::ExtractPayload(string("A%")) == string(""));
    NL_TEST_ASSERT(inSuite, QRCodeSetupPayloadParser::ExtractPayload(string("MT:%")) == string(""));
    NL_TEST_ASSERT(inSuite, QRCodeSetupPayloadParser::ExtractPayload(string("%MT:ABC")) == string("ABC"));
    NL_TEST_ASSERT(inSuite, QRCodeSetupPayloadParser::ExtractPayload(string("ABC")) == string(""));
}

// Test Suite

/**
 *  Test Suite that lists all the test functions.
 */
// clang-format off
const nlTest sTests[] =
{
    NL_TEST_DEF("Test Rendezvous Flags",                                            TestRendezvousFlags),
    NL_TEST_DEF("Test Commissioning Flow",                                          TestCommissioningFlow),
    NL_TEST_DEF("Test Maximum Values",                                              TestMaximumValues),
    NL_TEST_DEF("Test Base 38",                                                     TestBase38),
    NL_TEST_DEF("Test Bitset Length",                                               TestBitsetLen),
    NL_TEST_DEF("Test Payload Byte Array Representation",                           TestPayloadByteArrayRep),
    NL_TEST_DEF("Test Payload Base 38 Representation",                              TestPayloadBase38Rep),
    NL_TEST_DEF("Test Setup Payload Verify",                                        TestSetupPayloadVerify),
    NL_TEST_DEF("Test Payload Equality",                                            TestPayloadEquality),
    NL_TEST_DEF("Test Payload Inequality",                                          TestPayloadInEquality),
    NL_TEST_DEF("Test QRCode to Payload Generation",                                TestQRCodeToPayloadGeneration),
    NL_TEST_DEF("Test Invalid QR Code Payload - Wrong Character Set",               TestInvalidQRCodePayload_WrongCharacterSet),
    NL_TEST_DEF("Test Invalid QR Code Payload - Wrong  Length",                     TestInvalidQRCodePayload_WrongLength),
    NL_TEST_DEF("Test Extract Payload",                                             TestExtractPayload),

    NL_TEST_SENTINEL()
};
// clang-format on

} // namespace

/**
 *  Main
 */
int TestQuickResponseCode()
{
    // clang-format off
    nlTestSuite theSuite =
    {
        "chip-qrcode-general-tests",
        &sTests[0],
        nullptr,
        nullptr
    };
    // clang-format on

    // Generate machine-readable, comma-separated value (CSV) output.
    nl_test_set_output_style(OUTPUT_CSV);

    return chip::ExecuteTestsWithoutContext(&theSuite);
}

CHIP_REGISTER_TEST_SUITE(TestQuickResponseCode);