GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r1253:c62577560c5b

Merge branch 'develop' of https://hephaistos.lpp.polytechnique.fr/rhodecode/GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork into feature/TestEvents

perrinel -

r1253:c62577560c5b

parent child

Context file:

r1253:c62577560c5b

Collapse all files

plugins/amda/tests/FuzzingDefs.cpp created 644 +8 0

@@ -0,0 +1,8
	1	#include "FuzzingDefs.h"
	2
	3	const QString NB_MAX_OPERATIONS_PROPERTY = QStringLiteral("component");
	4	const QString NB_MAX_VARIABLES_PROPERTY = QStringLiteral("nbMaxVariables");
	5	const QString AVAILABLE_OPERATIONS_PROPERTY = QStringLiteral("availableOperations");
	6	const QString MAX_RANGE_PROPERTY = QStringLiteral("maxRange");
	7	const QString METADATA_POOL_PROPERTY = QStringLiteral("metadataPool");
	8	const QString PROVIDER_PROPERTY = QStringLiteral("provider");

plugins/amda/tests/FuzzingDefs.h created 644 +38 0

@@ -0,0 +1,38
	1	#ifndef SCIQLOP_FUZZINGDEFS_H
	2	#define SCIQLOP_FUZZINGDEFS_H
	3
	4	#include <QString>
	5	#include <QVariantHash>
	6
	7	// /////// //
	8	// Aliases //
	9	// /////// //
	10
	11	using MetadataPool = std::vector<QVariantHash>;
	12	Q_DECLARE_METATYPE(MetadataPool)
	13
	14	using Properties = QVariantHash;
	15
	16	// ///////// //
	17	// Constants //
	18	// ///////// //
	19
	20	/// Max number of operations to generate
	21	extern const QString NB_MAX_OPERATIONS_PROPERTY;
	22
	23	/// Max number of variables to manipulate through operations
	24	extern const QString NB_MAX_VARIABLES_PROPERTY;
	25
	26	/// Set of operations available for the test
	27	extern const QString AVAILABLE_OPERATIONS_PROPERTY;
	28
	29	/// Max range that an operation can reach
	30	extern const QString MAX_RANGE_PROPERTY;
	31
	32	/// Set of metadata that can be associated to a variable
	33	extern const QString METADATA_POOL_PROPERTY;
	34
	35	/// Provider used to retrieve data
	36	extern const QString PROVIDER_PROPERTY;
	37
	38	#endif // SCIQLOP_FUZZINGDEFS_H

plugins/amda/tests/FuzzingOperations.cpp created 644 +74 0

@@ -0,0 +1,74
	1	#include "FuzzingOperations.h"
	2	#include "FuzzingUtils.h"
	3
	4	#include <Data/IDataProvider.h>
	5
	6	#include <Variable/Variable.h>
	7	#include <Variable/VariableController.h>
	8
	9	#include <QUuid>
	10
	11	Q_LOGGING_CATEGORY(LOG_FuzzingOperations, "FuzzingOperations")
	12
	13	namespace {
	14
	15	struct CreateOperation : public IFuzzingOperation {
	16	bool canExecute(std::shared_ptr<Variable> variable) const override
	17	{
	18	// A variable can be created only if it doesn't exist yet
	19	return variable == nullptr;
	20	}
	21
	22	void execute(std::shared_ptr<Variable> &variable, VariableController &variableController,
	23	const Properties &properties) const override
	24	{
	25	// Retrieves metadata pool from properties, and choose one of the metadata entries to
	26	// associate it with the variable
	27	auto metaDataPool = properties.value(METADATA_POOL_PROPERTY).value<MetadataPool>();
	28	auto variableMetadata = RandomGenerator::instance().randomChoice(metaDataPool);
	29
	30	// Retrieves provider
	31	auto variableProvider
	32	= properties.value(PROVIDER_PROPERTY).value<std::shared_ptr<IDataProvider> >();
	33
	34	auto variableName = QString{"Var_%1"}.arg(QUuid::createUuid().toString());
	35	qCInfo(LOG_FuzzingOperations())
	36	<< "Creating variable" << variableName << "(metadata:" << variableMetadata << ")";
	37
	38	auto newVariable
	39	= variableController.createVariable(variableName, variableMetadata, variableProvider);
	40	std::swap(variable, newVariable);
	41	}
	42	};
	43
	44	struct UnknownOperation : public IFuzzingOperation {
	45	bool canExecute(std::shared_ptr<Variable> variable) const override
	46	{
	47	Q_UNUSED(variable);
	48	return false;
	49	}
	50
	51	void execute(std::shared_ptr<Variable> &variable, VariableController &variableController,
	52	const Properties &properties) const override
	53	{
	54	Q_UNUSED(variable);
	55	Q_UNUSED(variableController);
	56	Q_UNUSED(properties);
	57	// Does nothing
	58	}
	59	};
	60
	61	} // namespace
	62
	63	std::unique_ptr<IFuzzingOperation> FuzzingOperationFactory::create(FuzzingOperationType type)
	64	{
	65	switch (type) {
	66	case FuzzingOperationType::CREATE:
	67	return std::make_unique<CreateOperation>();
	68	default:
	69	// Default case returns unknown operation
	70	break;
	71	}
	72
	73	return std::make_unique<UnknownOperation>();
	74	}

