/*
 *
 *    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 manual setup
 *      code functionality.
 *
 */

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

#include <setup_payload/ManualSetupPayloadGenerator.h>
#include <setup_payload/ManualSetupPayloadParser.h>
#include <setup_payload/SetupPayload.h>

#include <lib/support/UnitTestContext.h>
#include <lib/support/UnitTestRegistration.h>
#include <lib/support/verhoeff/Verhoeff.h>

#include <algorithm>
#include <math.h>
#include <string>

using namespace chip;

namespace {

bool CheckGenerator(const PayloadContents & payload, std::string expectedResult, bool allowInvalidPayload = false)
{
    std::string result;
    ManualSetupPayloadGenerator generator(payload);
    generator.SetAllowInvalidPayload(allowInvalidPayload);

    CHIP_ERROR err = generator.payloadDecimalStringRepresentation(result);

    if (err != CHIP_NO_ERROR)
    {
        printf("Failed to generate decimal representation with error: %s\n", ErrorStr(err));
        return false;
    }

    if (!expectedResult.empty())
    {
        expectedResult += Verhoeff10::ComputeCheckChar(expectedResult.c_str());
    }

    bool same = result == expectedResult;
    if (!same)
    {
        printf("Actual result: %s\n", result.c_str());
        printf("Expected result: %s\n", expectedResult.c_str());
    }

    return same;
}

PayloadContents GetDefaultPayload()
{
    PayloadContents payload;
    payload.setUpPINCode = 12345679;
    payload.discriminator.SetLongValue(2560);

    return payload;
}

void TestDecimalRepresentation_PartialPayload(nlTestSuite * inSuite, void * inContext)
{
    PayloadContents payload = GetDefaultPayload();

    std::string expectedResult = "2412950753";

    NL_TEST_ASSERT(inSuite, CheckGenerator(payload, expectedResult));
}

void TestDecimalRepresentation_PartialPayload_RequiresCustomFlow(nlTestSuite * inSuite, void * inContext)
{
    PayloadContents payload   = GetDefaultPayload();
    payload.commissioningFlow = CommissioningFlow::kCustom;

    std::string expectedResult = "64129507530000000000";

    NL_TEST_ASSERT(inSuite, CheckGenerator(payload, expectedResult));
}

void TestDecimalRepresentation_FullPayloadWithZeros(nlTestSuite * inSuite, void * inContext)
{
    PayloadContents payload   = GetDefaultPayload();
    payload.commissioningFlow = CommissioningFlow::kCustom;
    payload.vendorID          = 1;
    payload.productID         = 1;

    std::string expectedResult = "64129507530000100001";

    NL_TEST_ASSERT(inSuite, CheckGenerator(payload, expectedResult));
}

void TestDecimalRepresentation_FullPayloadWithoutZeros_DoesNotRequireCustomFlow(nlTestSuite * inSuite, void * inContext)
{
    PayloadContents payload = GetDefaultPayload();
    payload.vendorID        = 45367;
    payload.productID       = 14526;

    std::string expectedResult = "2412950753";

    NL_TEST_ASSERT(inSuite, CheckGenerator(payload, expectedResult));
}

void TestDecimalRepresentation_FullPayloadWithoutZeros(nlTestSuite * inSuite, void * inContext)
{
    PayloadContents payload   = GetDefaultPayload();
    payload.commissioningFlow = CommissioningFlow::kCustom;
    payload.vendorID          = 45367;
    payload.productID         = 14526;

    std::string expectedResult = "64129507534536714526";

    NL_TEST_ASSERT(inSuite, CheckGenerator(payload, expectedResult));
}

void assertPayloadValues(nlTestSuite * inSuite, CHIP_ERROR actualError, CHIP_ERROR expectedError, const PayloadContents & payload,
                         uint32_t pinCode, const SetupDiscriminator & discriminator, uint16_t vendorID, uint16_t productID)
{
    NL_TEST_ASSERT(inSuite, actualError == expectedError);
    NL_TEST_ASSERT(inSuite, payload.setUpPINCode == pinCode);
    NL_TEST_ASSERT(inSuite, payload.discriminator == discriminator);
    NL_TEST_ASSERT(inSuite, payload.vendorID == vendorID);
    NL_TEST_ASSERT(inSuite, payload.productID == productID);
}

void TestGenerateAndParser_ManualSetupCodeWithLongDiscriminator(nlTestSuite * inSuite, void * inContext)
{
    PayloadContents payload = GetDefaultPayload();
    payload.discriminator.SetLongValue(0xa1f);

    {
        // Test short 11 digit code
        ManualSetupPayloadGenerator generator(payload);
        std::string result;
        NL_TEST_ASSERT(inSuite, generator.payloadDecimalStringRepresentation(result) == CHIP_NO_ERROR);

        SetupPayload outPayload;
        CHIP_ERROR err = ManualSetupPayloadParser(result).populatePayload(outPayload);
        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);

        SetupDiscriminator discriminator;
        discriminator.SetShortValue(0xa);
        assertPayloadValues(inSuite, err, CHIP_NO_ERROR, outPayload, payload.setUpPINCode, discriminator, payload.vendorID,
                            payload.productID);
    }

