/*
 *
 *    Copyright (c) 2017 Nest Labs, Inc.
 *    All rights reserved.
 *
 *    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.
 */
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#include <Weave/Core/WeaveCore.h>

#include "../lib/support/nlargparser.hpp"

using namespace nl::ArgParser;

static bool HandleOption(const char *progName, OptionSet *optSet, int id, const char *name, const char *arg);
static bool HandleNonOptionArgs(const char *progName, int argc, char *argv[]);
static void HandleArgError(const char *msg, ...);
static void ClearCallbackRecords();

#define DEBUG_TESTS 0

#define QuitWithError(MSG) \
do { \
    fprintf(stderr, "%s FAILED (line %d): ", __FUNCTION__, __LINE__); \
    fputs(MSG, stderr); \
    fputs("\n", stderr); \
    exit(EXIT_FAILURE); \
} while (0)

#define VerifyOrQuit(TST, MSG) \
do { \
    if (!(TST)) \
    { \
        QuitWithError(MSG); \
    } \
} while (0)

#define VerifyHandleOptionCallback(INDEX, EXPECT_PROG_NAME, EXPECT_OPTSET, EXPECT_ID, EXPECT_NAME, EXPECT_ARG)              \
do {                                                                                                                        \
    CallbackRecord& rec = sCallbackRecords[INDEX];                                                                          \
    const char *arg = EXPECT_ARG;                                                                                           \
    VerifyOrQuit(rec.Type == CallbackRecord::kHandleOption, "Invalid callback type (expected HandleOption)");               \
    VerifyOrQuit(strcmp(rec.ProgName, EXPECT_PROG_NAME) == 0, "Invalid value for HandleOption argument: progName");         \
    VerifyOrQuit(rec.OptSet == EXPECT_OPTSET, "Invalid value for HandleOption argument: optSet");                           \
    VerifyOrQuit(rec.Id == EXPECT_ID, "Invalid value for HandleOption argument: id");                                       \
    VerifyOrQuit(strcmp(rec.Name, EXPECT_NAME) == 0, "Invalid value for HandleOption argument: name");                      \
    if (arg != NULL)                                                                                                        \
        VerifyOrQuit(strcmp(rec.Arg, arg) == 0, "Invalid value for HandleOption argument: arg");                            \
    else                                                                                                                    \
        VerifyOrQuit(rec.Arg == NULL, "Invalid value for HandleOption argument: arg");                                      \
} while (0)

#define VerifyHandleNonOptionArgsCallback(INDEX, EXPECT_PROG_NAME, EXPECT_ARGC)                                             \
do {                                                                                                                        \
    CallbackRecord& rec = sCallbackRecords[INDEX];                                                                          \
    VerifyOrQuit(rec.Type == CallbackRecord::kHandleNonOptionArgs, "Invalid callback type (expected HandleNonOptionArgs)"); \
    VerifyOrQuit(strcmp(rec.ProgName, EXPECT_PROG_NAME) == 0, "Invalid value for HandleNonOptionArgs argument: progName");  \
    VerifyOrQuit(rec.Argc == EXPECT_ARGC, "Invalid value for HandleNonOptionArgs argument: argc");                          \
} while (0)

#define VerifyNonOptionArg(INDEX, EXPECT_ARG)                                                                               \
do {                                                                                                                        \
    CallbackRecord& rec = sCallbackRecords[INDEX];                                                                          \
    VerifyOrQuit(rec.Type == CallbackRecord::kNonOptionArg, "Invalid callback type (expected NonOptionArg)");               \
    VerifyOrQuit(strcmp(rec.Arg, EXPECT_ARG) == 0, "Invalid value for NonOptionArg");                                       \
} while (0)

#define VerifyPrintArgErrorCallback(INDEX)                                                                                  \
do {                                                                                                                        \
    CallbackRecord& rec = sCallbackRecords[INDEX];                                                                          \
    VerifyOrQuit(rec.Type == CallbackRecord::kArgError, "Invalid callback type (expected ArgError)");                       \
} while (0)