plugins/amda/tests/FuzzingOperations.h created 644 +49 0

@@ -0,0 +1,49
	1	#ifndef SCIQLOP_FUZZINGOPERATIONS_H
	2	#define SCIQLOP_FUZZINGOPERATIONS_H
	3
	4	#include "FuzzingDefs.h"
	5
	6	#include <memory>
	7	#include <set>
	8
	9	#include <QLoggingCategory>
	10	#include <QMetaType>
	11
	12	Q_DECLARE_LOGGING_CATEGORY(LOG_FuzzingOperations)
	13
	14	class Variable;
	15	class VariableController;
	16
	17	/**
	18	* Enumeration of types of existing fuzzing operations
	19	*/
	20	enum class FuzzingOperationType { CREATE };
	21
	22	/// Interface that represents an operation that can be executed during a fuzzing test
	23	struct IFuzzingOperation {
	24	virtual ~IFuzzingOperation() noexcept = default;
	25
	26	/// Checks if the operation can be executed according to the current state of the variable
	27	/// passed in parameter
	28	virtual bool canExecute(std::shared_ptr<Variable> variable) const = 0;
	29	/// Executes the operation on the variable passed in parameter
	30	/// @param variable the variable on which to execute the operation
	31	/// @param variableController the controller associated to the operation
	32	/// @param properties properties that can be used to configure the operation
	33	/// @remarks variable is passed as a reference because, according to the operation, it can be
	34	/// modified (in/out parameter)
	35	virtual void execute(std::shared_ptr<Variable> &variable,
	36	VariableController &variableController,
	37	const Properties &properties = {}) const = 0;
	38	};
	39
	40	/// Factory of @sa IFuzzingOperation
	41	struct FuzzingOperationFactory {
	42	/// Creates a fuzzing operation from a type
	43	static std::unique_ptr<IFuzzingOperation> create(FuzzingOperationType type);
	44	};
	45
	46	using OperationsTypes = std::set<FuzzingOperationType>;
	47	Q_DECLARE_METATYPE(OperationsTypes)
	48
	49	#endif // SCIQLOP_FUZZINGOPERATIONS_H

plugins/amda/tests/FuzzingUtils.cpp created 644 +25 0

@@ -0,0 +1,25
	1	#include "FuzzingUtils.h"
	2
	3	RandomGenerator &RandomGenerator::instance()
	4	{
	5	static auto instance = RandomGenerator();
	6	return instance;
	7	}
	8
	9	double RandomGenerator::generateDouble(double min, double max)
	10	{
	11	std::uniform_real_distribution<double> dist{min, max};
	12	return dist(m_Mt);
	13	}
	14
	15	int RandomGenerator::generateInt(int min, int max)
	16	{
	17	std::uniform_int_distribution<int> dist{min, max};
	18	return dist(m_Mt);
	19	}
	20
	21	RandomGenerator::RandomGenerator()
	22	{
	23	std::random_device rd{};
	24	m_Mt = std::mt19937{rd()};
	25	}

plugins/amda/tests/FuzzingUtils.h created 644 +41 0