    payload.vendorID          = 1;
    payload.productID         = 1;
    payload.commissioningFlow = CommissioningFlow::kCustom;
    payload.discriminator.SetLongValue(0xb1f);

    {
        // Test long 21 digit code
        ManualSetupPayloadGenerator generator(payload);
        std::string result;
        NL_TEST_ASSERT(inSuite, generator.payloadDecimalStringRepresentation(result) == CHIP_NO_ERROR);

        SetupPayload outPayload;
        CHIP_ERROR err = ManualSetupPayloadParser(result).populatePayload(outPayload);
        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);

        SetupDiscriminator discriminator;
        discriminator.SetShortValue(0xb);
        assertPayloadValues(inSuite, err, CHIP_NO_ERROR, outPayload, payload.setUpPINCode, discriminator, payload.vendorID,
                            payload.productID);
    }
}

void TestDecimalRepresentation_AllZeros(nlTestSuite * inSuite, void * inContext)
{
    PayloadContents payload;
    payload.setUpPINCode = 0;
    payload.discriminator.SetLongValue(0);

    std::string expectedResult;

    NL_TEST_ASSERT(inSuite, CheckGenerator(payload, expectedResult) == false);
}

void TestDecimalRepresentation_AllOnes(nlTestSuite * inSuite, void * inContext)
{
    PayloadContents payload;
    payload.setUpPINCode = 0x7FFFFFF;
    payload.discriminator.SetLongValue(0xFFF);
    payload.commissioningFlow = CommissioningFlow::kCustom;
    payload.vendorID          = 65535;
    payload.productID         = 65535;

    std::string expectedResult = "76553581916553565535";

    NL_TEST_ASSERT(inSuite, CheckGenerator(payload, expectedResult, /*allowInvalidPayload*/ true));
}

char ComputeCheckChar(const std::string & str)
{
    // Strip out dashes, if any, from the string before computing the checksum.
    std::string copy(str);
    copy.erase(std::remove(copy.begin(), copy.end(), '-'), copy.end());
    return Verhoeff10::ComputeCheckChar(copy.c_str());
}

void TestPayloadParser_FullPayload(nlTestSuite * inSuite, void * inContext)
{
    SetupPayload payload;
    std::string decimalString;

    decimalString = "63610875354536714526";
    decimalString += Verhoeff10::ComputeCheckChar(decimalString.c_str());
    CHIP_ERROR err = ManualSetupPayloadParser(decimalString).populatePayload(payload);
    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);

    SetupDiscriminator discriminator;
    discriminator.SetShortValue(0xa);
    assertPayloadValues(inSuite, err, CHIP_NO_ERROR, payload, 123456780, discriminator, 45367, 14526);

    // The same thing, but with dashes separating digit groups.
    decimalString = "6361-0875-3545-3671-4526";
    decimalString += ComputeCheckChar(decimalString);
    err = ManualSetupPayloadParser(decimalString).populatePayload(payload);
    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);

    discriminator.SetShortValue(0xa);
    assertPayloadValues(inSuite, err, CHIP_NO_ERROR, payload, 123456780, discriminator, 45367, 14526);

    decimalString = "52927623630456200032";
    decimalString += Verhoeff10::ComputeCheckChar(decimalString.c_str());
    err = ManualSetupPayloadParser(decimalString).populatePayload(payload);
    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);

    discriminator.SetShortValue(0x5);
    assertPayloadValues(inSuite, err, CHIP_NO_ERROR, payload, 38728284, discriminator, 4562, 32);

    decimalString = "40000100000000100001";
    decimalString += Verhoeff10::ComputeCheckChar(decimalString.c_str());
    err = ManualSetupPayloadParser(decimalString).populatePayload(payload);
    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);

    discriminator.SetShortValue(0);
    assertPayloadValues(inSuite, err, CHIP_NO_ERROR, payload, 1, discriminator, 1, 1);
}

