v811_spc009/external/parameter-framework/upstream/test/functional-tests/AutoSync.cpp

/*
 * Copyright (c) 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 "Config.hpp"
#include "ParameterFramework.hpp"
#include "DynamicLibrary.hpp"
#include <SubsystemObject.h>
#include <IntrospectionEntryPoint.h>
#include "Test.hpp"
#include <catch.hpp>
#include <string>
#include <iostream>
#include "Memory.hpp"

using std::string;

namespace parameterFramework
{

struct BoolPF : public ParameterFramework
{
    BoolPF() : ParameterFramework{createConfig()}
    {

        mDynamicLibrary = ::utility::make_unique<DynamicLibrary>(mSubsystemPath);
        REQUIRE(mDynamicLibrary != nullptr);
        mGetParamFunc = mDynamicLibrary->getSymbol<GetParamFunc>("getParameterValue");
        REQUIRE(mGetParamFunc != nullptr);
    }

    /** Set the boolean parameter value within the "Conf" configuration,
     * which is always applicable. */
    void setParameterValue(bool value)
    {
        std::string valueStr = value ? "1" : "0";
        setConfigurationParameter("Domain", "Conf", "/test/test/param", valueStr);
    }

    bool getParameterValue() { return mGetParamFunc(); }

private:
    static Config createConfig()
    {
        Config config;
        config.instances = R"(<BooleanParameter Name="param" Mapping="Object"/>)";
        config.plugins = {{PLUGIN_PATH, {PLUGIN_NAME}}};
        config.subsystemType = "INTROSPECTION";
        config.domains = R"(<ConfigurableDomain Name="Domain">
                                <Configurations>
                                    <Configuration Name="Conf">
                                        <CompoundRule Type="All"/>
                                    </Configuration>
                                </Configurations>

                                <ConfigurableElements>
                                    <ConfigurableElement Path="/test/test/param"/>
                                </ConfigurableElements>

                                <Settings>
                                    <Configuration Name="Conf">
                                        <ConfigurableElement Path="/test/test/param">
                                            <BooleanParameter Name="param">0</BooleanParameter>
                                        </ConfigurableElement>
                                    </Configuration>
                                </Settings>
                            </ConfigurableDomain>)";

        return config;
    }

    using GetParamFunc = bool (*)();
    std::string mSubsystemPath = std::string(PLUGIN_PATH) + (*PLUGIN_PATH ? "/" : "") + PLUGIN_NAME;
    std::unique_ptr<DynamicLibrary> mDynamicLibrary;
    bool (*mGetParamFunc)();
};

SCENARIO_METHOD(BoolPF, "Auto sync")
{
    GIVEN ("A Pfw that starts") {
        REQUIRE_NOTHROW(start());

        THEN ("Parameter value is false according to the settings") {
            REQUIRE_FALSE(getParameterValue());

            AND_THEN ("Tuning is off") {
                REQUIRE_FALSE(isTuningModeOn());

                WHEN ("Turning autosync on") {
                    REQUIRE_NOTHROW(setAutoSync(true));

                    AND_WHEN ("A parameter is set") {
                        REQUIRE_NOTHROW(setParameterValue(true));

                        THEN ("Sync is done") {
                            CHECK(getParameterValue());
                        }
                    }
                }
                WHEN ("Turning autosync off") {
                    REQUIRE_NOTHROW(setAutoSync(false));

                    AND_WHEN ("A parameter is set") {
                        REQUIRE_NOTHROW(setParameterValue(true));

                        THEN ("Sync should not have occurred yet") {
                            REQUIRE_FALSE(getParameterValue());

                            WHEN ("Turning autosync on") {
                                REQUIRE_NOTHROW(setAutoSync(true));

                                THEN ("Sync is done") {
                                    CHECK(getParameterValue());
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
} // namespace parameterFramework