@@ -0,0 +1,41
	1	#ifndef SCIQLOP_FUZZINGUTILS_H
	2	#define SCIQLOP_FUZZINGUTILS_H
	3
	4	#include <random>
	5
	6	/**
	7	* Class that proposes random utility methods
	8	*/
	9	class RandomGenerator {
	10	public:
	11	/// @return the unique instance of the random generator
	12	static RandomGenerator &instance();
	13
	14	/// Generates a random double between [min, max]
	15	double generateDouble(double min, double max);
	16	/// Generates a random int between [min, max]
	17	int generateInt(int min, int max);
	18
	19	/// Returns a random element among the elements of a container. If the container is empty,
	20	/// returns an element built by default
	21	template <typename T, typename ValueType = typename T::value_type>
	22	ValueType randomChoice(const T &container);
	23
	24	private:
	25	std::mt19937 m_Mt;
	26
	27	explicit RandomGenerator();
	28	};
	29
	30	template <typename T, typename ValueType>
	31	ValueType RandomGenerator::randomChoice(const T &container)
	32	{
	33	if (container.empty()) {
	34	return ValueType{};
	35	}
	36
	37	auto randomIndex = generateInt(0, container.size() - 1);
	38	return container.at(randomIndex);
	39	}
	40
	41	#endif // SCIQLOP_FUZZINGUTILS

plugins/amda/tests/TestAmdaFuzzing.cpp created 644 +241 0

