/*
 *
 *    Copyright (c) 2016-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.
 */

/**
 *    @file
 *      This file implements test app for the Weave Data Management(WDM) Next Profile.
 *
 *
 */

#define __STDC_FORMAT_MACROS

#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <inttypes.h>

// Note that the choice of namespace alias must be made up front for each and every compile unit
// This is because many include paths could set the default alias to unintended target.
#include <Weave/Profiles/bulk-data-transfer/Development/BDXManagedNamespace.hpp>
#include <Weave/Profiles/data-management/Current/WdmManagedNamespace.h>

#include "ToolCommon.h"
#include <Weave/Core/WeaveTLV.h>
#include <Weave/Core/WeaveCore.h>
#include <Weave/WeaveVersion.h>
#include "MockWdmViewClient.h"
#include "MockLoggingManager.h"
#include "MockWdmSubscriptionInitiator.h"
#include <Weave/Support/CodeUtils.h>
#include <Weave/Profiles/WeaveProfiles.h>
#include <Weave/Profiles/common/CommonProfile.h>
#include <Weave/Profiles/time/WeaveTime.h>
#include <SystemLayer/SystemTimer.h>
#include <time.h>
#include "MockLoggingManager.h"

#include "MockWdmSubscriptionInitiator.h"
#include "MockWdmSubscriptionResponder.h"
#include "WdmNextPerfUtility.h"

using nl::Inet::IPAddress;
using namespace nl::Weave;
using namespace nl::Weave::TLV;
using namespace nl::Weave::Profiles;
using nl::Weave::WeaveExchangeManager;

#define TOOL_NAME "TestWdmNext"

static bool HandleOption(const char *progName, OptionSet *optSet, int id, const char *name, const char *arg);
static void HandleWdmCompleteTest();
static void HandleError();

char * TestCaseId = NULL;
bool EnableStopTest = false;
bool EnableRetry = false;
bool EnableMockTimestampInitialCounter = false;
char * NumDataChangeBeforeCancellation = NULL;
char * FinalStatus = NULL;
char * TimeBetweenDataChangeMsec = NULL;
uint32_t TestIterations = 1;
int WdmRoleInTest = 0;
uint32_t TestDelayBetweenIterationMsec = 0;
bool EnableDataFlip = true;
bool EnableDictionaryTest = false;
char *  TimeBetweenLivenessCheckSec = NULL;
bool SavePerfData = false;
bool gClearDataSinkState = false;
// events
EventGenerator * gEventGenerator = NULL;

int TimeBetweenEvents = 1000;

uint64_t WdmPublisherNodeId = kAnyNodeId;
uint16_t WdmUseSubnetId = kWeaveSubnetId_NotSpecified;

enum
{
    kToolOpt_WdmPublisherNodeId                        = 1000,  // Specify the node ID of the WDM Publisher we should connect to
    kToolOpt_WdmUseSubnetId,                                    // True if the publisher is within the specified subnet
    //kToolOpt_WdmSimpleViewClient,
    //kToolOpt_WdmSimpleViewServer,
    kToolOpt_WdmSubscriptionClient,
    kToolOpt_WdmSubscriptionPublisher,
    kToolOpt_WdmInitMutualSubscription,
    kToolOpt_WdmRespMutualSubscription,
    kToolOpt_TestCaseId,
    kToolOpt_EnableStopTest,
    kToolOpt_NumDataChangeBeforeCancellation,
    kToolOpt_FinalStatus,
    kToolOpt_TimeBetweenDataChangeMsec,
    kToolOpt_TestIterations,
    kToolOpt_TestDelayBetweenIterationMsec,
    kToolOpt_EnableDataFlip,
    kToolOpt_EnableDictionaryTest,
    kToolOpt_SavePerfData,
    kToolOpt_EventGenerator,
    kToolOpt_TimeBetweenEvents,
    kToolOpt_ClearDataSinkStateBetweenTests,
    kToolOpt_TimeBetweenLivenessCheckSec,
    kToolOpt_WdmEnableRetry,
    kToolopt_EnableMockTimestampInitialCounter
};

static OptionDef gToolOptionDefs[] =
{
    { "test-case",                                      kArgumentRequired,  kToolOpt_TestCaseId },
    { "enable-stop",                                    kNoArgument,        kToolOpt_EnableStopTest },
    { "total-count",                                    kArgumentRequired,  kToolOpt_NumDataChangeBeforeCancellation },
    { "final-status",                                   kArgumentRequired,  kToolOpt_FinalStatus },
    { "timer-period",                                   kArgumentRequired,  kToolOpt_TimeBetweenDataChangeMsec },
    { "test-iterations",                                kArgumentRequired,  kToolOpt_TestIterations },
    { "test-delay",                                     kArgumentRequired,  kToolOpt_TestDelayBetweenIterationMsec },
    { "enable-flip",                                    kArgumentRequired,  kToolOpt_EnableDataFlip },
    { "enable-dictionary-test",                         kNoArgument,        kToolOpt_EnableDictionaryTest },
    { "save-perf",                                      kNoArgument,        kToolOpt_SavePerfData },
    { "event-generator",                                kArgumentRequired,  kToolOpt_EventGenerator },
    { "inter-event-period",                             kArgumentRequired,  kToolOpt_TimeBetweenEvents },
#if WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING
    { "wdm-publisher",                                  kArgumentRequired,  kToolOpt_WdmPublisherNodeId },
    { "wdm-subnet",                                     kArgumentRequired,  kToolOpt_WdmUseSubnetId },
    //{ "wdm-simple-view-client",                       kNoArgument,        kToolOpt_WdmSimpleViewClient },
    //{ "wdm-simple-view-server",                       kNoArgument,        kToolOpt_WdmSimpleViewServer },
    { "wdm-one-way-sub-client",                         kNoArgument,        kToolOpt_WdmSubscriptionClient },
    { "wdm-one-way-sub-publisher",                      kNoArgument,        kToolOpt_WdmSubscriptionPublisher },
    { "wdm-init-mutual-sub",                            kNoArgument,        kToolOpt_WdmInitMutualSubscription },
    { "wdm-resp-mutual-sub",                            kNoArgument,        kToolOpt_WdmRespMutualSubscription },
    { "clear-state-between-iterations",                 kNoArgument,        kToolOpt_ClearDataSinkStateBetweenTests },
    { "wdm-liveness-check-period",                      kArgumentRequired,  kToolOpt_TimeBetweenLivenessCheckSec },
    { "enable-retry",                                   kNoArgument,        kToolOpt_WdmEnableRetry },
    { "enable-mock-event-timestamp-initial-counter",    kNoArgument,        kToolopt_EnableMockTimestampInitialCounter },
#endif // WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING
    { NULL }
};

static const char *const gToolOptionHelp =
    "  --wdm-publisher <publisher node id>\n"
    "       Configure the node ID for WDM Next publisher\n"
    "\n"
    "  --wdm-subnet <subnet of the publisher in hex>\n"
    "       Predefined service subnet ID is 5\n"
    "\n"
    "  --wdm-simple-view-client\n"
    "       Initiate a simple WDM Next view client\n"
    "\n"
    "  --wdm-simple-view-server\n"
    "       Initiate a simple WDM Next view server\n"
    "\n"
    "  --wdm-one-way-sub-client\n"
    "       Initiate a subscription to some WDM Next publisher\n"
    "\n"
    "  --wdm-one-way-sub-publisher\n"
    "       Respond to a number of WDM Next subscriptions as a publisher\n"
    "\n"
    "  --wdm-init-mutual-sub\n"
    "       Initiate a subscription to some WDM Next publisher, while publishing at the same time \n"
    "\n"
    "  --wdm-resp-mutual-sub\n"
    "       Respond to WDM Next subscription as a publisher with a mutual subscription\n"
    "\n"
    "  --wdm-liveness-check-period\n"
    "       Specify the time, in seconds, between liveness check in WDM Next subscription as a publisher\n"
    "\n"
    "  --test-case <test case id>\n"
    "       Further configure device behavior with this test case id\n"
    "\n"
    "  --enable-stop\n"
    "       Terminate WDM Next test in advance for Happy test\n"
    "\n"
    "  --total-count\n"
    "      when it is -1, mutate trait instance for unlimited iterations, when it is X,\n"
    "      mutate trait instance for X iterations\n"
    "\n"
    "  --final-status\n"
    "      When Final Status is\n"
    "      0: Client Cancel,\n"
    "      1: Publisher Cancel,\n"
    "      2: Client Abort,\n"
    "      3: Publisher Abort,\n"
    "      4: Idle\n"
    "\n"
    "  --timer-period\n"
    "      Every timer-period, the timer handler is triggered to mutate the trait instance\n"
    "\n"
    "  --test-iterations\n"
    "      control the number of wdm test iterations\n"
    "\n"
    "  --clear-state-between-iterations\n"
    "      Clear data sink state between WDM test iterations. Default: state of the data \n"
    "      sinks is unchanged between iterations.\n"
    "\n"
    "  --test-delay\n"
    "      control the delay period among wdm test iterations\n"
    "\n"
    "  --enable-flip <true|false|yes|no|1|0>\n"
    "      Enable/disable flip trait data in HandleDataFlipTimeout\n"
    "\n"
    "  --enable-dictionary-test\n"
    "      Enable/disable dictionary tests\n"
    "\n"
    "  --save-perf\n"
    "      save wdm perf data in files\n"
    "\n"
    "  --event-generator [None | Debug | Livenesss | Security | Telemetry | TestTrait]\n"
    "       Generate structured Weave events using a particular generator:"
    "         None: no events\n"
    "         Debug: Freeform strings, from helloweave-app.  Uses debug_trait to emit messages at \n"
    "                   Production level\n"
    "         Liveness: Liveness events, using liveness_trait at Production level.\n"
    "         Security: Multi-trait scenario emitting events from debug_trait, open_close_trait,\n"
    "                   pincode_input_trait and bolt_lock_trait\n"
    "         Telemetry: WiFi telemetry events at Production level.\n"
    "         TestTrait: TestETrait events which cover a range of types.\n"
    "\n"
    "  --inter-event-period <ms>"
    "       Delay between emitting consecutive events (default 1s)\n"
    "\n"
    "  --enable-retry"
    "       Enable automatic retries by WDM\n"
    "\n"
    "  --enable-mock-event-timestamp-initial-counter"
    "       Enable mock event initial counter using timestamp\n"
    "\n";

static OptionSet gToolOptions =
{
    HandleOption,
    gToolOptionDefs,
    "GENERAL OPTIONS",
    gToolOptionHelp
};

static HelpOptions gHelpOptions(
    TOOL_NAME,
    "Usage: " TOOL_NAME " [<options>]\n",
    WEAVE_VERSION_STRING "\n" WEAVE_TOOL_COPYRIGHT
);

static OptionSet *gToolOptionSets[] =
{
    &gToolOptions,
    &gNetworkOptions,
    &gWeaveNodeOptions,
    &gWeaveSecurityMode,
    &gFaultInjectionOptions,
    &gHelpOptions,
    &gCASEOptions,
    &gGroupKeyEncOptions,
    NULL
};

int main(int argc, char *argv[])
{
    WEAVE_ERROR err;
    WdmNextPerfUtility &TimeRef = *WdmNextPerfUtility::Instance();
    struct timeval sleepTime;
    time_t begin, end;
    double seconds = 0;
    sleepTime.tv_sec = 0;
    sleepTime.tv_usec = 100000;
    nl::Weave::System::Stats::Snapshot before;
    nl::Weave::System::Stats::Snapshot after;
    const bool printStats = true;
    uint32_t KeyId = WeaveKeyId::kNone;

    InitToolCommon();

    SetupFaultInjectionContext(argc, argv);
    SetSignalHandler(DoneOnHandleSIGUSR1);

    if (argc == 1)
    {
        gHelpOptions.PrintBriefUsage(stderr);
        exit(EXIT_FAILURE);
    }

    if (!ParseArgsFromEnvVar(TOOL_NAME, TOOL_OPTIONS_ENV_VAR_NAME, gToolOptionSets, NULL, true) ||
        !ParseArgs(TOOL_NAME, argc, argv, gToolOptionSets))
    {
        exit(EXIT_FAILURE);
    }

    // This test program enables faults and stats prints always (no option taken from the CLI)
    gFaultInjectionOptions.DebugResourceUsage = true;
    gFaultInjectionOptions.PrintFaultCounters = true;

    if (gNetworkOptions.LocalIPv6Addr != IPAddress::Any)
    {

        if (!gNetworkOptions.LocalIPv6Addr.IsIPv6ULA())
        {
            printf("ERROR: Local address must be an IPv6 ULA\n");
            exit(-1);
        }

        gWeaveNodeOptions.FabricId = gNetworkOptions.LocalIPv6Addr.GlobalId();
        gWeaveNodeOptions.LocalNodeId = IPv6InterfaceIdToWeaveNodeId(gNetworkOptions.LocalIPv6Addr.InterfaceId());
        gWeaveNodeOptions.SubnetId = gNetworkOptions.LocalIPv6Addr.Subnet();
    }

    InitSystemLayer();

    InitNetwork();

    InitWeaveStack(true, true);

    if (EnableMockTimestampInitialCounter)
    {
        EnableMockEventTimestampInitialCounter();
    }

    InitializeEventLogging(&ExchangeMgr);

    KeyId = gGroupKeyEncOptions.GetEncKeyId();

    switch (WdmRoleInTest)
    {
        case 0:
            break;

#if ENABLE_VIEW_TEST

        case kToolOpt_WdmSimpleViewClient:
                if (WdmPublisherNodeId != kAnyNodeId)
                {
                    err = MockWdmViewClient::GetInstance()->Init(&ExchangeMgr, TestCaseId);
                    FAIL_ERROR(err, "MockWdmViewClient.Init failed");
                    MockWdmViewClient::GetInstance()-> onCompleteTest = HandleWdmCompleteTest;
                }
                else
                {
                    err = WEAVE_ERROR_INVALID_ARGUMENT;
                    FAIL_ERROR(err, "Simple View Client requires node ID to some publisher");
                }

                break;
            case kToolOpt_WdmSimpleViewServer:
                err = MockWdmViewServer::GetInstance()->Init(&ExchangeMgr, TestCaseId);
                FAIL_ERROR(err, "MockWdmViewServer.Init failed");
                break;

#endif // ENABLE_VIEW_TEST

        case kToolOpt_WdmInitMutualSubscription:
        case kToolOpt_WdmSubscriptionClient:

            if (WdmPublisherNodeId != kAnyNodeId)
            {
                err = MockWdmSubscriptionInitiator::GetInstance()->Init(&ExchangeMgr,
                                                                        kToolOpt_WdmInitMutualSubscription ==
                                                                        WdmRoleInTest,
                                                                        TestCaseId, NumDataChangeBeforeCancellation,
                                                                        FinalStatus, TimeBetweenDataChangeMsec,
                                                                        EnableDataFlip, TimeBetweenLivenessCheckSec,
                                                                        EnableDictionaryTest, gWeaveSecurityMode.SecurityMode,
                                                                        KeyId, EnableRetry);
                FAIL_ERROR(err, "MockWdmSubscriptionInitiator.Init failed");
                MockWdmSubscriptionInitiator::GetInstance()->onCompleteTest = HandleWdmCompleteTest;
                MockWdmSubscriptionInitiator::GetInstance()->onError = HandleError;

            }
            else
            {
                err = WEAVE_ERROR_INVALID_ARGUMENT;
                FAIL_ERROR(err, "MockWdmSubscriptionInitiator requires node ID to some publisher");
            }

            break;
        case kToolOpt_WdmRespMutualSubscription:
        case kToolOpt_WdmSubscriptionPublisher:
            if (EnableRetry)
            {
                err = WEAVE_ERROR_INVALID_ARGUMENT;
                FAIL_ERROR(err, "MockWdmSubcriptionResponder is incompatible with --enable-retry");
            }

            err = MockWdmSubscriptionResponder::GetInstance()->Init(&ExchangeMgr,
                                                                    kToolOpt_WdmRespMutualSubscription == WdmRoleInTest,
                                                                    TestCaseId, NumDataChangeBeforeCancellation,
                                                                    FinalStatus, TimeBetweenDataChangeMsec,
                                                                    EnableDataFlip, TimeBetweenLivenessCheckSec);
            FAIL_ERROR(err, "MockWdmSubscriptionResponder.Init failed");
            MockWdmSubscriptionResponder::GetInstance()->onCompleteTest = HandleWdmCompleteTest;
            MockWdmSubscriptionResponder::GetInstance()->onError = HandleError;
            if (gClearDataSinkState)
            {
                MockWdmSubscriptionResponder::GetInstance()->ClearDataSinkState();
            }
            break;
        default:
            err = WEAVE_ERROR_INVALID_ARGUMENT;
            FAIL_ERROR(err, "WdmRoleInTest is invalid");
    };

    nl::Weave::Stats::UpdateSnapshot(before);

    for (uint32_t iteration = 1; iteration <= TestIterations; iteration++)
    {

#ifdef ENABLE_WDMPERFDATA

        TimeRef();

#endif //ENABLE_WDMPERFDATA

        switch (WdmRoleInTest)
        {
        case 0:
            break;

#if ENABLE_VIEW_TEST

        case kToolOpt_WdmSimpleViewClient:
            if (gClearDataSinkState)
            {
                MockWdmViewClient::GetInstance()->ClearDataSinkState();
            }

            err = MockWdmViewClient::GetInstance()->StartTesting(WdmPublisherNodeId, WdmUseSubnetId);
            FAIL_ERROR(err, "MockWdmViewClient.StartTesting failed");
            break;

#endif

        case kToolOpt_WdmInitMutualSubscription:
        case kToolOpt_WdmSubscriptionClient:
            if (gClearDataSinkState)
            {
                MockWdmSubscriptionInitiator::GetInstance()->ClearDataSinkState();
            }
            err = MockWdmSubscriptionInitiator::GetInstance()->StartTesting(WdmPublisherNodeId, WdmUseSubnetId);
            if (err != WEAVE_NO_ERROR)
            {
                printf("\nMockWdmSubscriptionInitiator.StartTesting failed: %s\n", ErrorStr(err));
                Done = true;
            }
            //FAIL_ERROR(err, "MockWdmSubscriptionInitiator.StartTesting failed");
            break;
        default:
            printf("TestWdmNext server is ready\n");
        };

        PrintNodeConfig();

        if (gEventGenerator != NULL)
        {
            printf("Starting Event Generator\n");
            MockEventGenerator::GetInstance()->Init(&ExchangeMgr, gEventGenerator, TimeBetweenEvents, true);
        }

        while (!Done)
        {
            ServiceNetwork(sleepTime);
        }
        MockEventGenerator::GetInstance()->SetEventGeneratorStop();

        if (gEventGenerator != NULL)
        {
            while (!MockEventGenerator::GetInstance()->IsEventGeneratorStopped())
            {
                ServiceNetwork(sleepTime);
            }
        }


        printf("Current completed test iteration is %d\n", iteration);
        Done = false;

#ifdef ENABLE_WDMPERFDATA

        TimeRef();
        TimeRef.SetPerf();
        TimeRef.ReportPerf();

#endif //ENABLE_WDMPERFDATA

        if (gSigusr1Received)
        {
            printf("gSigusr1Received\n");
            break;
        }

        time(&begin);
        if (TestDelayBetweenIterationMsec != 0)
        {
            while (seconds * 1000 < TestDelayBetweenIterationMsec)
            {
                ServiceNetwork(sleepTime);
                time(&end);
                seconds = difftime(end, begin);
            }
            printf("delay %d milliseconds\n", TestDelayBetweenIterationMsec);
            seconds = 0;
        }
        else
        {
            printf("no delay\n");
        }

    }

    MockWdmSubscriptionInitiator::GetInstance()->PrintVersionsLog();

    MockWdmSubscriptionResponder::GetInstance()->PrintVersionsLog();


    if (SavePerfData)
    {
        TimeRef.SaveToFile();
    }

    TimeRef.Remove();

    ProcessStats(before, after, printStats, NULL);
    PrintFaultInjectionCounters();

    ShutdownWeaveStack();
    ShutdownNetwork();
    ShutdownSystemLayer();

    return 0;
}

bool HandleOption(const char *progName, OptionSet *optSet, int id, const char *name, const char *arg)
{
    switch (id)
    {
    case kToolOpt_WdmPublisherNodeId:
        if (!ParseNodeId(arg, WdmPublisherNodeId))
        {
            PrintArgError("%s: Invalid value specified for WDM publisher node id: %s\n", progName, arg);
            return false;
        }
        break;
    case kToolOpt_WdmUseSubnetId:
        if (!ParseSubnetId(arg, WdmUseSubnetId))
        {
            PrintArgError("%s: Invalid value specified for publisher subnet id: %s\n", progName, arg);
            return false;
        }
        break;

#if ENABLE_VIEW_TEST

    case kToolOpt_WdmSimpleViewClient:
        if (0 != WdmRoleInTest)
        {
            PrintArgError("%s: Mock WDM device can only play one role in WDM tests (%s)\n", progName, arg);
            return false;
        }
        WdmRoleInTest = kToolOpt_WdmSimpleViewClient;
        break;
    case kToolOpt_WdmSimpleViewServer:
        if (0 != WdmRoleInTest)
        {
            PrintArgError("%s: Mock WDM device can only play one role in WDM tests (%s)\n", progName, arg);
            return false;
        }
        WdmRoleInTest = kToolOpt_WdmSimpleViewServer;
        break;

#endif
    case kToolOpt_ClearDataSinkStateBetweenTests:
        gClearDataSinkState = true;
        break;

    case kToolOpt_WdmSubscriptionClient:
        if (0 != WdmRoleInTest)
        {
            PrintArgError("%s: Mock WDM device can only play one role in WDM tests (%s)\n", progName, arg);
            return false;
        }
        WdmRoleInTest = kToolOpt_WdmSubscriptionClient;
        break;
    case kToolOpt_WdmSubscriptionPublisher:
        if (0 != WdmRoleInTest)
        {
            PrintArgError("%s: Mock WDM device can only play one role in WDM tests (%s)\n", progName, arg);
            return false;
        }
        WdmRoleInTest = kToolOpt_WdmSubscriptionPublisher;
        break;
    case kToolOpt_WdmInitMutualSubscription:
        if (0 != WdmRoleInTest)
        {
            PrintArgError("%s: Mock WDM device can only play one role in WDM tests (%s)\n", progName, arg);
            return false;
        }
        WdmRoleInTest = kToolOpt_WdmInitMutualSubscription;
        break;
    case kToolOpt_WdmRespMutualSubscription:
        if (0 != WdmRoleInTest)
        {
            PrintArgError("%s: Mock WDM device can only play one role in WDM tests (%s)\n", progName, arg);
            return false;
        }
        WdmRoleInTest = kToolOpt_WdmRespMutualSubscription;
        break;

    case kToolOpt_WdmEnableRetry:
        EnableRetry = true;
        break;

    case kToolopt_EnableMockTimestampInitialCounter:
        EnableMockTimestampInitialCounter = true;
        break;

    case kToolOpt_TestCaseId:
        if (NULL != TestCaseId)
        {
            free(TestCaseId);
        }
        TestCaseId = strdup(arg);
        break;
    case kToolOpt_EnableStopTest:
        EnableStopTest = true;
        break;
    case kToolOpt_NumDataChangeBeforeCancellation:
        if (NULL != NumDataChangeBeforeCancellation)
        {
            free(NumDataChangeBeforeCancellation);
        }
        NumDataChangeBeforeCancellation = strdup(arg);
        break;
    case kToolOpt_TimeBetweenLivenessCheckSec:
        if (NULL != TimeBetweenLivenessCheckSec)
        {
            free(TimeBetweenLivenessCheckSec);
        }
        TimeBetweenLivenessCheckSec = strdup(arg);
        break;
    case kToolOpt_FinalStatus:
        if (NULL != FinalStatus)
        {
            free(FinalStatus);
        }
        FinalStatus = strdup(arg);
        break;
    case kToolOpt_TimeBetweenDataChangeMsec:
        if (NULL != TimeBetweenDataChangeMsec)
        {
            free(TimeBetweenDataChangeMsec);
        }
        TimeBetweenDataChangeMsec = strdup(arg);
        break;
    case kToolOpt_TestIterations:
        if (!ParseInt(arg, TestIterations))
        {
            PrintArgError("%s: Invalid value specified for test iterations: %s\n", progName, arg);
            return false;
        }
        break;
    case kToolOpt_TestDelayBetweenIterationMsec:
        if (!ParseInt(arg, TestDelayBetweenIterationMsec))
        {
            PrintArgError("%s: Invalid value specified for test delay between iterations: %s\n", progName, arg);
            return false;
        }
        break;
    case kToolOpt_EnableDataFlip:
        if (!ParseBoolean(arg, EnableDataFlip))
        {
            PrintArgError("%s: Invalid value specified for enable data flip: %s\n", progName, arg);
            return false;
        }
        break;
    case kToolOpt_EnableDictionaryTest:
        EnableDictionaryTest = true;
        break;
    case kToolOpt_SavePerfData:
        SavePerfData = true;
        break;
    case kToolOpt_EventGenerator:
        if (strncmp(arg, "None", strlen("None")) == 0)
            gEventGenerator = NULL;
        else if (strncmp(arg, "Debug", strlen("Debug")) == 0)
            gEventGenerator = GetTestDebugGenerator();
        else if (strncmp(arg, "Liveness", strlen("Liveness")) == 0)
            gEventGenerator = GetTestLivenessGenerator();
        else if (strncmp(arg, "Security", strlen("Security")) == 0)
            gEventGenerator = GetTestSecurityGenerator();
        else if (strncmp(arg, "Telemetry", strlen("Telemetry")) == 0)
            gEventGenerator = GetTestTelemetryGenerator();
        else if (strncmp(arg, "TestTrait", strlen("TestTrait")) == 0)
            gEventGenerator = GetTestTraitGenerator();
        else
        {
            PrintArgError("%s: Unrecognized event generator name\n", progName);
            return false;
        }
        break;
    case kToolOpt_TimeBetweenEvents:
    {
        char *endptr;
        TimeBetweenEvents = strtoul(arg, &endptr, 0);
        if (endptr == arg)
        {
            PrintArgError("%s: Invalid inter-event timeout\n", progName);
            return false;
        }
        break;
    }
    default:
        PrintArgError("%s: INTERNAL ERROR: Unhandled option: %s\n", progName, name);
        return false;
    }

    return true;
}

static void HandleWdmCompleteTest()
{
    if (EnableStopTest)
    {
        Done = true;
    }
}

static void HandleError()
{
    Done = true;
}