upstream/bindings/c/Test.cpp - platform/external/parameter-framework - Git at Google

 /*
  * 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 "ParameterFramework.h"

 #include "TmpFile.hpp"

 #define CATCH_CONFIG_MAIN // This tells Catch to provide a main()
 #include <catch.hpp>

 #include <string>
 #include <memory>
 #include <vector>
 #include <array>

 #include <cstring>
 #include <cerrno>
 #include <climits>

 struct Test
 {
     /** @return true if str is empty. */
     bool empty(const char *str)
     {
         REQUIRE(str != NULL);
         return *str == '\0';
     }

     void REQUIRE_FAILURE(bool success)
     {
         THEN ("It should be an error") {
             INFO("Previous pfw log: \n" + logLines);
             CAPTURE(pfwGetLastError(pfw));
             CHECK(not success);
             CHECK(not empty(pfwGetLastError(pfw)));
         }
     }

     void REQUIRE_SUCCESS(bool success)
     {
         THEN ("It should be a success") {
             INFO("Previous pfw log: \n" + logLines);
             CAPTURE(pfwGetLastError(pfw));
             CHECK(success);
             CHECK(empty(pfwGetLastError(pfw)));
         }
     }

     /** Wrap utility::TmpFile to add an implicit convertion to the temporary file.
      *
      * This avoids dozens of .getPath() in the following tests. */
     class TmpFile : private parameterFramework::utility::TmpFile
     {
     private:
         using Base = parameterFramework::utility::TmpFile;

     public:
         using Base::TmpFile;

         using Base::getPath;
         /** Implicitly convert to the path of the temporary file. */
         operator const char *() const { return getPath().c_str(); }
     };

     /** Log in logLines. */
     static void logCb(void *voidLogLines, PfwLogLevel level, const char *logLine)
     {
         std::string &logLines = *reinterpret_cast<std::string *>(voidLogLines);
         switch (level) {
         case pfwLogWarning:
             logLines += "Warning: ";
             break;
         case pfwLogInfo:
             logLines += "Info: ";
         }
         logLines += logLine;
         logLines += '\n';
     }

     /** Log buffer, will only be display in case of failure */
     std::string logLines;

     /** Pfw handler used in the tests. */
     PfwHandler *pfw;
 };

 TEST_CASE_METHOD(Test, "Parameter-framework c api use")
 {
     // Create criteria
     const char *letterList[] = {"a", "b", "c", nullptr};
     const char *numberList[] = {"1", "2", "3", nullptr};
     const PfwCriterion criteria[] = {
         {"inclusiveCrit", true, letterList}, {"exclusiveCrit", false, numberList},
     };
     size_t criterionNb = sizeof(criteria) / sizeof(criteria[0]);
     PfwLogger logger = {&logLines, logCb};

     // Create valid pfw config file
     const char *intParameterPath = "/test/system/integer";
     const char *stringParameterPath = "/test/system/string";
     TmpFile system("<?xml version='1.0' encoding='UTF-8'?>\
         <Subsystem Name='system' Type='Virtual'>\
             <ComponentLibrary/>\
             <InstanceDefinition>\
                 <IntegerParameter Name='integer' Size='32' Signed='true' Max='100'/>\
                 <StringParameter Name='string' MaxLength='9'/>\
             </InstanceDefinition>\
         </Subsystem>");
     TmpFile libraries("<?xml version='1.0' encoding='UTF-8'?>\
         <SystemClass Name='test'>\
             <SubsystemInclude Path='" +
                       system.getPath() + "'/>\
         </SystemClass>");
     TmpFile config("<?xml version='1.0' encoding='UTF-8'?>\
         <ParameterFrameworkConfiguration\
             SystemClassName='test' TuningAllowed='false'>\
             <SubsystemPlugins/>\
             <StructureDescriptionFileLocation Path='" +
                    libraries.getPath() + "'/>\
         </ParameterFrameworkConfiguration>");

     GIVEN ("A created parameter framework") {
         pfw = pfwCreate();
         REQUIRE(pfw != NULL);

         THEN ("Error message should be empty") {
             CHECK(empty(pfwGetLastError(pfw)));
         }

         WHEN ("The pfw is started without an existent file") {
             REQUIRE_FAILURE(pfwStart(pfw, "/doNotExist", criteria, criterionNb, &logger));
         }

         WHEN ("The pfw is started with duplicated criterion value") {
             const PfwCriterion duplicatedCriteria[] = {
                 {"duplicated name", true, letterList}, {"duplicated name", false, numberList},
             };
             REQUIRE_FAILURE(pfwStart(pfw, config, duplicatedCriteria, 2, &logger));
         }
         WHEN ("The pfw is started with duplicated criterion value state") {
             const char *values[] = {"a", "a", nullptr};
             const PfwCriterion duplicatedCriteria[] = {{"name", true, values}};

             WHEN ("Using test logger") {
                 REQUIRE_FAILURE(pfwStart(pfw, config, duplicatedCriteria, 1, &logger));
             }
             WHEN ("Using default logger") {
                 // Test coverage of default logger warning
                 REQUIRE_FAILURE(pfwStart(pfw, config, duplicatedCriteria, 1, nullptr));
             }
         }
         WHEN ("The pfw is started with NULL name criterion") {
             const PfwCriterion duplicatedCriteria[] = {{nullptr, true, letterList}};
             REQUIRE_FAILURE(pfwStart(pfw, config, duplicatedCriteria, 1, &logger));
         }
         WHEN ("The pfw is started with NULL criterion state list") {
             const PfwCriterion duplicatedCriteria[] = {{"name", true, nullptr}};
             REQUIRE_FAILURE(pfwStart(pfw, config, duplicatedCriteria, 1, &logger));
         }
         GIVEN ("A criteria with lots of values") {
             // Build a criterion with as many value as there is bits in int.
             std::vector<char> names(sizeof(int) * CHAR_BIT + 1, 'a');
             names.back() = '\0';
             std::vector<const char *> values(names.size());
             for (size_t i = 0; i < values.size(); ++i) {
                 values[i] = &names[i];
             }
             values.back() = nullptr;
             /* The pfw c api requires criterion values to be a NULL terminated
              * array of string. Each string is a pointer to a NULL terminated
              * array of char. The pfw requires each string to be different
              * from all others, ie strcmp(values[i], values[j]) != 0 for any
              * i j.
              *
              * In order to generate easily an array of different strings,
              * instantiate one string (names) big enough
              * (@see PfwCriterion::values).
              * Then instantiate an array of pointer (values),
              * each pointing to a different position in the previously
              * created string.
              *
              * Representation of the names and values vectors.
              *
              * n = number of bit in an int
              *            <--- n+1 elements --->
              * names    = |a|a|a|a|...|a|a|a|\0|
              *             ^ ^             ^
              * values[0] = ´ |             |
              * values[1] = --´             |
              * ...                         |
              * values[n - 1] =  -----------´
              * values[n] = NULL
              *
              */
             const PfwCriterion duplicatedCriteria[] = {{"name", true, &values[0]}};

             WHEN ("The pfw is started with a too long criterion state list") {
                 REQUIRE_FAILURE(pfwStart(pfw, config, duplicatedCriteria, 1, &logger));
             }
             WHEN ("The pfw is started with max length criterion state list") {
                 values[values.size() - 2] = nullptr; // Hide last value
                 REQUIRE_SUCCESS(pfwStart(pfw, config, duplicatedCriteria, 1, &logger));
             }
         }

         WHEN ("The pfw is started with zero criteria") {
             REQUIRE_SUCCESS(pfwStart(pfw, config, criteria, 0, &logger));
         }

         WHEN ("The pfw is started twice a pfw") {
             REQUIRE_SUCCESS(pfwStart(pfw, config, criteria, criterionNb, &logger));
             REQUIRE_FAILURE(pfwStart(pfw, config, criteria, criterionNb, &logger));
         }

         WHEN ("The pfw is started without a logger callback") {
             PfwLogger noLog = {nullptr, nullptr};
             REQUIRE_SUCCESS(pfwStart(pfw, config, criteria, criterionNb, &noLog));
         }
         WHEN ("The pfw is started with default logger") {
             REQUIRE_SUCCESS(pfwStart(pfw, config, criteria, criterionNb, nullptr));
         }

         WHEN ("Get criterion of a stopped pfw") {
             int value;
             REQUIRE_FAILURE(pfwGetCriterion(pfw, criteria[0].name, &value));
         }
         WHEN ("Set criterion of a stopped pfw") {
             REQUIRE_FAILURE(pfwSetCriterion(pfw, criteria[0].name, 1));
         }
         WHEN ("Commit criteria of a stopped pfw") {
             REQUIRE_FAILURE(pfwApplyConfigurations(pfw));
         }

         WHEN ("Bind parameter with a stopped pfw") {
             REQUIRE(pfwBindParameter(pfw, intParameterPath) == NULL);
         }

         WHEN ("The pfw is started correctly") {
             REQUIRE_SUCCESS(pfwStart(pfw, config, criteria, criterionNb, &logger));
             int value;

             WHEN ("Get not existing criterion") {
                 REQUIRE_FAILURE(pfwGetCriterion(pfw, "Do not exist", &value));
             }
             THEN ("All criterion should value 0") {
                 for (size_t i = 0; i < criterionNb; ++i) {
                     const char *criterionName = criteria[i].name;
                     CAPTURE(criterionName);
                     REQUIRE_SUCCESS(pfwGetCriterion(pfw, criterionName, &value));
                     REQUIRE(value == 0);
                 }
             }

             WHEN ("Set not existing criterion") {
                 REQUIRE_FAILURE(pfwSetCriterion(pfw, "Do not exist", 3));
             }
             WHEN ("Set criterion value") {
                 for (size_t i = 0; i < criterionNb; ++i) {
                     const char *criterionName = criteria[i].name;
                     CAPTURE(criterionName);
                     REQUIRE_SUCCESS(pfwSetCriterion(pfw, criterionName, 3));
                 }
                 THEN ("Get criterion value should return what was set") {
                     for (size_t i = 0; i < criterionNb; ++i) {
                         const char *criterionName = criteria[i].name;
                         CAPTURE(criterionName);
                         REQUIRE_SUCCESS(pfwGetCriterion(pfw, criterionName, &value));
                         REQUIRE(value == 3);
                     }
                 }
                 WHEN ("Set a new value to a criterion without committing first") {
                     const char *criterionName = criteria[0].name;
                     REQUIRE_SUCCESS(pfwSetCriterion(pfw, criterionName, 0));
                     THEN ("A warning message should have been displayed") {
                         INFO("Previous pfw log: \n" + logLines);
                         size_t logPos = logLines.find("Warning: Selection criterion "
                                                       "'inclusiveCrit' has been modified 1 time(s)"
                                                       " without any configuration application");
                         CHECK(logPos != std::string::npos);
                     }
                 }
             }
             WHEN ("Commit criteria of a started pfw") {
                 REQUIRE_SUCCESS(pfwApplyConfigurations(pfw));
             }
             WHEN ("Bind a non existing parameter") {
                 REQUIRE_FAILURE(pfwBindParameter(pfw, "do/not/exist") != nullptr);
             }

             GIVEN ("An integer parameter handle") {
                 PfwParameterHandler *param = pfwBindParameter(pfw, intParameterPath);
                 REQUIRE_SUCCESS(param != nullptr);

                 WHEN ("Set parameter out of range") {
                     REQUIRE_FAILURE(pfwSetIntParameter(param, 101));
                 }

                 WHEN ("Set parameter") {
                     REQUIRE_SUCCESS(pfwSetIntParameter(param, 11));
                     THEN ("Get parameter should return what was set") {
                         REQUIRE_SUCCESS(pfwGetIntParameter(param, &value));
                         REQUIRE(value == 11);
                     }
                 }

                 pfwUnbindParameter(param);
             }

             GIVEN ("An string parameter handle") {
                 PfwParameterHandler *param = pfwBindParameter(pfw, stringParameterPath);
                 REQUIRE_SUCCESS(param != nullptr);

                 WHEN ("Set parameter out of range") {
                     REQUIRE_FAILURE(pfwSetStringParameter(param, "ko_1234567"));
                 }

                 WHEN ("Set parameter") {
                     char *value;
                     REQUIRE_SUCCESS(pfwSetStringParameter(param, "ok"));
                     THEN ("Get parameter should return what was set") {
                         REQUIRE_SUCCESS(pfwGetStringParameter(param, &value));
                         REQUIRE(value == std::string("ok"));
                         pfwFree(value);
                     }
                 }

                 pfwUnbindParameter(param);
             }
         }

         pfwDestroy(pfw);
     }
 }
	/*
	* 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 "ParameterFramework.h"

	#include "TmpFile.hpp"

	#define CATCH_CONFIG_MAIN // This tells Catch to provide a main()
	#include <catch.hpp>

	#include <string>
	#include <memory>
	#include <vector>
	#include <array>

	#include <cstring>
	#include <cerrno>
	#include <climits>

	struct Test
	{
	/** @return true if str is empty. */
	bool empty(const char *str)
	{
	REQUIRE(str != NULL);
	return *str == '\0';
	}

	void REQUIRE_FAILURE(bool success)
	{
	THEN ("It should be an error") {
	INFO("Previous pfw log: \n" + logLines);
	CAPTURE(pfwGetLastError(pfw));
	CHECK(not success);
	CHECK(not empty(pfwGetLastError(pfw)));
	}
	}

	void REQUIRE_SUCCESS(bool success)
	{
	THEN ("It should be a success") {
	INFO("Previous pfw log: \n" + logLines);
	CAPTURE(pfwGetLastError(pfw));
	CHECK(success);
	CHECK(empty(pfwGetLastError(pfw)));
	}
	}

	/** Wrap utility::TmpFile to add an implicit convertion to the temporary file.
	*
	* This avoids dozens of .getPath() in the following tests. */
	class TmpFile : private parameterFramework::utility::TmpFile
	{
	private:
	using Base = parameterFramework::utility::TmpFile;

	public:
	using Base::TmpFile;

	using Base::getPath;
	/** Implicitly convert to the path of the temporary file. */
	operator const char *() const { return getPath().c_str(); }
	};

	/** Log in logLines. */
	static void logCb(void voidLogLines, PfwLogLevel level, const char logLine)
	{
	std::string &logLines = reinterpret_cast<std::string >(voidLogLines);
	switch (level) {
	case pfwLogWarning:
	logLines += "Warning: ";
	break;
	case pfwLogInfo:
	logLines += "Info: ";
	}
	logLines += logLine;
	logLines += '\n';
	}

	/** Log buffer, will only be display in case of failure */
	std::string logLines;

	/** Pfw handler used in the tests. */
	PfwHandler *pfw;
	};

	TEST_CASE_METHOD(Test, "Parameter-framework c api use")
	{
	// Create criteria
	const char *letterList[] = {"a", "b", "c", nullptr};
	const char *numberList[] = {"1", "2", "3", nullptr};
	const PfwCriterion criteria[] = {
	{"inclusiveCrit", true, letterList}, {"exclusiveCrit", false, numberList},
	};
	size_t criterionNb = sizeof(criteria) / sizeof(criteria[0]);
	PfwLogger logger = {&logLines, logCb};

	// Create valid pfw config file
	const char *intParameterPath = "/test/system/integer";
	const char *stringParameterPath = "/test/system/string";
	TmpFile system("<?xml version='1.0' encoding='UTF-8'?>\
	<Subsystem Name='system' Type='Virtual'>\
	<ComponentLibrary/>\
	<InstanceDefinition>\
	<IntegerParameter Name='integer' Size='32' Signed='true' Max='100'/>\
	<StringParameter Name='string' MaxLength='9'/>\
	</InstanceDefinition>\
	</Subsystem>");
	TmpFile libraries("<?xml version='1.0' encoding='UTF-8'?>\
	<SystemClass Name='test'>\
	<SubsystemInclude Path='" +
	system.getPath() + "'/>\
	</SystemClass>");
	TmpFile config("<?xml version='1.0' encoding='UTF-8'?>\
	<ParameterFrameworkConfiguration\
	SystemClassName='test' TuningAllowed='false'>\
	<SubsystemPlugins/>\
	<StructureDescriptionFileLocation Path='" +
	libraries.getPath() + "'/>\
	</ParameterFrameworkConfiguration>");

	GIVEN ("A created parameter framework") {
	pfw = pfwCreate();
	REQUIRE(pfw != NULL);

	THEN ("Error message should be empty") {
	CHECK(empty(pfwGetLastError(pfw)));
	}

	WHEN ("The pfw is started without an existent file") {
	REQUIRE_FAILURE(pfwStart(pfw, "/doNotExist", criteria, criterionNb, &logger));
	}

	WHEN ("The pfw is started with duplicated criterion value") {
	const PfwCriterion duplicatedCriteria[] = {
	{"duplicated name", true, letterList}, {"duplicated name", false, numberList},
	};
	REQUIRE_FAILURE(pfwStart(pfw, config, duplicatedCriteria, 2, &logger));
	}
	WHEN ("The pfw is started with duplicated criterion value state") {
	const char *values[] = {"a", "a", nullptr};
	const PfwCriterion duplicatedCriteria[] = {{"name", true, values}};

	WHEN ("Using test logger") {
	REQUIRE_FAILURE(pfwStart(pfw, config, duplicatedCriteria, 1, &logger));
	}
	WHEN ("Using default logger") {
	// Test coverage of default logger warning
	REQUIRE_FAILURE(pfwStart(pfw, config, duplicatedCriteria, 1, nullptr));
	}
	}
	WHEN ("The pfw is started with NULL name criterion") {
	const PfwCriterion duplicatedCriteria[] = {{nullptr, true, letterList}};
	REQUIRE_FAILURE(pfwStart(pfw, config, duplicatedCriteria, 1, &logger));
	}
	WHEN ("The pfw is started with NULL criterion state list") {
	const PfwCriterion duplicatedCriteria[] = {{"name", true, nullptr}};
	REQUIRE_FAILURE(pfwStart(pfw, config, duplicatedCriteria, 1, &logger));
	}
	GIVEN ("A criteria with lots of values") {
	// Build a criterion with as many value as there is bits in int.
	std::vector<char> names(sizeof(int) * CHAR_BIT + 1, 'a');
	names.back() = '\0';
	std::vector<const char *> values(names.size());
	for (size_t i = 0; i < values.size(); ++i) {
	values[i] = &names[i];
	}
	values.back() = nullptr;
	/* The pfw c api requires criterion values to be a NULL terminated
	* array of string. Each string is a pointer to a NULL terminated
	* array of char. The pfw requires each string to be different
	* from all others, ie strcmp(values[i], values[j]) != 0 for any
	* i j.
	*
	* In order to generate easily an array of different strings,
	* instantiate one string (names) big enough
	* (@see PfwCriterion::values).
	* Then instantiate an array of pointer (values),
	* each pointing to a different position in the previously
	* created string.
	*
	* Representation of the names and values vectors.
	*
	* n = number of bit in an int
	* <--- n+1 elements --->
	* names = \|a\|a\|a\|a\|...\|a\|a\|a\|\0\|
	* ^ ^ ^
	* values[0] = ´ \| \|
	* values[1] = --´ \|
	* ... \|
	* values[n - 1] = -----------´
	* values[n] = NULL
	*
	*/
	const PfwCriterion duplicatedCriteria[] = {{"name", true, &values[0]}};

	WHEN ("The pfw is started with a too long criterion state list") {
	REQUIRE_FAILURE(pfwStart(pfw, config, duplicatedCriteria, 1, &logger));
	}
	WHEN ("The pfw is started with max length criterion state list") {
	values[values.size() - 2] = nullptr; // Hide last value
	REQUIRE_SUCCESS(pfwStart(pfw, config, duplicatedCriteria, 1, &logger));
	}
	}

	WHEN ("The pfw is started with zero criteria") {
	REQUIRE_SUCCESS(pfwStart(pfw, config, criteria, 0, &logger));
	}

	WHEN ("The pfw is started twice a pfw") {
	REQUIRE_SUCCESS(pfwStart(pfw, config, criteria, criterionNb, &logger));
	REQUIRE_FAILURE(pfwStart(pfw, config, criteria, criterionNb, &logger));
	}

	WHEN ("The pfw is started without a logger callback") {
	PfwLogger noLog = {nullptr, nullptr};
	REQUIRE_SUCCESS(pfwStart(pfw, config, criteria, criterionNb, &noLog));
	}
	WHEN ("The pfw is started with default logger") {
	REQUIRE_SUCCESS(pfwStart(pfw, config, criteria, criterionNb, nullptr));
	}

	WHEN ("Get criterion of a stopped pfw") {
	int value;
	REQUIRE_FAILURE(pfwGetCriterion(pfw, criteria[0].name, &value));
	}
	WHEN ("Set criterion of a stopped pfw") {
	REQUIRE_FAILURE(pfwSetCriterion(pfw, criteria[0].name, 1));
	}
	WHEN ("Commit criteria of a stopped pfw") {
	REQUIRE_FAILURE(pfwApplyConfigurations(pfw));
	}

	WHEN ("Bind parameter with a stopped pfw") {
	REQUIRE(pfwBindParameter(pfw, intParameterPath) == NULL);
	}

	WHEN ("The pfw is started correctly") {
	REQUIRE_SUCCESS(pfwStart(pfw, config, criteria, criterionNb, &logger));
	int value;

	WHEN ("Get not existing criterion") {
	REQUIRE_FAILURE(pfwGetCriterion(pfw, "Do not exist", &value));
	}
	THEN ("All criterion should value 0") {
	for (size_t i = 0; i < criterionNb; ++i) {
	const char *criterionName = criteria[i].name;
	CAPTURE(criterionName);
	REQUIRE_SUCCESS(pfwGetCriterion(pfw, criterionName, &value));
	REQUIRE(value == 0);
	}
	}

	WHEN ("Set not existing criterion") {
	REQUIRE_FAILURE(pfwSetCriterion(pfw, "Do not exist", 3));
	}
	WHEN ("Set criterion value") {
	for (size_t i = 0; i < criterionNb; ++i) {
	const char *criterionName = criteria[i].name;
	CAPTURE(criterionName);
	REQUIRE_SUCCESS(pfwSetCriterion(pfw, criterionName, 3));
	}
	THEN ("Get criterion value should return what was set") {
	for (size_t i = 0; i < criterionNb; ++i) {
	const char *criterionName = criteria[i].name;
	CAPTURE(criterionName);
	REQUIRE_SUCCESS(pfwGetCriterion(pfw, criterionName, &value));
	REQUIRE(value == 3);
	}
	}
	WHEN ("Set a new value to a criterion without committing first") {
	const char *criterionName = criteria[0].name;
	REQUIRE_SUCCESS(pfwSetCriterion(pfw, criterionName, 0));
	THEN ("A warning message should have been displayed") {
	INFO("Previous pfw log: \n" + logLines);
	size_t logPos = logLines.find("Warning: Selection criterion "
	"'inclusiveCrit' has been modified 1 time(s)"
	" without any configuration application");
	CHECK(logPos != std::string::npos);
	}
	}
	}
	WHEN ("Commit criteria of a started pfw") {
	REQUIRE_SUCCESS(pfwApplyConfigurations(pfw));
	}
	WHEN ("Bind a non existing parameter") {
	REQUIRE_FAILURE(pfwBindParameter(pfw, "do/not/exist") != nullptr);
	}

	GIVEN ("An integer parameter handle") {
	PfwParameterHandler *param = pfwBindParameter(pfw, intParameterPath);
	REQUIRE_SUCCESS(param != nullptr);

	WHEN ("Set parameter out of range") {
	REQUIRE_FAILURE(pfwSetIntParameter(param, 101));
	}

	WHEN ("Set parameter") {
	REQUIRE_SUCCESS(pfwSetIntParameter(param, 11));
	THEN ("Get parameter should return what was set") {
	REQUIRE_SUCCESS(pfwGetIntParameter(param, &value));
	REQUIRE(value == 11);
	}
	}

	pfwUnbindParameter(param);
	}

	GIVEN ("An string parameter handle") {
	PfwParameterHandler *param = pfwBindParameter(pfw, stringParameterPath);
	REQUIRE_SUCCESS(param != nullptr);

	WHEN ("Set parameter out of range") {
	REQUIRE_FAILURE(pfwSetStringParameter(param, "ko_1234567"));
	}

	WHEN ("Set parameter") {
	char *value;
	REQUIRE_SUCCESS(pfwSetStringParameter(param, "ok"));
	THEN ("Get parameter should return what was set") {
	REQUIRE_SUCCESS(pfwGetStringParameter(param, &value));
	REQUIRE(value == std::string("ok"));
	pfwFree(value);
	}
	}

	pfwUnbindParameter(param);
	}
	}

	pfwDestroy(pfw);
	}
	}