@@ -0,0 +1,241
	1	#include "FuzzingDefs.h"
	2	#include "FuzzingOperations.h"
	3	#include "FuzzingUtils.h"
	4
	5	#include "AmdaProvider.h"
	6
	7	#include <Network/NetworkController.h>
	8	#include <SqpApplication.h>
	9	#include <Time/TimeController.h>
	10	#include <Variable/VariableController.h>
	11
	12	#include <QLoggingCategory>
	13	#include <QObject>
	14	#include <QtTest>
	15
	16	#include <memory>
	17
	18	Q_LOGGING_CATEGORY(LOG_TestAmdaFuzzing, "TestAmdaFuzzing")
	19
	20	namespace {
	21
	22	// /////// //
	23	// Aliases //
	24	// /////// //
	25
	26	using VariableId = int;
	27
	28	using VariableOperation = std::pair<VariableId, std::shared_ptr<IFuzzingOperation> >;
	29	using VariablesOperations = std::vector<VariableOperation>;
	30
	31	using OperationsPool = std::set<std::shared_ptr<IFuzzingOperation> >;
	32	using VariablesPool = std::map<VariableId, std::shared_ptr<Variable> >;
	33
	34	// ///////// //
	35	// Constants //
	36	// ///////// //
	37
	38	// Defaults values used when the associated properties have not been set for the test
	39	const auto NB_MAX_OPERATIONS_DEFAULT_VALUE = 100;
	40	const auto NB_MAX_VARIABLES_DEFAULT_VALUE = 1;
	41	const auto AVAILABLE_OPERATIONS_DEFAULT_VALUE
	42	= QVariant::fromValue(OperationsTypes{FuzzingOperationType::CREATE});
	43
	44	// /////// //
	45	// Methods //
	46	// /////// //
	47
	48	/// Goes through the variables pool and operations pool to determine the set of {variable/operation}
	49	/// pairs that are valid (i.e. operation that can be executed on variable)
	50	VariablesOperations availableOperations(const VariablesPool &variablesPool,
	51	const OperationsPool &operationsPool)
	52	{
	53	VariablesOperations result{};
	54
	55	for (const auto &variablesPoolEntry : variablesPool) {
	56	auto variableId = variablesPoolEntry.first;
	57	auto variable = variablesPoolEntry.second;
	58
	59	for (const auto &operation : operationsPool) {
	60	// A pair is valid if the current operation can be executed on the current variable
	61	if (operation->canExecute(variable)) {
	62	result.push_back({variableId, operation});
	63	}
	64	}
	65	}
	66
	67	return result;
	68	}
	69
	70	OperationsPool createOperationsPool(const OperationsTypes &types)
	71	{
	72	OperationsPool result{};
	73
	74	std::transform(types.cbegin(), types.cend(), std::inserter(result, result.end()),
	75	[](const auto &type) { return FuzzingOperationFactory::create(type); });
	76
	77	return result;
	78	}
	79
	80	/**
	81	* Class to run random tests
	82	*/
	83	class FuzzingTest {
	84	public:
	85	explicit FuzzingTest(VariableController &variableController, Properties properties)
	86	: m_VariableController{variableController},
	87	m_Properties{std::move(properties)},
	88	m_VariablesPool{}
	89	{
	90	// Inits variables pool: at init, all variables are null
	91	for (auto variableId = 0; variableId < nbMaxVariables(); ++variableId) {
	92	m_VariablesPool[variableId] = nullptr;
	93	}
	94	}
	95
	96	void execute()
	97	{
	98	qCInfo(LOG_TestAmdaFuzzing()) << "Running" << nbMaxOperations() << "operations on"
	99	<< nbMaxVariables() << "variable(s)...";
	100
	101	auto canExecute = true;
	102	for (auto i = 0; i < nbMaxOperations() && canExecute; ++i) {
	103	// Retrieves all operations that can be executed in the current context
	104	auto variableOperations = availableOperations(m_VariablesPool, operationsPool());
	105
	106	canExecute = !variableOperations.empty();
	107	if (canExecute) {
	108	// Of the operations available, chooses a random operation and executes it
	109	auto variableOperation
	110	= RandomGenerator::instance().randomChoice(variableOperations);
	111
	112	auto variableId = variableOperation.first;
	113	auto variable = m_VariablesPool.at(variableId);
	114	auto fuzzingOperation = variableOperation.second;
	115
	116	fuzzingOperation->execute(variable, m_VariableController, m_Properties);
	117
	118	// Updates variable pool with the new state of the variable after operation
	119	m_VariablesPool[variableId] = variable;
	120	}
	121	else {
	122	qCInfo(LOG_TestAmdaFuzzing())
	123	<< "No more operations are available, the execution of the test will stop...";
	124	}
	125	}
	126
	127	qCInfo(LOG_TestAmdaFuzzing()) << "Execution of the test completed.";
	128	}
	129
	130	private:
	131	int nbMaxOperations() const
	132	{
	133	static auto result
	134	= m_Properties.value(NB_MAX_OPERATIONS_PROPERTY, NB_MAX_OPERATIONS_DEFAULT_VALUE)
	135	.toInt();
	136	return result;
	137	}
	138
	139	int nbMaxVariables() const
	140	{
	141	static auto result
	142	= m_Properties.value(NB_MAX_VARIABLES_PROPERTY, NB_MAX_VARIABLES_DEFAULT_VALUE).toInt();
	143	return result;
	144	}
	145
	146	OperationsPool operationsPool() const
	147	{
	148	static auto result = createOperationsPool(
	149	m_Properties.value(AVAILABLE_OPERATIONS_PROPERTY, AVAILABLE_OPERATIONS_DEFAULT_VALUE)
	150	.value<OperationsTypes>());
	151	return result;
	152	}
	153
	154	VariableController &m_VariableController;
	155	Properties m_Properties;
	156	VariablesPool m_VariablesPool;
	157	};
	158
	159	} // namespace
	160
	161	class TestAmdaFuzzing : public QObject {
	162	Q_OBJECT
	163
	164	private slots:
	165	/// Input data for @sa testFuzzing()
	166	void testFuzzing_data();
	167	void testFuzzing();
	168	};
	169
	170	void TestAmdaFuzzing::testFuzzing_data()
	171	{
	172	// ////////////// //
	173	// Test structure //
	174	// ////////////// //
	175
	176	QTest::addColumn<Properties>("properties"); // Properties for random test
	177
	178	// ////////// //
	179	// Test cases //
	180	// ////////// //
	181
	182	auto maxRange = SqpRange::fromDateTime({2017, 1, 1}, {0, 0}, {2017, 1, 5}, {0, 0});
	183	MetadataPool metadataPool{{{"dataType", "vector"}, {"xml:id", "imf"}}};
	184
	185	// Note: we don't use auto here as we want to pass std::shared_ptr<IDataProvider> as is in the
	186	// QVariant
	187	std::shared_ptr<IDataProvider> provider = std::make_shared<AmdaProvider>();
	188
	189	QTest::newRow("fuzzingTest") << Properties{
	190	{MAX_RANGE_PROPERTY, QVariant::fromValue(maxRange)},
	191	{METADATA_POOL_PROPERTY, QVariant::fromValue(metadataPool)},
	192	{PROVIDER_PROPERTY, QVariant::fromValue(provider)}};
	193	}
	194
	195	void TestAmdaFuzzing::testFuzzing()
	196	{
	197	QFETCH(Properties, properties);
	198
	199	auto &variableController = sqpApp->variableController();
	200	auto &timeController = sqpApp->timeController();
	201
	202	// Generates random initial range (bounded to max range)
	203	auto maxRange = properties.value(MAX_RANGE_PROPERTY, QVariant::fromValue(INVALID_RANGE))
	204	.value<SqpRange>();
	205
	206	QVERIFY(maxRange != INVALID_RANGE);
	207
	208	auto initialRangeStart
	209	= RandomGenerator::instance().generateDouble(maxRange.m_TStart, maxRange.m_TEnd);
	210	auto initialRangeEnd
	211	= RandomGenerator::instance().generateDouble(maxRange.m_TStart, maxRange.m_TEnd);
	212	if (initialRangeStart > initialRangeEnd) {
	213	std::swap(initialRangeStart, initialRangeEnd);
	214	}
	215
	216	// Sets initial range on time controller
	217	SqpRange initialRange{initialRangeStart, initialRangeEnd};
	218	qCInfo(LOG_TestAmdaFuzzing()) << "Setting initial range to" << initialRange << "...";
	219	timeController.onTimeToUpdate(initialRange);
	220
	221	FuzzingTest test{variableController, properties};
	222	test.execute();
	223	}
	224
	225	int main(int argc, char *argv[])
	226	{
	227	QLoggingCategory::setFilterRules(
	228	"*.warning=false\n"
	229	"*.info=false\n"
	230	"*.debug=false\n"
	231	"FuzzingOperations.info=true\n"
	232	"TestAmdaFuzzing.info=true\n");
	233
	234	SqpApplication app{argc, argv};
	235	app.setAttribute(Qt::AA_Use96Dpi, true);
	236	TestAmdaFuzzing testObject{};
	237	QTEST_SET_MAIN_SOURCE_PATH
	238	return QTest::qExec(&testObject, argc, argv);
	239	}
	240
	241	#include "TestAmdaFuzzing.moc"

