├── .gitignore ├── Build ├── Dependencies │ └── deploy_dependencies.py └── Installer │ ├── Installer-Template.iss │ ├── create_installer.py │ └── modpath.iss ├── CMakeLists.txt ├── CoverageTool ├── CMakeLists.txt ├── CoverageTool.cpp └── CoverageTool.vcxproj ├── CppCoverage.sln ├── CppCoverage ├── Address.cpp ├── Address.hpp ├── BreakPoint.cpp ├── BreakPoint.hpp ├── CodeCoverageRunner.cpp ├── CodeCoverageRunner.hpp ├── CoverageDataMerger.cpp ├── CoverageDataMerger.hpp ├── CoverageFilterManager.cpp ├── CoverageFilterManager.hpp ├── CoverageFilterSettings.cpp ├── CoverageFilterSettings.hpp ├── CppCoverage.vcxproj ├── CppCoverageExport.hpp ├── DebugInformation.cpp ├── DebugInformation.hpp ├── Debugger.cpp ├── Debugger.hpp ├── ExceptionHandler.cpp ├── ExceptionHandler.hpp ├── ExecutedAddressManager.cpp ├── ExecutedAddressManager.hpp ├── FileDebugInformation.cpp ├── FileDebugInformation.hpp ├── HandleInformation.cpp ├── HandleInformation.hpp ├── ICoverageFilterManager.hpp ├── IDebugEventsHandler.cpp ├── IDebugEventsHandler.hpp ├── IDebugInformationEventHandler.cpp ├── IDebugInformationEventHandler.hpp ├── Options.cpp ├── Options.hpp ├── OptionsExport.cpp ├── OptionsExport.hpp ├── OptionsParser.cpp ├── OptionsParser.hpp ├── Patterns.cpp ├── Patterns.hpp ├── Process.cpp ├── Process.hpp ├── ProgramOptions.cpp ├── ProgramOptions.hpp ├── ReadMe.txt ├── RunCoverageSettings.cpp ├── RunCoverageSettings.hpp ├── StartInfo.cpp ├── StartInfo.hpp ├── UnifiedDiffCoverageFilterManager.cpp ├── UnifiedDiffCoverageFilterManager.hpp ├── UnifiedDiffSettings.cpp ├── UnifiedDiffSettings.hpp ├── WildcardCoverageFilter.cpp ├── WildcardCoverageFilter.hpp ├── Wildcards.cpp ├── Wildcards.hpp ├── stdafx.cpp └── stdafx.h ├── CppCoverageCross ├── CMakeLists.txt ├── CoverageData.cpp ├── CoverageData.hpp ├── CoverageRate.cpp ├── CoverageRate.hpp ├── CoverageRateComputer.cpp ├── CoverageRateComputer.hpp ├── CppCoverageCross.vcxproj ├── CppCoverageException.cpp ├── CppCoverageException.hpp ├── CppCoverageExport.hpp ├── FileCoverage.cpp ├── FileCoverage.hpp ├── LineCoverage.cpp ├── LineCoverage.hpp ├── ModuleCoverage.cpp └── ModuleCoverage.hpp ├── CppCoverageTest ├── CodeCoverageRunnerTest.cpp ├── CoverageDataMergerRandomTest.cpp ├── CoverageDataMergerTest.cpp ├── CoverageDataTest.cpp ├── CoverageFilterManagerMock.hpp ├── CoverageRateComputerTest.cpp ├── CoverageRateTest.cpp ├── CppCoverageExceptionTest.cpp ├── CppCoverageTest.cpp ├── CppCoverageTest.vcxproj ├── Data │ └── TestDiff.diff ├── DebugEventsMock.hpp ├── DebugInformationEventHandlerMock.hpp ├── DebugInformationTest.cpp ├── DebuggerTest.cpp ├── ExceptionHandlerTest.cpp ├── ExecutedAddressManagerTest.cpp ├── FileCoverageTest.cpp ├── HandleInformationTest.cpp ├── OptionsParserConfigTest.cpp ├── OptionsParserExportTest.cpp ├── OptionsParserPatternTest.cpp ├── OptionsParserTest.cpp ├── OptionsParserUnifiedDiffTest.cpp ├── ProcessTest.cpp ├── ReadMe.txt ├── StartInfoTest.cpp ├── TestTools.cpp ├── TestTools.hpp ├── UnifiedDiffCoverageFilterManagerTest.cpp ├── WildcardCoverageFilterTest.cpp ├── WildcardsTest.cpp ├── stdafx.cpp └── stdafx.h ├── CreateRelease.bat ├── Exporter ├── Binary │ ├── BinaryExporter.cpp │ ├── BinaryExporter.hpp │ ├── CoverageData.proto │ ├── CoverageDataDeserializer.cpp │ ├── CoverageDataDeserializer.hpp │ ├── CoverageDataSerializer.cpp │ ├── CoverageDataSerializer.hpp │ └── ProtoBuff.hpp ├── CMakeLists.txt ├── CoberturaExporter.cpp ├── CoberturaExporter.hpp ├── Exporter.vcxproj ├── ExporterException.cpp ├── ExporterException.hpp ├── ExporterExport.hpp ├── Html │ ├── CTemplate.hpp │ ├── HtmlExporter.cpp │ ├── HtmlExporter.hpp │ ├── HtmlFile.cpp │ ├── HtmlFile.hpp │ ├── HtmlFileCoverageExporter.cpp │ ├── HtmlFileCoverageExporter.hpp │ ├── HtmlFolderStructure.cpp │ ├── HtmlFolderStructure.hpp │ ├── Template │ │ ├── MainTemplate.html │ │ ├── SourceTemplate.html │ │ └── third-party │ │ │ ├── JQuery │ │ │ └── jquery-1.11.1.min.js │ │ │ ├── RGraph │ │ │ ├── libraries │ │ │ │ ├── RGraph.common.core.js │ │ │ │ ├── RGraph.common.dynamic.js │ │ │ │ ├── RGraph.common.tooltips.js │ │ │ │ └── RGraph.pie.js │ │ │ └── license.txt │ │ │ ├── css │ │ │ ├── style.css │ │ │ └── table-images │ │ │ │ ├── botleft.png │ │ │ │ ├── botright.png │ │ │ │ ├── left.png │ │ │ │ └── right.png │ │ │ └── google-code-prettify │ │ │ ├── prettify-CppCoverage.css │ │ │ ├── prettify.js │ │ │ └── run_prettify.js │ ├── TemplateHtmlExporter.cpp │ └── TemplateHtmlExporter.hpp ├── IExporter.hpp ├── stdafx.cpp └── stdafx.h ├── ExporterTest ├── BinaryExporterTest.cpp ├── CoberturaExporterTest.cpp ├── CoverageDataSerializerTest.cpp ├── Data │ ├── CoberturaExporterExpectedResult.xml │ ├── TestFile1.cpp │ └── TestFile2.cpp ├── ExporterTest.cpp ├── ExporterTest.vcxproj ├── HtmlExporterTest.cpp ├── HtmlFileCoverageExporterTest.cpp ├── HtmlFolderStructureTest.cpp ├── ReadMe.txt ├── TemplateHtmlExporterTest.cpp ├── stdafx.cpp └── stdafx.h ├── FileFilter ├── IRelocationsExtractor.hpp ├── LineFilter.cpp ├── LineFilter.hpp ├── LineInfo.hpp ├── ReleaseCoverageFilter.cpp ├── ReleaseCoverageFilter.hpp ├── RelocationsExtractor.cpp ├── RelocationsExtractor.hpp └── stdafx.h ├── FileFilterCross ├── AmbiguousPathException.cpp ├── AmbiguousPathException.hpp ├── CMakeLists.txt ├── File.cpp ├── File.hpp ├── FileFilter.vcxproj ├── FileFilterCross.vcxproj ├── FileFilterException.hpp ├── FileFilterExport.hpp ├── FileInfo.hpp ├── ModuleInfo.hpp ├── PathMatcher.cpp ├── PathMatcher.hpp ├── UnifiedDiffCoverageFilter.cpp ├── UnifiedDiffCoverageFilter.hpp ├── UnifiedDiffParser.cpp ├── UnifiedDiffParser.hpp ├── UnifiedDiffParserException.cpp ├── UnifiedDiffParserException.hpp ├── stdafx.cpp └── stdafx.h ├── FileFilterTest ├── Data │ ├── test.diff │ ├── test_add.diff │ ├── test_git.diff │ └── test_remove.diff ├── FileFilterTest.cpp ├── FileFilterTest.vcxproj ├── LineFilterTest.cpp ├── PathMatcherTest.cpp ├── RelocationsExtractorTest.cpp ├── Tools.cpp ├── Tools.hpp ├── UnifiedDiffCoverageFilterTest.cpp ├── UnifiedDiffParserTest.cpp ├── stdafx.cpp └── stdafx.h ├── IntegrationTests.testsettings ├── OpenCppCoverage ├── OpenCppCoverage.cpp ├── OpenCppCoverage.hpp ├── OpenCppCoverage.vcxproj ├── OpenCppCoverageException.hpp ├── OpenCppCoverageExport.hpp ├── ReadMe.txt ├── main.cpp ├── stdafx.cpp └── stdafx.h ├── OpenCppCoverageTest ├── CommandLineOptionsTest.cpp ├── ImportExportTests.cpp ├── OpenCppCoverageConsoleTest.cpp ├── OpenCppCoverageTest.cpp ├── OpenCppCoverageTest.vcxproj ├── OpenCppCoverageTestTools.cpp ├── OpenCppCoverageTestTools.hpp ├── stdafx.cpp └── stdafx.h ├── PropertySheets ├── Boost.64.props ├── Boost.props ├── CTemplate.Debug.props ├── CTemplate.Debug.x64.props ├── CTemplate.Release.props ├── CTemplate.Release.x64.props ├── Default.props ├── GMock.Debug.props ├── GMock.Debug.x64.props ├── GMock.Release.props ├── GMock.Release.x64.props ├── Poco.props ├── Poco.x64.props ├── ProtoBuff.Debug.props ├── ProtoBuff.Debug.x64.props ├── ProtoBuff.Release.props └── ProtoBuff.Release.x64.props ├── TestCoverageConsole ├── FileWithSpecialCharéàè.hpp ├── ReadMe.txt ├── SpecialLineInfo.cpp ├── SpecialLineInfo.hpp ├── TestBasic.cpp ├── TestBasic.hpp ├── TestCoverageConsole.cpp ├── TestCoverageConsole.hpp ├── TestCoverageConsole.vcxproj ├── TestDiff.cpp ├── TestDiff.hpp ├── TestThread.cpp └── TestThread.hpp ├── TestCoverageOptimizedBuild ├── TestCoverageOptimizedBuild.cpp ├── TestCoverageOptimizedBuild.hpp └── TestCoverageOptimizedBuild.vcxproj ├── TestCoverageSharedLib ├── ReadMe.txt ├── TestCoverageSharedLib.cpp ├── TestCoverageSharedLib.hpp ├── TestCoverageSharedLib.vcxproj ├── stdafx.cpp └── stdafx.h ├── TestHelper ├── AutoClose.hpp ├── Container.hpp ├── Container.inl ├── CoverageDataComparer.cpp ├── CoverageDataComparer.hpp ├── ReadMe.txt ├── TemporaryPath.cpp ├── TemporaryPath.hpp ├── TestHelper.vcxproj ├── TestHelperExport.hpp ├── Tools.cpp ├── Tools.hpp ├── stdafx.cpp └── stdafx.h ├── Tools ├── DbgHelp.hpp ├── MappedFile.cpp ├── MappedFile.hpp ├── ReadMe.txt ├── Tool.cpp ├── Tool.hpp ├── Tools.vcxproj ├── ToolsExport.hpp ├── dllmain.cpp ├── stdafx.cpp └── stdafx.h ├── ToolsCross ├── CMakeLists.txt ├── ExceptionBase.cpp ├── ExceptionBase.hpp ├── Log.cpp ├── Log.hpp ├── ScopedAction.cpp ├── ScopedAction.hpp ├── ToolsCross.vcxproj ├── ToolsException.hpp ├── ToolsExport.hpp ├── UniquePath.cpp └── UniquePath.hpp ├── ToolsLinux ├── CMakeLists.txt ├── Tool.cpp ├── Tool.hpp └── ToolsExport.hpp ├── ToolsTest ├── MappedFileTest.cpp ├── ReadMe.txt ├── ToolTest.cpp ├── ToolsTest.cpp ├── ToolsTest.vcxproj ├── stdafx.cpp └── stdafx.h └── UnitTests.testsettings /.gitignore: -------------------------------------------------------------------------------- 1 | */Debug 2 | */Release 3 | */x64 4 | Debug/ 5 | Release/ 6 | ipch/* 7 | *.sdf 8 | *.opensdf 9 | *.suo 10 | *.filters 11 | *.user 12 | *.ipch 13 | *.log 14 | *.opendb 15 | CoverageReport-* 16 | NewRelease 17 | TestResults/ 18 | packages/* 19 | Build/Installer/VCRedist/* 20 | Build/Dependencies/Dependencies-vs*.zip 21 | 22 | 23 | # Template file / unmanaged dll for the plugin 24 | VSPackage/OpenCppCoverage-x64 25 | VSPackage/OpenCppCoverage-x86 26 | 27 | # ProtoBuff files 28 | *.pb.* 29 | -------------------------------------------------------------------------------- /CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 2.8.12) 2 | project(CovTool) 3 | 4 | subdirs(CoverageTool CppCoverageCross Exporter FileFilterCross ToolsCross ToolsLinux) -------------------------------------------------------------------------------- /CoverageTool/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # Minimum CMake required 2 | cmake_minimum_required(VERSION 2.8.12) 3 | 4 | set(CMAKE_CXX_STANDARD 14) 5 | set(CMAKE_CXX_FLAGS "-D__STRICT_ANSI__") 6 | 7 | set(Boost_USE_STATIC_LIBS ON) 8 | set(Boost_USE_MULTITHREADED ON) 9 | set(Boost_USE_STATIC_RUNTIME OFF) 10 | find_package(Boost COMPONENTS filesystem log) 11 | 12 | message(STATUS "making CoverageTool...") 13 | link_libraries( 14 | Exporter 15 | CppCoverageCross 16 | FileFilterCross 17 | ToolsCross 18 | ToolsLinux 19 | ctemplate 20 | pthread) 21 | link_directories( 22 | /home/nicklas/Downloads/ctemplate-ctemplate-2.3/ 23 | ${Boost_LIBRARY_DIRS}) 24 | 25 | if(Boost_FOUND) 26 | message(STATUS "Boost_INCLUDE_DIRS: ${Boost_INCLUDE_DIRS}") 27 | message(STATUS "Boost_LIBRARIES: ${Boost_LIBRARIES}") 28 | message(STATUS "Boost_VERSION: ${Boost_VERSION}") 29 | include_directories(${PROJECT_SOURCE_DIR} ${Boost_INCLUDE_DIRS}) 30 | 31 | add_executable(CovTool CoverageTool.cpp) 32 | 33 | target_link_libraries(CovTool 34 | ${Boost_LIBRARIES} 35 | ) 36 | endif() 37 | -------------------------------------------------------------------------------- /CppCoverage/Address.hpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | #include 20 | #include "CppCoverageExport.hpp" 21 | 22 | namespace CppCoverage 23 | { 24 | class CPPCOVERAGE_DLL Address 25 | { 26 | public: 27 | Address(HANDLE hProcess, void* value); 28 | Address(const Address&) = default; 29 | 30 | HANDLE GetProcessHandle() const; 31 | void* GetValue() const; 32 | 33 | bool operator<(const Address& other) const; 34 | friend std::wostream& operator<<(std::wostream&, const Address&); 35 | 36 | private: 37 | Address& operator=(const Address&) = delete; 38 | 39 | private: 40 | HANDLE hProcess_; 41 | void* value_; 42 | }; 43 | } 44 | 45 | 46 | -------------------------------------------------------------------------------- /CppCoverage/BreakPoint.hpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | namespace CppCoverage 20 | { 21 | class Address; 22 | 23 | class BreakPoint 24 | { 25 | public: 26 | BreakPoint() = default; 27 | 28 | unsigned char SetBreakPointAt(const Address&) const; 29 | void RemoveBreakPoint(const Address&, unsigned char oldInstruction) const; 30 | 31 | void AdjustEipAfterBreakPointRemoval(HANDLE hThread) const; 32 | 33 | private: 34 | BreakPoint(const BreakPoint&) = delete; 35 | BreakPoint& operator=(const BreakPoint&) = delete; 36 | }; 37 | } 38 | 39 | 40 | -------------------------------------------------------------------------------- /CppCoverage/CoverageDataMerger.hpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | #include "CppCoverageExport.hpp" 20 | 21 | namespace CppCoverage 22 | { 23 | class CoverageData; 24 | 25 | class CPPCOVERAGE_DLL CoverageDataMerger 26 | { 27 | public: 28 | CoverageDataMerger() = default; 29 | 30 | CoverageData Merge(const std::vector&) const; 31 | void MergeFileCoverage(CoverageData&) const; 32 | 33 | private: 34 | CoverageDataMerger(const CoverageDataMerger&) = delete; 35 | CoverageDataMerger& operator=(const CoverageDataMerger&) = delete; 36 | }; 37 | } -------------------------------------------------------------------------------- /CppCoverage/CoverageFilterSettings.cpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #include "stdafx.h" 18 | #include "CoverageFilterSettings.hpp" 19 | 20 | #include 21 | 22 | namespace CppCoverage 23 | { 24 | //------------------------------------------------------------------------- 25 | CoverageFilterSettings::CoverageFilterSettings( 26 | const Patterns& modulePatterns, 27 | const Patterns& sourcePatterns) 28 | : modulePatterns_(modulePatterns) 29 | , sourcePatterns_(sourcePatterns) 30 | { 31 | } 32 | 33 | //------------------------------------------------------------------------- 34 | const Patterns& CoverageFilterSettings::GetModulePatterns() const 35 | { 36 | return modulePatterns_; 37 | } 38 | 39 | //------------------------------------------------------------------------- 40 | const Patterns& CoverageFilterSettings::GetSourcePatterns() const 41 | { 42 | return sourcePatterns_; 43 | } 44 | 45 | } 46 | 47 | -------------------------------------------------------------------------------- /CppCoverage/CoverageFilterSettings.hpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | #include 20 | #include 21 | 22 | #include "CppCoverageExport.hpp" 23 | #include "Patterns.hpp" 24 | 25 | namespace CppCoverage 26 | { 27 | class CPPCOVERAGE_DLL CoverageFilterSettings 28 | { 29 | public: 30 | CoverageFilterSettings(const Patterns& modulePatterns, const Patterns& sourcePatterns); 31 | CoverageFilterSettings(const CoverageFilterSettings&) = default; 32 | CoverageFilterSettings& operator=(const CoverageFilterSettings&) = delete; 33 | 34 | const Patterns& GetModulePatterns() const; 35 | const Patterns& GetSourcePatterns() const; 36 | 37 | private: 38 | Patterns modulePatterns_; 39 | Patterns sourcePatterns_; 40 | }; 41 | } 42 | 43 | 44 | -------------------------------------------------------------------------------- /CppCoverage/CppCoverageExport.hpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | //#ifdef CPPCOVERAGE_EXPORTS 20 | // #define CPPCOVERAGE_DLL __declspec(dllexport) 21 | //#else 22 | // #define CPPCOVERAGE_DLL _declspec(dllimport) 23 | //#endif 24 | #define CPPCOVERAGE_DLL 25 | 26 | #pragma warning (disable: 4251) 27 | 28 | 29 | 30 | -------------------------------------------------------------------------------- /CppCoverage/DebugInformation.hpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | #include "CppCoverageExport.hpp" 20 | #include "FileDebugInformation.hpp" 21 | 22 | namespace CppCoverage 23 | { 24 | class IDebugInformationEventHandler; 25 | class ICoverageFilterManager; 26 | 27 | class CPPCOVERAGE_DLL DebugInformation 28 | { 29 | public: 30 | explicit DebugInformation(HANDLE hProcess); 31 | ~DebugInformation(); 32 | 33 | void LoadModule( 34 | const std::wstring& filename, 35 | HANDLE hFile, 36 | void* baseOfImage, 37 | ICoverageFilterManager&, 38 | IDebugInformationEventHandler& debugInformationEventHandler) const; 39 | 40 | private: 41 | DebugInformation(const DebugInformation&) = delete; 42 | DebugInformation& operator=(const DebugInformation&) = delete; 43 | 44 | void UpdateSearchPath(const std::wstring&) const; 45 | 46 | private: 47 | HANDLE hProcess_; 48 | std::string defaultSearchPath_; 49 | FileDebugInformation fileDebugInformation_; 50 | }; 51 | } 52 | 53 | 54 | -------------------------------------------------------------------------------- /CppCoverage/FileDebugInformation.hpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2016 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | #include "CppCoverageExport.hpp" 20 | #include 21 | 22 | namespace FileFilter 23 | { 24 | class ModuleInfo; 25 | } 26 | 27 | namespace CppCoverage 28 | { 29 | class IDebugInformationEventHandler; 30 | class ICoverageFilterManager; 31 | 32 | class CPPCOVERAGE_DLL FileDebugInformation 33 | { 34 | public: 35 | FileDebugInformation() = default; 36 | 37 | void LoadFile( 38 | const FileFilter::ModuleInfo&, 39 | const std::wstring& filename, 40 | ICoverageFilterManager& coverageFilterManager, 41 | IDebugInformationEventHandler& debugInformationEventHandler) const; 42 | 43 | private: 44 | FileDebugInformation(const FileDebugInformation&) = delete; 45 | FileDebugInformation& operator=(const FileDebugInformation&) = delete; 46 | }; 47 | } 48 | -------------------------------------------------------------------------------- /CppCoverage/HandleInformation.hpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | #include 20 | 21 | #include "CppCoverageExport.hpp" 22 | 23 | namespace CppCoverage 24 | { 25 | class CPPCOVERAGE_DLL HandleInformation 26 | { 27 | public: 28 | HandleInformation(); 29 | std::wstring ComputeFilename(HANDLE hfile) const; 30 | 31 | private: 32 | HandleInformation(const HandleInformation&) = delete; 33 | HandleInformation& operator=(const HandleInformation&) = delete; 34 | }; 35 | } 36 | 37 | 38 | -------------------------------------------------------------------------------- /CppCoverage/ICoverageFilterManager.hpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2016 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | #include "CppCoverageExport.hpp" 20 | #include 21 | 22 | namespace FileFilter 23 | { 24 | class ModuleInfo; 25 | class FileInfo; 26 | class LineInfo; 27 | } 28 | 29 | namespace CppCoverage 30 | { 31 | class CoverageFilterSettings; 32 | 33 | class CPPCOVERAGE_DLL ICoverageFilterManager 34 | { 35 | public: 36 | virtual ~ICoverageFilterManager() = default; 37 | 38 | virtual bool IsModuleSelected(const std::wstring& filename) const = 0; 39 | virtual bool IsSourceFileSelected(const std::wstring& filename) = 0; 40 | virtual bool IsLineSelected( 41 | const FileFilter::ModuleInfo&, 42 | const FileFilter::FileInfo&, 43 | const FileFilter::LineInfo&) = 0; 44 | }; 45 | } 46 | 47 | 48 | -------------------------------------------------------------------------------- /CppCoverage/IDebugEventsHandler.hpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | #include 20 | 21 | #include "CppCoverageExport.hpp" 22 | 23 | namespace CppCoverage 24 | { 25 | class CPPCOVERAGE_DLL IDebugEventsHandler 26 | { 27 | public: 28 | enum class ExceptionType 29 | { 30 | BreakPoint, 31 | InvalidBreakPoint, 32 | NotHandled, 33 | Error, 34 | CppError 35 | }; 36 | 37 | IDebugEventsHandler() = default; 38 | virtual ~IDebugEventsHandler() = default; 39 | 40 | virtual void OnCreateProcess(const CREATE_PROCESS_DEBUG_INFO&); 41 | virtual void OnExitProcess(HANDLE hProcess, HANDLE hThread, const EXIT_PROCESS_DEBUG_INFO&); 42 | virtual void OnLoadDll(HANDLE hProcess, HANDLE hThread, const LOAD_DLL_DEBUG_INFO&); 43 | virtual void OnUnloadDll(HANDLE hProcess, HANDLE hThread, const UNLOAD_DLL_DEBUG_INFO&); 44 | virtual ExceptionType OnException(HANDLE hProcess, HANDLE hThread, const EXCEPTION_DEBUG_INFO&); 45 | 46 | private: 47 | IDebugEventsHandler(const IDebugEventsHandler&) = delete; 48 | IDebugEventsHandler& operator=(const IDebugEventsHandler&) = delete; 49 | }; 50 | } 51 | 52 | 53 | -------------------------------------------------------------------------------- /CppCoverage/IDebugInformationEventHandler.cpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #include "stdafx.h" 18 | #include "IDebugInformationEventHandler.hpp" 19 | 20 | namespace CppCoverage 21 | { 22 | } 23 | -------------------------------------------------------------------------------- /CppCoverage/IDebugInformationEventHandler.hpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | #include 20 | #include 21 | #include "CppCoverageExport.hpp" 22 | 23 | namespace CppCoverage 24 | { 25 | class Address; 26 | 27 | class CPPCOVERAGE_DLL IDebugInformationEventHandler 28 | { 29 | public: 30 | IDebugInformationEventHandler() = default; 31 | virtual ~IDebugInformationEventHandler() = default; 32 | 33 | virtual void OnNewLine(const std::wstring& fileName, int lineNumber, const Address&) = 0; 34 | 35 | private: 36 | IDebugInformationEventHandler(const IDebugInformationEventHandler&) = delete; 37 | IDebugInformationEventHandler& operator=(const IDebugInformationEventHandler&) = delete; 38 | }; 39 | } 40 | 41 | 42 | -------------------------------------------------------------------------------- /CppCoverage/OptionsExport.hpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | #include 20 | #include 21 | 22 | #include "CppCoverageExport.hpp" 23 | 24 | namespace CppCoverage 25 | { 26 | enum class OptionsExportType 27 | { 28 | Html, 29 | Cobertura, 30 | Binary 31 | }; 32 | 33 | class CPPCOVERAGE_DLL OptionsExport 34 | { 35 | public: 36 | explicit OptionsExport(OptionsExportType type); 37 | OptionsExport(OptionsExportType type, const boost::filesystem::path&); 38 | 39 | OptionsExport(const OptionsExport&) = default; 40 | OptionsExport& operator=(const OptionsExport&) = default; 41 | 42 | OptionsExportType GetType() const; 43 | const std::wstring& GetTypeString() const; 44 | const boost::optional& GetOutputPath() const; 45 | 46 | friend std::wostream& operator<<(std::wostream& ostr, const OptionsExport&); 47 | 48 | private: 49 | OptionsExportType type_; 50 | boost::optional outputPath_; 51 | }; 52 | } 53 | 54 | -------------------------------------------------------------------------------- /CppCoverage/Patterns.hpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | #include 20 | #include 21 | 22 | #include "CppCoverageExport.hpp" 23 | 24 | namespace CppCoverage 25 | { 26 | class CPPCOVERAGE_DLL Patterns 27 | { 28 | public: 29 | typedef std::vector T_Patterns; 30 | 31 | public: 32 | explicit Patterns(bool isRegexCaseSensitiv = false); 33 | Patterns(const Patterns&) = default; 34 | Patterns(Patterns&&); 35 | 36 | void AddSelectedPatterns(const std::wstring&); 37 | const T_Patterns& GetSelectedPatterns() const; 38 | 39 | void AddExcludedPatterns(const std::wstring&); 40 | const T_Patterns& GetExcludedPatterns() const; 41 | 42 | bool IsRegexCaseSensitiv() const; 43 | 44 | Patterns& operator=(const Patterns&) = default; 45 | 46 | CPPCOVERAGE_DLL friend std::wostream& operator<<(std::wostream&, const Patterns&); 47 | 48 | private: 49 | T_Patterns selectedPatterns_; 50 | T_Patterns excludedPatterns_; 51 | bool isRegexCaseSensitiv_; 52 | }; 53 | } 54 | 55 | -------------------------------------------------------------------------------- /CppCoverage/Process.hpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | #include 20 | #include 21 | 22 | #include "CppCoverageExport.hpp" 23 | #include "StartInfo.hpp" 24 | 25 | namespace CppCoverage 26 | { 27 | class CPPCOVERAGE_DLL Process 28 | { 29 | public: 30 | Process(const StartInfo& startInfo); 31 | ~Process(); 32 | 33 | void Start(DWORD creationFlags); 34 | 35 | private: 36 | Process(const Process&) = delete; 37 | Process& operator=(const Process&) = delete; 38 | 39 | private: 40 | boost::optional processInformation_; 41 | const StartInfo startInfo_; 42 | }; 43 | } 44 | 45 | -------------------------------------------------------------------------------- /CppCoverage/StartInfo.hpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | #include 20 | #include 21 | #include 22 | #include 23 | #include 24 | 25 | #include "CppCoverageExport.hpp" 26 | 27 | namespace CppCoverage 28 | { 29 | class CPPCOVERAGE_DLL StartInfo 30 | { 31 | public: 32 | explicit StartInfo(const boost::filesystem::path&); 33 | 34 | StartInfo(StartInfo&&); 35 | 36 | StartInfo(const StartInfo&) = default; 37 | StartInfo& operator=(const StartInfo&) = default; 38 | 39 | void SetWorkingDirectory(const boost::filesystem::path&); 40 | void AddArgument(const std::wstring&); 41 | 42 | const boost::filesystem::path& GetPath() const; 43 | const std::vector& GetArguments() const; 44 | const boost::filesystem::path* GetWorkingDirectory() const; 45 | 46 | friend CPPCOVERAGE_DLL std::wostream& operator<<(std::wostream& ostr, const StartInfo&); 47 | 48 | private: 49 | boost::filesystem::path path_; 50 | std::vector arguments_; 51 | boost::optional workingDirectory_; 52 | }; 53 | } 54 | 55 | 56 | -------------------------------------------------------------------------------- /CppCoverage/UnifiedDiffSettings.cpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2016 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #include "stdafx.h" 18 | #include "UnifiedDiffSettings.hpp" 19 | 20 | namespace CppCoverage 21 | { 22 | //------------------------------------------------------------------------- 23 | UnifiedDiffSettings::UnifiedDiffSettings( 24 | const boost::filesystem::path& unifiedDiffPath, 25 | const boost::optional& rootDiffFolder) 26 | : unifiedDiffPath_{unifiedDiffPath} 27 | , rootDiffFolder_{rootDiffFolder} 28 | { 29 | } 30 | 31 | //------------------------------------------------------------------------- 32 | const boost::filesystem::path& UnifiedDiffSettings::GetUnifiedDiffPath() const 33 | { 34 | return unifiedDiffPath_; 35 | } 36 | 37 | //------------------------------------------------------------------------- 38 | const boost::optional& UnifiedDiffSettings::GetRootDiffFolder() const 39 | { 40 | return rootDiffFolder_; 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /CppCoverage/UnifiedDiffSettings.hpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2016 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | #include 20 | #include 21 | 22 | #include "CppCoverageExport.hpp" 23 | 24 | namespace CppCoverage 25 | { 26 | class CPPCOVERAGE_DLL UnifiedDiffSettings 27 | { 28 | public: 29 | UnifiedDiffSettings( 30 | const boost::filesystem::path& unifiedDiffPath, 31 | const boost::optional& rootDiffFolder); 32 | UnifiedDiffSettings(const UnifiedDiffSettings&) = default; 33 | UnifiedDiffSettings(UnifiedDiffSettings&&) = default; 34 | 35 | const boost::filesystem::path& GetUnifiedDiffPath() const; 36 | const boost::optional& GetRootDiffFolder() const; 37 | 38 | UnifiedDiffSettings& operator=(const UnifiedDiffSettings&) = default; 39 | 40 | private: 41 | boost::filesystem::path unifiedDiffPath_; 42 | boost::optional rootDiffFolder_; 43 | }; 44 | } 45 | -------------------------------------------------------------------------------- /CppCoverage/WildcardCoverageFilter.hpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | #include 20 | #include 21 | #include 22 | 23 | #include "CppCoverageExport.hpp" 24 | 25 | namespace CppCoverage 26 | { 27 | class CoverageFilterSettings; 28 | class Patterns; 29 | 30 | class CPPCOVERAGE_DLL WildcardCoverageFilter 31 | { 32 | public: 33 | explicit WildcardCoverageFilter(const CoverageFilterSettings&); 34 | ~WildcardCoverageFilter(); 35 | 36 | bool IsModuleSelected(const std::wstring& filename) const; 37 | bool IsSourceFileSelected(const std::wstring& filename) const; 38 | 39 | private: 40 | WildcardCoverageFilter(const WildcardCoverageFilter&) = delete; 41 | WildcardCoverageFilter& operator=(const WildcardCoverageFilter&) = delete; 42 | 43 | struct Filter; 44 | 45 | std::unique_ptr BuildFilter(const Patterns& pattern) const; 46 | bool Match( 47 | const std::wstring& str, 48 | const Filter& filter, 49 | std::wostream& ostr) const; 50 | private: 51 | std::unique_ptr moduleFilter_; 52 | std::unique_ptr sourceFilter_; 53 | }; 54 | } 55 | 56 | 57 | -------------------------------------------------------------------------------- /CppCoverage/Wildcards.hpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | #include 20 | #include 21 | 22 | #include "CppCoverageExport.hpp" 23 | 24 | namespace CppCoverage 25 | { 26 | class CPPCOVERAGE_DLL Wildcards 27 | { 28 | public: 29 | static const std::vector EscapedChars; 30 | 31 | public: 32 | explicit Wildcards(std::wstring, bool isRegexCaseSensitiv = false); 33 | Wildcards(Wildcards&&); 34 | 35 | bool Match(const std::wstring& str) const; 36 | 37 | friend CPPCOVERAGE_DLL std::wostream& operator<<(std::wostream&, const Wildcards&); 38 | 39 | private: 40 | Wildcards(const Wildcards&) = delete; 41 | Wildcards& operator=(const Wildcards&) = delete; 42 | 43 | private: 44 | std::wregex wildcars_; 45 | std::wstring originalStr_; 46 | }; 47 | } -------------------------------------------------------------------------------- /CppCoverage/stdafx.cpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #include "stdafx.h" 18 | 19 | // TODO: reference any additional headers you need in STDAFX.H 20 | // and not in this file 21 | -------------------------------------------------------------------------------- /CppCoverage/stdafx.h: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | #define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers 20 | // Windows Header Files: 21 | #include 22 | 23 | #include 24 | #include 25 | 26 | const int PathBufferSize = 40 * 1000; -------------------------------------------------------------------------------- /CppCoverageCross/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 2.8.12) 2 | 3 | set (CMAKE_CXX_STANDARD 14) 4 | 5 | add_library(CppCoverageCross 6 | CoverageData.hpp 7 | CoverageData.cpp 8 | CoverageRate.hpp 9 | CoverageRate.cpp 10 | CoverageRateComputer.hpp 11 | CoverageRateComputer.cpp 12 | CppCoverageException.hpp 13 | CppCoverageException.cpp 14 | CppCoverageExport.hpp 15 | FileCoverage.hpp 16 | FileCoverage.cpp 17 | LineCoverage.hpp 18 | LineCoverage.cpp 19 | ModuleCoverage.hpp 20 | ModuleCoverage.cpp) 21 | 22 | include_directories(${CMAKE_SOURCE_DIR}) 23 | link_directories(${CMAKE_SOURCE_DIR}) -------------------------------------------------------------------------------- /CppCoverageCross/CoverageRate.hpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | #include "CppCoverageExport.hpp" 20 | 21 | namespace CppCoverage 22 | { 23 | class CPPCOVERAGE_DLL CoverageRate 24 | { 25 | public: 26 | CoverageRate(); 27 | CoverageRate(int executedLinesCount, int unexecutedLinesCount); 28 | 29 | CoverageRate& operator=(const CoverageRate&) = delete; 30 | CoverageRate(const CoverageRate&) = default; 31 | 32 | int GetExecutedLinesCount() const; 33 | int GetUnExecutedLinesCount() const; 34 | int GetTotalLinesCount() const; 35 | int GetPercentRate() const; 36 | double GetRate() const; 37 | 38 | CoverageRate& operator+=(const CoverageRate&); 39 | 40 | private: 41 | int executedLinesCount_; 42 | int unexecutedLinesCount_; 43 | }; 44 | } 45 | 46 | -------------------------------------------------------------------------------- /CppCoverageCross/CppCoverageException.cpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #include "CppCoverageException.hpp" 18 | 19 | #include 20 | #include 21 | #ifdef _WIN32 22 | #include 23 | #elif __linux__ 24 | #include 25 | #endif 26 | 27 | namespace CppCoverage 28 | { 29 | //------------------------------------------------------------------------- 30 | std::wstring GetErrorMessage(int lastErrorCode) 31 | { 32 | std::vector sysMsg(64 * 1024); 33 | std::wostringstream ostr; 34 | #ifdef _WIN_32 35 | if (FormatMessage( 36 | FORMAT_MESSAGE_FROM_SYSTEM, 37 | NULL, lastErrorCode, 38 | MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL), 39 | &sysMsg[0], static_cast(sysMsg.size()), NULL)) 40 | { 41 | ostr << &sysMsg[0]; 42 | } 43 | else 44 | { 45 | ostr << "Last error code:" << lastErrorCode; 46 | } 47 | #elif __LINUX__ 48 | ostr << "Last error code:" << lastErrorCode; 49 | #endif 50 | 51 | return ostr.str(); 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /CppCoverageCross/CppCoverageException.hpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | #include 20 | #include "CppCoverageExport.hpp" 21 | #include 22 | 23 | namespace CppCoverage 24 | { 25 | CPPCOVERAGE_DLL std::wstring GetErrorMessage(int errorCode); 26 | } 27 | 28 | GENERATE_EXCEPTION_CLASS(CppCoverage, CppCoverageException); 29 | 30 | #define THROW(message) THROW_BASE(CppCoverage, CppCoverageException, message) 31 | #define THROW_LAST_ERROR(message, lastErrorCode) THROW_BASE(CppCoverage, CppCoverageException, message << CppCoverage::GetErrorMessage(lastErrorCode)) 32 | -------------------------------------------------------------------------------- /CppCoverageCross/CppCoverageExport.hpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | //#ifdef CPPCOVERAGE_EXPORTS 20 | //#define CPPCOVERAGE_DLL __declspec(dllexport) 21 | //#else 22 | //#define CPPCOVERAGE_DLL _declspec(dllimport) 23 | #define CPPCOVERAGE_DLL 24 | //#endif 25 | 26 | #pragma warning (disable: 4251) 27 | 28 | 29 | 30 | -------------------------------------------------------------------------------- /CppCoverageCross/FileCoverage.hpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | #include 20 | #include 21 | #include 22 | 23 | #include "LineCoverage.hpp" 24 | #include "CppCoverageExport.hpp" 25 | 26 | namespace CppCoverage 27 | { 28 | class CPPCOVERAGE_DLL FileCoverage 29 | { 30 | public: 31 | explicit FileCoverage(const boost::filesystem::path& path); 32 | 33 | void AddLine(unsigned int lineNumber, bool hasBeenExecuted); 34 | void UpdateLine(unsigned int lineNumber, bool hasBeenExecuted); 35 | 36 | const boost::filesystem::path& GetPath() const; 37 | const LineCoverage* operator[](unsigned int line) const; 38 | std::vector GetLines() const; 39 | 40 | FileCoverage& operator=(const FileCoverage&) = default; 41 | 42 | private: 43 | FileCoverage(const FileCoverage&) = delete; 44 | 45 | private: 46 | boost::filesystem::path path_; 47 | std::map lines_; 48 | }; 49 | } 50 | 51 | 52 | -------------------------------------------------------------------------------- /CppCoverageCross/LineCoverage.cpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #include "LineCoverage.hpp" 18 | 19 | namespace CppCoverage 20 | { 21 | //------------------------------------------------------------------------- 22 | LineCoverage::LineCoverage(unsigned int lineNumber, bool hasBeenExecuted) 23 | : lineNumber_(lineNumber) 24 | , hasBeenExecuted_(hasBeenExecuted) 25 | { 26 | } 27 | 28 | //------------------------------------------------------------------------- 29 | unsigned int LineCoverage::GetLineNumber() const 30 | { 31 | return lineNumber_; 32 | } 33 | 34 | //------------------------------------------------------------------------- 35 | bool LineCoverage::HasBeenExecuted() const 36 | { 37 | return hasBeenExecuted_; 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /CppCoverageCross/LineCoverage.hpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | #include "CppCoverageExport.hpp" 20 | 21 | namespace CppCoverage 22 | { 23 | class CPPCOVERAGE_DLL LineCoverage 24 | { 25 | public: 26 | LineCoverage(unsigned int lineNumber, bool hasBeenExecuted); 27 | LineCoverage(const LineCoverage&) = default; 28 | 29 | unsigned int GetLineNumber() const; 30 | bool HasBeenExecuted() const; 31 | 32 | private: 33 | unsigned int lineNumber_; 34 | bool hasBeenExecuted_; 35 | }; 36 | } 37 | 38 | 39 | -------------------------------------------------------------------------------- /CppCoverageCross/ModuleCoverage.cpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #include "ModuleCoverage.hpp" 18 | 19 | #include "FileCoverage.hpp" 20 | 21 | namespace CppCoverage 22 | { 23 | //------------------------------------------------------------------------- 24 | ModuleCoverage::ModuleCoverage(const boost::filesystem::path& path) 25 | : path_(path) 26 | { 27 | } 28 | 29 | //------------------------------------------------------------------------- 30 | ModuleCoverage::~ModuleCoverage() 31 | { 32 | } 33 | 34 | //------------------------------------------------------------------------- 35 | FileCoverage& ModuleCoverage::AddFile(const boost::filesystem::path& filePath) 36 | { 37 | files_.push_back(std::unique_ptr(new FileCoverage(filePath))); 38 | 39 | return *files_.back(); 40 | } 41 | 42 | //------------------------------------------------------------------------- 43 | const boost::filesystem::path& ModuleCoverage::GetPath() const 44 | { 45 | return path_; 46 | } 47 | 48 | //------------------------------------------------------------------------- 49 | const ModuleCoverage::T_FileCoverageCollection& ModuleCoverage::GetFiles() const 50 | { 51 | return files_; 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /CppCoverageCross/ModuleCoverage.hpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | #include 20 | #include 21 | 22 | #include 23 | 24 | #include "CppCoverageExport.hpp" 25 | 26 | namespace CppCoverage 27 | { 28 | class FileCoverage; 29 | 30 | class CPPCOVERAGE_DLL ModuleCoverage 31 | { 32 | public: 33 | typedef std::vector> T_FileCoverageCollection; 34 | 35 | public: 36 | explicit ModuleCoverage(const boost::filesystem::path& path); 37 | ~ModuleCoverage(); 38 | 39 | FileCoverage& AddFile(const boost::filesystem::path& filename); 40 | 41 | const boost::filesystem::path& GetPath() const; 42 | const T_FileCoverageCollection& GetFiles() const; 43 | 44 | private: 45 | ModuleCoverage(const ModuleCoverage&) = delete; 46 | ModuleCoverage& operator=(const ModuleCoverage&) = delete; 47 | 48 | private: 49 | T_FileCoverageCollection files_; 50 | boost::filesystem::path path_; 51 | }; 52 | } 53 | 54 | 55 | -------------------------------------------------------------------------------- /CppCoverageTest/CoverageFilterManagerMock.hpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2016 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | #include 20 | #include "CppCoverage/ICoverageFilterManager.hpp" 21 | 22 | namespace CppCoverageTest 23 | { 24 | class CoverageFilterManagerMock : public CppCoverage::ICoverageFilterManager 25 | { 26 | public: 27 | CoverageFilterManagerMock() = default; 28 | 29 | MOCK_CONST_METHOD1(IsModuleSelected, bool(const std::wstring&)); 30 | MOCK_METHOD1(IsSourceFileSelected, bool(const std::wstring&)); 31 | MOCK_METHOD3(IsLineSelected, 32 | bool(const FileFilter::ModuleInfo&, 33 | const FileFilter::FileInfo&, 34 | const FileFilter::LineInfo&)); 35 | 36 | private: 37 | CoverageFilterManagerMock(const CoverageFilterManagerMock&) = delete; 38 | CoverageFilterManagerMock& operator=(const CoverageFilterManagerMock&) = delete; 39 | }; 40 | } 41 | 42 | 43 | -------------------------------------------------------------------------------- /CppCoverageTest/CppCoverageExceptionTest.cpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #include "stdafx.h" 18 | 19 | #include "CppCoverage/CppCoverageException.hpp" 20 | 21 | namespace cov = CppCoverage; 22 | 23 | namespace CppCoverageTest 24 | { 25 | 26 | //------------------------------------------------------------------------- 27 | TEST(CppCoverageException, GetErrorMessage) 28 | { 29 | ASSERT_NE(L"", cov::GetErrorMessage(1)); 30 | } 31 | 32 | //------------------------------------------------------------------------- 33 | TEST(CppCoverageException, GetErrorMessageInvalid) 34 | { 35 | ASSERT_NE(L"", cov::GetErrorMessage(-1)); 36 | } 37 | } -------------------------------------------------------------------------------- /CppCoverageTest/CppCoverageTest.cpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #include "stdafx.h" 18 | #include 19 | 20 | #include "ToolsCross/Log.hpp" 21 | 22 | //----------------------------------------------------------------------------- 23 | int _tmain(int argc, _TCHAR* argv[]) 24 | { 25 | Tools::EnableLogger(false); 26 | ::testing::InitGoogleMock(&argc, argv); 27 | return RUN_ALL_TESTS(); 28 | } 29 | 30 | -------------------------------------------------------------------------------- /CppCoverageTest/Data/TestDiff.diff: -------------------------------------------------------------------------------- 1 | diff --git a/TestCoverageConsole/TestDiff.cpp b/TestCoverageConsole/Tes 2 | index 8944117..c9f2773 100644 3 | --- a/TestCoverageConsole/TestDiff.cpp 4 | +++ b/TestCoverageConsole/TestDiff.cpp 5 | @@ -22,10 +22,10 @@ namespace TestCoverageConsole 6 | void FilterByDiff() 7 | { 8 | int value1 = 0; 9 | - if (true) 10 | - int value2 = 0; 11 | - if (false) 12 | - int value3 = 0; 13 | + if (true) // In Diff 14 | + int value2 = 0; // In Diff 15 | + if (false) // In Diff 16 | + int value3 = 0; // In Diff 17 | int value4 = 0; 18 | } 19 | } 20 | \ No newline at end of file -------------------------------------------------------------------------------- /CppCoverageTest/DebugEventsMock.hpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | #include "CppCoverage/IDebugEventsHandler.hpp" 20 | 21 | namespace CppCoverageTest 22 | { 23 | class DebugEventsHandlerMock : public CppCoverage::IDebugEventsHandler 24 | { 25 | public: 26 | DebugEventsHandlerMock() = default; 27 | 28 | MOCK_METHOD1(OnCreateProcess, void(const CREATE_PROCESS_DEBUG_INFO&)); 29 | MOCK_METHOD3(OnExitProcess, void(HANDLE, HANDLE, const EXIT_PROCESS_DEBUG_INFO&)); 30 | MOCK_METHOD3(OnLoadDll, void(HANDLE, HANDLE, const LOAD_DLL_DEBUG_INFO&)); 31 | MOCK_METHOD3(OnUnloadDll, void(HANDLE, HANDLE, const UNLOAD_DLL_DEBUG_INFO&)); 32 | MOCK_METHOD3(OnException, ExceptionType(HANDLE, HANDLE, const EXCEPTION_DEBUG_INFO&)); 33 | 34 | private: 35 | DebugEventsHandlerMock(const DebugEventsHandlerMock&) = delete; 36 | DebugEventsHandlerMock& operator=(const DebugEventsHandlerMock&) = delete; 37 | }; 38 | } -------------------------------------------------------------------------------- /CppCoverageTest/DebugInformationEventHandlerMock.hpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | #include "CppCoverage/IDebugInformationEventHandler.hpp" 20 | 21 | namespace CppCoverageTest 22 | { 23 | class DebugInformationEventHandlerMock : public CppCoverage::IDebugInformationEventHandler 24 | { 25 | public: 26 | DebugInformationEventHandlerMock() = default; 27 | 28 | MOCK_CONST_METHOD1(IsSourceFileSelected, bool(const std::wstring&)); 29 | MOCK_METHOD3(OnNewLine, void(const std::wstring& fileName, int lineNumber, const CppCoverage::Address&)); 30 | 31 | private: 32 | DebugInformationEventHandlerMock(const DebugInformationEventHandlerMock&) = delete; 33 | DebugInformationEventHandlerMock& operator=(const DebugInformationEventHandlerMock&) = delete; 34 | }; 35 | } 36 | 37 | 38 | -------------------------------------------------------------------------------- /CppCoverageTest/HandleInformationTest.cpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #include "stdafx.h" 18 | 19 | #include 20 | 21 | #include "CppCoverage/HandleInformation.hpp" 22 | #include "TestCoverageConsole/TestCoverageConsole.hpp" 23 | #include "ToolsCross/Tool.hpp" 24 | 25 | #include "TestTools.hpp" 26 | 27 | namespace cov = CppCoverage; 28 | namespace fs = boost::filesystem; 29 | 30 | namespace CppCoverageTest 31 | { 32 | //------------------------------------------------------------------------- 33 | TEST(HandleInformationTest, ComputeFilename) 34 | { 35 | auto outputBinaryPath = TestCoverageConsole::GetOutputBinaryPath(); 36 | fs::path path; 37 | 38 | TestTools::GetHandles(outputBinaryPath, [&](HANDLE hProcess, HANDLE hFile) 39 | { 40 | cov::HandleInformation handleInformation; 41 | 42 | path = handleInformation.ComputeFilename(hFile); 43 | }); 44 | 45 | ASSERT_EQ(outputBinaryPath, path); 46 | } 47 | } -------------------------------------------------------------------------------- /CppCoverageTest/ProcessTest.cpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #include "stdafx.h" 18 | 19 | #include "CppCoverage/StartInfo.hpp" 20 | #include "CppCoverage/Process.hpp" 21 | 22 | #include "TestCoverageConsole/TestCoverageConsole.hpp" 23 | #include "TestCoverageSharedLib/TestCoverageSharedLib.hpp" 24 | 25 | namespace cov = CppCoverage; 26 | 27 | namespace CppCoverageTest 28 | { 29 | //------------------------------------------------------------------------- 30 | TEST(Process, StartWithArgument) 31 | { 32 | cov::StartInfo startInfo{ TestCoverageConsole::GetOutputBinaryPath() }; 33 | startInfo.AddArgument(TestCoverageConsole::TestThrowHandledException); 34 | 35 | cov::Process process{ startInfo }; 36 | ASSERT_NO_THROW(process.Start(0)); 37 | } 38 | 39 | //------------------------------------------------------------------------- 40 | TEST(Process, InvalidProgram) 41 | { 42 | cov::StartInfo startInfo{ TestCoverageSharedLib::GetOutputBinaryPath() }; 43 | 44 | cov::Process process{ startInfo }; 45 | ASSERT_THROW(process.Start(0), std::runtime_error); 46 | } 47 | } -------------------------------------------------------------------------------- /CppCoverageTest/ReadMe.txt: -------------------------------------------------------------------------------- 1 | ======================================================================== 2 | CONSOLE APPLICATION : CppCoverageTest Project Overview 3 | ======================================================================== 4 | 5 | AppWizard has created this CppCoverageTest application for you. 6 | 7 | This file contains a summary of what you will find in each of the files that 8 | make up your CppCoverageTest application. 9 | 10 | 11 | CppCoverageTest.vcxproj 12 | This is the main project file for VC++ projects generated using an Application Wizard. 13 | It contains information about the version of Visual C++ that generated the file, and 14 | information about the platforms, configurations, and project features selected with the 15 | Application Wizard. 16 | 17 | CppCoverageTest.vcxproj.filters 18 | This is the filters file for VC++ projects generated using an Application Wizard. 19 | It contains information about the association between the files in your project 20 | and the filters. This association is used in the IDE to show grouping of files with 21 | similar extensions under a specific node (for e.g. ".cpp" files are associated with the 22 | "Source Files" filter). 23 | 24 | CppCoverageTest.cpp 25 | This is the main application source file. 26 | 27 | ///////////////////////////////////////////////////////////////////////////// 28 | Other standard files: 29 | 30 | StdAfx.h, StdAfx.cpp 31 | These files are used to build a precompiled header (PCH) file 32 | named CppCoverageTest.pch and a precompiled types file named StdAfx.obj. 33 | 34 | ///////////////////////////////////////////////////////////////////////////// 35 | Other notes: 36 | 37 | AppWizard uses "TODO:" comments to indicate parts of the source code you 38 | should add to or customize. 39 | 40 | ///////////////////////////////////////////////////////////////////////////// 41 | -------------------------------------------------------------------------------- /CppCoverageTest/TestTools.hpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | #include 20 | 21 | #include 22 | #include 23 | 24 | #include "CppCoverage/OptionsParser.hpp" 25 | #include "CppCoverage/Options.hpp" 26 | 27 | namespace boost 28 | { 29 | namespace filesystem 30 | { 31 | class path; 32 | } 33 | } 34 | 35 | namespace CppCoverageTest 36 | { 37 | class TestTools 38 | { 39 | public: 40 | typedef std::function T_HandlesFct; 41 | 42 | public: 43 | TestTools() = delete; 44 | 45 | static void GetHandles(const boost::filesystem::path&, T_HandlesFct); 46 | 47 | static boost::optional Parse( 48 | const CppCoverage::OptionsParser& parser, 49 | const std::vector& arguments, 50 | bool appendProgramToRun = true, 51 | std::wostream* emptyOptionsExplanation = nullptr); 52 | 53 | static const std::string OptionPrefix; 54 | static const std::string ProgramToRun; 55 | }; 56 | } 57 | 58 | -------------------------------------------------------------------------------- /CppCoverageTest/stdafx.cpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #include "stdafx.h" 18 | -------------------------------------------------------------------------------- /CppCoverageTest/stdafx.h: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | #include 20 | #include -------------------------------------------------------------------------------- /Exporter/Binary/BinaryExporter.cpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #include "../stdafx.h" 18 | #include "BinaryExporter.hpp" 19 | 20 | #include 21 | 22 | #include 23 | 24 | #include "CoverageDataSerializer.hpp" 25 | #ifdef __linux__ 26 | #include 27 | #elif _WIN32 28 | #include 29 | #endif 30 | 31 | namespace Exporter 32 | { 33 | //------------------------------------------------------------------------- 34 | boost::filesystem::path BinaryExporter::GetDefaultPath(const std::wstring& prefix) const 35 | { 36 | boost::filesystem::path path{ prefix }; 37 | 38 | path += ".cov"; 39 | 40 | return path; 41 | } 42 | 43 | //------------------------------------------------------------------------- 44 | void BinaryExporter::Export( 45 | const CppCoverage::CoverageData& coverageData, 46 | const boost::filesystem::path& output) 47 | { 48 | CoverageDataSerializer coverageDataSerializer; 49 | 50 | coverageDataSerializer.Serialize(coverageData, output); 51 | Tools::ShowOutputMessage(L"Coverage binary generated in file: ", output); 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /Exporter/Binary/BinaryExporter.hpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | #include "../ExporterExport.hpp" 20 | #include "../IExporter.hpp" 21 | 22 | namespace Exporter 23 | { 24 | class EXPORTER_DLL BinaryExporter : public IExporter 25 | { 26 | public: 27 | BinaryExporter() = default; 28 | 29 | boost::filesystem::path GetDefaultPath(const std::wstring& prefix) const override; 30 | void Export(const CppCoverage::CoverageData&, const boost::filesystem::path& output) override; 31 | 32 | private: 33 | BinaryExporter(const BinaryExporter&) = delete; 34 | BinaryExporter& operator=(const BinaryExporter&) = delete; 35 | }; 36 | } 37 | 38 | -------------------------------------------------------------------------------- /Exporter/Binary/CoverageData.proto: -------------------------------------------------------------------------------- 1 | package ProtoBuff; 2 | 3 | message LineCoverage 4 | { 5 | required uint32 lineNumber = 1; 6 | required bool hasBeenExecuted = 2; 7 | } 8 | 9 | message FileCoverage 10 | { 11 | required string path = 1; 12 | repeated LineCoverage lines = 2; 13 | } 14 | 15 | message ModuleCoverage 16 | { 17 | required string path = 1; 18 | repeated FileCoverage files = 2; 19 | } 20 | 21 | message CoverageData 22 | { 23 | required string name = 1; 24 | required int32 exitCode = 2; 25 | required uint64 moduleCount = 3; 26 | } -------------------------------------------------------------------------------- /Exporter/Binary/CoverageDataDeserializer.hpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | #include "../ExporterExport.hpp" 20 | 21 | namespace boost 22 | { 23 | namespace filesystem 24 | { 25 | class path; 26 | } 27 | } 28 | 29 | namespace CppCoverage 30 | { 31 | class CoverageData; 32 | } 33 | 34 | namespace Exporter 35 | { 36 | class EXPORTER_DLL CoverageDataDeserializer 37 | { 38 | public: 39 | CoverageDataDeserializer() = default; 40 | 41 | CppCoverage::CoverageData Deserialize(const boost::filesystem::path&, const std::string& errorIfNotCorrectFormat) const; 42 | 43 | private: 44 | CoverageDataDeserializer(const CoverageDataDeserializer&) = delete; 45 | CoverageDataDeserializer& operator=(const CoverageDataDeserializer&) = delete; 46 | }; 47 | } 48 | 49 | -------------------------------------------------------------------------------- /Exporter/Binary/CoverageDataSerializer.hpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | #include "../ExporterExport.hpp" 20 | 21 | namespace CppCoverage 22 | { 23 | class CoverageData; 24 | } 25 | 26 | namespace boost 27 | { 28 | namespace filesystem 29 | { 30 | class path; 31 | } 32 | } 33 | 34 | namespace Exporter 35 | { 36 | class EXPORTER_DLL CoverageDataSerializer 37 | { 38 | public: 39 | const static unsigned int FileTypeId; 40 | 41 | CoverageDataSerializer() = default; 42 | 43 | void Serialize(const CppCoverage::CoverageData&, const boost::filesystem::path&) const; 44 | 45 | private: 46 | CoverageDataSerializer(const CoverageDataSerializer&) = delete; 47 | CoverageDataSerializer& operator=(const CoverageDataSerializer&) = delete; 48 | }; 49 | } 50 | 51 | -------------------------------------------------------------------------------- /Exporter/Binary/ProtoBuff.hpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | #pragma warning(push) 20 | 21 | #pragma warning(disable: 4244) // conversion from '__int64' to 'int', possible loss of data 22 | 23 | #include 24 | #include 25 | 26 | #pragma warning(pop) 27 | 28 | 29 | -------------------------------------------------------------------------------- /Exporter/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 2.8.12) 2 | 3 | set(CMAKE_CXX_STANDARD 14) 4 | 5 | find_package(Protobuf REQUIRED) 6 | include_directories(${CMAKE_SOURCE_DIR} 7 | ${PROTOBUF_INCLUDE_DIRS} 8 | /home/nicklas/Downloads/ctemplate-ctemplate-2.3/src) 9 | 10 | PROTOBUF_GENERATE_CPP(PROTO_SRC PROTO_HEADER Binary/CoverageData.proto) 11 | 12 | set_source_files_properties(${PROTO_SRC} ${PROTO_HEADER} PROPERTIES GENERATED TRUE) 13 | 14 | add_library(Exporter 15 | ${PROTO_SRC} 16 | ${PROTO_HEADER} 17 | CoberturaExporter.cpp 18 | CoberturaExporter.hpp 19 | ExporterException.cpp 20 | ExporterException.hpp 21 | ExporterExport.hpp 22 | IExporter.hpp 23 | stdafx.cpp 24 | stdafx.h 25 | Binary/BinaryExporter.cpp 26 | Binary/BinaryExporter.hpp 27 | Binary/CoverageDataDeserializer.cpp 28 | Binary/CoverageDataDeserializer.hpp 29 | Binary/CoverageDataSerializer.cpp 30 | Binary/CoverageDataSerializer.hpp 31 | Binary/ProtoBuff.hpp 32 | Html/CTemplate.hpp 33 | Html/HtmlExporter.cpp 34 | Html/HtmlExporter.hpp 35 | Html/HtmlFile.cpp 36 | Html/HtmlFile.hpp 37 | Html/HtmlFileCoverageExporter.cpp 38 | Html/HtmlFileCoverageExporter.hpp 39 | Html/HtmlFolderStructure.cpp 40 | Html/HtmlFolderStructure.hpp 41 | Html/TemplateHtmlExporter.cpp 42 | Html/TemplateHtmlExporter.hpp 43 | ) 44 | 45 | link_directories(${CMAKE_SOURCE_DIR} ${PROTOBUF_LIBRARIES}) -------------------------------------------------------------------------------- /Exporter/CoberturaExporter.hpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | #include 20 | 21 | #include "ExporterExport.hpp" 22 | #include "IExporter.hpp" 23 | 24 | namespace CppCoverage 25 | { 26 | class CoverageData; 27 | } 28 | 29 | namespace boost 30 | { 31 | namespace filesystem 32 | { 33 | class path; 34 | } 35 | } 36 | 37 | namespace Exporter 38 | { 39 | class EXPORTER_DLL CoberturaExporter: public IExporter 40 | { 41 | public: 42 | CoberturaExporter() ; 43 | 44 | boost::filesystem::path GetDefaultPath(const std::wstring& runningCommandFilename) const override; 45 | void Export(const CppCoverage::CoverageData&, const boost::filesystem::path& output) override; 46 | void Export(const CppCoverage::CoverageData&, std::wostream&) const; 47 | 48 | private: 49 | CoberturaExporter(const CoberturaExporter&) = delete; 50 | CoberturaExporter& operator=(const CoberturaExporter&) = delete; 51 | }; 52 | } 53 | 54 | -------------------------------------------------------------------------------- /Exporter/ExporterException.cpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #include "stdafx.h" 18 | #include "ExporterException.hpp" 19 | 20 | namespace Exporter 21 | { 22 | } -------------------------------------------------------------------------------- /Exporter/ExporterException.hpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | #include 20 | 21 | GENERATE_EXCEPTION_CLASS(Exporter, ExporterException); 22 | 23 | #define THROW(message) THROW_BASE(Exporter, ExporterException, message) 24 | 25 | -------------------------------------------------------------------------------- /Exporter/ExporterExport.hpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | //#ifdef EXPORTER_EXPORTS 20 | //#define EXPORTER_DLL __declspec(dllexport) 21 | //#else 22 | //#define EXPORTER_DLL _declspec(dllimport) 23 | #define EXPORTER_DLL 24 | //#endif 25 | 26 | #pragma warning (disable: 4251) 27 | 28 | 29 | 30 | -------------------------------------------------------------------------------- /Exporter/Html/CTemplate.hpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | #pragma warning(push) 20 | 21 | #pragma warning(disable: 4005) // 'va_copy' : macro redefinition 22 | #pragma warning(disable: 4251) // needs to have dll-interface to be used by clients of class 23 | #pragma warning(disable: 4273) // inconsistent dll linkage 24 | #pragma warning(disable: 4267) // 'initializing' : conversion from 'size_t' to 'int' 25 | 26 | //template std::vector; // To avoid error C4251 27 | #define _SILENCE_STDEXT_HASH_DEPRECATION_WARNINGS 28 | #define __MINGW64__ // disable snprintf 29 | #include 30 | #include 31 | #undef _SILENCE_STDEXT_HASH_DEPRECATION_WARNING 32 | #undef __MINGW64__ 33 | 34 | #pragma warning(pop) 35 | -------------------------------------------------------------------------------- /Exporter/Html/HtmlFile.cpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #include "../stdafx.h" 18 | #include "HtmlFile.hpp" 19 | 20 | namespace Exporter 21 | { 22 | //------------------------------------------------------------------------- 23 | HtmlFile::HtmlFile( 24 | boost::filesystem::path absolutePath, 25 | boost::filesystem::path relativeLinkPath) 26 | : absolutePath_(absolutePath) 27 | , relativeLinkPath_(relativeLinkPath) 28 | { 29 | } 30 | 31 | //------------------------------------------------------------------------- 32 | const boost::filesystem::path& HtmlFile::GetAbsolutePath() const 33 | { 34 | return absolutePath_; 35 | } 36 | 37 | //------------------------------------------------------------------------- 38 | const boost::filesystem::path& HtmlFile::GetRelativeLinkPath() const 39 | { 40 | return relativeLinkPath_; 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /Exporter/Html/HtmlFile.hpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | #include 20 | 21 | #include "../ExporterExport.hpp" 22 | 23 | namespace Exporter 24 | { 25 | class EXPORTER_DLL HtmlFile 26 | { 27 | public: 28 | HtmlFile( 29 | boost::filesystem::path absolutePath, 30 | boost::filesystem::path relativeLinkPath); 31 | HtmlFile(const HtmlFile&) = default; 32 | 33 | const boost::filesystem::path& GetAbsolutePath() const; 34 | const boost::filesystem::path& GetRelativeLinkPath() const; 35 | 36 | private: 37 | HtmlFile& operator=(const HtmlFile&) = delete; 38 | 39 | boost::filesystem::path absolutePath_; 40 | boost::filesystem::path relativeLinkPath_; 41 | }; 42 | } 43 | 44 | -------------------------------------------------------------------------------- /Exporter/Html/HtmlFolderStructure.hpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | #include 20 | #include 21 | 22 | #include "HtmlFile.hpp" 23 | #include "../ExporterExport.hpp" 24 | 25 | namespace Exporter 26 | { 27 | class EXPORTER_DLL HtmlFolderStructure 28 | { 29 | public: 30 | static const std::wstring ThirdParty; 31 | static const std::wstring FolderModules; 32 | 33 | public: 34 | HtmlFolderStructure(const boost::filesystem::path& templateFolder); 35 | ~HtmlFolderStructure(); 36 | 37 | boost::filesystem::path CreateCurrentRoot(const boost::filesystem::path& outputFolder); 38 | HtmlFile CreateCurrentModule(const boost::filesystem::path&); 39 | HtmlFile GetHtmlFilePath(const boost::filesystem::path& filePath) const; 40 | 41 | private: 42 | HtmlFolderStructure(const HtmlFolderStructure&) = delete; 43 | HtmlFolderStructure& operator=(const HtmlFolderStructure&) = delete; 44 | 45 | private: 46 | boost::filesystem::path templateFolder_; 47 | 48 | struct Hierarchy; 49 | std::unique_ptr optionalCurrentRoot_; 50 | std::unique_ptr optionalCurrentModule_; 51 | }; 52 | } 53 | 54 | -------------------------------------------------------------------------------- /Exporter/Html/Template/SourceTemplate.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | {{TITLE}} 6 | 7 | 8 | 9 | 10 |

{{SOURCE_WARNING_MESSAGE}}

11 | 
{{CODE}}
12 | 13 | -------------------------------------------------------------------------------- /Exporter/Html/Template/third-party/css/style.css: -------------------------------------------------------------------------------- 1 | /* ------------------ 2 | styling from http://www.smashingmagazine.com/2008/08/13/top-10-css-table-designs/ 3 | ------------------ */ 4 | 5 | #rounded-corner 6 | { 7 | font-family: "Lucida Sans Unicode", "Lucida Grande", Sans-Serif; 8 | font-size: 12px; 9 | margin: 45px; 10 | width: 90%; 11 | text-align: left; 12 | border-collapse: collapse; 13 | } 14 | #rounded-corner thead th.rounded-left 15 | { 16 | background: #b9c9fe url('table-images/left.png') left -1px no-repeat; 17 | } 18 | #rounded-corner thead th.rounded-right 19 | { 20 | background: #b9c9fe url('table-images/right.png') right -1px no-repeat; 21 | } 22 | #rounded-corner th 23 | { 24 | padding: 8px; 25 | font-weight: normal; 26 | font-size: 13px; 27 | color: #039; 28 | background: #b9c9fe; 29 | } 30 | #rounded-corner td 31 | { 32 | padding: 8px; 33 | background: #e8edff; 34 | border-top: 1px solid #fff; 35 | color: #669; 36 | } 37 | #rounded-corner tfoot td.rounded-foot-left 38 | { 39 | background: #e8edff url('table-images/botleft.png') left bottom no-repeat; 40 | } 41 | #rounded-corner tfoot td.rounded-foot-right 42 | { 43 | background: #e8edff url('table-images/botright.png') right bottom no-repeat; 44 | } 45 | #rounded-corner tbody tr:hover td 46 | { 47 | background: #d0dafd; 48 | } -------------------------------------------------------------------------------- /Exporter/Html/Template/third-party/css/table-images/botleft.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Unity-Technologies/OpenCppCoverage/4ae21f3f0bce5a6b305f584b3ef9d9c2cd7c5545/Exporter/Html/Template/third-party/css/table-images/botleft.png -------------------------------------------------------------------------------- /Exporter/Html/Template/third-party/css/table-images/botright.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Unity-Technologies/OpenCppCoverage/4ae21f3f0bce5a6b305f584b3ef9d9c2cd7c5545/Exporter/Html/Template/third-party/css/table-images/botright.png -------------------------------------------------------------------------------- /Exporter/Html/Template/third-party/css/table-images/left.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Unity-Technologies/OpenCppCoverage/4ae21f3f0bce5a6b305f584b3ef9d9c2cd7c5545/Exporter/Html/Template/third-party/css/table-images/left.png -------------------------------------------------------------------------------- /Exporter/Html/Template/third-party/css/table-images/right.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Unity-Technologies/OpenCppCoverage/4ae21f3f0bce5a6b305f584b3ef9d9c2cd7c5545/Exporter/Html/Template/third-party/css/table-images/right.png -------------------------------------------------------------------------------- /Exporter/Html/Template/third-party/google-code-prettify/prettify-CppCoverage.css: -------------------------------------------------------------------------------- 1 | .pln{color:#000}@media screen{.str{color:#080}.kwd{color:#008}.com{color:#800}.typ{color:#606}.lit{color:#066}.pun,.opn,.clo{color:#660}.tag{color:#008}.atn{color:#606}.atv{color:#080}.dec,.var{color:#606}.fun{color:red}}@media print,projection{.str{color:#060}.kwd{color:#006;font-weight:bold}.com{color:#600;font-style:italic}.typ{color:#404;font-weight:bold}.lit{color:#044}.pun,.opn,.clo{color:#440}.tag{color:#006;font-weight:bold}.atn{color:#404}.atv{color:#060}}pre.prettyprint{padding:2px;border:1px solid #888}ol.linenums{margin-top:0;margin-bottom:0}li.L1,li.L3,li.L5,li.L7,li.L9{background:#eee} -------------------------------------------------------------------------------- /Exporter/IExporter.hpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | #include 20 | 21 | namespace boost 22 | { 23 | namespace filesystem 24 | { 25 | class path; 26 | } 27 | } 28 | 29 | namespace CppCoverage 30 | { 31 | class CoverageData; 32 | } 33 | 34 | namespace Exporter 35 | { 36 | class EXPORTER_DLL IExporter 37 | { 38 | public: 39 | IExporter() = default; 40 | 41 | virtual boost::filesystem::path GetDefaultPath(const std::wstring& prefix) const = 0; 42 | virtual void Export(const CppCoverage::CoverageData&, const boost::filesystem::path& output) = 0; 43 | 44 | private: 45 | IExporter(const IExporter&) = delete; 46 | IExporter& operator=(const IExporter&) = delete; 47 | }; 48 | } 49 | 50 | -------------------------------------------------------------------------------- /Exporter/stdafx.cpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #include "stdafx.h" 18 | -------------------------------------------------------------------------------- /Exporter/stdafx.h: -------------------------------------------------------------------------------- 1 | // stdafx.h : include file for standard system include files, 2 | // or project specific include files that are used frequently, but 3 | // are changed infrequently 4 | // 5 | 6 | #pragma once 7 | 8 | #define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers 9 | // Windows Header Files: 10 | //#include 11 | 12 | #include 13 | #include 14 | 15 | // TODO: reference additional headers your program requires here 16 | -------------------------------------------------------------------------------- /ExporterTest/CoberturaExporterTest.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Unity-Technologies/OpenCppCoverage/4ae21f3f0bce5a6b305f584b3ef9d9c2cd7c5545/ExporterTest/CoberturaExporterTest.cpp -------------------------------------------------------------------------------- /ExporterTest/CoverageDataSerializerTest.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Unity-Technologies/OpenCppCoverage/4ae21f3f0bce5a6b305f584b3ef9d9c2cd7c5545/ExporterTest/CoverageDataSerializerTest.cpp -------------------------------------------------------------------------------- /ExporterTest/Data/CoberturaExporterExpectedResult.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | -------------------------------------------------------------------------------- /ExporterTest/Data/TestFile1.cpp: -------------------------------------------------------------------------------- 1 | void foo() 2 | { 3 | } -------------------------------------------------------------------------------- /ExporterTest/Data/TestFile2.cpp: -------------------------------------------------------------------------------- 1 | void foo() 2 | { 3 | } -------------------------------------------------------------------------------- /ExporterTest/ExporterTest.cpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #include "stdafx.h" 18 | #include 19 | 20 | #include "ToolsCross/Log.hpp" 21 | 22 | //----------------------------------------------------------------------------- 23 | int _tmain(int argc, _TCHAR* argv[]) 24 | { 25 | Tools::EnableLogger(false); 26 | ::testing::InitGoogleMock(&argc, argv); 27 | return RUN_ALL_TESTS(); 28 | } -------------------------------------------------------------------------------- /ExporterTest/ReadMe.txt: -------------------------------------------------------------------------------- 1 | ======================================================================== 2 | CONSOLE APPLICATION : ExporterTest Project Overview 3 | ======================================================================== 4 | 5 | AppWizard has created this ExporterTest application for you. 6 | 7 | This file contains a summary of what you will find in each of the files that 8 | make up your ExporterTest application. 9 | 10 | 11 | ExporterTest.vcxproj 12 | This is the main project file for VC++ projects generated using an Application Wizard. 13 | It contains information about the version of Visual C++ that generated the file, and 14 | information about the platforms, configurations, and project features selected with the 15 | Application Wizard. 16 | 17 | ExporterTest.vcxproj.filters 18 | This is the filters file for VC++ projects generated using an Application Wizard. 19 | It contains information about the association between the files in your project 20 | and the filters. This association is used in the IDE to show grouping of files with 21 | similar extensions under a specific node (for e.g. ".cpp" files are associated with the 22 | "Source Files" filter). 23 | 24 | ExporterTest.cpp 25 | This is the main application source file. 26 | 27 | ///////////////////////////////////////////////////////////////////////////// 28 | Other standard files: 29 | 30 | StdAfx.h, StdAfx.cpp 31 | These files are used to build a precompiled header (PCH) file 32 | named ExporterTest.pch and a precompiled types file named StdAfx.obj. 33 | 34 | ///////////////////////////////////////////////////////////////////////////// 35 | Other notes: 36 | 37 | AppWizard uses "TODO:" comments to indicate parts of the source code you 38 | should add to or customize. 39 | 40 | ///////////////////////////////////////////////////////////////////////////// 41 | -------------------------------------------------------------------------------- /ExporterTest/stdafx.cpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #include "stdafx.h" 18 | -------------------------------------------------------------------------------- /ExporterTest/stdafx.h: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | #include 20 | #include 21 | -------------------------------------------------------------------------------- /FileFilter/IRelocationsExtractor.hpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2016 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | #include 20 | #include 21 | #include "FileFilterCross/FileFilterExport.hpp" 22 | 23 | namespace FileFilter 24 | { 25 | class FILEFILTER_DLL IRelocationsExtractor 26 | { 27 | public: 28 | ~IRelocationsExtractor() {} 29 | virtual std::unordered_set Extract( 30 | HANDLE hProcess, 31 | DWORD64 baseOfImage, 32 | DWORD64 baseAddress) const = 0; 33 | }; 34 | } -------------------------------------------------------------------------------- /FileFilter/LineInfo.hpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2016 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | #include 20 | #include 21 | 22 | namespace FileFilter 23 | { 24 | class LineInfo 25 | { 26 | public: 27 | LineInfo( 28 | int lineNumber, 29 | DWORD64 lineAddress, 30 | ULONG symbolIndex, 31 | const std::wstring& symbolName) 32 | : lineNumber_{ lineNumber } 33 | , lineAddress_{ lineAddress } 34 | , symbolIndex_{ symbolIndex } 35 | , symbolName_{ symbolName } 36 | {} 37 | 38 | const int lineNumber_; 39 | const DWORD64 lineAddress_; 40 | const ULONG symbolIndex_; 41 | const std::wstring symbolName_; 42 | }; 43 | } -------------------------------------------------------------------------------- /FileFilter/RelocationsExtractor.hpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2016 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | #include 20 | #include 21 | #include "FileFilterCross/FileFilterExport.hpp" 22 | #include "IRelocationsExtractor.hpp" 23 | 24 | namespace FileFilter 25 | { 26 | class IRelocationsExtractor; 27 | 28 | class FILEFILTER_DLL RelocationsExtractor: public IRelocationsExtractor 29 | { 30 | public: 31 | std::unordered_set Extract( 32 | HANDLE hProcess, 33 | DWORD64 baseOfImage, 34 | DWORD64 baseAddress) const; 35 | }; 36 | } -------------------------------------------------------------------------------- /FileFilter/stdafx.h: -------------------------------------------------------------------------------- 1 | // stdafx.h : include file for standard system include files, 2 | // or project specific include files that are used frequently, but 3 | // are changed infrequently 4 | // 5 | 6 | #pragma once 7 | 8 | #define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers 9 | // Windows Header Files: 10 | #include 11 | 12 | #include 13 | #include 14 | 15 | -------------------------------------------------------------------------------- /FileFilterCross/AmbiguousPathException.hpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2016 OpenCppCoverage 3 | 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | #include "FileFilterExport.hpp" 20 | #include 21 | 22 | #pragma warning(push) 23 | #pragma warning(disable: 4275) // warning C4275: non dll-interface class 'std::exception' used as base for dll-interface class 24 | 25 | namespace FileFilter 26 | { 27 | class FILEFILTER_DLL AmbiguousPathException : public std::runtime_error 28 | { 29 | public: 30 | AmbiguousPathException( 31 | const boost::filesystem::path& postFixPath, 32 | const boost::filesystem::path& firstPossiblePath, 33 | const boost::filesystem::path& secondPossiblePath); 34 | 35 | AmbiguousPathException(const AmbiguousPathException&) = default; 36 | 37 | const boost::filesystem::path& GetPostFixPath() const; 38 | const boost::filesystem::path& GetFirstPossiblePath() const; 39 | const boost::filesystem::path& GetSecondPossiblePath() const; 40 | 41 | private: 42 | boost::filesystem::path postFixPath_; 43 | boost::filesystem::path firstPossiblePath_; 44 | boost::filesystem::path secondPossiblePath_; 45 | }; 46 | } 47 | 48 | #pragma warning(pop) 49 | 50 | -------------------------------------------------------------------------------- /FileFilterCross/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 2.8.12) 2 | 3 | set(CMAKE_CXX_STANDARD 14) 4 | 5 | add_library(FileFilterCross 6 | AmbiguousPathException.cpp 7 | AmbiguousPathException.hpp 8 | File.cpp 9 | File.hpp 10 | FileFilterException.hpp 11 | FileFilterExport.hpp 12 | FileInfo.hpp 13 | ModuleInfo.hpp 14 | PathMatcher.cpp 15 | PathMatcher.hpp 16 | stdafx.cpp 17 | stdafx.h 18 | UnifiedDiffCoverageFilter.cpp 19 | UnifiedDiffCoverageFilter.hpp 20 | UnifiedDiffParser.cpp 21 | UnifiedDiffParser.hpp 22 | UnifiedDiffParserException.cpp 23 | UnifiedDiffParserException.hpp 24 | ) 25 | 26 | if(Boost_FOUND) 27 | message(STATUS "Boost_INCLUDE_DIRS: ${Boost_INCLUDE_DIRS}") 28 | message(STATUS "Boost_LIBRARIES: ${Boost_LIBRARIES}") 29 | message(STATUS "Boost_VERSION: ${Boost_VERSION}") 30 | include_directories(${PROJECT_SOURCE_DIR} ${Boost_INCLUDE_DIRS}) 31 | 32 | target_link_libraries(FileFilterCross 33 | ${Boost_LIBRARIES} 34 | ) 35 | endif() 36 | 37 | include_directories(${CMAKE_SOURCE_DIR}) 38 | link_directories(${CMAKE_SOURCE_DIR}) -------------------------------------------------------------------------------- /FileFilterCross/File.hpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2016 OpenCppCoverage 3 | 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | #include "FileFilterExport.hpp" 20 | #include 21 | #include 22 | 23 | namespace FileFilter 24 | { 25 | class FILEFILTER_DLL File 26 | { 27 | public: 28 | explicit File(const boost::filesystem::path&); 29 | File(File&&) = default; 30 | File& operator=(File&&) = default; 31 | 32 | void AddSelectedLines(const std::vector&); 33 | 34 | const boost::filesystem::path& GetPath() const; 35 | void SetPath(const boost::filesystem::path&); 36 | 37 | bool IsLineSelected(int) const; 38 | const std::set& GetSelectedLines() const; 39 | 40 | bool operator==(const File&) const; 41 | 42 | File operator* (const File &file) { return *this; } 43 | 44 | private: 45 | File(const File&) = default; 46 | File& operator=(const File&) = delete; 47 | 48 | boost::filesystem::path path_; 49 | std::set selectedLines_; 50 | }; 51 | } 52 | 53 | -------------------------------------------------------------------------------- /FileFilterCross/FileFilterException.hpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2016 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | #include 20 | 21 | GENERATE_EXCEPTION_CLASS(FileFilter, FileFilterException); 22 | 23 | #define THROW(message) THROW_BASE(FileFilter, FileFilterException, message) 24 | 25 | -------------------------------------------------------------------------------- /FileFilterCross/FileFilterExport.hpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | //#ifdef FILEFILTER_EXPORTS 20 | //#define FILEFILTER_DLL __declspec(dllexport) 21 | //#else 22 | //#define FILEFILTER_DLL _declspec(dllimport) 23 | #define FILEFILTER_DLL 24 | //#endif 25 | 26 | #pragma warning (disable: 4251) -------------------------------------------------------------------------------- /FileFilterCross/FileInfo.hpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2016 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | //#include 20 | #include 21 | #include 22 | 23 | #include "FileFilter/LineInfo.hpp" 24 | 25 | namespace FileFilter 26 | { 27 | class FileInfo 28 | { 29 | public: 30 | FileInfo( 31 | const boost::filesystem::path& filePath, 32 | std::vector&& lineInfoColllection) 33 | : filePath_{ filePath } 34 | , lineInfoColllection_{ std::move(lineInfoColllection) } 35 | {} 36 | 37 | const boost::filesystem::path filePath_; 38 | const std::vector lineInfoColllection_; 39 | }; 40 | } 41 | -------------------------------------------------------------------------------- /FileFilterCross/ModuleInfo.hpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2016 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | #include 20 | #include 21 | 22 | namespace FileFilter 23 | { 24 | class ModuleInfo 25 | { 26 | public: 27 | //--------------------------------------------------------------------------- 28 | ModuleInfo( 29 | HANDLE hProcess, 30 | const boost::uuids::uuid& uniqueId, 31 | void* baseOfImage, 32 | DWORD64 baseAddress) 33 | : hProcess_ {hProcess} 34 | , uniqueId_{ uniqueId } 35 | , baseOfImage_{ baseOfImage } 36 | , baseAddress_{ baseAddress } 37 | {} 38 | 39 | const HANDLE hProcess_; 40 | const boost::uuids::uuid uniqueId_; 41 | void* const baseOfImage_; 42 | const DWORD64 baseAddress_; 43 | }; 44 | } 45 | -------------------------------------------------------------------------------- /FileFilterCross/PathMatcher.hpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2016 OpenCppCoverage 3 | 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | #include "FileFilterExport.hpp" 20 | #include 21 | #include 22 | #include 23 | 24 | namespace boost 25 | { 26 | namespace filesystem 27 | { 28 | class path; 29 | } 30 | } 31 | 32 | namespace FileFilter 33 | { 34 | class File; 35 | 36 | class FILEFILTER_DLL PathMatcher 37 | { 38 | public: 39 | explicit PathMatcher( 40 | std::vector&&, 41 | const boost::optional& parentPath); 42 | ~PathMatcher(); 43 | 44 | File* Match(const boost::filesystem::path&); 45 | 46 | using PathCollection = std::vector; 47 | PathCollection GetUnmatchedPaths() const; 48 | 49 | private: 50 | PathMatcher(const PathMatcher&) = delete; 51 | PathMatcher& operator=(const PathMatcher&) = delete; 52 | PathMatcher(PathMatcher&&) = delete; 53 | PathMatcher& operator=(PathMatcher&&) = delete; 54 | 55 | class IPathMatcherEngine; 56 | class PostFixPathMatcherEngine; 57 | class FullPathMatcherEngine; 58 | 59 | std::unique_ptr pathMatcherEngine_; 60 | }; 61 | } 62 | 63 | -------------------------------------------------------------------------------- /FileFilterCross/UnifiedDiffParserException.hpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2016 OpenCppCoverage 3 | 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | #include "FileFilterExport.hpp" 20 | #include 21 | #include 22 | 23 | #pragma warning(push) 24 | #pragma warning(disable: 4275) // warning C4275: non dll-interface class 'std::exception' used as base for dll-interface class 25 | 26 | namespace FileFilter 27 | { 28 | class FILEFILTER_DLL UnifiedDiffParserException : public std::runtime_error 29 | { 30 | public: 31 | static const std::wstring ErrorContextHunks; 32 | static const std::wstring ErrorNoFilenameBeforeHunks; 33 | static const std::wstring ErrorCannotReadLine; 34 | static const std::wstring ErrorExpectFromFilePrefix; 35 | static const std::wstring ErrorInvalidHunks; 36 | 37 | explicit UnifiedDiffParserException(const std::wstring& message); 38 | }; 39 | } 40 | 41 | #pragma warning(pop) 42 | 43 | -------------------------------------------------------------------------------- /FileFilterCross/stdafx.cpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #include "stdafx.h" 18 | -------------------------------------------------------------------------------- /FileFilterCross/stdafx.h: -------------------------------------------------------------------------------- 1 | // stdafx.h : include file for standard system include files, 2 | // or project specific include files that are used frequently, but 3 | // are changed infrequently 4 | // 5 | 6 | #pragma once 7 | 8 | #define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers 9 | // Windows Header Files: 10 | //#include 11 | 12 | #include 13 | #include 14 | 15 | -------------------------------------------------------------------------------- /FileFilterTest/Data/test_add.diff: -------------------------------------------------------------------------------- 1 | diff --git a/FileFilter/stdafx.h b/FileFilter/stdafx.h 2 | new file mode 100644 3 | index 0000000..293d34a 4 | --- /dev/null 5 | +++ b/FileFilter/stdafx.h 6 | @@ -0,0 +1,14 @@ 7 | +// stdafx.h : include file for standard system include files, 8 | +// or project specific include files that are used frequently, but 9 | +// are changed infrequently 10 | +// 11 | + 12 | +#pragma once 13 | + 14 | +#define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers 15 | +// Windows Header Files: 16 | +#include 17 | + 18 | +#include 19 | +#include 20 | + -------------------------------------------------------------------------------- /FileFilterTest/FileFilterTest.cpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2016 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #include "stdafx.h" 18 | #include 19 | 20 | //----------------------------------------------------------------------------- 21 | int _tmain(int argc, _TCHAR* argv[]) 22 | { 23 | ::testing::InitGoogleMock(&argc, argv); 24 | return RUN_ALL_TESTS(); 25 | } 26 | 27 | -------------------------------------------------------------------------------- /FileFilterTest/Tools.cpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2016 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #include "stdafx.h" 18 | #include "FileFilter/File.hpp" 19 | 20 | namespace FileFilterTest 21 | { 22 | //----------------------------------------------------------------- 23 | std::vector ToFiles(const std::vector& filenames) 24 | { 25 | std::vector files; 26 | 27 | for (auto& filename : filenames) 28 | files.emplace_back(filename); 29 | 30 | return files; 31 | } 32 | } -------------------------------------------------------------------------------- /FileFilterTest/Tools.hpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2016 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | #include 20 | #include 21 | 22 | namespace FileFilter 23 | { 24 | class File; 25 | } 26 | 27 | namespace FileFilterTest 28 | { 29 | std::vector ToFiles(const std::vector& filenames); 30 | } 31 | 32 | -------------------------------------------------------------------------------- /FileFilterTest/stdafx.cpp: -------------------------------------------------------------------------------- 1 | // stdafx.cpp : source file that includes just the standard includes 2 | // FileFilterTest.pch will be the pre-compiled header 3 | // stdafx.obj will contain the pre-compiled type information 4 | 5 | #include "stdafx.h" 6 | -------------------------------------------------------------------------------- /FileFilterTest/stdafx.h: -------------------------------------------------------------------------------- 1 | // stdafx.h : include file for standard system include files, 2 | // or project specific include files that are used frequently, but 3 | // are changed infrequently 4 | // 5 | 6 | #pragma once 7 | 8 | #include 9 | #include 10 | -------------------------------------------------------------------------------- /IntegrationTests.testsettings: -------------------------------------------------------------------------------- 1 |  2 | 3 | This test run configuration uses the VS IDE host type in the test run. 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | -------------------------------------------------------------------------------- /OpenCppCoverage/OpenCppCoverage.hpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | #include 20 | 21 | namespace OpenCppCoverage 22 | { 23 | class OpenCppCoverage 24 | { 25 | public: 26 | OpenCppCoverage() = default; 27 | 28 | int Run(int argc, const char** argv, std::wostream* emptyOptionsExplanation) const; 29 | 30 | private: 31 | OpenCppCoverage(const OpenCppCoverage&) = delete; 32 | OpenCppCoverage& operator=(const OpenCppCoverage&) = delete; 33 | }; 34 | } 35 | 36 | -------------------------------------------------------------------------------- /OpenCppCoverage/OpenCppCoverageException.hpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | #include "tools/ExceptionBase.hpp" 20 | 21 | GENERATE_EXCEPTION_CLASS(CppCoverageConsole, CppCoverageConsoleException); 22 | 23 | #define THROW(message) THROW_BASE(CppCoverageConsole, CppCoverageConsoleException, message) 24 | 25 | -------------------------------------------------------------------------------- /OpenCppCoverage/OpenCppCoverageExport.hpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | //#ifdef OPEN_CPP_COVERAGE_EXPORTS 20 | //#define OPEN_CPP_COVERAGE_DLL __declspec(dllexport) 21 | //#else 22 | //#define OPEN_CPP_COVERAGE_DLL _declspec(dllimport) 23 | //#endif 24 | #define OPEN_CPP_COVERAGE_DLL 25 | 26 | #pragma warning (disable: 4251) -------------------------------------------------------------------------------- /OpenCppCoverage/ReadMe.txt: -------------------------------------------------------------------------------- 1 | ======================================================================== 2 | CONSOLE APPLICATION : CppCoverageConsole Project Overview 3 | ======================================================================== 4 | 5 | AppWizard has created this CppCoverageConsole application for you. 6 | 7 | This file contains a summary of what you will find in each of the files that 8 | make up your CppCoverageConsole application. 9 | 10 | 11 | CppCoverageConsole.vcxproj 12 | This is the main project file for VC++ projects generated using an Application Wizard. 13 | It contains information about the version of Visual C++ that generated the file, and 14 | information about the platforms, configurations, and project features selected with the 15 | Application Wizard. 16 | 17 | CppCoverageConsole.vcxproj.filters 18 | This is the filters file for VC++ projects generated using an Application Wizard. 19 | It contains information about the association between the files in your project 20 | and the filters. This association is used in the IDE to show grouping of files with 21 | similar extensions under a specific node (for e.g. ".cpp" files are associated with the 22 | "Source Files" filter). 23 | 24 | CppCoverageConsole.cpp 25 | This is the main application source file. 26 | 27 | ///////////////////////////////////////////////////////////////////////////// 28 | Other standard files: 29 | 30 | StdAfx.h, StdAfx.cpp 31 | These files are used to build a precompiled header (PCH) file 32 | named CppCoverageConsole.pch and a precompiled types file named StdAfx.obj. 33 | 34 | ///////////////////////////////////////////////////////////////////////////// 35 | Other notes: 36 | 37 | AppWizard uses "TODO:" comments to indicate parts of the source code you 38 | should add to or customize. 39 | 40 | ///////////////////////////////////////////////////////////////////////////// 41 | -------------------------------------------------------------------------------- /OpenCppCoverage/main.cpp: -------------------------------------------------------------------------------- 1 | // CppCoverageConsole.cpp : Defines the entry point for the console application. 2 | // 3 | 4 | // OpenCppCoverage is an open source code coverage for C++. 5 | // Copyright (C) 2014 OpenCppCoverage 6 | // 7 | // This program is free software: you can redistribute it and/or modify 8 | // it under the terms of the GNU General Public License as published by 9 | // the Free Software Foundation, either version 3 of the License, or 10 | // any later version. 11 | // 12 | // This program is distributed in the hope that it will be useful, 13 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 14 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 | // GNU General Public License for more details. 16 | // 17 | // You should have received a copy of the GNU General Public License 18 | // along with this program. If not, see . 19 | 20 | #include "stdafx.h" 21 | 22 | #include 23 | #include 24 | 25 | #ifdef _WIN32 26 | #include 27 | #elif __linux__ 28 | #include 29 | #endif 30 | 31 | #include "OpenCppCoverage.hpp" 32 | 33 | //----------------------------------------------------------------------------- 34 | int main(int argc, const char* argv[]) 35 | { 36 | Tools::CreateMiniDumpOnUnHandledException(); 37 | 38 | try 39 | { 40 | OpenCppCoverage::OpenCppCoverage openCppCoverage; 41 | 42 | return openCppCoverage.Run(argc, argv, &std::wcerr); 43 | } 44 | catch (const std::exception& e) 45 | { 46 | std::cerr << "Error: " << e.what() << std::endl; 47 | } 48 | 49 | return 1; 50 | } -------------------------------------------------------------------------------- /OpenCppCoverage/stdafx.cpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #include "stdafx.h" 18 | -------------------------------------------------------------------------------- /OpenCppCoverage/stdafx.h: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | #include 20 | #include 21 | -------------------------------------------------------------------------------- /OpenCppCoverageTest/OpenCppCoverageTest.cpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #include "stdafx.h" 18 | #include 19 | 20 | //----------------------------------------------------------------------------- 21 | int _tmain(int argc, _TCHAR* argv[]) 22 | { 23 | ::testing::InitGoogleMock(&argc, argv); 24 | return RUN_ALL_TESTS(); 25 | } 26 | -------------------------------------------------------------------------------- /OpenCppCoverageTest/OpenCppCoverageTestTools.hpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | #include 20 | #include 21 | 22 | namespace boost 23 | { 24 | namespace filesystem 25 | { 26 | class path; 27 | } 28 | } 29 | 30 | namespace OpenCppCoverageTest 31 | { 32 | void AddDefaultFilters( 33 | std::vector>& coverageArguments, 34 | const boost::filesystem::path& programToRun); 35 | 36 | void AddDefaultHtmlExport( 37 | std::vector>& coverageArguments, 38 | const boost::filesystem::path& outputFolder); 39 | 40 | std::pair BuildExportTypeString( 41 | const std::string& exportType, 42 | const boost::filesystem::path& output); 43 | 44 | int RunCoverageFor( 45 | const std::vector>& coverageArguments, 46 | const boost::filesystem::path& programToRun, 47 | const std::vector& arguments); 48 | 49 | std::string GetSolutionFolderName(); 50 | } -------------------------------------------------------------------------------- /OpenCppCoverageTest/stdafx.cpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #include "stdafx.h" 18 | -------------------------------------------------------------------------------- /OpenCppCoverageTest/stdafx.h: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | #include 20 | #include 21 | -------------------------------------------------------------------------------- /PropertySheets/Boost.64.props: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | 5 | 6 | $(ExecutablePath) 7 | 8 | 9 | 10 | $(BOOST_FOLDER);%(AdditionalIncludeDirectories) 11 | BOOST_ALL_DYN_LINK;_SCL_SECURE_NO_WARNINGS;%(PreprocessorDefinitions) 12 | 13 | 14 | $(BOOST_FOLDER)/stage/lib/x64;%(AdditionalLibraryDirectories) 15 | 16 | 17 | 18 | -------------------------------------------------------------------------------- /PropertySheets/Boost.props: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | 5 | 6 | $(ExecutablePath) 7 | 8 | 9 | 10 | $(BOOST_FOLDER);%(AdditionalIncludeDirectories) 11 | BOOST_ALL_DYN_LINK;_SCL_SECURE_NO_WARNINGS;%(PreprocessorDefinitions) 12 | 13 | 14 | $(BOOST_FOLDER)/stage/lib/x86;%(AdditionalLibraryDirectories) 15 | 16 | 17 | 18 | -------------------------------------------------------------------------------- /PropertySheets/CTemplate.Debug.props: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | 5 | 6 | 7 | 8 | $(CTEMPLATE_ROOT)/Debug;%(AdditionalLibraryDirectories) 9 | libctemplate-debug.lib;template_test_util_test.lib;%(AdditionalDependencies) 10 | 11 | 12 | $(CTEMPLATE_ROOT)/src/windows;$(CTEMPLATE_ROOT)/src;%(AdditionalIncludeDirectories) 13 | 14 | 15 | 16 | -------------------------------------------------------------------------------- /PropertySheets/CTemplate.Debug.x64.props: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | 5 | 6 | 7 | 8 | $(CTEMPLATE_ROOT)\x64\Debug;%(AdditionalLibraryDirectories) 9 | libctemplate-debug.lib;template_test_util_test.lib;%(AdditionalDependencies) 10 | 11 | 12 | $(CTEMPLATE_ROOT)/src/windows;$(CTEMPLATE_ROOT)/src;%(AdditionalIncludeDirectories) 13 | 14 | 15 | 16 | -------------------------------------------------------------------------------- /PropertySheets/CTemplate.Release.props: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | 5 | 6 | 7 | 8 | $(CTEMPLATE_ROOT)/src/windows;$(CTEMPLATE_ROOT)/src;%(AdditionalIncludeDirectories) 9 | 10 | 11 | $(CTEMPLATE_ROOT)/Release;%(AdditionalLibraryDirectories) 12 | libctemplate.lib;template_test_util_test.lib;%(AdditionalDependencies) 13 | 14 | 15 | 16 | -------------------------------------------------------------------------------- /PropertySheets/CTemplate.Release.x64.props: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | 5 | 6 | 7 | 8 | $(CTEMPLATE_ROOT)/src/windows;$(CTEMPLATE_ROOT)/src;%(AdditionalIncludeDirectories) 9 | 10 | 11 | $(CTEMPLATE_ROOT)/x64/Release;%(AdditionalLibraryDirectories) 12 | libctemplate.lib;template_test_util_test.lib;%(AdditionalDependencies) 13 | 14 | 15 | 16 | -------------------------------------------------------------------------------- /PropertySheets/Default.props: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | 5 | 6 | 7 | 8 | $(SolutionDir);$(ProjectDir);%(AdditionalIncludeDirectories) 9 | OPENCPPCOVERAGE_VERSION="0.9.6";_CRT_SECURE_NO_WARNINGS;PROJECT_DIR=R"|($(ProjectDir))|";SOLUTION_DIR=R"|($(SolutionDir))|";TARGET_FILE_NAME=R"|($(TargetFileName))|";OUT_DIR=R"|($(OutDir))|";NOMINMAX;%(PreprocessorDefinitions) 10 | true 11 | true 12 | 13 | 14 | 15 | -------------------------------------------------------------------------------- /PropertySheets/GMock.Debug.props: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | 5 | 6 | 7 | 8 | $(GMOCK_ROOT)/include;$(GMOCK_ROOT)/gtest/include;%(AdditionalIncludeDirectories) 9 | 10 | 11 | $(GMOCK_ROOT)/build/Debug;%(AdditionalLibraryDirectories) 12 | gmock.lib;%(AdditionalDependencies) 13 | 14 | 15 | 16 | -------------------------------------------------------------------------------- /PropertySheets/GMock.Debug.x64.props: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | 5 | 6 | 7 | 8 | $(GMOCK_ROOT)/include;$(GMOCK_ROOT)/gtest/include;%(AdditionalIncludeDirectories) 9 | 10 | 11 | $(GMOCK_ROOT)/build/x64/Debug;%(AdditionalLibraryDirectories) 12 | gmock.lib;%(AdditionalDependencies) 13 | 14 | 15 | 16 | -------------------------------------------------------------------------------- /PropertySheets/GMock.Release.props: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | 5 | 6 | 7 | 8 | $(GMOCK_ROOT)/include;$(GMOCK_ROOT)/gtest/include;%(AdditionalIncludeDirectories) 9 | 10 | 11 | $(GMOCK_ROOT)/build/Release;%(AdditionalLibraryDirectories) 12 | gmock.lib;%(AdditionalDependencies) 13 | 14 | 15 | 16 | -------------------------------------------------------------------------------- /PropertySheets/GMock.Release.x64.props: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | 5 | 6 | 7 | 8 | $(GMOCK_ROOT)/include;$(GMOCK_ROOT)/gtest/include;%(AdditionalIncludeDirectories) 9 | 10 | 11 | $(GMOCK_ROOT)/build/x64/Release;%(AdditionalLibraryDirectories) 12 | gmock.lib;%(AdditionalDependencies) 13 | 14 | 15 | 16 | -------------------------------------------------------------------------------- /PropertySheets/Poco.props: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | 5 | 6 | 7 | 8 | $(POCO_ROOT)/lib;%(AdditionalLibraryDirectories) 9 | 10 | 11 | $(POCO_ROOT)/Foundation/include;%(AdditionalIncludeDirectories) 12 | 13 | 14 | 15 | -------------------------------------------------------------------------------- /PropertySheets/Poco.x64.props: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | 5 | 6 | 7 | 8 | $(POCO_ROOT)/lib64;%(AdditionalLibraryDirectories) 9 | 10 | 11 | $(POCO_ROOT)/Foundation/include;%(AdditionalIncludeDirectories) 12 | 13 | 14 | 15 | -------------------------------------------------------------------------------- /PropertySheets/ProtoBuff.Debug.props: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | 5 | 6 | <_PropertySheetDisplayName>ProtoBuff.Debug 7 | 8 | 9 | 10 | $(PROTOBUFF_FOLDER)/src;%(AdditionalIncludeDirectories) 11 | 12 | 13 | $(PROTOBUFF_FOLDER)\vsprojects\Debug;%(AdditionalLibraryDirectories) 14 | libprotobuf.lib;%(AdditionalDependencies) 15 | 16 | 17 | 18 | -------------------------------------------------------------------------------- /PropertySheets/ProtoBuff.Debug.x64.props: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | 5 | 6 | <_PropertySheetDisplayName>ProtoBuff.Debug.x64 7 | 8 | 9 | 10 | $(PROTOBUFF_FOLDER)/src;%(AdditionalIncludeDirectories) 11 | 12 | 13 | $(PROTOBUFF_FOLDER)\vsprojects\x64\Debug;%(AdditionalLibraryDirectories) 14 | libprotobuf.lib;%(AdditionalDependencies) 15 | 16 | 17 | 18 | -------------------------------------------------------------------------------- /PropertySheets/ProtoBuff.Release.props: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | 5 | 6 | <_PropertySheetDisplayName>ProtoBuff.Release 7 | 8 | 9 | 10 | $(PROTOBUFF_FOLDER)/src;%(AdditionalIncludeDirectories) 11 | 12 | 13 | $(PROTOBUFF_FOLDER)\vsprojects\Release;%(AdditionalLibraryDirectories) 14 | libprotobuf.lib;%(AdditionalDependencies) 15 | 16 | 17 | 18 | -------------------------------------------------------------------------------- /PropertySheets/ProtoBuff.Release.x64.props: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | 5 | 6 | <_PropertySheetDisplayName>ProtoBuff.Release.x64 7 | 8 | 9 | 10 | $(PROTOBUFF_FOLDER)/src;%(AdditionalIncludeDirectories) 11 | 12 | 13 | $(PROTOBUFF_FOLDER)\vsprojects\x64\Release;%(AdditionalLibraryDirectories) 14 | libprotobuf.lib;%(AdditionalDependencies) 15 | 16 | 17 | 18 | -------------------------------------------------------------------------------- /TestCoverageConsole/FileWithSpecialCharéàè.hpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2016 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | #include 20 | 21 | namespace TestCoverageConsole 22 | { 23 | //------------------------------------------------------------------------- 24 | inline boost::filesystem::path GetFileWithSpecialChars() 25 | { 26 | return boost::filesystem::path(__FILE__).filename(); 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /TestCoverageConsole/SpecialLineInfo.cpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #include "SpecialLineInfo.hpp" 18 | #include 19 | 20 | namespace TestCoverageConsole 21 | { 22 | //------------------------------------------------------------------------- 23 | void SpecialLineInfo() 24 | { 25 | // Generate a SRCCODEINFO::LineNumber == 0x00feefee 26 | try 27 | { 28 | throw 42; 29 | } 30 | catch (...) 31 | { 32 | } 33 | } 34 | } -------------------------------------------------------------------------------- /TestCoverageConsole/SpecialLineInfo.hpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | #include 20 | 21 | namespace TestCoverageConsole 22 | { 23 | void SpecialLineInfo(); 24 | 25 | //------------------------------------------------------------------------- 26 | inline boost::filesystem::path GetSpecialLineInfoFilename() 27 | { 28 | return boost::filesystem::path(__FILE__).replace_extension("cpp").filename(); 29 | } 30 | } -------------------------------------------------------------------------------- /TestCoverageConsole/TestBasic.hpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | #include 20 | #include 21 | 22 | namespace TestCoverageConsole 23 | { 24 | void RunTestBasic(); 25 | void RunChildProcesses(int argc, _TCHAR* argv[]); 26 | void UnloadReloadDll(); 27 | 28 | //------------------------------------------------------------------------- 29 | inline int GetTestBasicLine() 30 | { 31 | return 32; 32 | } 33 | 34 | //------------------------------------------------------------------------- 35 | inline boost::filesystem::path GetTestBasicFilename() 36 | { 37 | return boost::filesystem::path(__FILE__).replace_extension("cpp").filename(); 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /TestCoverageConsole/TestCoverageConsole.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Unity-Technologies/OpenCppCoverage/4ae21f3f0bce5a6b305f584b3ef9d9c2cd7c5545/TestCoverageConsole/TestCoverageConsole.cpp -------------------------------------------------------------------------------- /TestCoverageConsole/TestDiff.cpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2017 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #include "TestDiff.hpp" 18 | 19 | namespace TestCoverageConsole 20 | { 21 | //----------------------------------------------------------------------------- 22 | void FilterByDiff() 23 | { 24 | int value1 = 0; 25 | if (true) // In Diff 26 | int value2 = 0; // In Diff 27 | if (false) // In Diff 28 | int value3 = 0; // In Diff 29 | int value4 = 0; 30 | } 31 | } -------------------------------------------------------------------------------- /TestCoverageConsole/TestDiff.hpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2017 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | #include 20 | 21 | namespace TestCoverageConsole 22 | { 23 | void FilterByDiff(); 24 | 25 | //------------------------------------------------------------------------- 26 | inline boost::filesystem::path GetTestDiffFilename() 27 | { 28 | return boost::filesystem::path(__FILE__).replace_extension("cpp").filename(); 29 | } 30 | } -------------------------------------------------------------------------------- /TestCoverageConsole/TestThread.cpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | #include "TestThread.hpp" 20 | 21 | #include 22 | 23 | namespace TestCoverageConsole 24 | { 25 | //----------------------------------------------------------------------------- 26 | void RunThread() 27 | { 28 | std::thread t([]() 29 | { 30 | int answer = 42; 31 | }); 32 | t.join(); 33 | } 34 | } -------------------------------------------------------------------------------- /TestCoverageConsole/TestThread.hpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | #include 20 | 21 | namespace TestCoverageConsole 22 | { 23 | void RunThread(); 24 | 25 | //------------------------------------------------------------------------- 26 | inline boost::filesystem::path GetTestThreadFilename() 27 | { 28 | return boost::filesystem::path(__FILE__).replace_extension("cpp").filename(); 29 | } 30 | } -------------------------------------------------------------------------------- /TestCoverageOptimizedBuild/TestCoverageOptimizedBuild.hpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2017 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #include 18 | 19 | namespace TestCoverageOptimizedBuild 20 | { 21 | __declspec(dllexport) boost::filesystem::path GetMainCppPath(); 22 | __declspec(dllexport) boost::filesystem::path GetOutputBinaryPath(); 23 | __declspec(dllexport) void TestOptimizedBuild(); 24 | } 25 | -------------------------------------------------------------------------------- /TestCoverageSharedLib/TestCoverageSharedLib.cpp: -------------------------------------------------------------------------------- 1 | // DllForCppCoverageTest.cpp : Defines the entry point for the application. 2 | // 3 | 4 | // OpenCppCoverage is an open source code coverage for C++. 5 | // Copyright (C) 2014 OpenCppCoverage 6 | // 7 | // This program is free software: you can redistribute it and/or modify 8 | // it under the terms of the GNU General Public License as published by 9 | // the Free Software Foundation, either version 3 of the License, or 10 | // any later version. 11 | // 12 | // This program is distributed in the hope that it will be useful, 13 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 14 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 | // GNU General Public License for more details. 16 | // 17 | // You should have received a copy of the GNU General Public License 18 | // along with this program. If not, see . 19 | 20 | #include "stdafx.h" 21 | #include "TestCoverageSharedLib.hpp" 22 | 23 | #include 24 | 25 | namespace fs = boost::filesystem; 26 | 27 | namespace TestCoverageSharedLib 28 | { 29 | //------------------------------------------------------------------------- 30 | bool IsOdd(int n) 31 | { 32 | if (n % 2 == 0) 33 | return true; 34 | 35 | return false; 36 | } 37 | 38 | //------------------------------------------------------------------------- 39 | fs::path GetMainCppPath() 40 | { 41 | return __FILE__ ; 42 | } 43 | 44 | //------------------------------------------------------------------------- 45 | fs::path GetOutputBinaryPath() 46 | { 47 | return boost::filesystem::path(OUT_DIR) / TARGET_FILE_NAME; 48 | } 49 | 50 | //------------------------------------------------------------------------- 51 | void CallSharedFunctionFromSharedLib() 52 | { 53 | SharedFunction(true); 54 | } 55 | } -------------------------------------------------------------------------------- /TestCoverageSharedLib/TestCoverageSharedLib.hpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | #include 20 | 21 | namespace TestCoverageSharedLib 22 | { 23 | __declspec(dllexport) boost::filesystem::path GetMainCppPath(); 24 | __declspec(dllexport) boost::filesystem::path GetOutputBinaryPath(); 25 | __declspec(dllexport) bool IsOdd(int n); 26 | 27 | __declspec(dllexport) void CallSharedFunctionFromSharedLib(); 28 | 29 | //------------------------------------------------------------------------- 30 | inline boost::filesystem::path GetSharedFunctionFilename() 31 | { 32 | return boost::filesystem::path(__FILE__).filename(); 33 | } 34 | 35 | //------------------------------------------------------------------------- 36 | inline int GetSharedFunctionLine() 37 | { 38 | return __LINE__ + 4; 39 | } 40 | 41 | //------------------------------------------------------------------------- 42 | inline bool SharedFunction(bool calledFromSharedLib) 43 | { 44 | if (calledFromSharedLib) 45 | return true; 46 | return false; 47 | } 48 | } 49 | -------------------------------------------------------------------------------- /TestCoverageSharedLib/stdafx.cpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #include "stdafx.h" 18 | -------------------------------------------------------------------------------- /TestCoverageSharedLib/stdafx.h: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | #define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers 20 | // Windows Header Files: 21 | #include 22 | 23 | -------------------------------------------------------------------------------- /TestHelper/Container.hpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | namespace TestHelper 20 | { 21 | template 22 | void AssertContainerEqual( 23 | const Container& container1, 24 | const Container& container2, 25 | const CompareFct& compareFct); 26 | 27 | template 28 | void AssertContainerUniquePtrEqual( 29 | const Container& container1, 30 | const Container& container2, 31 | const CompareFct& compareFct); 32 | 33 | template 34 | bool IsFirstContainsSecond( 35 | const Container& container1, 36 | const Container& container2, 37 | const std::function& getKeyFct, 38 | const CompareFct& compareFct); 39 | } 40 | 41 | #include "Container.inl" -------------------------------------------------------------------------------- /TestHelper/CoverageDataComparer.hpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | #include "TestHelperExport.hpp" 20 | #include 21 | 22 | namespace CppCoverage 23 | { 24 | class CoverageData; 25 | class ModuleCoverage; 26 | } 27 | 28 | namespace TestHelper 29 | { 30 | class TEST_HELPER_DLL CoverageDataComparer 31 | { 32 | public: 33 | CoverageDataComparer() = default; 34 | 35 | void AssertEquals(const CppCoverage::CoverageData&, const CppCoverage::CoverageData&) const; 36 | void AssertEquals(const CppCoverage::ModuleCoverage*, const CppCoverage::ModuleCoverage*) const; 37 | 38 | using ModuleCoveragePtr = std::unique_ptr; 39 | using ModuleCoverageCollection = std::vector; 40 | 41 | bool IsFirstModuleContainsSecond( 42 | const ModuleCoveragePtr& module1, 43 | const ModuleCoveragePtr& module2) const; 44 | 45 | bool IsFirstCollectionContainsSecond( 46 | const ModuleCoverageCollection& container1, 47 | const ModuleCoverageCollection& container2) const; 48 | private: 49 | CoverageDataComparer(const CoverageDataComparer&) = delete; 50 | CoverageDataComparer& operator=(const CoverageDataComparer&) = delete; 51 | }; 52 | } -------------------------------------------------------------------------------- /TestHelper/ReadMe.txt: -------------------------------------------------------------------------------- 1 | ======================================================================== 2 | CONSOLE APPLICATION : TestHelper Project Overview 3 | ======================================================================== 4 | 5 | AppWizard has created this TestHelper application for you. 6 | 7 | This file contains a summary of what you will find in each of the files that 8 | make up your TestHelper application. 9 | 10 | 11 | TestHelper.vcxproj 12 | This is the main project file for VC++ projects generated using an Application Wizard. 13 | It contains information about the version of Visual C++ that generated the file, and 14 | information about the platforms, configurations, and project features selected with the 15 | Application Wizard. 16 | 17 | TestHelper.vcxproj.filters 18 | This is the filters file for VC++ projects generated using an Application Wizard. 19 | It contains information about the association between the files in your project 20 | and the filters. This association is used in the IDE to show grouping of files with 21 | similar extensions under a specific node (for e.g. ".cpp" files are associated with the 22 | "Source Files" filter). 23 | 24 | TestHelper.cpp 25 | This is the main application source file. 26 | 27 | ///////////////////////////////////////////////////////////////////////////// 28 | Other standard files: 29 | 30 | StdAfx.h, StdAfx.cpp 31 | These files are used to build a precompiled header (PCH) file 32 | named TestHelper.pch and a precompiled types file named StdAfx.obj. 33 | 34 | ///////////////////////////////////////////////////////////////////////////// 35 | Other notes: 36 | 37 | AppWizard uses "TODO:" comments to indicate parts of the source code you 38 | should add to or customize. 39 | 40 | ///////////////////////////////////////////////////////////////////////////// 41 | -------------------------------------------------------------------------------- /TestHelper/TemporaryPath.hpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | #include 20 | 21 | #include "TestHelperExport.hpp" 22 | 23 | namespace TestHelper 24 | { 25 | enum class TemporaryPathOption 26 | { 27 | DoNotCreate, 28 | CreateAsFile, 29 | CreateAsFolder 30 | }; 31 | 32 | class TEST_HELPER_DLL TemporaryPath 33 | { 34 | public: 35 | 36 | explicit TemporaryPath(TemporaryPathOption = TemporaryPathOption::DoNotCreate); 37 | ~TemporaryPath(); 38 | 39 | operator const boost::filesystem::path& () const; 40 | const boost::filesystem::path& GetPath() const; 41 | 42 | private: 43 | TemporaryPath(const TemporaryPath&) = delete; 44 | TemporaryPath& operator=(const TemporaryPath&) = delete; 45 | 46 | private: 47 | boost::filesystem::path path_; 48 | }; 49 | } -------------------------------------------------------------------------------- /TestHelper/TestHelperExport.hpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | #ifdef TEST_HELPER_EXPORTS 20 | #define TEST_HELPER_DLL __declspec(dllexport) 21 | #else 22 | #define TEST_HELPER_DLL _declspec(dllimport) 23 | #endif 24 | 25 | #pragma warning (disable: 4251) 26 | -------------------------------------------------------------------------------- /TestHelper/Tools.cpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2016 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | #include "stdafx.h" 20 | #include "Tools.hpp" 21 | #include 22 | #include 23 | 24 | //------------------------------------------------------------------------- 25 | void TestUnloadDll() 26 | { 27 | } 28 | 29 | namespace TestHelper 30 | { 31 | //------------------------------------------------------------------------- 32 | boost::filesystem::path GetTestUnloadDllFilename() 33 | { 34 | return boost::filesystem::path(__FILE__).filename(); 35 | } 36 | 37 | //------------------------------------------------------------------------- 38 | boost::filesystem::path GetOutputBinaryPath() 39 | { 40 | return TARGET_FILE_NAME; 41 | } 42 | 43 | //------------------------------------------------------------------------- 44 | void CreateEmptyFile(const boost::filesystem::path& path) 45 | { 46 | std::ofstream ofs; 47 | ofs.open(path.string(), std::ios::out); 48 | } 49 | } -------------------------------------------------------------------------------- /TestHelper/Tools.hpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2016 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | #include "TestHelperExport.hpp" 20 | 21 | namespace boost 22 | { 23 | namespace filesystem 24 | { 25 | class path; 26 | } 27 | } 28 | 29 | extern "C" 30 | { 31 | void TEST_HELPER_DLL TestUnloadDll(); 32 | } 33 | 34 | namespace TestHelper 35 | { 36 | boost::filesystem::path TEST_HELPER_DLL GetTestUnloadDllFilename(); 37 | boost::filesystem::path TEST_HELPER_DLL GetOutputBinaryPath(); 38 | 39 | void TEST_HELPER_DLL CreateEmptyFile(const boost::filesystem::path&); 40 | } 41 | -------------------------------------------------------------------------------- /TestHelper/stdafx.cpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #include "stdafx.h" 18 | 19 | // TODO: reference any additional headers you need in STDAFX.H 20 | // and not in this file 21 | -------------------------------------------------------------------------------- /TestHelper/stdafx.h: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | #include 20 | #include 21 | -------------------------------------------------------------------------------- /Tools/DbgHelp.hpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2016 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | #pragma warning(push) 20 | #pragma warning(disable: 4091) // 'typedef ': ignored on left of '' when no variable is declared 21 | #include 22 | #pragma warning(pop) 23 | -------------------------------------------------------------------------------- /Tools/MappedFile.hpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2017 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | #include 20 | #include 21 | #include 22 | #include 23 | 24 | #include "ToolsExport.hpp" 25 | 26 | namespace Tools 27 | { 28 | class TOOLS_DLL MappedFile 29 | { 30 | public: 31 | static std::unique_ptr TryCreate(const boost::filesystem::path&); 32 | 33 | const std::vector& GetLines() const; 34 | 35 | MappedFile(const MappedFile&) = delete; 36 | MappedFile& operator=(const MappedFile&) = delete; 37 | MappedFile(MappedFile&&) = default; 38 | 39 | private: 40 | explicit MappedFile(const boost::filesystem::path&); 41 | 42 | std::vector lines_; 43 | }; 44 | } -------------------------------------------------------------------------------- /Tools/Tool.hpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | #include 20 | #include 21 | 22 | #include 23 | #include 24 | 25 | #include "ToolsExport.hpp" 26 | 27 | namespace Tools 28 | { 29 | TOOLS_DLL std::wstring LocalToWString(const std::string&); 30 | TOOLS_DLL std::wstring Utf8ToWString(const std::string&); 31 | TOOLS_DLL std::string ToLocalString(const std::wstring&); 32 | TOOLS_DLL std::string ToUtf8String(const std::wstring&); 33 | 34 | TOOLS_DLL boost::optional Try(std::function); 35 | TOOLS_DLL boost::filesystem::path GetTemplateFolder(); 36 | 37 | TOOLS_DLL void CreateMiniDumpOnUnHandledException(); 38 | 39 | TOOLS_DLL void ShowOutputMessage(const std::wstring& message, const boost::filesystem::path& path); 40 | TOOLS_DLL std::wstring GetSeparatorLine(); 41 | 42 | TOOLS_DLL void CreateParentFolderIfNeeded(const boost::filesystem::path& path); 43 | } 44 | 45 | 46 | -------------------------------------------------------------------------------- /Tools/ToolsExport.hpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | //#ifdef TOOLS_EXPORTS 20 | //#define TOOLS_DLL __declspec(dllexport) 21 | //#else 22 | //#define TOOLS_DLL _declspec(dllimport) 23 | //#endif 24 | #define TOOLS_DLL 25 | 26 | #pragma warning (disable: 4251) 27 | -------------------------------------------------------------------------------- /Tools/dllmain.cpp: -------------------------------------------------------------------------------- 1 | // dllmain.cpp : Defines the entry point for the DLL application. 2 | // OpenCppCoverage is an open source code coverage for C++. 3 | // Copyright (C) 2014 OpenCppCoverage 4 | // 5 | // This program is free software: you can redistribute it and/or modify 6 | // it under the terms of the GNU General Public License as published by 7 | // the Free Software Foundation, either version 3 of the License, or 8 | // any later version. 9 | // 10 | // This program is distributed in the hope that it will be useful, 11 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 12 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 | // GNU General Public License for more details. 14 | // 15 | // You should have received a copy of the GNU General Public License 16 | // along with this program. If not, see . 17 | 18 | #include "stdafx.h" 19 | 20 | BOOL APIENTRY DllMain( HMODULE hModule, 21 | DWORD ul_reason_for_call, 22 | LPVOID lpReserved 23 | ) 24 | { 25 | switch (ul_reason_for_call) 26 | { 27 | case DLL_PROCESS_ATTACH: 28 | case DLL_THREAD_ATTACH: 29 | case DLL_THREAD_DETACH: 30 | case DLL_PROCESS_DETACH: 31 | break; 32 | } 33 | return TRUE; 34 | } 35 | 36 | -------------------------------------------------------------------------------- /Tools/stdafx.cpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #include "stdafx.h" 18 | -------------------------------------------------------------------------------- /Tools/stdafx.h: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | #define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers 20 | // Windows Header Files: 21 | #include 22 | -------------------------------------------------------------------------------- /ToolsCross/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 2.8.12) 2 | set(CMAKE_CXX_STANDARD 14) 3 | 4 | include_directories(${CMAKE_SOURCE_DIR}) 5 | 6 | add_library(ToolsCross 7 | ExceptionBase.cpp 8 | ExceptionBase.hpp 9 | Log.hpp 10 | Log.cpp 11 | ScopedAction.hpp 12 | ScopedAction.cpp 13 | ToolsException.hpp 14 | ToolsExport.hpp 15 | UniquePath.hpp 16 | UniquePath.cpp) 17 | 18 | link_directories(${CMAKE_SOURCE_DIR}) -------------------------------------------------------------------------------- /ToolsCross/ExceptionBase.cpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #include "ExceptionBase.hpp" 18 | #ifdef _WIN32 19 | #include 20 | #elif __linux__ 21 | #include 22 | #endif 23 | 24 | namespace Tools 25 | { 26 | //------------------------------------------------------------------------- 27 | ExceptionBase::ExceptionBase(const std::wstring& message) 28 | : std::runtime_error(ToLocalString(message).c_str()) 29 | { 30 | } 31 | } -------------------------------------------------------------------------------- /ToolsCross/ScopedAction.cpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #include "ScopedAction.hpp" 18 | 19 | #include 20 | 21 | #ifdef _WIN32 22 | #include 23 | #elif __linux__ 24 | #include 25 | #endif 26 | #include "Log.hpp" 27 | 28 | namespace Tools 29 | { 30 | //------------------------------------------------------------------------- 31 | ScopedAction::ScopedAction(std::function action) 32 | : action_(action) 33 | { 34 | } 35 | 36 | //------------------------------------------------------------------------- 37 | ScopedAction::~ScopedAction() 38 | { 39 | auto error = Try([&] 40 | { 41 | action_(); 42 | }); 43 | 44 | if (error) 45 | LOG_ERROR << *error; 46 | } 47 | 48 | } 49 | -------------------------------------------------------------------------------- /ToolsCross/ScopedAction.hpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | #include 20 | 21 | #include "ToolsExport.hpp" 22 | 23 | namespace Tools 24 | { 25 | class TOOLS_DLL ScopedAction 26 | { 27 | public: 28 | explicit ScopedAction(std::function); 29 | ~ScopedAction(); 30 | 31 | private: 32 | ScopedAction(const ScopedAction&) = delete; 33 | ScopedAction& operator=(const ScopedAction&) = delete; 34 | 35 | private: 36 | std::function action_; 37 | }; 38 | } 39 | -------------------------------------------------------------------------------- /ToolsCross/ToolsException.hpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | #include "ExceptionBase.hpp" 20 | 21 | GENERATE_EXCEPTION_CLASS(Tools, ToolsException); 22 | 23 | #define THROW(message) THROW_BASE(Tools, ToolsException, message) 24 | 25 | -------------------------------------------------------------------------------- /ToolsCross/ToolsExport.hpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | //#ifdef TOOLS_EXPORTS 20 | //#define TOOLS_DLL __declspec(dllexport) 21 | //#else 22 | //#define TOOLS_DLL _declspec(dllimport) 23 | #define TOOLS_DLL 24 | //#endif 25 | 26 | #pragma warning (disable: 4251) 27 | -------------------------------------------------------------------------------- /ToolsCross/UniquePath.cpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2016 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #include "UniquePath.hpp" 18 | 19 | #include 20 | 21 | namespace Tools 22 | { 23 | //------------------------------------------------------------------------- 24 | boost::filesystem::path UniquePath::GetUniquePath(const boost::filesystem::path& path) 25 | { 26 | auto uniquePath = path; 27 | auto filenameWithoutExtension = path.filename().replace_extension(L""); 28 | 29 | for (int i = 2; existingPathSet_.count(uniquePath) != 0; ++i) 30 | { 31 | auto filename = filenameWithoutExtension.wstring() + std::to_wstring(i) + path.extension().wstring(); 32 | uniquePath = path.parent_path() / filename; 33 | } 34 | existingPathSet_.insert(uniquePath); 35 | return uniquePath; 36 | } 37 | } 38 | -------------------------------------------------------------------------------- /ToolsCross/UniquePath.hpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2016 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | #include "ToolsExport.hpp" 20 | 21 | #include 22 | 23 | namespace boost 24 | { 25 | namespace filesystem 26 | { 27 | class path; 28 | } 29 | } 30 | 31 | namespace Tools 32 | { 33 | class TOOLS_DLL UniquePath 34 | { 35 | public: 36 | UniquePath() = default; 37 | 38 | UniquePath(const UniquePath&) = delete; 39 | UniquePath& operator=(const UniquePath&) = delete; 40 | UniquePath(UniquePath&&) = delete; 41 | UniquePath& operator=(UniquePath&&) = delete; 42 | 43 | // GetUniquePath returns "path" if there was no previous 44 | // call to GetUniquePath with this value else it returns an unique 45 | // path starting with "path". 46 | boost::filesystem::path GetUniquePath(const boost::filesystem::path& path); 47 | 48 | private: 49 | std::set existingPathSet_; 50 | }; 51 | } 52 | -------------------------------------------------------------------------------- /ToolsLinux/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 2.8.12) 2 | set(CMAKE_CXX_STANDARD 14) 3 | 4 | add_library(ToolsLinux 5 | Tool.hpp 6 | Tool.cpp 7 | ToolsExport.hpp) 8 | 9 | 10 | include_directories(${PROJECT_SOURCE_DIR}) -------------------------------------------------------------------------------- /ToolsLinux/Tool.hpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | #include 20 | #include 21 | 22 | #include 23 | #include 24 | 25 | #include "ToolsExport.hpp" 26 | #include 27 | 28 | namespace Tools 29 | { 30 | TOOLS_DLL std::wstring LocalToWString(const std::string&); 31 | TOOLS_DLL std::wstring Utf8ToWString(const std::string&); 32 | TOOLS_DLL std::string ToLocalString(const std::wstring&); 33 | TOOLS_DLL std::string ToUtf8String(const std::wstring&); 34 | 35 | TOOLS_DLL boost::optional Try(std::function); 36 | TOOLS_DLL boost::filesystem::path GetTemplateFolder(); 37 | 38 | TOOLS_DLL void CreateMiniDumpOnUnHandledException(); 39 | 40 | TOOLS_DLL void ShowOutputMessage(const std::wstring& message, const boost::filesystem::path& path); 41 | TOOLS_DLL std::wstring GetSeparatorLine(); 42 | 43 | TOOLS_DLL void CreateParentFolderIfNeeded(const boost::filesystem::path& path); 44 | } 45 | -------------------------------------------------------------------------------- /ToolsLinux/ToolsExport.hpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2014 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | #define TOOLS_DLL 20 | 21 | #pragma warning (disable: 4251) 22 | -------------------------------------------------------------------------------- /ToolsTest/ReadMe.txt: -------------------------------------------------------------------------------- 1 | ======================================================================== 2 | CONSOLE APPLICATION : ToolsTest Project Overview 3 | ======================================================================== 4 | 5 | AppWizard has created this ToolsTest application for you. 6 | 7 | This file contains a summary of what you will find in each of the files that 8 | make up your ToolsTest application. 9 | 10 | 11 | ToolsTest.vcxproj 12 | This is the main project file for VC++ projects generated using an Application Wizard. 13 | It contains information about the version of Visual C++ that generated the file, and 14 | information about the platforms, configurations, and project features selected with the 15 | Application Wizard. 16 | 17 | ToolsTest.vcxproj.filters 18 | This is the filters file for VC++ projects generated using an Application Wizard. 19 | It contains information about the association between the files in your project 20 | and the filters. This association is used in the IDE to show grouping of files with 21 | similar extensions under a specific node (for e.g. ".cpp" files are associated with the 22 | "Source Files" filter). 23 | 24 | ToolsTest.cpp 25 | This is the main application source file. 26 | 27 | ///////////////////////////////////////////////////////////////////////////// 28 | Other standard files: 29 | 30 | StdAfx.h, StdAfx.cpp 31 | These files are used to build a precompiled header (PCH) file 32 | named ToolsTest.pch and a precompiled types file named StdAfx.obj. 33 | 34 | ///////////////////////////////////////////////////////////////////////////// 35 | Other notes: 36 | 37 | AppWizard uses "TODO:" comments to indicate parts of the source code you 38 | should add to or customize. 39 | 40 | ///////////////////////////////////////////////////////////////////////////// 41 | -------------------------------------------------------------------------------- /ToolsTest/ToolTest.cpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2016 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #include "stdafx.h" 18 | #include "ToolsCross/Tool.hpp" 19 | 20 | namespace ToolsTests 21 | { 22 | //--------------------------------------------------------------------- 23 | TEST(Tool, ToLocalString) 24 | { 25 | ASSERT_EQ("", Tools::ToLocalString(L"")); 26 | ASSERT_EQ("123456789", Tools::ToLocalString(L"123456789")); 27 | ASSERT_EQ(1, Tools::ToLocalString(L"1").size()); 28 | ASSERT_EQ(std::string("���"), Tools::ToLocalString(L"���")); 29 | } 30 | 31 | //--------------------------------------------------------------------- 32 | TEST(Tool, LocalToWString) 33 | { 34 | ASSERT_EQ(L"", Tools::LocalToWString("")); 35 | ASSERT_EQ(L"123456789", Tools::LocalToWString("123456789")); 36 | ASSERT_EQ(1, Tools::LocalToWString("1").size()); 37 | ASSERT_EQ(std::wstring(L"���"), Tools::LocalToWString("���")); 38 | } 39 | 40 | //--------------------------------------------------------------------- 41 | TEST(Tool, Uft8) 42 | { 43 | ASSERT_EQ(L"���", Tools::Utf8ToWString(Tools::ToUtf8String(L"���"))); 44 | } 45 | } -------------------------------------------------------------------------------- /ToolsTest/ToolsTest.cpp: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2016 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #include "stdafx.h" 18 | #include 19 | 20 | //----------------------------------------------------------------------------- 21 | int _tmain(int argc, _TCHAR* argv[]) 22 | { 23 | ::testing::InitGoogleMock(&argc, argv); 24 | return RUN_ALL_TESTS(); 25 | } -------------------------------------------------------------------------------- /ToolsTest/stdafx.cpp: -------------------------------------------------------------------------------- 1 | // stdafx.cpp : source file that includes just the standard includes 2 | // ToolsTest.pch will be the pre-compiled header 3 | // stdafx.obj will contain the pre-compiled type information 4 | 5 | #include "stdafx.h" 6 | 7 | // TODO: reference any additional headers you need in STDAFX.H 8 | // and not in this file 9 | -------------------------------------------------------------------------------- /ToolsTest/stdafx.h: -------------------------------------------------------------------------------- 1 | // OpenCppCoverage is an open source code coverage for C++. 2 | // Copyright (C) 2016 OpenCppCoverage 3 | // 4 | // This program is free software: you can redistribute it and/or modify 5 | // it under the terms of the GNU General Public License as published by 6 | // the Free Software Foundation, either version 3 of the License, or 7 | // any later version. 8 | // 9 | // This program is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | // GNU General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU General Public License 15 | // along with this program. If not, see . 16 | 17 | #pragma once 18 | 19 | #include 20 | #include 21 | -------------------------------------------------------------------------------- /UnitTests.testsettings: -------------------------------------------------------------------------------- 1 | 2 | 7 | 8 | This test run configuration is used for running the unit tests 9 | 10 | --------------------------------------------------------------------------------