void TestGenerateAndParser_FullPayload(nlTestSuite * inSuite, void * inContext)
{
    PayloadContents payload   = GetDefaultPayload();
    payload.vendorID          = 1;
    payload.productID         = 1;
    payload.commissioningFlow = CommissioningFlow::kCustom;

    ManualSetupPayloadGenerator generator(payload);
    std::string result;
    NL_TEST_ASSERT(inSuite, generator.payloadDecimalStringRepresentation(result) == CHIP_NO_ERROR);

    SetupPayload outPayload;
    CHIP_ERROR err = ManualSetupPayloadParser(result).populatePayload(outPayload);
    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);

    SetupDiscriminator discriminator;
    discriminator.SetShortValue(payload.discriminator.GetShortValue());
    assertPayloadValues(inSuite, err, CHIP_NO_ERROR, outPayload, payload.setUpPINCode, discriminator, payload.vendorID,
                        payload.productID);
}

void TestGenerateAndParser_PartialPayload(nlTestSuite * inSuite, void * inContext)
{
    PayloadContents payload = GetDefaultPayload();

    ManualSetupPayloadGenerator generator(payload);
    std::string result;
    NL_TEST_ASSERT(inSuite, generator.payloadDecimalStringRepresentation(result) == CHIP_NO_ERROR);

    SetupPayload outPayload;
    CHIP_ERROR err = ManualSetupPayloadParser(result).populatePayload(outPayload);
    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);

    SetupDiscriminator discriminator;
    discriminator.SetShortValue(payload.discriminator.GetShortValue());
    assertPayloadValues(inSuite, err, CHIP_NO_ERROR, outPayload, payload.setUpPINCode, discriminator, payload.vendorID,
                        payload.productID);
}

void TestPayloadParser_PartialPayload(nlTestSuite * inSuite, void * inContext)
{
    CHIP_ERROR err;
    SetupPayload payload;
    std::string decimalString;

    decimalString = "2361087535";
    decimalString += Verhoeff10::ComputeCheckChar(decimalString.c_str());
    NL_TEST_ASSERT(inSuite, decimalString.length() == 11);
    err = ManualSetupPayloadParser(decimalString).populatePayload(payload);
    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);

    SetupDiscriminator discriminator;
    discriminator.SetShortValue(0xa);
    assertPayloadValues(inSuite, err, CHIP_NO_ERROR, payload, 123456780, discriminator, 0, 0);

    // The same thing, but with dashes separating digit groups.
    decimalString = "236-108753-5";
    decimalString += ComputeCheckChar(decimalString);
    NL_TEST_ASSERT(inSuite, decimalString.length() == 13);
    err = ManualSetupPayloadParser(decimalString).populatePayload(payload);
    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);

    discriminator.SetShortValue(0xa);
    assertPayloadValues(inSuite, err, CHIP_NO_ERROR, payload, 123456780, discriminator, 0, 0);

    decimalString = "0000010000";
    decimalString += Verhoeff10::ComputeCheckChar(decimalString.c_str());
    NL_TEST_ASSERT(inSuite, decimalString.length() == 11);
    err = ManualSetupPayloadParser(decimalString).populatePayload(payload);
    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);

    discriminator.SetShortValue(0);
    assertPayloadValues(inSuite, err, CHIP_NO_ERROR, payload, 1, discriminator, 0, 0);

    decimalString = "63610875350000000000";
    decimalString += Verhoeff10::ComputeCheckChar(decimalString.c_str());
    NL_TEST_ASSERT(inSuite, decimalString.length() == 21);
    err = ManualSetupPayloadParser(decimalString).populatePayload(payload);
    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);

    discriminator.SetShortValue(0xa);
    assertPayloadValues(inSuite, err, CHIP_NO_ERROR, payload, 123456780, discriminator, 0, 0);

    // no discriminator (= 0)
    decimalString = "0033407535";
    decimalString += Verhoeff10::ComputeCheckChar(decimalString.c_str());
    NL_TEST_ASSERT(inSuite, decimalString.length() == 11);
    err = ManualSetupPayloadParser(decimalString).populatePayload(payload);
    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);

    // no vid (= 0)
    decimalString = "63610875350000014526";
    decimalString += Verhoeff10::ComputeCheckChar(decimalString.c_str());
    NL_TEST_ASSERT(inSuite, decimalString.length() == 21);
    err = ManualSetupPayloadParser(decimalString).populatePayload(payload);
    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);

    // no pid (= 0)
    decimalString = "63610875354536700000";
    decimalString += Verhoeff10::ComputeCheckChar(decimalString.c_str());
    NL_TEST_ASSERT(inSuite, decimalString.length() == 21);
    err = ManualSetupPayloadParser(decimalString).populatePayload(payload);
    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
}

void TestShortCodeReadWrite(nlTestSuite * inSuite, void * context)
{
    PayloadContents inPayload = GetDefaultPayload();

    SetupPayload outPayload;

    std::string result;
    ManualSetupPayloadGenerator generator(inPayload);
    generator.payloadDecimalStringRepresentation(result);
    ManualSetupPayloadParser(result).populatePayload(outPayload);

    // Override the discriminator in the input payload with the short version,
    // since that's what we will produce.
    inPayload.discriminator.SetShortValue(inPayload.discriminator.GetShortValue());
    NL_TEST_ASSERT(inSuite, inPayload == outPayload);
}

void TestLongCodeReadWrite(nlTestSuite * inSuite, void * context)
{
    PayloadContents inPayload   = GetDefaultPayload();
    inPayload.commissioningFlow = CommissioningFlow::kCustom;
    inPayload.vendorID          = 1;
    inPayload.productID         = 1;

    SetupPayload outPayload;

    std::string result;
    ManualSetupPayloadGenerator generator(inPayload);
    generator.payloadDecimalStringRepresentation(result);
    ManualSetupPayloadParser(result).populatePayload(outPayload);

    // Override the discriminator in the input payload with the short version,
    // since that's what we will produce.
    inPayload.discriminator.SetShortValue(inPayload.discriminator.GetShortValue());
    NL_TEST_ASSERT(inSuite, inPayload == outPayload);
}

void assertEmptyPayloadWithError(nlTestSuite * inSuite, CHIP_ERROR actualError, CHIP_ERROR expectedError,
                                 const SetupPayload & payload)
{
    NL_TEST_ASSERT(inSuite, actualError == expectedError);
    NL_TEST_ASSERT(inSuite,
                   payload.setUpPINCode == 0 && payload.discriminator.GetLongValue() == 0 && payload.productID == 0 &&
                       payload.vendorID == 0);
}

void TestPayloadParser_InvalidEntry(nlTestSuite * inSuite, void * inContext)
{
    SetupPayload payload;
    std::string decimalString;

    // Empty input
    decimalString = "";
    decimalString += Verhoeff10::ComputeCheckChar(decimalString.c_str());
    assertEmptyPayloadWithError(inSuite, ManualSetupPayloadParser(decimalString).populatePayload(payload),
                                CHIP_ERROR_INVALID_STRING_LENGTH, payload);

    // Invalid character
    decimalString = "24184.2196";
    decimalString += Verhoeff10::ComputeCheckChar(decimalString.c_str());
    assertEmptyPayloadWithError(inSuite, ManualSetupPayloadParser(decimalString).populatePayload(payload),
                                CHIP_ERROR_INVALID_INTEGER_VALUE, payload);

    // too short
    decimalString = "2456";
    decimalString += Verhoeff10::ComputeCheckChar(decimalString.c_str());
    assertEmptyPayloadWithError(inSuite, ManualSetupPayloadParser(decimalString).populatePayload(payload),
                                CHIP_ERROR_INVALID_STRING_LENGTH, payload);

    // too long for long code
    decimalString = "123456789123456785671";
    decimalString += Verhoeff10::ComputeCheckChar(decimalString.c_str());
    assertEmptyPayloadWithError(inSuite, ManualSetupPayloadParser(decimalString).populatePayload(payload),
                                CHIP_ERROR_INVALID_STRING_LENGTH, payload);

    // too long for short code
    decimalString = "12749875380";
    decimalString += Verhoeff10::ComputeCheckChar(decimalString.c_str());
    assertEmptyPayloadWithError(inSuite, ManualSetupPayloadParser(decimalString).populatePayload(payload),
                                CHIP_ERROR_INVALID_STRING_LENGTH, payload);

    // bit to indicate short code but long code length
    decimalString = "23456789123456785610";
    decimalString += Verhoeff10::ComputeCheckChar(decimalString.c_str());
    assertEmptyPayloadWithError(inSuite, ManualSetupPayloadParser(decimalString).populatePayload(payload),
                                CHIP_ERROR_INVALID_STRING_LENGTH, payload);
    // no pin code (= 0)
    decimalString = "2327680000";
    decimalString += Verhoeff10::ComputeCheckChar(decimalString.c_str());
    assertEmptyPayloadWithError(inSuite, ManualSetupPayloadParser(decimalString).populatePayload(payload),
                                CHIP_ERROR_INVALID_ARGUMENT, payload);
    // wrong check digit
    decimalString = "02684354589";
    assertEmptyPayloadWithError(inSuite, ManualSetupPayloadParser(decimalString).populatePayload(payload),
                                CHIP_ERROR_INTEGRITY_CHECK_FAILED, payload);
}

void TestCheckDecimalStringValidity(nlTestSuite * inSuite, void * inContext)
{
    std::string outReprensation;
    char checkDigit;
    std::string representationWithoutCheckDigit;
    std::string decimalString;

    representationWithoutCheckDigit = "";
    NL_TEST_ASSERT(inSuite,
                   ManualSetupPayloadParser::CheckDecimalStringValidity(representationWithoutCheckDigit, outReprensation) ==
                       CHIP_ERROR_INVALID_STRING_LENGTH);

    representationWithoutCheckDigit = "1";
    NL_TEST_ASSERT(inSuite,
                   ManualSetupPayloadParser::CheckDecimalStringValidity(representationWithoutCheckDigit, outReprensation) ==
                       CHIP_ERROR_INVALID_STRING_LENGTH);

    representationWithoutCheckDigit = "10109";
    checkDigit                      = Verhoeff10::ComputeCheckChar(representationWithoutCheckDigit.c_str());
    decimalString                   = representationWithoutCheckDigit + checkDigit;
    NL_TEST_ASSERT(inSuite, ManualSetupPayloadParser::CheckDecimalStringValidity(decimalString, outReprensation) == CHIP_NO_ERROR);
    NL_TEST_ASSERT(inSuite, outReprensation == representationWithoutCheckDigit);

    representationWithoutCheckDigit = "0000";
    checkDigit                      = Verhoeff10::ComputeCheckChar(representationWithoutCheckDigit.c_str());
    decimalString                   = representationWithoutCheckDigit + checkDigit;
    NL_TEST_ASSERT(inSuite, ManualSetupPayloadParser::CheckDecimalStringValidity(decimalString, outReprensation) == CHIP_NO_ERROR);
    NL_TEST_ASSERT(inSuite, outReprensation == representationWithoutCheckDigit);
}

void TestCheckCodeLengthValidity(nlTestSuite * inSuite, void * inContext)
{
    NL_TEST_ASSERT(inSuite, ManualSetupPayloadParser::CheckCodeLengthValidity("01234567890123456789", true) == CHIP_NO_ERROR);
    NL_TEST_ASSERT(inSuite, ManualSetupPayloadParser::CheckCodeLengthValidity("0123456789", false) == CHIP_NO_ERROR);

    NL_TEST_ASSERT(inSuite,
                   ManualSetupPayloadParser::CheckCodeLengthValidity("01234567891", false) == CHIP_ERROR_INVALID_STRING_LENGTH);
    NL_TEST_ASSERT(inSuite,
                   ManualSetupPayloadParser::CheckCodeLengthValidity("012345678", false) == CHIP_ERROR_INVALID_STRING_LENGTH);
    NL_TEST_ASSERT(inSuite,
                   ManualSetupPayloadParser::CheckCodeLengthValidity("012345678901234567891", true) ==
                       CHIP_ERROR_INVALID_STRING_LENGTH);
    NL_TEST_ASSERT(inSuite,
                   ManualSetupPayloadParser::CheckCodeLengthValidity("0123456789012345678", true) ==
                       CHIP_ERROR_INVALID_STRING_LENGTH);
}

void TestDecimalStringToNumber(nlTestSuite * inSuite, void * inContext)
{
    uint32_t number;
    NL_TEST_ASSERT(inSuite, ManualSetupPayloadParser::ToNumber("12345", number) == CHIP_NO_ERROR);
    NL_TEST_ASSERT(inSuite, number == 12345);

    NL_TEST_ASSERT(inSuite, ManualSetupPayloadParser::ToNumber("01234567890", number) == CHIP_NO_ERROR);
    NL_TEST_ASSERT(inSuite, number == 1234567890);

    NL_TEST_ASSERT(inSuite, ManualSetupPayloadParser::ToNumber("00000001", number) == CHIP_NO_ERROR);
    NL_TEST_ASSERT(inSuite, number == 1);

    NL_TEST_ASSERT(inSuite, ManualSetupPayloadParser::ToNumber("0", number) == CHIP_NO_ERROR);
    NL_TEST_ASSERT(inSuite, number == 0);

    NL_TEST_ASSERT(inSuite, ManualSetupPayloadParser::ToNumber("012345.123456789", number) == CHIP_ERROR_INVALID_INTEGER_VALUE);
    NL_TEST_ASSERT(inSuite, ManualSetupPayloadParser::ToNumber("/", number) == CHIP_ERROR_INVALID_INTEGER_VALUE);
}

void TestReadCharsFromDecimalString(nlTestSuite * inSuite, void * inContext)
{
    uint32_t number;
    size_t index = 3;
    NL_TEST_ASSERT(inSuite, ManualSetupPayloadParser::ReadDigitsFromDecimalString("12345", index, number, 2) == CHIP_NO_ERROR);
    NL_TEST_ASSERT(inSuite, number == 45);

    index = 2;
    NL_TEST_ASSERT(inSuite,
                   ManualSetupPayloadParser::ReadDigitsFromDecimalString("6256276377282", index, number, 7) == CHIP_NO_ERROR);
    NL_TEST_ASSERT(inSuite, number == 5627637);

    index = 0;
    NL_TEST_ASSERT(inSuite, ManualSetupPayloadParser::ReadDigitsFromDecimalString("10", index, number, 2) == CHIP_NO_ERROR);
    NL_TEST_ASSERT(inSuite, number == 10);

    index = 0;
    NL_TEST_ASSERT(inSuite, ManualSetupPayloadParser::ReadDigitsFromDecimalString("01", index, number, 2) == CHIP_NO_ERROR);
    NL_TEST_ASSERT(inSuite, number == 1);

    index = 1;
    NL_TEST_ASSERT(inSuite, ManualSetupPayloadParser::ReadDigitsFromDecimalString("11", index, number, 1) == CHIP_NO_ERROR);
    NL_TEST_ASSERT(inSuite, number == 1);

    index = 2;
    NL_TEST_ASSERT(inSuite, ManualSetupPayloadParser::ReadDigitsFromDecimalString("100001", index, number, 3) == CHIP_NO_ERROR);

    index = 1;
    NL_TEST_ASSERT(inSuite,
                   ManualSetupPayloadParser::ReadDigitsFromDecimalString("12345", index, number, 5) ==
                       CHIP_ERROR_INVALID_STRING_LENGTH);
    NL_TEST_ASSERT(
        inSuite, ManualSetupPayloadParser::ReadDigitsFromDecimalString("12", index, number, 5) == CHIP_ERROR_INVALID_STRING_LENGTH);

    index = 200;
    NL_TEST_ASSERT(inSuite,
                   ManualSetupPayloadParser::ReadDigitsFromDecimalString("6256276377282", index, number, 1) ==
                       CHIP_ERROR_INVALID_STRING_LENGTH);
}

