HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r1180:08e858e2cf84

Fixes clang-format for resource files

Alexandre Leroux -

r1180:08e858e2cf84

parent child

Context file:

r1180:08e858e2cf84

Collapse all files

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/tests/FuzzingOperations.cpp +23 -13

             #include "FuzzingOperations.h"
             #include "FuzzingUtils.h"
             #include <Data/IDataProvider.h>
             #include <Variable/Variable.h>
             #include <Variable/VariableController.h>
             #include <QUuid>
             Q_LOGGING_CATEGORY(LOG_FuzzingOperations, "FuzzingOperations")
             namespace {
             struct CreateOperation : public IFuzzingOperation {
-                bool canExecute(std::shared_ptr<Variable> variable) const override {
+                bool canExecute(std::shared_ptr<Variable> variable) const override
+                {
                     // A variable can be created only if it doesn't exist yet
                     return variable == nullptr;
                 }
-                void execute(std::shared_ptr<Variable>& variable, VariableController &variableController, const Properties &properties) const override{
+                void execute(std::shared_ptr<Variable> &variable, VariableController &variableController,
-                    // Retrieves metadata pool from properties, and choose one of the metadata entries to associate it with the variable
+                             const Properties &properties) const override
+                {
+                    // Retrieves metadata pool from properties, and choose one of the metadata entries to
+                    // associate it with the variable
                     auto metaDataPool = properties.value(METADATA_POOL_PROPERTY).value<MetadataPool>();
                     auto variableMetadata = RandomGenerator::instance().randomChoice(metaDataPool);
                     // Retrieves provider
-                    auto variableProvider = properties.value(PROVIDER_PROPERTY).value<std::shared_ptr<IDataProvider>>();
+                    auto variableProvider
+                        = properties.value(PROVIDER_PROPERTY).value<std::shared_ptr<IDataProvider> >();
                     auto variableName = QString{"Var_%1"}.arg(QUuid::createUuid().toString());
-                    qCInfo(LOG_FuzzingOperations()) << "Creating variable" << variableName << "(metadata:" << variableMetadata << ")";
+                    qCInfo(LOG_FuzzingOperations())
+                        << "Creating variable" << variableName << "(metadata:" << variableMetadata << ")";
-                    auto newVariable = variableController.createVariable(variableName, variableMetadata, variableProvider);
+                    auto newVariable
+                        = variableController.createVariable(variableName, variableMetadata, variableProvider);
                     std::swap(variable, newVariable);
                 }
             };
             struct UnknownOperation : public IFuzzingOperation {
-                bool canExecute(std::shared_ptr<Variable> variable) const override {
+                bool canExecute(std::shared_ptr<Variable> variable) const override
+                {
                     Q_UNUSED(variable);
                     return false;
                 }
-                void execute(std::shared_ptr<Variable>& variable, VariableController &variableController, const Properties &properties) const override{
+                void execute(std::shared_ptr<Variable> &variable, VariableController &variableController,
+                             const Properties &properties) const override
+                {
                     Q_UNUSED(variable);
                     Q_UNUSED(variableController);
                     Q_UNUSED(properties);
                     // Does nothing
                 }
             };
             } // namespace
             std::unique_ptr<IFuzzingOperation> FuzzingOperationFactory::create(FuzzingOperationType type)
             {
                 switch (type) {
-                case FuzzingOperationType::CREATE:
+                    case FuzzingOperationType::CREATE:
-                    return std::make_unique<CreateOperation>();
+                        return std::make_unique<CreateOperation>();
-                default:
+                    default:
-                    // Default case returns unknown operation
+                        // Default case returns unknown operation
-                    break;
+                        break;
                 }
                 return std::make_unique<UnknownOperation>();
             }

plugins/amda/tests/FuzzingOperations.h +8 -6

             #ifndef SCIQLOP_FUZZINGOPERATIONS_H
             #define SCIQLOP_FUZZINGOPERATIONS_H
             #include "FuzzingDefs.h"
             #include <memory>
             #include <set>
             #include <QLoggingCategory>
             #include <QMetaType>
             Q_DECLARE_LOGGING_CATEGORY(LOG_FuzzingOperations)
             class Variable;
             class VariableController;
             /**
              * Enumeration of types of existing fuzzing operations
              */
-            enum class FuzzingOperationType {
+            enum class FuzzingOperationType { CREATE };
-                CREATE
-            };
             /// Interface that represents an operation that can be executed during a fuzzing test
             struct IFuzzingOperation {
                 virtual ~IFuzzingOperation() noexcept = default;
-                /// Checks if the operation can be executed according to the current state of the variable passed in parameter
+                /// Checks if the operation can be executed according to the current state of the variable
+                /// passed in parameter
                 virtual bool canExecute(std::shared_ptr<Variable> variable) const = 0;
                 /// Executes the operation on the variable passed in parameter
                 /// @param variable the variable on which to execute the operation
                 /// @param variableController the controller associated to the operation
                 /// @param properties properties that can be used to configure the operation
-                /// @remarks variable is passed as a reference because, according to the operation, it can be modified (in/out parameter)
+                /// @remarks variable is passed as a reference because, according to the operation, it can be
-                virtual void execute(std::shared_ptr<Variable> &variable, VariableController& variableController, const Properties& properties = {}) const = 0;
+                /// modified (in/out parameter)
+                virtual void execute(std::shared_ptr<Variable> &variable,
+                                     VariableController &variableController,
+                                     const Properties &properties = {}) const = 0;
             };
             /// Factory of @sa IFuzzingOperation
             struct FuzzingOperationFactory {
                 /// Creates a fuzzing operation from a type
                 static std::unique_ptr<IFuzzingOperation> create(FuzzingOperationType type);
             };
             using OperationsTypes = std::set<FuzzingOperationType>;
             Q_DECLARE_METATYPE(OperationsTypes)
             #endif // SCIQLOP_FUZZINGOPERATIONS_H

plugins/amda/tests/FuzzingUtils.h +5 -5

             #ifndef SCIQLOP_FUZZINGUTILS_H
             #define SCIQLOP_FUZZINGUTILS_H
             #include <random>
             /**
              * Class that proposes random utility methods
              */
             class RandomGenerator {
             public:
                 /// @return the unique instance of the random generator
                 static RandomGenerator &instance();
                 /// Generates a random double between [min, max]
                 double generateDouble(double min, double max);
                 /// Generates a random int between [min, max]
                 int generateInt(int min, int max);
-                /// Returns a random element among the elements of a container. If the container is empty, returns an element built by default
+                /// Returns a random element among the elements of a container. If the container is empty,
+                /// returns an element built by default
                 template <typename T, typename ValueType = typename T::value_type>
-                ValueType randomChoice(const T& container);
+                ValueType randomChoice(const T &container);
             private:
                 std::mt19937 m_Mt;
                 explicit RandomGenerator();
             };
-            template<typename T, typename ValueType>
+            template <typename T, typename ValueType>
             ValueType RandomGenerator::randomChoice(const T &container)
             {
-                if(container.empty()){
+                if (container.empty()) {
                     return ValueType{};
                 }
                 auto randomIndex = generateInt(0, container.size() - 1);
                 return container.at(randomIndex);
             }
             #endif // SCIQLOP_FUZZINGUTILS

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