GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r1206:9f9ab053f00b

Adds utility class to get random values

Alexandre Leroux -

r1206:9f9ab053f00b

parent child

Context file:

r1206:9f9ab053f00b

Collapse all files

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, returns an element built by default
	20	template <typename T, typename ValueType = typename T::value_type>
	21	ValueType randomChoice(const T& container);
	22
	23	private:
	24	std::mt19937 m_Mt;
	25
	26	explicit RandomGenerator();
	27	};
	28
	29	template<typename T, typename ValueType>
	30	ValueType RandomGenerator::randomChoice(const T &container)
	31	{
	32	if(container.empty()){
	33	return ValueType{};
	34	}
	35
	36	auto randomIndex = generateInt(0, container.size() - 1);
	37	return container.at(randomIndex);
	38	}
	39
	40	#endif // SCIQLOP_FUZZINGUTILS
	41

plugins/amda/meson.build +2 0

             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/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

plugins/amda/tests/TestAmdaFuzzing.cpp +3 -1

             #include "FuzzingDefs.h"
             #include "FuzzingOperations.h"
+            #include "FuzzingUtils.h"
             #include <Network/NetworkController.h>
             #include <SqpApplication.h>
             #include <Time/TimeController.h>
             #include <Variable/VariableController.h>
             #include <QLoggingCategory>
             #include <QObject>
             #include <QtTest>
             #include <memory>
             Q_LOGGING_CATEGORY(LOG_TestAmdaFuzzing, "TestAmdaFuzzing")
             namespace {
             // /////// //
             // Aliases //
             // /////// //
             using VariableId = int;
             using VariableOperation = std::pair<VariableId, std::shared_ptr<IFuzzingOperation> >;
             using VariablesOperations = std::vector<VariableOperation>;
             using OperationsPool = std::set<std::shared_ptr<IFuzzingOperation> >;
             using VariablesPool = std::map<VariableId, std::shared_ptr<Variable> >;
             // ///////// //
             // Constants //
             // ///////// //
             // Defaults values used when the associated properties have not been set for the test
             const auto NB_MAX_OPERATIONS_DEFAULT_VALUE = 100;
             const auto NB_MAX_VARIABLES_DEFAULT_VALUE = 1;
             const auto AVAILABLE_OPERATIONS_DEFAULT_VALUE
                 = QVariant::fromValue(OperationsTypes{FuzzingOperationType::CREATE});
             // /////// //
             // Methods //
             // /////// //
             /// Goes through the variables pool and operations pool to determine the set of {variable/operation}
             /// pairs that are valid (i.e. operation that can be executed on variable)
             VariablesOperations availableOperations(const VariablesPool &variablesPool,
                                                     const OperationsPool &operationsPool)
             {
                 VariablesOperations result{};
                 for (const auto &variablesPoolEntry : variablesPool) {
                     auto variableId = variablesPoolEntry.first;
                     auto variable = variablesPoolEntry.second;
                     for (const auto &operation : operationsPool) {
                         // A pair is valid if the current operation can be executed on the current variable
                         if (operation->canExecute(variable)) {
                             result.push_back({variableId, operation});
                         }
                     }
                 }
                 return result;
             }
             OperationsPool createOperationsPool(const OperationsTypes &types)
             {
                 OperationsPool result{};
                 std::transform(types.cbegin(), types.cend(), std::inserter(result, result.end()),
                                [](const auto &type) { return FuzzingOperationFactory::create(type); });
                 return result;
             }
             /**
              * Class to run random tests
              */
             class FuzzingTest {
             public:
                 explicit FuzzingTest(VariableController &variableController, Properties properties)
                         : m_VariableController{variableController},
                           m_Properties{std::move(properties)},
                           m_VariablesPool{}
                 {
                     // Inits variables pool: at init, all variables are null
                     for (auto variableId = 0; variableId < nbMaxVariables(); ++variableId) {
                         m_VariablesPool[variableId] = nullptr;
                     }
                 }
                 void execute()
                 {
                     qCInfo(LOG_TestAmdaFuzzing()) << "Running" << nbMaxOperations() << "operations on"
                                                   << nbMaxVariables() << "variables...";
                     auto canExecute = true;
                     for (auto i = 0; i < nbMaxOperations() && canExecute; ++i) {
                         // Retrieves all operations that can be executed in the current context
                         auto variableOperations = availableOperations(m_VariablesPool, operationsPool());
                         canExecute = !variableOperations.empty();
                         if (canExecute) {
                             // Of the operations available, chooses a random operation and executes it
                             auto variableOperation
-                                = /* TODO: gets a random operation */;
+                                = RandomGenerator::instance().randomChoice(variableOperations);
                             auto variableId = variableOperation.first;
                             auto variable = m_VariablesPool.at(variableId);
                             auto fuzzingOperation = variableOperation.second;
                             fuzzingOperation->execute(variable, m_VariableController, m_Properties);
                             // Updates variable pool with the new state of the variable after operation
                             m_VariablesPool[variableId] = variable;
                         }
                         else {
                             qCInfo(LOG_TestAmdaFuzzing())
                                 << "No more operations are available, the execution of the test will stop...";
                         }
                     }
                     qCInfo(LOG_TestAmdaFuzzing()) << "Execution of the test completed.";
                 }
             private:
                 int nbMaxOperations() const
                 {
                     static auto result
                         = m_Properties.value(NB_MAX_OPERATIONS_PROPERTY, NB_MAX_OPERATIONS_DEFAULT_VALUE)
                               .toInt();
                     return result;
                 }
                 int nbMaxVariables() const
                 {
                     static auto result
                         = m_Properties.value(NB_MAX_VARIABLES_PROPERTY, NB_MAX_VARIABLES_DEFAULT_VALUE).toInt();
                     return result;
                 }
                 OperationsPool operationsPool() const
                 {
                     static auto result = createOperationsPool(
                         m_Properties.value(AVAILABLE_OPERATIONS_PROPERTY, AVAILABLE_OPERATIONS_DEFAULT_VALUE)
                             .value<OperationsTypes>());
                     return result;
                 }
                 VariableController &m_VariableController;
                 Properties m_Properties;
                 VariablesPool m_VariablesPool;
             };
             } // namespace
             class TestAmdaFuzzing : public QObject {
                 Q_OBJECT
             private slots:
                 /// Input data for @sa testFuzzing()
                 void testFuzzing_data();
                 void testFuzzing();
             };
             void TestAmdaFuzzing::testFuzzing_data()
             {
                 // ////////////// //
                 // Test structure //
                 // ////////////// //
                 QTest::addColumn<Properties>("properties"); // Properties for random test
                 // ////////// //
                 // Test cases //
                 // ////////// //
                 ///@todo: complete
             }
             void TestAmdaFuzzing::testFuzzing()
             {
                 QFETCH(Properties, properties);
                 auto &variableController = sqpApp->variableController();
                 auto &timeController = sqpApp->timeController();
                 FuzzingTest test{variableController, properties};
                 test.execute();
             }
             int main(int argc, char *argv[])
             {
                 QLoggingCategory::setFilterRules(
                     "*.warning=false\n"
                     "*.info=false\n"
                     "*.debug=false\n"
                     "FuzzingOperations.info=true\n"
                     "TestAmdaFuzzing.info=true\n");
                 SqpApplication app{argc, argv};
                 app.setAttribute(Qt::AA_Use96Dpi, true);
                 TestAmdaFuzzing testObject{};
                 QTEST_SET_MAIN_SOURCE_PATH
                 return QTest::qExec(&testObject, argc, argv);
             }
             #include "TestAmdaFuzzing.moc"

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