#define VerifyArgErrorContains(INDEX, EXPECT_TEXT)                                                                          \
do {                                                                                                                        \
    CallbackRecord& rec = sCallbackRecords[INDEX];                                                                          \
    VerifyOrQuit(strstr(rec.Error, EXPECT_TEXT) != NULL, "Expected text not found in error output");                        \
} while (0)

struct CallbackRecord
{
    enum
    {
        kHandleOption,
        kHandleNonOptionArgs,
        kNonOptionArg,
        kArgError
    } Type;
    char *ProgName;
    OptionSet *OptSet;
    int Id;
    char *Name;
    char *Arg;
    int Argc;
    char *Error;
};

enum
{
    kMaxCallbackRecords = 100
};

static CallbackRecord sCallbackRecords[kMaxCallbackRecords];
static size_t sCallbackRecordCount = 0;

static OptionDef sOptionSetA_Defs[] =
{
    { "foo",  kNoArgument, '1'  },
    { "bar",  kNoArgument, 1001 },
    { "baz",  kArgumentRequired, 'Z'  },
    { }
};

static OptionSet sOptionSetA =
{
    HandleOption,
    sOptionSetA_Defs,
    "OPTION SET A",
    "help text for option set A\n"
    "-1 --foo\n"
    "--bar\n"
    "-Z --baz\n"
};

static OptionDef sOptionSetB_Defs[] =
{
    { "stop", kNoArgument, 's'  },
    { "run",  kArgumentRequired, 1000  },
    { "walk", kNoArgument, 1001 },
    { }
};

static OptionSet sOptionSetB =
{
    HandleOption,
    sOptionSetB_Defs,
    "OPTION SET B",
    "help text for option set B\n"
    "-s --stop\n"
    "--run\n"
    "--walk\n"
};

static void SimpleParseTest_SingleLongOption()
{
    bool res;

    static OptionSet *optionSets[] =
    {
        &sOptionSetA,
        &sOptionSetB,
        NULL
    };
    static const char *argv[] =
    {
        "",
        "--foo",
		NULL
    };
    static int argc = sizeof(argv) / sizeof(argv[0]) - 1;

    ClearCallbackRecords();
    PrintArgError = HandleArgError;

    res = ParseArgs(__FUNCTION__, argc, (char **)argv, optionSets, HandleNonOptionArgs);
    VerifyOrQuit(res == true, "ParseArgs() returned false");
    VerifyOrQuit(sCallbackRecordCount == 2, "Invalid value returned for sCallbackRecordCount");
    VerifyHandleOptionCallback(0, __FUNCTION__, &sOptionSetA, '1',  "--foo", NULL);
    VerifyHandleNonOptionArgsCallback(1, __FUNCTION__, 0);
}

static void SimpleParseTest_SingleShortOption()
{
    bool res;

    static OptionSet *optionSets[] =
    {
        &sOptionSetA,
        &sOptionSetB,
        NULL
    };
    static const char *argv[] =
    {
        "",
        "-s",
		NULL
    };
    static int argc = sizeof(argv) / sizeof(argv[0]) - 1;

    ClearCallbackRecords();
    PrintArgError = HandleArgError;

    res = ParseArgs(__FUNCTION__, argc, (char **)argv, optionSets, HandleNonOptionArgs);
    VerifyOrQuit(res == true, "ParseArgs() returned false");
    VerifyOrQuit(sCallbackRecordCount == 2, "Invalid value returned for sCallbackRecordCount");
    VerifyHandleOptionCallback(0, __FUNCTION__, &sOptionSetB, 's',  "-s",    NULL);
    VerifyHandleNonOptionArgsCallback(1, __FUNCTION__, 0);
}