core/include/Data/SqpRange.h +8 0

             #ifndef SCIQLOP_SQPRANGE_H
             #define SCIQLOP_SQPRANGE_H
             #include <QObject>
             #include <QDebug>
             #include <Common/DateUtils.h>
             #include <Common/MetaTypes.h>
             #include <cmath>
             /**
              * @brief The SqpRange struct holds the information of time parameters
              */
             struct SqpRange {
+                /// Creates SqpRange from dates and times
+                static SqpRange fromDateTime(const QDate &startDate, const QTime &startTime,
+                                             const QDate &endDate, const QTime &endTime)
+                {
+                    return {DateUtils::secondsSinceEpoch(QDateTime{startDate, startTime}),
+                            DateUtils::secondsSinceEpoch(QDateTime{endDate, endTime})};
+                }
                 /// Start time (UTC)
                 double m_TStart;
                 /// End time (UTC)
                 double m_TEnd;
                 bool contains(const SqpRange &dateTime) const noexcept
                 {
                     return (m_TStart <= dateTime.m_TStart && m_TEnd >= dateTime.m_TEnd);
                 }
                 bool intersect(const SqpRange &dateTime) const noexcept
                 {
                     return (m_TEnd >= dateTime.m_TStart && m_TStart <= dateTime.m_TEnd);
                 }
                 bool operator==(const SqpRange &other) const
                 {
                     auto equals = [](const auto &v1, const auto &v2) {
                         return (std::isnan(v1) && std::isnan(v2)) || v1 == v2;
                     };
                     return equals(m_TStart, other.m_TStart) && equals(m_TEnd, other.m_TEnd);
                 }
                 bool operator!=(const SqpRange &other) const { return !(*this == other); }
             };
             const auto INVALID_RANGE
                 = SqpRange{std::numeric_limits<double>::quiet_NaN(), std::numeric_limits<double>::quiet_NaN()};
             inline QDebug operator<<(QDebug d, SqpRange obj)
             {
                 auto tendDateTimeStart = DateUtils::dateTime(obj.m_TStart);
                 auto tendDateTimeEnd = DateUtils::dateTime(obj.m_TEnd);
                 d << "ts: " << tendDateTimeStart << " te: " << tendDateTimeEnd;
                 return d;
             }
             // Required for using shared_ptr in signals/slots
             SCIQLOP_REGISTER_META_TYPE(SQPRANGE_REGISTRY, SqpRange)
             #endif // SCIQLOP_SQPRANGE_H