void TestShortCodeCharLengths(nlTestSuite * inSuite, void * inContext)
{
    size_t numBits                        = 1 + kSetupPINCodeFieldLengthInBits + kManualSetupDiscriminatorFieldLengthInBits;
    size_t manualSetupShortCodeCharLength = static_cast<size_t>(ceil(log10(pow(2, numBits))));
    NL_TEST_ASSERT(inSuite, manualSetupShortCodeCharLength == kManualSetupShortCodeCharLength);

    size_t manualSetupVendorIdCharLength = static_cast<size_t>(ceil(log10(pow(2, kVendorIDFieldLengthInBits))));
    NL_TEST_ASSERT(inSuite, manualSetupVendorIdCharLength == kManualSetupVendorIdCharLength);

    size_t manualSetupProductIdCharLength = static_cast<size_t>(ceil(log10(pow(2, kProductIDFieldLengthInBits))));
    NL_TEST_ASSERT(inSuite, manualSetupProductIdCharLength == kManualSetupProductIdCharLength);

    size_t manualSetupLongCodeCharLength =
        kManualSetupShortCodeCharLength + kManualSetupVendorIdCharLength + kManualSetupProductIdCharLength;
    NL_TEST_ASSERT(inSuite, manualSetupLongCodeCharLength == kManualSetupLongCodeCharLength);
}

/**
 *  Test Suite that lists all the Test functions.
 */
// clang-format off
const nlTest sTests[] =
{
    NL_TEST_DEF("Generate Decimal Representation from Partial Payload",                 TestDecimalRepresentation_PartialPayload),
    NL_TEST_DEF("Generate Decimal Representation from Partial Payload (Custom Flow)",   TestDecimalRepresentation_PartialPayload_RequiresCustomFlow),
    NL_TEST_DEF("Generate Decimal Representation from Full Payload with Zeros",         TestDecimalRepresentation_FullPayloadWithZeros),
    NL_TEST_DEF("Decimal Representation from Full Payload without Zeros",               TestDecimalRepresentation_FullPayloadWithoutZeros_DoesNotRequireCustomFlow),
    NL_TEST_DEF("Decimal Representation from Full Payload without Zeros (Custom Flow)", TestDecimalRepresentation_FullPayloadWithoutZeros),
    NL_TEST_DEF("Test 12 bit discriminator for manual setup code",                      TestGenerateAndParser_ManualSetupCodeWithLongDiscriminator),
    NL_TEST_DEF("Test Decimal Representation - All Zeros",                              TestDecimalRepresentation_AllZeros),
    NL_TEST_DEF("Test Decimal Representation - All Ones",                               TestDecimalRepresentation_AllOnes),
    NL_TEST_DEF("Parse from Partial Payload",                                           TestPayloadParser_PartialPayload),
    NL_TEST_DEF("Parse from Full Payload",                                              TestPayloadParser_FullPayload),
    NL_TEST_DEF("Test Invalid Entry To QR Code Parser",                                 TestPayloadParser_InvalidEntry),
    NL_TEST_DEF("Test Short Read Write",                                                TestShortCodeReadWrite),
    NL_TEST_DEF("Test Long Read Write",                                                 TestLongCodeReadWrite),
    NL_TEST_DEF("Check Decimal String Validity",                                        TestCheckDecimalStringValidity),
    NL_TEST_DEF("Check QR Code Length Validity",                                        TestCheckCodeLengthValidity),
    NL_TEST_DEF("Test Decimal String to Number",                                        TestDecimalStringToNumber),
    NL_TEST_DEF("Test Short Code Character Lengths",                                    TestShortCodeCharLengths),
    NL_TEST_DEF("Test Read Characters from Decimal String",                             TestReadCharsFromDecimalString),
    NL_TEST_DEF("Generate Full Payload and Parse it",                                   TestGenerateAndParser_FullPayload),
    NL_TEST_DEF("Generate Partial Payload and Parse it",                                TestGenerateAndParser_PartialPayload),

    NL_TEST_SENTINEL()
};
// clang-format on

} // namespace

/**
 *  Main
 */
int TestManualSetupCode()
{
    // clang-format off
    nlTestSuite theSuite =
    {
        "chip-manual-code-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(TestManualSetupCode);