static void SimpleParseTest_SingleLongOptionWithValue()
{
    bool res;

    static OptionSet *optionSets[] =
    {
        &sOptionSetA,
        &sOptionSetB,
        NULL
    };
    static const char *argv[] =
    {
        "",
        "--run", "run-value",
		NULL
    };
    static int argc = sizeof(argv) / sizeof(argv[0]) - 1;

    ClearCallbackRecords();
    PrintArgError = HandleArgError;

    res = ParseArgs(__FUNCTION__, argc, (char **)argv, optionSets, HandleNonOptionArgs);
    VerifyOrQuit(res == true, "ParseArgs() returned false");
    VerifyOrQuit(sCallbackRecordCount == 2, "Invalid value returned for sCallbackRecordCount");
    VerifyHandleOptionCallback(0, __FUNCTION__, &sOptionSetB, 1000, "--run", "run-value");
    VerifyHandleNonOptionArgsCallback(1, __FUNCTION__, 0);
}

static void SimpleParseTest_SingleShortOptionWithValue()
{
    bool res;

    static OptionSet *optionSets[] =
    {
        &sOptionSetA,
        &sOptionSetB,
        NULL
    };
    static const char *argv[] =
    {
        "",
        "-Z", "baz-value",
		NULL
    };
    static int argc = sizeof(argv) / sizeof(argv[0]) - 1;

    ClearCallbackRecords();
    PrintArgError = HandleArgError;

    res = ParseArgs(__FUNCTION__, argc, (char **)argv, optionSets, HandleNonOptionArgs);
    VerifyOrQuit(res == true, "ParseArgs() returned false");
    VerifyOrQuit(sCallbackRecordCount == 2, "Invalid value returned for sCallbackRecordCount");
    VerifyHandleOptionCallback(0, __FUNCTION__, &sOptionSetA, 'Z', "-Z", "baz-value");
    VerifyHandleNonOptionArgsCallback(1, __FUNCTION__, 0);
}

static void SimpleParseTest_VariousShortAndLongWithArgs()
{
    bool res;

    static OptionSet *optionSets[] =
    {
        &sOptionSetA,
        &sOptionSetB,
        NULL
    };
    static const char *argv[] =
    {
        "",
        "--foo",
        "--run", "run-value",
        "-s",
        "--bar",
        "-1Z", "baz-value",
        "--run", "run-value-2",
        "non-opt-arg-1",
        "non-opt-arg-2",
        "non-opt-arg-3",
        "non-opt-arg-4",
		NULL
    };
    static int argc = sizeof(argv) / sizeof(argv[0]) - 1;

    ClearCallbackRecords();
    PrintArgError = HandleArgError;

    res = ParseArgs(__FUNCTION__, argc, (char **)argv, optionSets, HandleNonOptionArgs);
    VerifyOrQuit(res == true, "ParseArgs() returned false");
    VerifyOrQuit(sCallbackRecordCount == 12, "Invalid value returned for sCallbackRecordCount");
    VerifyHandleOptionCallback(0, __FUNCTION__, &sOptionSetA, '1',  "--foo", NULL);
    VerifyHandleOptionCallback(1, __FUNCTION__, &sOptionSetB, 1000, "--run", "run-value");
    VerifyHandleOptionCallback(2, __FUNCTION__, &sOptionSetB, 's',  "-s",    NULL);
    VerifyHandleOptionCallback(3, __FUNCTION__, &sOptionSetA, 1001, "--bar", NULL);
    VerifyHandleOptionCallback(4, __FUNCTION__, &sOptionSetA, '1',  "-1",    NULL);
    VerifyHandleOptionCallback(5, __FUNCTION__, &sOptionSetA, 'Z',  "-Z",    "baz-value");
    VerifyHandleOptionCallback(6, __FUNCTION__, &sOptionSetB, 1000, "--run", "run-value-2");
    VerifyHandleNonOptionArgsCallback(7, __FUNCTION__, 4);
    VerifyNonOptionArg(8,  "non-opt-arg-1");
    VerifyNonOptionArg(9,  "non-opt-arg-2");
    VerifyNonOptionArg(10, "non-opt-arg-3");
    VerifyNonOptionArg(11, "non-opt-arg-4");
}