plugins/amda/CMakeLists.txt +1 0

             ## amda - CMakeLists.txt
             STRING(TOLOWER ${CMAKE_PROJECT_NAME} LIBRARY_PREFFIX)
             SET(SQPAMDA_LIBRARY_NAME "${LIBRARY_PREFFIX}_amda${DEBUG_SUFFIX}")
             SET(SOURCES_DIR "${CMAKE_CURRENT_SOURCE_DIR}/src")
             SET(INCLUDES_DIR "${CMAKE_CURRENT_SOURCE_DIR}/include")
             SET(RESOURCES_DIR "${CMAKE_CURRENT_SOURCE_DIR}/resources")
             SET(TESTS_RESOURCES_DIR "${CMAKE_CURRENT_SOURCE_DIR}/tests-resources")
             # Include amda directory
             INCLUDE_DIRECTORIES(${INCLUDES_DIR})
             INCLUDE_DIRECTORIES(${RESOURCES_DIR})
             #
             # Find Qt modules
             #
             SCIQLOP_FIND_QT(Core Widgets Network)
             #
             # Find dependent libraries
             # ========================
             # sciqlop plugin
             find_package(sciqlop-plugin)
             INCLUDE_DIRECTORIES(${SCIQLOP-PLUGIN_INCLUDE_DIR})
             # sciqlop core
             find_package(sciqlop-core)
             INCLUDE_DIRECTORIES(${SCIQLOP-CORE_INCLUDE_DIR})
             list(APPEND LIBRARIES ${SCIQLOP-CORE_LIBRARIES})
             # sciqlop gui
             find_package(sciqlop-gui)
             INCLUDE_DIRECTORIES(${SCIQLOP-GUI_INCLUDE_DIR})
             list(APPEND LIBRARIES ${SCIQLOP-GUI_LIBRARIES})
             # Description file
             FILE (GLOB_RECURSE PLUGIN_FILE ${RESOURCES_DIR}/amda.json)
             # Resources files
             FILE (GLOB_RECURSE PROJECT_RESOURCES ${RESOURCES_DIR}/*.qrc)
             #
             # Compile the library
             #
             ADD_DEFINITIONS(-DAMDA_LIB)
             FILE (GLOB_RECURSE MODULE_SOURCES
                     ${INCLUDES_DIR}/*.h
                     ${SOURCES_DIR}/*.c
                     ${SOURCES_DIR}/*.cpp
                     ${SOURCES_DIR}/*.h
                     ${PLUGIN_FILE})
             QT5_ADD_RESOURCES(RCC_AMDA
                 ${PROJECT_RESOURCES}
             )
             ADD_LIBRARY(${SQPAMDA_LIBRARY_NAME} ${MODULE_SOURCES} ${RCC_AMDA})
             set_property(TARGET ${SQPAMDA_LIBRARY_NAME} PROPERTY CXX_STANDARD 14)
             set_property(TARGET ${SQPAMDA_LIBRARY_NAME} PROPERTY CXX_STANDARD_REQUIRED ON)
             INSTALL(TARGETS ${SQPAMDA_LIBRARY_NAME}
               RUNTIME DESTINATION ${INSTALL_BINARY_DIR}
               LIBRARY DESTINATION ${INSTALL_PLUGINS_LIBRARY_DIR}
               ARCHIVE DESTINATION ${INSTALL_PLUGINS_LIBRARY_DIR}
             )
             TARGET_LINK_LIBRARIES(${SQPAMDA_LIBRARY_NAME} ${LIBRARIES})
             qt5_use_modules(${SQPAMDA_LIBRARY_NAME} Core Widgets Network)
             add_dependencies(${SQPAMDA_LIBRARY_NAME} ${SQPPLUGIN_LIBRARY_NAME} ${SQPGUI_LIBRARY_NAME} ${SQPCORE_LIBRARY_NAME})
             # From cmake documentation: http://www.cmake.org/cmake/help/v3.0/manual/cmake-buildsystem.7.html
             # Entries in the COMPILE_DEFINITIONS are prefixed with -D or /D and added to the compile line in an unspecified order.
             # The DEFINE_SYMBOL target property is also added as a compile definition as a special convenience case for SHARED and MODULE library targets
             IF(BUILD_SHARED_LIBS)
                     SET_TARGET_PROPERTIES(${SQPAMDA_LIBRARY_NAME} PROPERTIES COMPILE_DEFINITIONS "SCIQLOP_EXPORT")
             ELSE()
                     TARGET_COMPILE_DEFINITIONS(${SQPAMDA_LIBRARY_NAME} PUBLIC "SCIQLOP_STATIC_LIBRARIES")
             ENDIF()
             # Set the variable to parent scope so that the other projects can copy the
             # dependent shared libraries
             SCIQLOP_SET_TO_PARENT_SCOPE(SQPAMDA_LIBRARY_NAME)
             # Copy extern shared libraries to the lib folder
             SCIQLOP_COPY_TO_TARGET(LIBRARY ${SQPAMDA_LIBRARY_NAME} ${EXTERN_SHARED_LIBRARIES})
             # Add the files to the list of files to be analyzed
             LIST(APPEND CHECKSTYLE_INPUT_FILES ${MODULE_SOURCES})
             SCIQLOP_SET_TO_PARENT_SCOPE(CHECKSTYLE_INPUT_FILES)
             # Vera++ exclusion files
             LIST(APPEND CHECKSTYLE_EXCLUSION_FILES ${CMAKE_CURRENT_SOURCE_DIR}/vera-exclusions/exclusions.txt)
             SCIQLOP_SET_TO_PARENT_SCOPE(CHECKSTYLE_EXCLUSION_FILES)
             #
             # Compile the tests
             #
             IF(BUILD_TESTS)
                     INCLUDE_DIRECTORIES(${SOURCES_DIR})
                     FILE (GLOB_RECURSE TESTS_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/Test*.cpp)
                     FILE (GLOB_RECURSE TESTS_HEADERS ${CMAKE_CURRENT_SOURCE_DIR}/Test*.h)
                     SET( TEST_LIBRARIES ${SQPAMDA_LIBRARY_NAME})
                     FOREACH( testFile ${TESTS_SOURCES} )
                             GET_FILENAME_COMPONENT( testDirectory ${testFile} DIRECTORY )
                             GET_FILENAME_COMPONENT( testName ${testFile} NAME_WE )
                             # Add to the list of sources files all the sources in the same
                             # directory that aren't another test
                             FILE (GLOB currentTestSources
                                     ${testDirectory}/*.c
                                     ${testDirectory}/*.cpp
                                     ${testDirectory}/*.h)
                             LIST (REMOVE_ITEM currentTestSources ${TESTS_SOURCES})
+                            LIST(APPEND testFilesToFormat ${currentTestSources})
                             # LIST (REMOVE_ITEM currentTestSources ${TESTS_HEADERS})
                             ADD_EXECUTABLE(${testName} ${testFile} ${currentTestSources})
                             set_property(TARGET ${testName} PROPERTY CXX_STANDARD 14)
                             set_property(TARGET ${testName} PROPERTY CXX_STANDARD_REQUIRED ON)
                             TARGET_LINK_LIBRARIES( ${testName} ${TEST_LIBRARIES} )
                             qt5_use_modules(${testName} Test)
                             ADD_TEST( NAME ${testName} COMMAND ${testName} )
                             SCIQLOP_COPY_TO_TARGET(RUNTIME ${testName} ${EXTERN_SHARED_LIBRARIES})
                     ENDFOREACH( testFile )
                     LIST(APPEND testFilesToFormat ${TESTS_SOURCES})
                     LIST(APPEND testFilesToFormat ${TESTS_HEADERS})
                     LIST(APPEND FORMATTING_INPUT_FILES ${testFilesToFormat})
                     SCIQLOP_SET_TO_PARENT_SCOPE(FORMATTING_INPUT_FILES)
                     ADD_DEFINITIONS(-DAMDA_TESTS_RESOURCES_DIR="${TESTS_RESOURCES_DIR}")
             ENDIF(BUILD_TESTS)
             #
             # Set the files that must be formatted by clang-format.
             #
             LIST (APPEND FORMATTING_INPUT_FILES ${MODULE_SOURCES})
             SCIQLOP_SET_TO_PARENT_SCOPE(FORMATTING_INPUT_FILES)
             #
             # Set the directories that doxygen must browse to generate the
             # documentation.
             #
             # Source directories:
             LIST (APPEND DOXYGEN_INPUT_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/docs")
             LIST (APPEND DOXYGEN_INPUT_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/src")
             SCIQLOP_SET_TO_PARENT_SCOPE(DOXYGEN_INPUT_DIRS)
             # Source directories to exclude from the documentation generation
             #LIST (APPEND DOXYGEN_EXCLUDE_PATTERNS "${CMAKE_CURRENT_SOURCE_DIR}/path/to/subdir/*")
             SCIQLOP_SET_TO_PARENT_SCOPE(DOXYGEN_EXCLUDE_PATTERNS)
             #
             # Set the directories with the sources to analyze and propagate the
             # modification to the parent scope
             #
             # Source directories to analyze:
             LIST (APPEND ANALYSIS_INPUT_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/src")
             LIST (APPEND ANALYSIS_INPUT_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/tests")
             SCIQLOP_SET_TO_PARENT_SCOPE(ANALYSIS_INPUT_DIRS)
             # Source directories to exclude from the analysis
             #LIST (APPEND ANALYSIS_EXCLUDE_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/path/to/subdir")
             SCIQLOP_SET_TO_PARENT_SCOPE(ANALYSIS_EXCLUDE_DIRS)

plugins/amda/meson.build +12 -1

             amdaplugin_moc_headers = [
               'include/AmdaPlugin.h',
               'include/AmdaProvider.h'
             ]
             amdaplugin_sources = [
               'src/AmdaDefs.cpp',
               'src/AmdaParser.cpp',
               'src/AmdaPlugin.cpp',
               'src/AmdaProvider.cpp',
               'src/AmdaResultParser.cpp',
               'src/AmdaResultParserDefs.cpp',
               'src/AmdaResultParserHelper.cpp',
               'src/AmdaServer.cpp'
             ]
             amdaplugin_ui_files = []
             amdaplugin_resources_files = [
               'resources/amdaresources.qrc'
             ]
             amdaplugin_inc = include_directories(['include', '../../plugin/include'])
             moc_gen = generator(moc,
                             output  : 'moc_@BASENAME@.cpp',
                             arguments : ['@INPUT@',
                              '-DSCIQLOP_PLUGIN_JSON_FILE_PATH="'+meson.source_root()+'/plugins/amda/resources/amda.json"',
                              '-I', meson.current_source_dir()+'/include',
                              '-I', meson.current_source_dir()+'/../../plugin/include',
                              '-o', '@OUTPUT@'])
             rcc_gen = generator(rcc,
                             output  : 'qrc_@BASENAME@.cpp',
                             arguments : ['--name=@BASENAME@"',
                              '--output',
                              '@OUTPUT@',
                              '@INPUT@'])
             amdaplugin_moc_plugin_files = moc_gen.process(amdaplugin_moc_headers)
             amdaplugin_rcc_plugin_files = rcc_gen.process(amdaplugin_resources_files)
             #amdaplugin_rcc_plugin_files = qt5.preprocess(
             #                               qresources : amdaplugin_resources_files)
             amdaplugin_moc_files = qt5.preprocess(
                                            ui_files : amdaplugin_ui_files)
             sciqlop_amdaplugin = library('amdaplugin',
                                    amdaplugin_sources,
                                    amdaplugin_moc_files,
                                    amdaplugin_rcc_plugin_files,
                                    amdaplugin_moc_plugin_files,
                                    cpp_args : ['-DAMDA_LIB','-DQT_PLUGIN'],
                                    include_directories : [amdaplugin_inc],
                                    dependencies : [sciqlop_core, sciqlop_gui],
                                    install : true
                                    )
             tests = [
               [['tests/TestAmdaParser.cpp'],'test_amda_parser','AMDA parser test'],
               [['tests/TestAmdaResultParser.cpp'],'test_amda_result_parser','AMDA result parser test'],
-              [['tests/TestAmdaAcquisition.cpp'],'test_amda_acquisition','AMDA Acquisition test']
+              [['tests/TestAmdaAcquisition.cpp'],'test_amda_acquisition','AMDA Acquisition test'],
+              [['tests/TestAmdaFuzzing.cpp'],'test_amda_fuzzing','AMDA fuzzing test']
+            ]
+            tests_sources = [
+              'tests/FuzzingDefs.h',
+              'tests/FuzzingDefs.cpp',
+              'tests/FuzzingOperations.h',
+              'tests/FuzzingOperations.cpp',
+              'tests/FuzzingUtils.h',
+              'tests/FuzzingUtils.cpp'
             ]
             foreach unit_test : tests
               test_moc_files = qt5.preprocess(moc_sources : unit_test[0])
               test_exe = executable(unit_test[1],unit_test[0] , test_moc_files,
                                       link_with : [sciqlop_amdaplugin],
                                       include_directories : [amdaplugin_inc],
                                       cpp_args : ['-DAMDA_TESTS_RESOURCES_DIR="'+meson.current_source_dir()+'/tests-resources"'],
+            						  sources : [tests_sources],
                                       dependencies : [sciqlop_core, sciqlop_gui, qt5test])
               test(unit_test[2], test_exe, args: ['-teamcity', '-o', '@0@.teamcity.txt'.format(unit_test[1])], timeout: 3 * 60)
             endforeach

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages