path: root/upstream/test/test-platform/TestPlatform.cpp

/*
 * Copyright (c) 2011-2015, Intel Corporation
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without modification,
 * are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice, this
 * list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation and/or
 * other materials provided with the distribution.
 *
 * 3. Neither the name of the copyright holder nor the names of its contributors
 * may be used to endorse or promote products derived from this software without
 * specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
 * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include <stdlib.h>
#include <sstream>
#include <assert.h>
#include <errno.h>
#include <convert.hpp>
#include <sstream>
#include "TestPlatform.h"

using std::string;

CTestPlatform::CTestPlatform(const string &strClass, std::string bindAddress)
    : mParameterMgrPlatformConnector(strClass), mLogger(), mRemoteProcessorServer(bindAddress)
{
    mParameterMgrPlatformConnector.setLogger(&mLogger);
}

CTestPlatform::~CTestPlatform()
{
}

CTestPlatform::CommandReturn CTestPlatform::exit(const IRemoteCommand & /*command*/,
                                                 string & /*strResult*/)
{
    mRemoteProcessorServer.stop();

    return CTestPlatform::CCommandHandler::EDone;
}

bool CTestPlatform::run(std::string &strError)
{
    // Start remote processor server
    if (!mRemoteProcessorServer.start(strError)) {

        strError = "TestPlatform: Unable to start remote processor server: " + strError;
        return false;
    }

    CCommandHandler commandHandler(this);

    // Add command parsers
    commandHandler.addCommandParser("exit", &CTestPlatform::exit, 0, "", "Exit TestPlatform");
    commandHandler.addCommandParser("createExclusiveSelectionCriterionFromStateList",
                                    &CTestPlatform::createExclusiveSelectionCriterionFromStateList,
                                    2, "<name> <stateList>",
                                    "Create inclusive selection criterion from state name list");
    commandHandler.addCommandParser("createInclusiveSelectionCriterionFromStateList",
                                    &CTestPlatform::createInclusiveSelectionCriterionFromStateList,
                                    2, "<name> <stateList>",
                                    "Create exclusive selection criterion from state name list");

    commandHandler.addCommandParser("createExclusiveSelectionCriterion",
                                    &CTestPlatform::createExclusiveSelectionCriterion, 2,
                                    "<name> <nbStates>", "Create inclusive selection criterion");
    commandHandler.addCommandParser("createInclusiveSelectionCriterion",
                                    &CTestPlatform::createInclusiveSelectionCriterion, 2,
                                    "<name> <nbStates>", "Create exclusive selection criterion");

    commandHandler.addCommandParser("start", &CTestPlatform::startParameterMgr, 0, "",
                                    "Start ParameterMgr");

    commandHandler.addCommandParser("setCriterionState", &CTestPlatform::setCriterionState, 2,
                                    "<name> <state>",
                                    "Set the current state of a selection criterion");
    commandHandler.addCommandParser(
        "applyConfigurations", &CTestPlatform::applyConfigurations, 0, "",
        "Apply configurations selected by current selection criteria states");

    commandHandler.addCommandParser(
        "setFailureOnMissingSubsystem",
        &CTestPlatform::setter<&CParameterMgrPlatformConnector::setFailureOnMissingSubsystem>, 1,
        "true|false", "Set policy for missing subsystems, "
                      "either abort start or fallback on virtual subsystem.");
    commandHandler.addCommandParser(
        "getMissingSubsystemPolicy",
        &CTestPlatform::getter<&CParameterMgrPlatformConnector::getFailureOnMissingSubsystem>, 0,
        "", "Get policy for missing subsystems, "
            "either abort start or fallback on virtual subsystem.");

    commandHandler.addCommandParser(
        "setFailureOnFailedSettingsLoad",
        &CTestPlatform::setter<&CParameterMgrPlatformConnector::setFailureOnFailedSettingsLoad>, 1,
        "true|false",
        "Set policy for failed settings load, either abort start or continue without domains.");
    commandHandler.addCommandParser(
        "getFailedSettingsLoadPolicy",
        &CTestPlatform::getter<&CParameterMgrPlatformConnector::getFailureOnFailedSettingsLoad>, 0,
        "", "Get policy for failed settings load, either abort start or continue without domains.");

    commandHandler.addCommandParser(
        "setValidateSchemasOnStart",
        &CTestPlatform::setter<&CParameterMgrPlatformConnector::setValidateSchemasOnStart>, 1,
        "true|false", "Set policy for schema validation based on .xsd files (false by default).");
    commandHandler.addCommandParser(
        "getValidateSchemasOnStart",
        &CTestPlatform::getter<&CParameterMgrPlatformConnector::getValidateSchemasOnStart>, 0, "",
        "Get policy for schema validation based on .xsd files.");

    commandHandler.addCommandParser("getSchemaUri", &CTestPlatform::getSchemaUri, 0, "",
                                    "Get the directory where schemas can be found.");
    commandHandler.addCommandParser("setSchemaUri", &CTestPlatform::setSchemaUri, 1, "<directory>",
                                    "Set the directory where schemas can be found.");

    return mRemoteProcessorServer.process(commandHandler);
}

//////////////// Remote command parsers
/// Selection Criterion
CTestPlatform::CommandReturn CTestPlatform::createExclusiveSelectionCriterionFromStateList(
    const IRemoteCommand &remoteCommand, string &strResult)
{
    return createExclusiveSelectionCriterionFromStateList(remoteCommand.getArgument(0),
                                                          remoteCommand, strResult)
               ? CTestPlatform::CCommandHandler::EDone
               : CTestPlatform::CCommandHandler::EFailed;
}

CTestPlatform::CommandReturn CTestPlatform::createInclusiveSelectionCriterionFromStateList(
    const IRemoteCommand &remoteCommand, string &strResult)
{
    return createInclusiveSelectionCriterionFromStateList(remoteCommand.getArgument(0),
                                                          remoteCommand, strResult)
               ? CTestPlatform::CCommandHandler::EDone
               : CTestPlatform::CCommandHandler::EFailed;
}

CTestPlatform::CommandReturn CTestPlatform::createExclusiveSelectionCriterion(
    const IRemoteCommand &remoteCommand, string &strResult)
{
    return createExclusiveSelectionCriterion(
               remoteCommand.getArgument(0),
               strtoul(remoteCommand.getArgument(1).c_str(), nullptr, 0), strResult)
               ? CTestPlatform::CCommandHandler::EDone
               : CTestPlatform::CCommandHandler::EFailed;
}

CTestPlatform::CommandReturn CTestPlatform::createInclusiveSelectionCriterion(
    const IRemoteCommand &remoteCommand, string &strResult)
{
    return createInclusiveSelectionCriterion(
               remoteCommand.getArgument(0),
               strtoul(remoteCommand.getArgument(1).c_str(), nullptr, 0), strResult)
               ? CTestPlatform::CCommandHandler::EDone
               : CTestPlatform::CCommandHandler::EFailed;
}

CTestPlatform::CommandReturn CTestPlatform::startParameterMgr(
    const IRemoteCommand & /*remoteCommand*/, string &strResult)
{
    return mParameterMgrPlatformConnector.start(strResult)
               ? CTestPlatform::CCommandHandler::EDone
               : CTestPlatform::CCommandHandler::EFailed;
}

template <CTestPlatform::setter_t setFunction>
CTestPlatform::CommandReturn CTestPlatform::setter(const IRemoteCommand &remoteCommand,
                                                   string &strResult)
{
    const string &strAbort = remoteCommand.getArgument(0);

    bool bFail;

    if (!convertTo(strAbort, bFail)) {
        return CTestPlatform::CCommandHandler::EShowUsage;
    }

    return (mParameterMgrPlatformConnector.*setFunction)(bFail, strResult)
               ? CTestPlatform::CCommandHandler::EDone
               : CTestPlatform::CCommandHandler::EFailed;
}

template <CTestPlatform::getter_t getFunction>
CTestPlatform::CommandReturn CTestPlatform::getter(const IRemoteCommand & /*command*/,
                                                   string &strResult)
{
    strResult = (mParameterMgrPlatformConnector.*getFunction)() ? "true" : "false";

    return CTestPlatform::CCommandHandler::ESucceeded;
}

CTestPlatform::CommandReturn CTestPlatform::getSchemaUri(const IRemoteCommand & /*remotecommand*/,
                                                         string &result)
{
    result = mParameterMgrPlatformConnector.getSchemaUri();
    return CTestPlatform::CCommandHandler::EDone;
}

CTestPlatform::CommandReturn CTestPlatform::setSchemaUri(const IRemoteCommand &remotecommand,
                                                         string & /*result*/)
{
    mParameterMgrPlatformConnector.setSchemaUri(remotecommand.getArgument(0));
    return CTestPlatform::CCommandHandler::EDone;
}

CTestPlatform::CommandReturn CTestPlatform::setCriterionState(const IRemoteCommand &remoteCommand,
                                                              string &strResult)
{

    bool bSuccess;

    uint32_t state;

    if (convertTo(remoteCommand.getArgument(1), state)) {
        // Sucessfull conversion, set criterion state by numerical state
        bSuccess = setCriterionState(remoteCommand.getArgument(0), state, strResult);

    } else {
        // Conversion failed, set criterion state by lexical state
        bSuccess = setCriterionStateByLexicalSpace(remoteCommand, strResult);
    }

    return bSuccess ? CTestPlatform::CCommandHandler::EDone
                    : CTestPlatform::CCommandHandler::EFailed;
}

CTestPlatform::CommandReturn CTestPlatform::applyConfigurations(const IRemoteCommand & /*command*/,
                                                                string & /*strResult*/)
{
    mParameterMgrPlatformConnector.applyConfigurations();

    return CTestPlatform::CCommandHandler::EDone;
}

//////////////// Remote command handlers

bool CTestPlatform::createExclusiveSelectionCriterionFromStateList(
    const string &strName, const IRemoteCommand &remoteCommand, string &strResult)
{
    ISelectionCriterionTypeInterface *pCriterionType =
        mParameterMgrPlatformConnector.createSelectionCriterionType(false);

    assert(pCriterionType != nullptr);

    size_t nbStates = remoteCommand.getArgumentCount() - 1;

    for (size_t state = 0; state < nbStates; state++) {

        const std::string &strValue = remoteCommand.getArgument(state + 1);

        // FIXME state type vs addValuePair params
        if (!pCriterionType->addValuePair(int(state), strValue, strResult)) {

            strResult = "Unable to add value: " + strValue + ": " + strResult;

            return false;
        }
    }

    mParameterMgrPlatformConnector.createSelectionCriterion(strName, pCriterionType);

    return true;
}

bool CTestPlatform::createInclusiveSelectionCriterionFromStateList(
    const string &strName, const IRemoteCommand &remoteCommand, string &strResult)
{
    ISelectionCriterionTypeInterface *pCriterionType =
        mParameterMgrPlatformConnector.createSelectionCriterionType(true);

    assert(pCriterionType != nullptr);

    size_t nbStates = remoteCommand.getArgumentCount() - 1;

    for (size_t state = 0; state < nbStates; state++) {

        const std::string &strValue = remoteCommand.getArgument(state + 1);

        if (!pCriterionType->addValuePair(0x1 << state, strValue, strResult)) {

            strResult = "Unable to add value: " + strValue + ": " + strResult;

            return false;
        }
    }

    mParameterMgrPlatformConnector.createSelectionCriterion(strName, pCriterionType);

    return true;
}

bool CTestPlatform::createExclusiveSelectionCriterion(const string &strName, size_t nbStates,
                                                      string &strResult)
{
    ISelectionCriterionTypeInterface *pCriterionType =
        mParameterMgrPlatformConnector.createSelectionCriterionType(false);

    for (size_t state = 0; state < nbStates; state++) {

        std::ostringstream ostrValue;

        ostrValue << "State_";
        ostrValue << state;

        // FIXME state type vs addValuePair params
        if (!pCriterionType->addValuePair(int(state), ostrValue.str(), strResult)) {

            strResult = "Unable to add value: " + ostrValue.str() + ": " + strResult;

            return false;
        }
    }

    mParameterMgrPlatformConnector.createSelectionCriterion(strName, pCriterionType);

    return true;
}

bool CTestPlatform::createInclusiveSelectionCriterion(const string &strName, size_t nbStates,
                                                      string &strResult)
{
    ISelectionCriterionTypeInterface *pCriterionType =
        mParameterMgrPlatformConnector.createSelectionCriterionType(true);

    for (size_t state = 0; state < nbStates; state++) {

        std::ostringstream ostrValue;

        ostrValue << "State_0x";
        ostrValue << (0x1 << state);

        if (!pCriterionType->addValuePair(0x1 << state, ostrValue.str(), strResult)) {

            strResult = "Unable to add value: " + ostrValue.str() + ": " + strResult;

            return false;
        }
    }

    mParameterMgrPlatformConnector.createSelectionCriterion(strName, pCriterionType);

    return true;
}

bool CTestPlatform::setCriterionState(const string &strName, uint32_t uiState, string &strResult)
{
    ISelectionCriterionInterface *pCriterion =
        mParameterMgrPlatformConnector.getSelectionCriterion(strName);

    if (!pCriterion) {

        strResult = "Unable to retrieve selection criterion: " + strName;

        return false;
    }

    pCriterion->setCriterionState(uiState);

    return true;
}

bool CTestPlatform::setCriterionStateByLexicalSpace(const IRemoteCommand &remoteCommand,
                                                    string &strResult)
{

    // Get criterion name
    std::string strCriterionName = remoteCommand.getArgument(0);

    ISelectionCriterionInterface *pCriterion =
        mParameterMgrPlatformConnector.getSelectionCriterion(strCriterionName);

    if (!pCriterion) {

        strResult = "Unable to retrieve selection criterion: " + strCriterionName;

        return false;
    }

    // Get criterion type
    const ISelectionCriterionTypeInterface *pCriterionType = pCriterion->getCriterionType();

    // Get substate number, the first argument (index 0) is the criterion name
    size_t nbSubStates = remoteCommand.getArgumentCount() - 1;

    // Check that exclusive criterion has only one substate
    if (!pCriterionType->isTypeInclusive() && nbSubStates != 1) {

        strResult = "Exclusive criterion " + strCriterionName + " can only have one state";

        return false;
    }

    /// Translate lexical state to numerical state
    int iNumericalState = 0;
    size_t lexicalSubStateIndex;

    // Parse lexical substates
    std::string strLexicalState = "";

    for (lexicalSubStateIndex = 1; lexicalSubStateIndex <= nbSubStates; lexicalSubStateIndex++) {
        /*
         * getNumericalValue method from ISelectionCriterionTypeInterface strip his parameter
         * first parameter based on | sign. In case that the user uses multiple parameters
         * to set InclusiveCriterion value, we aggregate all desired values to be sure
         * they will be handled correctly.
         */
        if (lexicalSubStateIndex != 1) {
            strLexicalState += "|";
        }
        strLexicalState += remoteCommand.getArgument(lexicalSubStateIndex);
    }

    // Translate lexical to numerical substate
    if (!pCriterionType->getNumericalValue(strLexicalState, iNumericalState)) {

        strResult = "Unable to find lexical state \"" + strLexicalState + "\" in criteria " +
                    strCriterionName;

        return false;
    }

    // Set criterion new state
    pCriterion->setCriterionState(iNumericalState);

    return true;
}