static void UnknownOptionTest_UnknownShortOption()
{
    bool res;

    static OptionSet *optionSets[] =
    {
        &sOptionSetB,
        &sOptionSetA,
        NULL
    };
    static const char *argv[] =
    {
        "",
        "--foo",
        "--run", "run-value",
        "-q", // <-- unknown option -q
        "--bar",
        "non-opt-arg-1",
		NULL
    };
    static int argc = sizeof(argv) / sizeof(argv[0]) - 1;

    ClearCallbackRecords();
    PrintArgError = HandleArgError;

    res = ParseArgs(__FUNCTION__, argc, (char **)argv, optionSets, HandleNonOptionArgs);
    VerifyOrQuit(res == false, "ParseArgs() returned true");
    VerifyOrQuit(sCallbackRecordCount == 3, "Invalid value returned for sCallbackRecordCount");
    VerifyHandleOptionCallback(0, __FUNCTION__, &sOptionSetA, '1',  "--foo", NULL);
    VerifyHandleOptionCallback(1, __FUNCTION__, &sOptionSetB, 1000, "--run", "run-value");
    VerifyPrintArgErrorCallback(2);
    VerifyArgErrorContains(2, "Unknown");
    VerifyArgErrorContains(2, "-q");
}

static void UnknownOptionTest_UnknownLongOption()
{
    bool res;

    static OptionSet *optionSets[] =
    {
        &sOptionSetB,
        &sOptionSetA,
        NULL
    };
    static const char *argv[] =
    {
        "",
        "--foo",
        "--run", "run-value",
        "--bad", // <-- unknown option --bad
        "--bar",
        "non-opt-arg-1",
		NULL
    };
    static int argc = sizeof(argv) / sizeof(argv[0]) - 1;

    ClearCallbackRecords();
    PrintArgError = HandleArgError;

    res = ParseArgs(__FUNCTION__, argc, (char **)argv, optionSets, HandleNonOptionArgs);
    VerifyOrQuit(res == false, "ParseArgs() returned true");
    VerifyOrQuit(sCallbackRecordCount == 3, "Invalid value returned for sCallbackRecordCount");
    VerifyHandleOptionCallback(0, __FUNCTION__, &sOptionSetA, '1',  "--foo", NULL);
    VerifyHandleOptionCallback(1, __FUNCTION__, &sOptionSetB, 1000, "--run", "run-value");
    VerifyPrintArgErrorCallback(2);
    VerifyArgErrorContains(2, "Unknown option");
    VerifyArgErrorContains(2, "--bad");
}

static void UnknownOptionTest_UnknownShortOptionAfterKnown()
{
    bool res;

    static OptionSet *optionSets[] =
    {
        &sOptionSetB,
        &sOptionSetA,
        NULL
    };
    static const char *argv[] =
    {
        "",
        "--foo",
        "--run", "run-value",
        "-1Q", // <-- unknown option -Q
        "--bar",
        "non-opt-arg-1",
		NULL
    };
    static int argc = sizeof(argv) / sizeof(argv[0]) - 1;

    ClearCallbackRecords();
    PrintArgError = HandleArgError;

    res = ParseArgs(__FUNCTION__, argc, (char **)argv, optionSets, HandleNonOptionArgs);
    VerifyOrQuit(res == false, "ParseArgs() returned true");
    VerifyOrQuit(sCallbackRecordCount == 4, "Invalid value returned for sCallbackRecordCount");
    VerifyHandleOptionCallback(0, __FUNCTION__, &sOptionSetA, '1',  "--foo", NULL);
    VerifyHandleOptionCallback(1, __FUNCTION__, &sOptionSetB, 1000, "--run", "run-value");
    VerifyHandleOptionCallback(2, __FUNCTION__, &sOptionSetA, '1',  "-1",    NULL);
    VerifyPrintArgErrorCallback(3);
    VerifyArgErrorContains(3, "Unknown");
    VerifyArgErrorContains(3, "-Q");
}

static void UnknownOptionTest_UnknownShortOptionBeforeKnown()
{
    bool res;

    static OptionSet *optionSets[] =
    {
        &sOptionSetA,
        &sOptionSetB,
        NULL
    };
    static const char *argv[] =
    {
        "",
        "-Q1", // <-- unknown option -Q
		NULL
    };
    static int argc = sizeof(argv) / sizeof(argv[0]) - 1;

    ClearCallbackRecords();
    PrintArgError = HandleArgError;

    res = ParseArgs(__FUNCTION__, argc, (char **)argv, optionSets, HandleNonOptionArgs);
    VerifyOrQuit(res == false, "ParseArgs() returned true");
    VerifyOrQuit(sCallbackRecordCount == 1, "Invalid value returned for sCallbackRecordCount");
    VerifyPrintArgErrorCallback(0);
    VerifyArgErrorContains(0, "Unknown");
    VerifyArgErrorContains(0, "-Q");
}

static void UnknownOptionTest_UnknownShortOptionAfterArgs()
{
    bool res;

    static OptionSet *optionSets[] =
    {
        &sOptionSetA,
        &sOptionSetB,
        NULL
    };
    static const char *argv[] =
    {
        "",
        "non-opt-arg-1",
        "non-opt-arg-2",
        "-Q", // <-- unknown option -Q
		NULL
    };
    static int argc = sizeof(argv) / sizeof(argv[0]) - 1;

    ClearCallbackRecords();
    PrintArgError = HandleArgError;

    res = ParseArgs(__FUNCTION__, argc, (char **)argv, optionSets, HandleNonOptionArgs);
    VerifyOrQuit(res == false, "ParseArgs() returned true");
    VerifyOrQuit(sCallbackRecordCount == 1, "Invalid value returned for sCallbackRecordCount");
    VerifyPrintArgErrorCallback(0);
    VerifyArgErrorContains(0, "Unknown");
    VerifyArgErrorContains(0, "-Q");
}

static void UnknownOptionTest_UnknownLongOptionAfterArgs()
{
    bool res;

    static OptionSet *optionSets[] =
    {
        &sOptionSetA,
        &sOptionSetB,
        NULL
    };
    static const char *argv[] =
    {
        "",
        "non-opt-arg-1",
        "non-opt-arg-2",
        "--barf", // <-- unknown option --barf
		NULL
    };
    static int argc = sizeof(argv) / sizeof(argv[0]) - 1;

    ClearCallbackRecords();
    PrintArgError = HandleArgError;

    res = ParseArgs(__FUNCTION__, argc, (char **)argv, optionSets, HandleNonOptionArgs);
    VerifyOrQuit(res == false, "ParseArgs() returned true");
    VerifyOrQuit(sCallbackRecordCount == 1, "Invalid value returned for sCallbackRecordCount");
    VerifyPrintArgErrorCallback(0);
    VerifyArgErrorContains(0, "Unknown");
    VerifyArgErrorContains(0, "--barf");
}

static void UnknownOptionTest_IgnoreUnknownLongOption()
{
    bool res;

    static OptionSet *optionSets[] =
    {
        &sOptionSetA,
        &sOptionSetB,
        NULL
    };
    static const char *argv[] =
    {
        "",
        "non-opt-arg-1",
        "non-opt-arg-2",
        "--foob", // <-- unknown option --foob
        "-Zbaz-value",
		NULL
    };
    static int argc = sizeof(argv) / sizeof(argv[0]) - 1;

    ClearCallbackRecords();
    PrintArgError = HandleArgError;

    res = ParseArgs(__FUNCTION__, argc, (char **)argv, optionSets, HandleNonOptionArgs, true);
    VerifyOrQuit(res == true, "ParseArgs() returned false");

    VerifyOrQuit(sCallbackRecordCount == 4, "Invalid value returned for sCallbackRecordCount");

    VerifyHandleOptionCallback(0, __FUNCTION__, &sOptionSetA, 'Z',  "-Z", "baz-value");
    VerifyHandleNonOptionArgsCallback(1, __FUNCTION__, 2);
    VerifyNonOptionArg(2, "non-opt-arg-1");
    VerifyNonOptionArg(3, "non-opt-arg-2");
}

static void UnknownOptionTest_IgnoreUnknownShortOption()
{
    bool res;

    static OptionSet *optionSets[] =
    {
        &sOptionSetA,
        &sOptionSetB,
        NULL
    };
    static const char *argv[] =
    {
        "",
        "non-opt-arg-1",
        "non-opt-arg-2",
        "-Q1", // <-- unknown option -Q
        "-Zbaz-value",
		NULL
    };
    static int argc = sizeof(argv) / sizeof(argv[0]) - 1;

    ClearCallbackRecords();
    PrintArgError = HandleArgError;

    res = ParseArgs(__FUNCTION__, argc, (char **)argv, optionSets, HandleNonOptionArgs, true);
    VerifyOrQuit(res == true, "ParseArgs() returned false");

    VerifyOrQuit(sCallbackRecordCount == 5, "Invalid value returned for sCallbackRecordCount");

    VerifyHandleOptionCallback(0, __FUNCTION__, &sOptionSetA, '1',  "-1", NULL);
    VerifyHandleOptionCallback(1, __FUNCTION__, &sOptionSetA, 'Z',  "-Z", "baz-value");
    VerifyHandleNonOptionArgsCallback(2, __FUNCTION__, 2);
    VerifyNonOptionArg(3, "non-opt-arg-1");
    VerifyNonOptionArg(4, "non-opt-arg-2");
}

static void MissingValueTest_MissingShortOptionValue()
{
    bool res;

    static OptionSet *optionSets[] =
    {
        &sOptionSetA,
        &sOptionSetB,
        NULL
    };
    static const char *argv[] =
    {
        "",
        "-Z",
		NULL
    };
    static int argc = sizeof(argv) / sizeof(argv[0]) - 1;

    ClearCallbackRecords();
    PrintArgError = HandleArgError;

    res = ParseArgs(__FUNCTION__, argc, (char **)argv, optionSets, HandleNonOptionArgs, true);
    VerifyOrQuit(res == false, "ParseArgs() returned true");
    VerifyOrQuit(sCallbackRecordCount == 1, "Invalid value returned for sCallbackRecordCount");
    VerifyPrintArgErrorCallback(0);
    VerifyArgErrorContains(0, "Missing");
    VerifyArgErrorContains(0, "-Z");
}

static void MissingValueTest_MissingLongOptionValue()
{
    bool res;

    static OptionSet *optionSets[] =
    {
        &sOptionSetA,
        &sOptionSetB,
        NULL
    };
    static const char *argv[] =
    {
        "",
        "--run",
		NULL
    };
    static int argc = sizeof(argv) / sizeof(argv[0]) - 1;

    ClearCallbackRecords();
    PrintArgError = HandleArgError;

    res = ParseArgs(__FUNCTION__, argc, (char **)argv, optionSets, HandleNonOptionArgs, true);
    VerifyOrQuit(res == false, "ParseArgs() returned true");
    VerifyOrQuit(sCallbackRecordCount == 1, "Invalid value returned for sCallbackRecordCount");
    VerifyPrintArgErrorCallback(0);
    VerifyArgErrorContains(0, "Missing");
    VerifyArgErrorContains(0, "--run");
}

static void ClearCallbackRecords()
{
    for (size_t i = 0; i < sCallbackRecordCount; i++)
    {
        if (sCallbackRecords[i].ProgName != NULL)
            free(sCallbackRecords[i].ProgName);
        if (sCallbackRecords[i].Name != NULL)
            free(sCallbackRecords[i].Name);
        if (sCallbackRecords[i].Arg != NULL)
            free(sCallbackRecords[i].Arg);
        if (sCallbackRecords[i].Error != NULL)
            free(sCallbackRecords[i].Error);
    }
    memset(sCallbackRecords, 0, sizeof(sCallbackRecords));
    sCallbackRecordCount = 0;
}

static bool HandleOption(const char *progName, OptionSet *optSet, int id, const char *name, const char *arg)
{
#if DEBUG_TESTS
    printf("HandleOption called: progName:%s optSet:%08lX id:%d name:%s arg:%s\n", progName, (intptr_t)optSet, id, name, arg);
#endif

    VerifyOrQuit(sCallbackRecordCount < kMaxCallbackRecords, "Out of callback records");
    sCallbackRecords[sCallbackRecordCount].Type = CallbackRecord::kHandleOption;
    sCallbackRecords[sCallbackRecordCount].ProgName = strdup(progName);
    sCallbackRecords[sCallbackRecordCount].OptSet = optSet;
    sCallbackRecords[sCallbackRecordCount].Id = id;
    sCallbackRecords[sCallbackRecordCount].Name = strdup(name);
    sCallbackRecords[sCallbackRecordCount].Arg = (arg != NULL) ? strdup(arg) : NULL;
    sCallbackRecordCount++;
    return true;
}

static bool HandleNonOptionArgs(const char *progName, int argc, char *argv[])
{
#if DEBUG_TESTS
    printf("HandleNonOptionArgs called: progName:%s argc:%d argv[0]:%s argv[1]:%s argv[2]:%s argv[3]:%s \n",
            progName, argc,
            (argc > 0) ? argv[0] : "(n/a)",
            (argc > 1) ? argv[1] : "(n/a)",
            (argc > 2) ? argv[2] : "(n/a)",
            (argc > 3) ? argv[3] : "(n/a)"
    );
#endif

    VerifyOrQuit(sCallbackRecordCount < kMaxCallbackRecords, "Out of callback records");
    sCallbackRecords[sCallbackRecordCount].Type = CallbackRecord::kHandleNonOptionArgs;
    sCallbackRecords[sCallbackRecordCount].ProgName = strdup(progName);
    sCallbackRecords[sCallbackRecordCount].Argc = argc;
    sCallbackRecordCount++;

    for (int i = 0; i < argc; i++)
    {
        VerifyOrQuit(sCallbackRecordCount < kMaxCallbackRecords, "Out of callback records");
        sCallbackRecords[sCallbackRecordCount].Type = CallbackRecord::kNonOptionArg;
        sCallbackRecords[sCallbackRecordCount].Arg = strdup(argv[i]);
        sCallbackRecordCount++;
    }

    return true;
}

static void HandleArgError(const char *msg, ...)
{
    int     status;
    va_list ap;

    VerifyOrQuit(sCallbackRecordCount < kMaxCallbackRecords, "Out of callback records");

    sCallbackRecords[sCallbackRecordCount].Type = CallbackRecord::kArgError;

    va_start(ap, msg);
    status = vasprintf(&sCallbackRecords[sCallbackRecordCount].Error, msg, ap);
    (void)status;
    va_end(ap);

#if DEBUG_TESTS
    printf("HandleArgError called: error: %s", sCallbackRecords[sCallbackRecordCount].Error);
#endif

    sCallbackRecordCount++;
}

int main(int argc, char *argv[])
{
    SimpleParseTest_SingleLongOption();
    SimpleParseTest_SingleShortOption();
    SimpleParseTest_SingleLongOptionWithValue();
    SimpleParseTest_SingleShortOptionWithValue();
    SimpleParseTest_VariousShortAndLongWithArgs();

    UnknownOptionTest_UnknownShortOption();
    UnknownOptionTest_UnknownLongOption();
    UnknownOptionTest_UnknownShortOptionAfterArgs();
    UnknownOptionTest_UnknownShortOptionAfterKnown();
    UnknownOptionTest_UnknownShortOptionBeforeKnown();
    UnknownOptionTest_UnknownLongOptionAfterArgs();
    UnknownOptionTest_IgnoreUnknownShortOption();
    UnknownOptionTest_IgnoreUnknownLongOption();

    MissingValueTest_MissingShortOptionValue();
    MissingValueTest_MissingLongOptionValue();

    ClearCallbackRecords();

    printf("All tests succeeded\n");

    return EXIT_SUCCESS;
}