├── .gitignore ├── 3rdparty ├── fake_boost │ ├── config │ │ ├── general.h │ │ └── platdef.h │ ├── fake_boost.h │ └── type │ │ ├── typeof.h │ │ └── typetools.h └── msinttypes │ ├── inttypes.h │ └── stdint.h ├── CMakeLists.txt ├── COPYING ├── ExportLite.ps1 ├── HEADER ├── Makefile ├── ProjectVar.txt ├── README.md ├── TODO.md ├── build.ps1 ├── build.sh ├── build_install.ps1 ├── build_install.sh ├── clean.bat ├── docs ├── AdvancedGuideOfMockcpp.md ├── BuildGuide ├── BuildSystemDescription.md ├── ChineseVersionManual.md ├── CxxTestingTips.md ├── EnglishManual.md ├── FeatureTracking.md ├── INSTALL ├── Installation.md ├── OnGoingFeatures.md ├── ProjectHome.md ├── SimpleUserInstruction_zh.md ├── SoftwareArchitecture.md ├── UpdateHistory.md └── images │ └── 2021-03-14-09-55-56.png ├── include └── mockcpp │ ├── AfterMatchBuilder.h │ ├── AfterMatchBuilder.tcc │ ├── AfterMatcher.h │ ├── ApiHook.h │ ├── ApiHookFunctor.h │ ├── ApiHookGenerator.h │ ├── ApiHookHolder.h │ ├── ApiHookHolderFactory.h │ ├── ApiHookKey.h │ ├── ApiHookMocker.h │ ├── ArgumentsList.h │ ├── ArgumentsMacroHelpers.h │ ├── ArgumentsMatchBuilder.h │ ├── ArgumentsMatchBuilder.tcc │ ├── Asserter.h │ ├── AssertionFailedError.h │ ├── BeforeMatchBuilder.h │ ├── BeforeMatchBuilder.tcc │ ├── BeforeMatcher.h │ ├── CallerMatchBuilder.h │ ├── CallerMatchBuilder.tcc │ ├── CallerMatcher.h │ ├── ChainableMockMethod.h │ ├── ChainableMockMethodContainer.h │ ├── ChainableMockMethodCore.h │ ├── ChainableMockMethodIndexKey.h │ ├── ChainableMockMethodKey.h │ ├── ChainableMockMethodNameKey.h │ ├── ChainableMockObject.h │ ├── ChainableMockObjectBase.h │ ├── ChainingMockHelper.h │ ├── CheckWith.h │ ├── CodeModifier.h │ ├── Constraint.h │ ├── ConstraintSet.h │ ├── DecoratedConstraint.h │ ├── DefaultBuilder.h │ ├── DefaultMatcher.h │ ├── DefaultStub.h │ ├── DelegatedMethod.h │ ├── DelegatedMethodGetter.h │ ├── DestructorChecker.h │ ├── DieStub.h │ ├── DummyBuilder.h │ ├── EqualityUtil.h │ ├── Exception.h │ ├── ExpectsMatcher.h │ ├── Formatter.h │ ├── Functor.h │ ├── GenericMethodIndicesChecker.h │ ├── GlobalMockObject.h │ ├── GnuMethodIndicesChecker.h │ ├── GnuMethodInfoReader.h │ ├── HookMockObject.h │ ├── IdentityBuilder.h │ ├── Ignore.h │ ├── IgnoreHandler.h │ ├── IgnoreResultHandler.h │ ├── IgnoreResultHandlerFactory.h │ ├── IgnoreReturnStub.h │ ├── IncrementStub.h │ ├── IndexInvokableGetter.h │ ├── InterfaceInfo.h │ ├── Invocation.h │ ├── InvocationId.h │ ├── InvocationMockBuilder.h │ ├── InvocationMockBuilder.tcc │ ├── InvocationMockBuilderGetter.h │ ├── InvocationMocker.h │ ├── InvocationMockerContainer.h │ ├── InvocationMockerNamespace.h │ ├── InvocationMockerSet.h │ ├── InvocationTimesMatcher.h │ ├── InvocationWithReturnType.h │ ├── Invokable.h │ ├── InvokedAtLeast.h │ ├── InvokedAtMost.h │ ├── InvokedExactly.h │ ├── InvokedOnce.h │ ├── InvokedTimesMatcher.h │ ├── InvokedTimesReader.h │ ├── InvokedTimesRecorder.h │ ├── IsAnything.h │ ├── IsAnythingHelper.h │ ├── IsConst.h │ ├── IsEqual.h │ ├── IsGreaterThan.h │ ├── IsLessThan.h │ ├── IsMirror.h │ ├── IsNotEqual.h │ ├── IsRef.h │ ├── IsStringContains.h │ ├── IsStringEndWith.h │ ├── IsStringStartWith.h │ ├── JmpCode.h │ ├── Matcher.h │ ├── Method.h │ ├── MethodIndiceChecker.h │ ├── MethodInfoReader.h │ ├── MethodTypeTraits.h │ ├── MismatchResultHandler.h │ ├── MismatchResultHandlerFactory.h │ ├── MockBuilder.h │ ├── MockObject.h │ ├── MockObjectBase.h │ ├── MockObjectHelper.h │ ├── MoreStubBuilder.h │ ├── MoreStubBuilder.tcc │ ├── MsvcMethodInfoReader.h │ ├── MsvcRtti.h │ ├── NormalResultHandler.h │ ├── NormalResultHandlerFactory.h │ ├── ObjNameGetter.h │ ├── OrderingMatcher.h │ ├── OutBound.h │ ├── OutBoundPointer.h │ ├── OutputStringStream.h │ ├── ParameterizedApiHookHolder.h │ ├── PendingMatcher.h │ ├── ProcStub.h │ ├── ProcessWith.h │ ├── RepeatMacros.h │ ├── RepeatStub.h │ ├── ReportFailure.h │ ├── Result.h │ ├── ResultHandler.h │ ├── ResultHandlerFactory.h │ ├── ReturnObjectList.h │ ├── ReturnStub.h │ ├── SelfDescribe.h │ ├── SimpleInvocationRecorder.h │ ├── Spy.h │ ├── StatelessMatcher.h │ ├── StringConstraint.h │ ├── StringPredict.h │ ├── Stub.h │ ├── StubBuilder.h │ ├── StubBuilder.tcc │ ├── StubContainer.h │ ├── StubsBuilder.h │ ├── StubsMatcher.h │ ├── TestFailureMatcher.h │ ├── ThenStub.h │ ├── ThrowExceptionStub.h │ ├── TypeString.h │ ├── TypeTraits.h │ ├── TypelessConstraint.h │ ├── TypelessConstraintAdapter.h │ ├── TypelessStub.h │ ├── TypelessStubAdapter.h │ ├── VirtualTable.h │ ├── VirtualTableUtils.h │ ├── Void.h │ ├── VoidResultHandler.h │ ├── VoidResultHandlerFactory.h │ ├── WillStub.h │ ├── mockable.h │ ├── mockcpp.h │ ├── mockcpp.hpp │ ├── mokc.h │ ├── types │ ├── Any.h │ ├── AnyBase.h │ ├── AnyCast.h │ ├── Holder.h │ ├── PlaceHolder.h │ ├── RefAny.h │ ├── RefHolder.h │ └── ValueHolder.h │ └── utils.h ├── src ├── AfterMatcher.cpp ├── Any.cpp ├── AnyBase.cpp ├── AnyCast.cpp ├── ApiHook.cpp ├── ApiHookKey.cpp ├── Asserter.cpp ├── AssertionFailedError.cpp ├── BeforeMatcher.cpp ├── CMakeLists.txt ├── CallerMatcher.cpp ├── ChainableMockMethodContainer.cpp ├── ChainableMockMethodCore.cpp ├── ChainableMockMethodIndexKey.cpp ├── ChainableMockMethodNameKey.cpp ├── ChainableMockObject.cpp ├── ChainableMockObjectBase.cpp ├── ChainingMockHelper.cpp ├── ConstraintSet.cpp ├── DecoratedConstraint.cpp ├── DefaultMatcher.cpp ├── DefaultStub.cpp ├── DelegatedMethodGetter.cpp ├── DieStub.cpp ├── DummyApiHook.cpp ├── Exception.cpp ├── ExpectsMatcher.cpp ├── Formatter.cpp ├── GlobalMockObject.cpp ├── HookMockObject.cpp ├── IdentityBuilder.cpp ├── Ignore.cpp ├── IgnoreResultHandler.cpp ├── IgnoreResultHandlerFactory.cpp ├── IgnoreReturnStub.cpp ├── InterfaceInfo.cpp ├── Invocation.cpp ├── InvocationId.cpp ├── InvocationMockBuilderGetter.cpp ├── InvocationMocker.cpp ├── InvocationMockerSet.cpp ├── InvocationTimesMatcher.cpp ├── InvokedAtLeast.cpp ├── InvokedAtMost.cpp ├── InvokedExactly.cpp ├── InvokedOnce.cpp ├── InvokedTimesMatcher.cpp ├── IsAnythingHelper.cpp ├── IsStringContains.cpp ├── IsStringEndWith.cpp ├── IsStringStartWith.cpp ├── JmpCode.cpp ├── JmpCodeArch.h ├── JmpCodeX64.h ├── JmpCodeX86.h ├── JmpOnlyApiHook.cpp ├── JmpOnlyApiHook.h ├── MethodIndiceChecker.cpp ├── MismatchResultHandler.cpp ├── MismatchResultHandlerFactory.cpp ├── MockObjectBase.cpp ├── NormalResultHandler.cpp ├── NormalResultHandlerFactory.cpp ├── OutBoundPointer.cpp ├── PendingMatcher.cpp ├── ProcStub.cpp ├── RefAny.cpp ├── RepeatStub.cpp ├── Result.cpp ├── ReturnObjectList.cpp ├── ReturnStub.cpp ├── SimpleInvocationRecorder.cpp ├── StringConstraint.cpp ├── StubContainer.cpp ├── StubsMatcher.cpp ├── TestFailureMatcher.cpp ├── ThenStub.cpp ├── TypeString.cpp ├── TypelessConstraintAdapter.cpp ├── TypelessStubAdapter.cpp ├── UnixCodeModifier.cpp ├── VirtualTable.cpp ├── VirtualTableUtils.cpp ├── VoidResultHandler.cpp ├── VoidResultHandlerFactory.cpp ├── WillStub.cpp ├── WinCodeModifier.cpp ├── generate_arg_related_files.py ├── generate_vtbl_related_files.py ├── get_long_opt.py └── ports │ └── failure │ ├── catch2_report_failure.cpp │ ├── cppunit_report_failure.cpp │ ├── cpputest_report_failure.cpp │ ├── gtest_report_failure.cpp │ └── stdexcept_report_failure.cpp ├── tests ├── 3rdparty │ └── testngpp │ │ ├── CMakeLists.txt │ │ ├── COPYING │ │ ├── ExportLite.ps1 │ │ ├── LICENSE │ │ ├── Makefile │ │ ├── ProjectVar.txt │ │ ├── build.ps1 │ │ ├── build.sh │ │ ├── build_install.ps1 │ │ ├── build_install.sh │ │ ├── change-name.sh │ │ ├── docs │ │ ├── BuildGuide │ │ ├── ChineseUserManual.md │ │ ├── InstallationMSVC.md │ │ ├── ProjectHome.md │ │ ├── SimpleUserInstruction_zh.md │ │ ├── UpdateHistory.md │ │ ├── testngpp-msvc.pdf │ │ └── testngpp中文指导.docx │ │ ├── include │ │ ├── cxxtest │ │ │ └── TestSuite.h │ │ ├── ltdl.h │ │ ├── mem_checker │ │ │ ├── bool_array.h │ │ │ ├── check_status.h │ │ │ ├── class_level_lock.h │ │ │ ├── cont_ptr_utils.h │ │ │ ├── debug_new.h │ │ │ ├── fast_mutex.h │ │ │ ├── fixed_mem_pool.h │ │ │ ├── format.h │ │ │ ├── interface_4cuser.h │ │ │ ├── interface_4cxxuser.h │ │ │ ├── interface_4user.h │ │ │ ├── interface_4xunit.h │ │ │ ├── mem_pool_base.h │ │ │ ├── object_level_lock.h │ │ │ ├── pctimer.h │ │ │ ├── reporter.h │ │ │ ├── set_assign.h │ │ │ ├── static_assert.h │ │ │ └── static_mem_pool.h │ │ ├── msinttypes │ │ │ ├── inttypes.h │ │ │ └── stdint.h │ │ ├── testcpp │ │ │ └── testcpp.hpp │ │ └── testngpp │ │ │ ├── Any.h │ │ │ ├── Asserter.h │ │ │ ├── Backward.h │ │ │ ├── DataDrivenDef.h │ │ │ ├── NoThrowsReporter.h │ │ │ ├── TestDefMacros.h │ │ │ ├── TestFixture.h │ │ │ ├── TestModule.h │ │ │ ├── TypeTraits.h │ │ │ ├── comm │ │ │ ├── ExceptionKeywords.h │ │ │ ├── PipeReadableChannel.h │ │ │ ├── PipeWrittableChannel.h │ │ │ ├── ReadableChannel.h │ │ │ ├── Win32PipeReadableChannel.h │ │ │ ├── Win32PipeWrittableChannel.h │ │ │ └── WrittableChannel.h │ │ │ ├── internal │ │ │ ├── AssertionFailure.h │ │ │ ├── DataDriven.h │ │ │ ├── Error.h │ │ │ ├── Exception.h │ │ │ ├── Info.h │ │ │ ├── MemChecker.h │ │ │ ├── Taggable.h │ │ │ ├── TagsFilterRule.h │ │ │ ├── TestCase.h │ │ │ ├── TestCaseInfoReader.h │ │ │ ├── TestFixtureDesc.h │ │ │ ├── TestFixtureInfoReader.h │ │ │ ├── TestSuiteDesc.h │ │ │ ├── TestSuiteInfoReader.h │ │ │ └── Warning.h │ │ │ ├── listener │ │ │ ├── MemLeakCountCollector.h │ │ │ ├── TagsFilterResultCollector.h │ │ │ ├── TestCaseListener.h │ │ │ ├── TestCaseResultCollector.h │ │ │ ├── TestCaseResultReporter.h │ │ │ ├── TestFixtureResultCollector.h │ │ │ ├── TestListener.h │ │ │ ├── TestResultCollector.h │ │ │ ├── TestResultReporter.h │ │ │ ├── TestSuiteListener.h │ │ │ ├── TestSuiteResultCollector.h │ │ │ └── TestSuiteResultReporter.h │ │ │ ├── runner │ │ │ ├── AndCompositeTaggableFilter.h │ │ │ ├── EOFError.h │ │ │ ├── EmptyTagsFilter.h │ │ │ ├── EnvironmentCleaner.h │ │ │ ├── FixtureTagsFilter.h │ │ │ ├── GeneralTagsFilter.h │ │ │ ├── GeneralTestFilter.h │ │ │ ├── MatchAllTagsFilter.h │ │ │ ├── NameMatcher.h │ │ │ ├── NotCompositeTaggableFilter.h │ │ │ ├── OrCompositeTaggableFilter.h │ │ │ ├── OrCompositeTestFilter.h │ │ │ ├── PosixFNMatcher.h │ │ │ ├── ResourceCheckPoint.h │ │ │ ├── Sandbox.h │ │ │ ├── SandboxHandler.h │ │ │ ├── SandboxProcessor.h │ │ │ ├── SandboxTypedef.h │ │ │ ├── SandboxTypedefUnix.h │ │ │ ├── SimpleTestCaseResultReporter.h │ │ │ ├── SimpleTestCaseRunner.h │ │ │ ├── SimpleTestHierarchyRunner.h │ │ │ ├── SimpleTestResultDispatcher.h │ │ │ ├── SimpleTestResultManager.h │ │ │ ├── SimpleTestResultReporter.h │ │ │ ├── SimpleTestSuiteResultReporter.h │ │ │ ├── SmartTestCaseResultCollector.h │ │ │ ├── TaggableObjFilter.h │ │ │ ├── TagsFilters.h │ │ │ ├── TagsParser.h │ │ │ ├── TestCaseContainer.h │ │ │ ├── TestCaseFilter.h │ │ │ ├── TestCaseHierarchy.h │ │ │ ├── TestCaseResultDispatcher.h │ │ │ ├── TestCaseRunner.h │ │ │ ├── TestCaseRunnerFactory.h │ │ │ ├── TestCaseSandbox.h │ │ │ ├── TestCaseSandboxHandler.h │ │ │ ├── TestCaseSandboxResultDecoder.h │ │ │ ├── TestCaseSandboxResultReporter.h │ │ │ ├── TestFilter.h │ │ │ ├── TestFilterFactory.h │ │ │ ├── TestFixtureContext.h │ │ │ ├── TestFixtureRunner.h │ │ │ ├── TestFixtureRunnerFactory.h │ │ │ ├── TestHierarchyHandler.h │ │ │ ├── TestHierarchyRunner.h │ │ │ ├── TestHierarchySandboxRunner.h │ │ │ ├── TestResultDispatcher.h │ │ │ ├── TestResultManager.h │ │ │ ├── TestRunner.h │ │ │ ├── TestRunnerContext.h │ │ │ ├── TestSuiteContext.h │ │ │ ├── TestSuiteDescEntryNameGetter.h │ │ │ ├── TestSuiteResultDispatcher.h │ │ │ ├── TestSuiteRunner.h │ │ │ ├── WildcardTestFilter.h │ │ │ └── loaders │ │ │ │ ├── DLModuleLoader.h │ │ │ │ ├── LTModuleLoader.h │ │ │ │ ├── ModuleLoader.h │ │ │ │ ├── ModuleLoaderFactory.h │ │ │ │ ├── ModuleTestListenerLoader.h │ │ │ │ ├── ModuleTestListenerLoaderFactory.h │ │ │ │ ├── ModuleTestSuiteLoader.h │ │ │ │ ├── ModuleTestSuiteLoaderFactory.h │ │ │ │ ├── TestListenerLoader.h │ │ │ │ ├── TestListenerLoaderFactory.h │ │ │ │ ├── TestSuiteLoader.h │ │ │ │ ├── TestSuiteLoaderFactory.h │ │ │ │ └── Win32DllModuleLoader.h │ │ │ ├── testngpp.h │ │ │ ├── testngpp.hpp │ │ │ ├── utils │ │ │ ├── ConsoleState.h │ │ │ ├── Formatter.h │ │ │ ├── InternalError.h │ │ │ ├── OptionList.h │ │ │ ├── StringList.h │ │ │ ├── StringToOptions.h │ │ │ ├── StupidTimer.h │ │ │ └── TypeString.h │ │ │ └── win32 │ │ │ ├── Win32Sandbox.h │ │ │ ├── Win32TestCaseRunnerResultReporter.h │ │ │ ├── Win32TestCaseSandbox.h │ │ │ ├── Win32TestHierarchySandboxRunner.h │ │ │ └── Win32ThrowLastError.h │ │ ├── premake4.exe │ │ ├── samples │ │ ├── CMakeLists.txt │ │ ├── TestBar.h │ │ ├── TestCxxTest.h │ │ ├── TestFoo.h │ │ ├── TestMemLeak.h │ │ ├── run-sample.bat.in │ │ └── run-sample.in │ │ ├── scripts │ │ ├── CMakeLists.txt │ │ ├── premake4.lua │ │ ├── pycompile.py │ │ ├── setup.py │ │ ├── setup_linux.py │ │ ├── testngppgen.py │ │ └── testngppgen │ │ │ ├── AnnotationParser.py │ │ │ ├── ClassDeclParser.py │ │ │ ├── DataProvider.py │ │ │ ├── DataProviderParser.py │ │ │ ├── ElemParser.py │ │ │ ├── Fixture.py │ │ │ ├── FixtureParser.py │ │ │ ├── Generator.py │ │ │ ├── LogicalLine.py │ │ │ ├── Message.py │ │ │ ├── Name.py │ │ │ ├── Output.py │ │ │ ├── Phase0.py │ │ │ ├── Phase1.py │ │ │ ├── Phase1Result.py │ │ │ ├── Phase2.py │ │ │ ├── Phase3.py │ │ │ ├── Phase4.py │ │ │ ├── PreprocessScope.py │ │ │ ├── PreprocessScopeParser.py │ │ │ ├── Process.py │ │ │ ├── TagsParser.py │ │ │ ├── TestCase.py │ │ │ ├── TestCaseParser.py │ │ │ ├── TestScope.py │ │ │ ├── Useless.py │ │ │ ├── Utils.py │ │ │ └── __init__.py │ │ ├── src │ │ ├── CMakeLists.txt │ │ ├── Formatter.cpp │ │ ├── MemChecker.cpp │ │ ├── TestCase.cpp │ │ ├── TestFixture.cpp │ │ ├── TestSuiteDesc.cpp │ │ ├── TypeString.cpp │ │ ├── except │ │ │ ├── AssertionFailure.cpp │ │ │ ├── CMakeLists.txt │ │ │ └── Exception.cpp │ │ ├── listeners │ │ │ ├── CMakeLists.txt │ │ │ ├── StdoutTestListener.cpp │ │ │ ├── XMLBuilder.cpp │ │ │ ├── XMLBuilder.h │ │ │ ├── XMLTestListener.cpp │ │ │ └── XMLTestListener.h │ │ ├── mem_checker │ │ │ ├── CMakeLists.txt │ │ │ ├── NoThrowsReporter.cpp │ │ │ ├── bool_array.cpp │ │ │ ├── check_status.cpp │ │ │ ├── debug_new.cpp │ │ │ ├── interface_4xunit.cpp │ │ │ ├── mem_pool_base.cpp │ │ │ ├── reporter.cpp │ │ │ └── static_mem_pool.cpp │ │ ├── runner │ │ │ ├── CMakeLists.txt │ │ │ ├── ResourceCheckPoint.cpp │ │ │ ├── TestRunner.cpp │ │ │ ├── TestRunnerMain.cpp │ │ │ ├── filters │ │ │ │ ├── GeneralTestFilter.cpp │ │ │ │ ├── OrCompositeTestFilter.cpp │ │ │ │ ├── PosixFNMatcher.cpp │ │ │ │ ├── TestFilterFactory.cpp │ │ │ │ ├── WildcardTestFilter.cpp │ │ │ │ ├── Win32Fnmatch.c │ │ │ │ └── Win32Fnmatch.h │ │ │ ├── loaders │ │ │ │ ├── DLModuleLoader.cpp │ │ │ │ ├── DLModuleLoaderFactory.cpp │ │ │ │ ├── LTModuleLoader.cpp │ │ │ │ ├── LTModuleLoaderFactory.cpp │ │ │ │ ├── ModuleTestListenerLoader.cpp │ │ │ │ ├── ModuleTestListenerLoaderFactory.cpp │ │ │ │ ├── ModuleTestSuiteLoader.cpp │ │ │ │ ├── ModuleTestSuiteLoaderFactory.cpp │ │ │ │ ├── Win32DllModuleLoader.cpp │ │ │ │ └── Win32DllModuleLoaderFactory.cpp │ │ │ ├── reports │ │ │ │ ├── SimpleTestCaseResultReporter.cpp │ │ │ │ ├── SimpleTestResultDispatcher.cpp │ │ │ │ ├── SimpleTestResultManager.cpp │ │ │ │ ├── SimpleTestResultReporter.cpp │ │ │ │ ├── SimpleTestSuiteResultReporter.cpp │ │ │ │ └── SmartTestCaseResultCollector.cpp │ │ │ ├── runners │ │ │ │ ├── SimpleTestCaseRunner.cpp │ │ │ │ ├── SimpleTestHierarchyRunner.cpp │ │ │ │ ├── TestCaseHierarchy.cpp │ │ │ │ ├── TestCaseRunnerFactory.cpp │ │ │ │ ├── TestFixtureContext.cpp │ │ │ │ ├── TestFixtureRunner.cpp │ │ │ │ ├── TestFixtureRunnerFactory.cpp │ │ │ │ ├── TestHierarchyHandler.cpp │ │ │ │ ├── TestRunnerContext.cpp │ │ │ │ ├── TestSuiteContext.cpp │ │ │ │ └── TestSuiteRunner.cpp │ │ │ ├── sandbox │ │ │ │ ├── Sandbox.cpp │ │ │ │ ├── SandboxProcessor.cpp │ │ │ │ ├── TestCaseSandbox.cpp │ │ │ │ ├── TestCaseSandboxHandler.cpp │ │ │ │ ├── TestCaseSandboxResultDecoder.cpp │ │ │ │ ├── TestCaseSandboxResultReporter.cpp │ │ │ │ └── TestHierarchySandboxRunner.cpp │ │ │ ├── tags │ │ │ │ ├── AndCompositeTaggableFilter.cpp │ │ │ │ ├── EmptyTagsFilter.cpp │ │ │ │ ├── FixtureTagsFilter.cpp │ │ │ │ ├── GeneralTagsFilter.cpp │ │ │ │ ├── MatchAllTagsFilter.cpp │ │ │ │ ├── NotCompositeTaggableFilter.cpp │ │ │ │ ├── OrCompositeTaggableFilter.cpp │ │ │ │ ├── TagsFilters.cpp │ │ │ │ └── TagsParser.cpp │ │ │ ├── utils │ │ │ │ ├── PipeReadableChannel.cpp │ │ │ │ └── PipeWrittableChannel.cpp │ │ │ └── win32 │ │ │ │ ├── GetLastError.cpp │ │ │ │ ├── TestCaseSandboxRunnerMain.cpp │ │ │ │ ├── Win32PipeReadableChannel.cpp │ │ │ │ ├── Win32PipeWrittableChannel.cpp │ │ │ │ ├── Win32Sandbox.cpp │ │ │ │ ├── Win32TestCaseSandbox.cpp │ │ │ │ └── Win32TestHierarchySandboxRunner.cpp │ │ └── utils │ │ │ ├── CMakeLists.txt │ │ │ ├── ConsoleState.cpp │ │ │ ├── GetOpt.c │ │ │ ├── GetOpt.h │ │ │ ├── OptionList.cpp │ │ │ ├── StringToOptions.cpp │ │ │ └── StupidTimer.cpp │ │ ├── tests │ │ ├── 3rdparty │ │ │ ├── mockcpp │ │ │ │ ├── include │ │ │ │ │ └── mockcpp │ │ │ │ │ │ ├── AfterMatchBuilder.h │ │ │ │ │ │ ├── AfterMatchBuilder.tcc │ │ │ │ │ │ ├── AfterMatcher.h │ │ │ │ │ │ ├── ApiHook.h │ │ │ │ │ │ ├── ApiHookFunctor.h │ │ │ │ │ │ ├── ApiHookGenerator.h │ │ │ │ │ │ ├── ApiHookHolder.h │ │ │ │ │ │ ├── ApiHookHolderFactory.h │ │ │ │ │ │ ├── ApiHookKey.h │ │ │ │ │ │ ├── ApiHookMocker.h │ │ │ │ │ │ ├── ArgumentsList.h │ │ │ │ │ │ ├── ArgumentsMacroHelpers.h │ │ │ │ │ │ ├── ArgumentsMatchBuilder.h │ │ │ │ │ │ ├── ArgumentsMatchBuilder.tcc │ │ │ │ │ │ ├── Asserter.h │ │ │ │ │ │ ├── AssertionFailedError.h │ │ │ │ │ │ ├── BeforeMatchBuilder.h │ │ │ │ │ │ ├── BeforeMatchBuilder.tcc │ │ │ │ │ │ ├── BeforeMatcher.h │ │ │ │ │ │ ├── CallerMatchBuilder.h │ │ │ │ │ │ ├── CallerMatchBuilder.tcc │ │ │ │ │ │ ├── CallerMatcher.h │ │ │ │ │ │ ├── ChainableMockMethod.h │ │ │ │ │ │ ├── ChainableMockMethodContainer.h │ │ │ │ │ │ ├── ChainableMockMethodCore.h │ │ │ │ │ │ ├── ChainableMockMethodIndexKey.h │ │ │ │ │ │ ├── ChainableMockMethodKey.h │ │ │ │ │ │ ├── ChainableMockMethodNameKey.h │ │ │ │ │ │ ├── ChainableMockObject.h │ │ │ │ │ │ ├── ChainableMockObjectBase.h │ │ │ │ │ │ ├── ChainingMockHelper.h │ │ │ │ │ │ ├── CheckWith.h │ │ │ │ │ │ ├── CodeModifier.h │ │ │ │ │ │ ├── Constraint.h │ │ │ │ │ │ ├── ConstraintSet.h │ │ │ │ │ │ ├── DecoratedConstraint.h │ │ │ │ │ │ ├── DefaultBuilder.h │ │ │ │ │ │ ├── DefaultMatcher.h │ │ │ │ │ │ ├── DefaultStub.h │ │ │ │ │ │ ├── DelegatedMethod.h │ │ │ │ │ │ ├── DelegatedMethodGetter.h │ │ │ │ │ │ ├── DestructorChecker.h │ │ │ │ │ │ ├── DieStub.h │ │ │ │ │ │ ├── DummyBuilder.h │ │ │ │ │ │ ├── EqualityUtil.h │ │ │ │ │ │ ├── Exception.h │ │ │ │ │ │ ├── ExpectsMatcher.h │ │ │ │ │ │ ├── Formatter.h │ │ │ │ │ │ ├── Functor.h │ │ │ │ │ │ ├── GenericMethodIndicesChecker.h │ │ │ │ │ │ ├── GlobalMockObject.h │ │ │ │ │ │ ├── GnuMethodIndicesChecker.h │ │ │ │ │ │ ├── GnuMethodInfoReader.h │ │ │ │ │ │ ├── HookMockObject.h │ │ │ │ │ │ ├── IdentityBuilder.h │ │ │ │ │ │ ├── Ignore.h │ │ │ │ │ │ ├── IgnoreHandler.h │ │ │ │ │ │ ├── IgnoreResultHandler.h │ │ │ │ │ │ ├── IgnoreResultHandlerFactory.h │ │ │ │ │ │ ├── IgnoreReturnStub.h │ │ │ │ │ │ ├── IncrementStub.h │ │ │ │ │ │ ├── IndexInvokableGetter.h │ │ │ │ │ │ ├── InterfaceInfo.h │ │ │ │ │ │ ├── Invocation.h │ │ │ │ │ │ ├── InvocationId.h │ │ │ │ │ │ ├── InvocationMockBuilder.h │ │ │ │ │ │ ├── InvocationMockBuilder.tcc │ │ │ │ │ │ ├── InvocationMockBuilderGetter.h │ │ │ │ │ │ ├── InvocationMocker.h │ │ │ │ │ │ ├── InvocationMockerContainer.h │ │ │ │ │ │ ├── InvocationMockerNamespace.h │ │ │ │ │ │ ├── InvocationMockerSet.h │ │ │ │ │ │ ├── InvocationTimesMatcher.h │ │ │ │ │ │ ├── InvocationWithReturnType.h │ │ │ │ │ │ ├── Invokable.h │ │ │ │ │ │ ├── InvokedAtLeast.h │ │ │ │ │ │ ├── InvokedAtMost.h │ │ │ │ │ │ ├── InvokedExactly.h │ │ │ │ │ │ ├── InvokedOnce.h │ │ │ │ │ │ ├── InvokedTimesMatcher.h │ │ │ │ │ │ ├── InvokedTimesReader.h │ │ │ │ │ │ ├── InvokedTimesRecorder.h │ │ │ │ │ │ ├── IsAnything.h │ │ │ │ │ │ ├── IsAnythingHelper.h │ │ │ │ │ │ ├── IsConst.h │ │ │ │ │ │ ├── IsEqual.h │ │ │ │ │ │ ├── IsGreaterThan.h │ │ │ │ │ │ ├── IsLessThan.h │ │ │ │ │ │ ├── IsMirror.h │ │ │ │ │ │ ├── IsNotEqual.h │ │ │ │ │ │ ├── IsRef.h │ │ │ │ │ │ ├── IsStringContains.h │ │ │ │ │ │ ├── IsStringEndWith.h │ │ │ │ │ │ ├── IsStringStartWith.h │ │ │ │ │ │ ├── JmpCode.h │ │ │ │ │ │ ├── Matcher.h │ │ │ │ │ │ ├── Method.h │ │ │ │ │ │ ├── MethodIndiceChecker.h │ │ │ │ │ │ ├── MethodInfoReader.h │ │ │ │ │ │ ├── MethodTypeTraits.h │ │ │ │ │ │ ├── MismatchResultHandler.h │ │ │ │ │ │ ├── MismatchResultHandlerFactory.h │ │ │ │ │ │ ├── MockBuilder.h │ │ │ │ │ │ ├── MockObject.h │ │ │ │ │ │ ├── MockObjectBase.h │ │ │ │ │ │ ├── MockObjectHelper.h │ │ │ │ │ │ ├── MoreStubBuilder.h │ │ │ │ │ │ ├── MoreStubBuilder.tcc │ │ │ │ │ │ ├── MsvcMethodInfoReader.h │ │ │ │ │ │ ├── MsvcRtti.h │ │ │ │ │ │ ├── NormalResultHandler.h │ │ │ │ │ │ ├── NormalResultHandlerFactory.h │ │ │ │ │ │ ├── ObjNameGetter.h │ │ │ │ │ │ ├── OrderingMatcher.h │ │ │ │ │ │ ├── OutBound.h │ │ │ │ │ │ ├── OutBoundPointer.h │ │ │ │ │ │ ├── OutputStringStream.h │ │ │ │ │ │ ├── ParameterizedApiHookHolder.h │ │ │ │ │ │ ├── PendingMatcher.h │ │ │ │ │ │ ├── ProcStub.h │ │ │ │ │ │ ├── ProcessWith.h │ │ │ │ │ │ ├── RepeatMacros.h │ │ │ │ │ │ ├── RepeatStub.h │ │ │ │ │ │ ├── ReportFailure.h │ │ │ │ │ │ ├── Result.h │ │ │ │ │ │ ├── ResultHandler.h │ │ │ │ │ │ ├── ResultHandlerFactory.h │ │ │ │ │ │ ├── ReturnObjectList.h │ │ │ │ │ │ ├── ReturnStub.h │ │ │ │ │ │ ├── SelfDescribe.h │ │ │ │ │ │ ├── SimpleInvocationRecorder.h │ │ │ │ │ │ ├── Spy.h │ │ │ │ │ │ ├── StatelessMatcher.h │ │ │ │ │ │ ├── StringConstraint.h │ │ │ │ │ │ ├── StringPredict.h │ │ │ │ │ │ ├── Stub.h │ │ │ │ │ │ ├── StubBuilder.h │ │ │ │ │ │ ├── StubBuilder.tcc │ │ │ │ │ │ ├── StubContainer.h │ │ │ │ │ │ ├── StubsBuilder.h │ │ │ │ │ │ ├── StubsMatcher.h │ │ │ │ │ │ ├── TestFailureMatcher.h │ │ │ │ │ │ ├── ThenStub.h │ │ │ │ │ │ ├── ThrowExceptionStub.h │ │ │ │ │ │ ├── TypeString.h │ │ │ │ │ │ ├── TypeTraits.h │ │ │ │ │ │ ├── TypelessConstraint.h │ │ │ │ │ │ ├── TypelessConstraintAdapter.h │ │ │ │ │ │ ├── TypelessStub.h │ │ │ │ │ │ ├── TypelessStubAdapter.h │ │ │ │ │ │ ├── VirtualTable.h │ │ │ │ │ │ ├── VirtualTableUtils.h │ │ │ │ │ │ ├── Void.h │ │ │ │ │ │ ├── VoidResultHandler.h │ │ │ │ │ │ ├── VoidResultHandlerFactory.h │ │ │ │ │ │ ├── WillStub.h │ │ │ │ │ │ ├── mockable.h │ │ │ │ │ │ ├── mockcpp.h │ │ │ │ │ │ ├── mockcpp.hpp │ │ │ │ │ │ ├── mokc.h │ │ │ │ │ │ ├── types │ │ │ │ │ │ ├── Any.h │ │ │ │ │ │ ├── AnyBase.h │ │ │ │ │ │ ├── AnyCast.h │ │ │ │ │ │ ├── Holder.h │ │ │ │ │ │ ├── PlaceHolder.h │ │ │ │ │ │ ├── RefAny.h │ │ │ │ │ │ ├── RefHolder.h │ │ │ │ │ │ └── ValueHolder.h │ │ │ │ │ │ └── utils.h │ │ │ │ └── src │ │ │ │ │ ├── AfterMatcher.cpp │ │ │ │ │ ├── Any.cpp │ │ │ │ │ ├── AnyBase.cpp │ │ │ │ │ ├── AnyCast.cpp │ │ │ │ │ ├── ApiHook.cpp │ │ │ │ │ ├── ApiHookKey.cpp │ │ │ │ │ ├── Asserter.cpp │ │ │ │ │ ├── AssertionFailedError.cpp │ │ │ │ │ ├── BeforeMatcher.cpp │ │ │ │ │ ├── CMakeLists.txt │ │ │ │ │ ├── CallerMatcher.cpp │ │ │ │ │ ├── ChainableMockMethodContainer.cpp │ │ │ │ │ ├── ChainableMockMethodCore.cpp │ │ │ │ │ ├── ChainableMockMethodIndexKey.cpp │ │ │ │ │ ├── ChainableMockMethodNameKey.cpp │ │ │ │ │ ├── ChainableMockObject.cpp │ │ │ │ │ ├── ChainableMockObjectBase.cpp │ │ │ │ │ ├── ChainingMockHelper.cpp │ │ │ │ │ ├── ConstraintSet.cpp │ │ │ │ │ ├── DecoratedConstraint.cpp │ │ │ │ │ ├── DefaultMatcher.cpp │ │ │ │ │ ├── DefaultStub.cpp │ │ │ │ │ ├── DelegatedMethodGetter.cpp │ │ │ │ │ ├── DieStub.cpp │ │ │ │ │ ├── DummyApiHook.cpp │ │ │ │ │ ├── Exception.cpp │ │ │ │ │ ├── ExpectsMatcher.cpp │ │ │ │ │ ├── Formatter.cpp │ │ │ │ │ ├── GlobalMockObject.cpp │ │ │ │ │ ├── HookMockObject.cpp │ │ │ │ │ ├── IdentityBuilder.cpp │ │ │ │ │ ├── Ignore.cpp │ │ │ │ │ ├── IgnoreResultHandler.cpp │ │ │ │ │ ├── IgnoreResultHandlerFactory.cpp │ │ │ │ │ ├── IgnoreReturnStub.cpp │ │ │ │ │ ├── InterfaceInfo.cpp │ │ │ │ │ ├── Invocation.cpp │ │ │ │ │ ├── InvocationId.cpp │ │ │ │ │ ├── InvocationMockBuilderGetter.cpp │ │ │ │ │ ├── InvocationMocker.cpp │ │ │ │ │ ├── InvocationMockerSet.cpp │ │ │ │ │ ├── InvocationTimesMatcher.cpp │ │ │ │ │ ├── InvokedAtLeast.cpp │ │ │ │ │ ├── InvokedAtMost.cpp │ │ │ │ │ ├── InvokedExactly.cpp │ │ │ │ │ ├── InvokedOnce.cpp │ │ │ │ │ ├── InvokedTimesMatcher.cpp │ │ │ │ │ ├── IsAnythingHelper.cpp │ │ │ │ │ ├── IsStringContains.cpp │ │ │ │ │ ├── IsStringEndWith.cpp │ │ │ │ │ ├── IsStringStartWith.cpp │ │ │ │ │ ├── JmpCode.cpp │ │ │ │ │ ├── JmpCodeArch.h │ │ │ │ │ ├── JmpCodeX64.h │ │ │ │ │ ├── JmpCodeX86.h │ │ │ │ │ ├── JmpOnlyApiHook.cpp │ │ │ │ │ ├── JmpOnlyApiHook.h │ │ │ │ │ ├── MethodIndiceChecker.cpp │ │ │ │ │ ├── MismatchResultHandler.cpp │ │ │ │ │ ├── MismatchResultHandlerFactory.cpp │ │ │ │ │ ├── MockObjectBase.cpp │ │ │ │ │ ├── NormalResultHandler.cpp │ │ │ │ │ ├── NormalResultHandlerFactory.cpp │ │ │ │ │ ├── OutBoundPointer.cpp │ │ │ │ │ ├── PendingMatcher.cpp │ │ │ │ │ ├── ProcStub.cpp │ │ │ │ │ ├── RefAny.cpp │ │ │ │ │ ├── RepeatStub.cpp │ │ │ │ │ ├── Result.cpp │ │ │ │ │ ├── ReturnObjectList.cpp │ │ │ │ │ ├── ReturnStub.cpp │ │ │ │ │ ├── SimpleInvocationRecorder.cpp │ │ │ │ │ ├── StringConstraint.cpp │ │ │ │ │ ├── StubContainer.cpp │ │ │ │ │ ├── StubsMatcher.cpp │ │ │ │ │ ├── TestFailureMatcher.cpp │ │ │ │ │ ├── ThenStub.cpp │ │ │ │ │ ├── TypeString.cpp │ │ │ │ │ ├── TypelessConstraintAdapter.cpp │ │ │ │ │ ├── TypelessStubAdapter.cpp │ │ │ │ │ ├── UnixCodeModifier.cpp │ │ │ │ │ ├── VirtualTable.cpp │ │ │ │ │ ├── VirtualTableUtils.cpp │ │ │ │ │ ├── VoidResultHandler.cpp │ │ │ │ │ ├── VoidResultHandlerFactory.cpp │ │ │ │ │ ├── WillStub.cpp │ │ │ │ │ ├── WinCodeModifier.cpp │ │ │ │ │ ├── generate_arg_related_files.py │ │ │ │ │ ├── generate_vtbl_related_files.py │ │ │ │ │ ├── get_long_opt.py │ │ │ │ │ └── ports │ │ │ │ │ └── failure │ │ │ │ │ ├── catch2_report_failure.cpp │ │ │ │ │ ├── cppunit_report_failure.cpp │ │ │ │ │ ├── cpputest_report_failure.cpp │ │ │ │ │ ├── gtest_report_failure.cpp │ │ │ │ │ └── stdexcept_report_failure.cpp │ │ │ └── testngppst │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── ProjectVar.txt │ │ │ │ ├── include │ │ │ │ ├── cxxtest │ │ │ │ │ └── TestSuite.h │ │ │ │ ├── ltdl.h │ │ │ │ ├── mem_checker │ │ │ │ │ ├── bool_array.h │ │ │ │ │ ├── check_status.h │ │ │ │ │ ├── class_level_lock.h │ │ │ │ │ ├── cont_ptr_utils.h │ │ │ │ │ ├── debug_new.h │ │ │ │ │ ├── fast_mutex.h │ │ │ │ │ ├── fixed_mem_pool.h │ │ │ │ │ ├── format.h │ │ │ │ │ ├── interface_4cuser.h │ │ │ │ │ ├── interface_4cxxuser.h │ │ │ │ │ ├── interface_4user.h │ │ │ │ │ ├── interface_4xunit.h │ │ │ │ │ ├── mem_pool_base.h │ │ │ │ │ ├── object_level_lock.h │ │ │ │ │ ├── pctimer.h │ │ │ │ │ ├── reporter.h │ │ │ │ │ ├── set_assign.h │ │ │ │ │ ├── static_assert.h │ │ │ │ │ └── static_mem_pool.h │ │ │ │ ├── testcpp │ │ │ │ │ └── testcpp.hpp │ │ │ │ └── testngppst │ │ │ │ │ ├── Any.h │ │ │ │ │ ├── Asserter.h │ │ │ │ │ ├── Backward.h │ │ │ │ │ ├── DataDrivenDef.h │ │ │ │ │ ├── NoThrowsReporter.h │ │ │ │ │ ├── TestDefMacros.h │ │ │ │ │ ├── TestFixture.h │ │ │ │ │ ├── TestModule.h │ │ │ │ │ ├── TypeTraits.h │ │ │ │ │ ├── comm │ │ │ │ │ ├── ExceptionKeywords.h │ │ │ │ │ ├── PipeReadableChannel.h │ │ │ │ │ ├── PipeWrittableChannel.h │ │ │ │ │ ├── ReadableChannel.h │ │ │ │ │ ├── Win32PipeReadableChannel.h │ │ │ │ │ ├── Win32PipeWrittableChannel.h │ │ │ │ │ └── WrittableChannel.h │ │ │ │ │ ├── internal │ │ │ │ │ ├── AssertionFailure.h │ │ │ │ │ ├── DataDriven.h │ │ │ │ │ ├── Error.h │ │ │ │ │ ├── Exception.h │ │ │ │ │ ├── Info.h │ │ │ │ │ ├── MemChecker.h │ │ │ │ │ ├── Taggable.h │ │ │ │ │ ├── TagsFilterRule.h │ │ │ │ │ ├── TestCase.h │ │ │ │ │ ├── TestCaseInfoReader.h │ │ │ │ │ ├── TestFixtureDesc.h │ │ │ │ │ ├── TestFixtureInfoReader.h │ │ │ │ │ ├── TestSuiteDesc.h │ │ │ │ │ ├── TestSuiteInfoReader.h │ │ │ │ │ └── Warning.h │ │ │ │ │ ├── listener │ │ │ │ │ ├── MemLeakCountCollector.h │ │ │ │ │ ├── TagsFilterResultCollector.h │ │ │ │ │ ├── TestCaseListener.h │ │ │ │ │ ├── TestCaseResultCollector.h │ │ │ │ │ ├── TestCaseResultReporter.h │ │ │ │ │ ├── TestFixtureResultCollector.h │ │ │ │ │ ├── TestListener.h │ │ │ │ │ ├── TestResultCollector.h │ │ │ │ │ ├── TestResultReporter.h │ │ │ │ │ ├── TestSuiteListener.h │ │ │ │ │ ├── TestSuiteResultCollector.h │ │ │ │ │ └── TestSuiteResultReporter.h │ │ │ │ │ ├── runner │ │ │ │ │ ├── AndCompositeTaggableFilter.h │ │ │ │ │ ├── EOFError.h │ │ │ │ │ ├── EmptyTagsFilter.h │ │ │ │ │ ├── EnvironmentCleaner.h │ │ │ │ │ ├── FixtureTagsFilter.h │ │ │ │ │ ├── GeneralTagsFilter.h │ │ │ │ │ ├── GeneralTestFilter.h │ │ │ │ │ ├── MatchAllTagsFilter.h │ │ │ │ │ ├── NameMatcher.h │ │ │ │ │ ├── NotCompositeTaggableFilter.h │ │ │ │ │ ├── OrCompositeTaggableFilter.h │ │ │ │ │ ├── OrCompositeTestFilter.h │ │ │ │ │ ├── PosixFNMatcher.h │ │ │ │ │ ├── ResourceCheckPoint.h │ │ │ │ │ ├── Sandbox.h │ │ │ │ │ ├── SandboxHandler.h │ │ │ │ │ ├── SandboxProcessor.h │ │ │ │ │ ├── SandboxTypedef.h │ │ │ │ │ ├── SandboxTypedefUnix.h │ │ │ │ │ ├── SimpleTestCaseResultReporter.h │ │ │ │ │ ├── SimpleTestCaseRunner.h │ │ │ │ │ ├── SimpleTestHierarchyRunner.h │ │ │ │ │ ├── SimpleTestResultDispatcher.h │ │ │ │ │ ├── SimpleTestResultManager.h │ │ │ │ │ ├── SimpleTestResultReporter.h │ │ │ │ │ ├── SimpleTestSuiteResultReporter.h │ │ │ │ │ ├── SmartTestCaseResultCollector.h │ │ │ │ │ ├── TaggableObjFilter.h │ │ │ │ │ ├── TagsFilters.h │ │ │ │ │ ├── TagsParser.h │ │ │ │ │ ├── TestCaseContainer.h │ │ │ │ │ ├── TestCaseFilter.h │ │ │ │ │ ├── TestCaseHierarchy.h │ │ │ │ │ ├── TestCaseResultDispatcher.h │ │ │ │ │ ├── TestCaseRunner.h │ │ │ │ │ ├── TestCaseRunnerFactory.h │ │ │ │ │ ├── TestCaseSandbox.h │ │ │ │ │ ├── TestCaseSandboxHandler.h │ │ │ │ │ ├── TestCaseSandboxResultDecoder.h │ │ │ │ │ ├── TestCaseSandboxResultReporter.h │ │ │ │ │ ├── TestFilter.h │ │ │ │ │ ├── TestFilterFactory.h │ │ │ │ │ ├── TestFixtureContext.h │ │ │ │ │ ├── TestFixtureRunner.h │ │ │ │ │ ├── TestFixtureRunnerFactory.h │ │ │ │ │ ├── TestHierarchyHandler.h │ │ │ │ │ ├── TestHierarchyRunner.h │ │ │ │ │ ├── TestHierarchySandboxRunner.h │ │ │ │ │ ├── TestResultDispatcher.h │ │ │ │ │ ├── TestResultManager.h │ │ │ │ │ ├── TestRunner.h │ │ │ │ │ ├── TestRunnerContext.h │ │ │ │ │ ├── TestSuiteContext.h │ │ │ │ │ ├── TestSuiteDescEntryNameGetter.h │ │ │ │ │ ├── TestSuiteResultDispatcher.h │ │ │ │ │ ├── TestSuiteRunner.h │ │ │ │ │ ├── WildcardTestFilter.h │ │ │ │ │ └── loaders │ │ │ │ │ │ ├── DLModuleLoader.h │ │ │ │ │ │ ├── LTModuleLoader.h │ │ │ │ │ │ ├── ModuleLoader.h │ │ │ │ │ │ ├── ModuleLoaderFactory.h │ │ │ │ │ │ ├── ModuleTestListenerLoader.h │ │ │ │ │ │ ├── ModuleTestListenerLoaderFactory.h │ │ │ │ │ │ ├── ModuleTestSuiteLoader.h │ │ │ │ │ │ ├── ModuleTestSuiteLoaderFactory.h │ │ │ │ │ │ ├── TestListenerLoader.h │ │ │ │ │ │ ├── TestListenerLoaderFactory.h │ │ │ │ │ │ ├── TestSuiteLoader.h │ │ │ │ │ │ ├── TestSuiteLoaderFactory.h │ │ │ │ │ │ └── Win32DllModuleLoader.h │ │ │ │ │ ├── testngppst.h │ │ │ │ │ ├── testngppst.hpp │ │ │ │ │ ├── utils │ │ │ │ │ ├── ConsoleState.h │ │ │ │ │ ├── Formatter.h │ │ │ │ │ ├── InternalError.h │ │ │ │ │ ├── OptionList.h │ │ │ │ │ ├── StringList.h │ │ │ │ │ ├── StringToOptions.h │ │ │ │ │ ├── StupidTimer.h │ │ │ │ │ └── TypeString.h │ │ │ │ │ └── win32 │ │ │ │ │ ├── Win32Sandbox.h │ │ │ │ │ ├── Win32TestCaseRunnerResultReporter.h │ │ │ │ │ ├── Win32TestCaseSandbox.h │ │ │ │ │ ├── Win32TestHierarchySandboxRunner.h │ │ │ │ │ └── Win32ThrowLastError.h │ │ │ │ ├── scripts │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── premake4.lua │ │ │ │ ├── pycompile.py │ │ │ │ ├── setup.py │ │ │ │ ├── testngppstgen.py │ │ │ │ └── testngppstgen │ │ │ │ │ ├── AnnotationParser.py │ │ │ │ │ ├── ClassDeclParser.py │ │ │ │ │ ├── DataProvider.py │ │ │ │ │ ├── DataProviderParser.py │ │ │ │ │ ├── ElemParser.py │ │ │ │ │ ├── Fixture.py │ │ │ │ │ ├── FixtureParser.py │ │ │ │ │ ├── Generator.py │ │ │ │ │ ├── LogicalLine.py │ │ │ │ │ ├── Message.py │ │ │ │ │ ├── Name.py │ │ │ │ │ ├── Output.py │ │ │ │ │ ├── Phase0.py │ │ │ │ │ ├── Phase1.py │ │ │ │ │ ├── Phase1Result.py │ │ │ │ │ ├── Phase2.py │ │ │ │ │ ├── Phase3.py │ │ │ │ │ ├── Phase4.py │ │ │ │ │ ├── PreprocessScope.py │ │ │ │ │ ├── PreprocessScopeParser.py │ │ │ │ │ ├── Process.py │ │ │ │ │ ├── TagsParser.py │ │ │ │ │ ├── TestCase.py │ │ │ │ │ ├── TestCaseParser.py │ │ │ │ │ ├── TestScope.py │ │ │ │ │ ├── Useless.py │ │ │ │ │ ├── Utils.py │ │ │ │ │ └── __init__.py │ │ │ │ └── src │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── Formatter.cpp │ │ │ │ ├── MemChecker.cpp │ │ │ │ ├── TestCase.cpp │ │ │ │ ├── TestFixture.cpp │ │ │ │ ├── TestSuiteDesc.cpp │ │ │ │ ├── TypeString.cpp │ │ │ │ ├── except │ │ │ │ ├── AssertionFailure.cpp │ │ │ │ ├── CMakeLists.txt │ │ │ │ └── Exception.cpp │ │ │ │ ├── listeners │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── StdoutTestListener.cpp │ │ │ │ ├── XMLBuilder.cpp │ │ │ │ ├── XMLBuilder.h │ │ │ │ ├── XMLTestListener.cpp │ │ │ │ └── XMLTestListener.h │ │ │ │ ├── mem_checker │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── NoThrowsReporter.cpp │ │ │ │ ├── bool_array.cpp │ │ │ │ ├── check_status.cpp │ │ │ │ ├── debug_new.cpp │ │ │ │ ├── interface_4xunit.cpp │ │ │ │ ├── mem_pool_base.cpp │ │ │ │ ├── reporter.cpp │ │ │ │ └── static_mem_pool.cpp │ │ │ │ ├── runner │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── ResourceCheckPoint.cpp │ │ │ │ ├── TestRunner.cpp │ │ │ │ ├── TestRunnerMain.cpp │ │ │ │ ├── filters │ │ │ │ │ ├── GeneralTestFilter.cpp │ │ │ │ │ ├── OrCompositeTestFilter.cpp │ │ │ │ │ ├── PosixFNMatcher.cpp │ │ │ │ │ ├── TestFilterFactory.cpp │ │ │ │ │ ├── WildcardTestFilter.cpp │ │ │ │ │ ├── Win32Fnmatch.c │ │ │ │ │ └── Win32Fnmatch.h │ │ │ │ ├── loaders │ │ │ │ │ ├── DLModuleLoader.cpp │ │ │ │ │ ├── DLModuleLoaderFactory.cpp │ │ │ │ │ ├── LTModuleLoader.cpp │ │ │ │ │ ├── LTModuleLoaderFactory.cpp │ │ │ │ │ ├── ModuleTestListenerLoader.cpp │ │ │ │ │ ├── ModuleTestListenerLoaderFactory.cpp │ │ │ │ │ ├── ModuleTestSuiteLoader.cpp │ │ │ │ │ ├── ModuleTestSuiteLoaderFactory.cpp │ │ │ │ │ ├── Win32DllModuleLoader.cpp │ │ │ │ │ └── Win32DllModuleLoaderFactory.cpp │ │ │ │ ├── reports │ │ │ │ │ ├── SimpleTestCaseResultReporter.cpp │ │ │ │ │ ├── SimpleTestResultDispatcher.cpp │ │ │ │ │ ├── SimpleTestResultManager.cpp │ │ │ │ │ ├── SimpleTestResultReporter.cpp │ │ │ │ │ ├── SimpleTestSuiteResultReporter.cpp │ │ │ │ │ └── SmartTestCaseResultCollector.cpp │ │ │ │ ├── runners │ │ │ │ │ ├── SimpleTestCaseRunner.cpp │ │ │ │ │ ├── SimpleTestHierarchyRunner.cpp │ │ │ │ │ ├── TestCaseHierarchy.cpp │ │ │ │ │ ├── TestCaseRunnerFactory.cpp │ │ │ │ │ ├── TestFixtureContext.cpp │ │ │ │ │ ├── TestFixtureRunner.cpp │ │ │ │ │ ├── TestFixtureRunnerFactory.cpp │ │ │ │ │ ├── TestHierarchyHandler.cpp │ │ │ │ │ ├── TestRunnerContext.cpp │ │ │ │ │ ├── TestSuiteContext.cpp │ │ │ │ │ └── TestSuiteRunner.cpp │ │ │ │ ├── sandbox │ │ │ │ │ ├── Sandbox.cpp │ │ │ │ │ ├── SandboxProcessor.cpp │ │ │ │ │ ├── TestCaseSandbox.cpp │ │ │ │ │ ├── TestCaseSandboxHandler.cpp │ │ │ │ │ ├── TestCaseSandboxResultDecoder.cpp │ │ │ │ │ ├── TestCaseSandboxResultReporter.cpp │ │ │ │ │ └── TestHierarchySandboxRunner.cpp │ │ │ │ ├── tags │ │ │ │ │ ├── AndCompositeTaggableFilter.cpp │ │ │ │ │ ├── EmptyTagsFilter.cpp │ │ │ │ │ ├── FixtureTagsFilter.cpp │ │ │ │ │ ├── GeneralTagsFilter.cpp │ │ │ │ │ ├── MatchAllTagsFilter.cpp │ │ │ │ │ ├── NotCompositeTaggableFilter.cpp │ │ │ │ │ ├── OrCompositeTaggableFilter.cpp │ │ │ │ │ ├── TagsFilters.cpp │ │ │ │ │ └── TagsParser.cpp │ │ │ │ ├── utils │ │ │ │ │ ├── PipeReadableChannel.cpp │ │ │ │ │ └── PipeWrittableChannel.cpp │ │ │ │ └── win32 │ │ │ │ │ ├── GetLastError.cpp │ │ │ │ │ ├── TestCaseSandboxRunnerMain.cpp │ │ │ │ │ ├── Win32PipeReadableChannel.cpp │ │ │ │ │ ├── Win32PipeWrittableChannel.cpp │ │ │ │ │ ├── Win32Sandbox.cpp │ │ │ │ │ ├── Win32TestCaseSandbox.cpp │ │ │ │ │ └── Win32TestHierarchySandboxRunner.cpp │ │ │ │ └── utils │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── ConsoleState.cpp │ │ │ │ ├── GetOpt.c │ │ │ │ ├── GetOpt.h │ │ │ │ ├── OptionList.cpp │ │ │ │ ├── StringToOptions.cpp │ │ │ │ └── StupidTimer.cpp │ │ ├── CMakeLists.txt │ │ └── ut │ │ │ ├── CMakeLists.txt │ │ │ ├── FTestFixture1.h │ │ │ ├── FTestFixture2.h │ │ │ ├── MyTestCase.h │ │ │ ├── TestAsserter.h │ │ │ ├── TestAssertionFailure.h │ │ │ ├── TestDataDriven.h │ │ │ ├── TestExceptionKeywords.h │ │ │ ├── TestFixtureDef.h │ │ │ ├── TestGeneralTestFilter.h │ │ │ ├── TestMemChecker.h │ │ │ ├── TestModuleTestSuiteLoader.h │ │ │ ├── TestOrCompositeTestFilter.h │ │ │ ├── TestPipeReadableChannel.h │ │ │ ├── TestPipeWrittableChannel.h │ │ │ ├── TestPosixFNMatcher.h │ │ │ ├── TestSandbox.h │ │ │ ├── TestSandboxProcessor.h │ │ │ ├── TestSimpleTestSuiteResultReporter.h │ │ │ ├── TestStringToOptions.h │ │ │ ├── TestTagsParser.h │ │ │ ├── TestTestCase.h │ │ │ ├── TestTestCaseHierarchy.h │ │ │ ├── TestTestCaseSandboxResultReporter.h │ │ │ ├── TestTestFilterFactory.h │ │ │ ├── TestTestFixtureDesc.h │ │ │ ├── TestTestFixtureSandboxRunner.h │ │ │ ├── TestTestSuiteContext.h │ │ │ ├── TestTestSuiteDesc.h │ │ │ ├── TestXMLBuilder.h │ │ │ ├── TestXMLTestListener.h │ │ │ ├── gt.py │ │ │ └── testngpp-ut │ │ └── update-testngppst.sh ├── CMakeLists.txt └── ut │ ├── CMakeLists.txt │ ├── MockMethodSamples.h │ ├── TestAny.h │ ├── TestApiHook.h │ ├── TestApiHookBase.h │ ├── TestApiHookStdcall.h │ ├── TestChainableMockMethod.h │ ├── TestChainableMockMethodContainer.h │ ├── TestChainableMockMethodNameKey.h │ ├── TestChainableObject.h │ ├── TestCheck.h │ ├── TestConstraintSet.h │ ├── TestDelegatedMethod.h │ ├── TestDestructorChecker.h │ ├── TestFormatter.h │ ├── TestHolder.h │ ├── TestIgnoreReturnValue.h │ ├── TestIncrementStub.h │ ├── TestInterfaceInfo.h │ ├── TestInvocation.h │ ├── TestInvocationMocker.h │ ├── TestIsEqual.h │ ├── TestIsStringContains.h │ ├── TestIsStringEndWith.h │ ├── TestIsStringStartWith.h │ ├── TestMethodInfoReader.h │ ├── TestMockObject.h │ ├── TestMockObject2.h │ ├── TestMockcppSample.h │ ├── TestNonvirtualMethodMocker.h │ ├── TestOverloadMethodMocker.h │ ├── TestReturnObjectList.h │ ├── TestSmartPointerChecker.h │ ├── TestStaticMethodMocker.h │ ├── TestStringConstraint.h │ ├── TestStubContainter.h │ ├── TestVirtualTable.h │ ├── gt.py │ └── mockcpp-ut └── tools ├── CMakeLists.txt ├── build_functions.ps1 ├── build_functions.sh └── testngpp.cmake /CMakeLists.txt: -------------------------------------------------------------------------------- 1 | 2 | CMAKE_MINIMUM_REQUIRED(VERSION 3.12...3.19) 3 | 4 | PROJECT(mockcpp) 5 | 6 | INCLUDE(ProjectVar.txt) 7 | 8 | ADD_SUBDIRECTORY(src) 9 | 10 | INSTALL(DIRECTORY include/mockcpp DESTINATION include 11 | PATTERN ".svn" EXCLUDE) 12 | 13 | INSTALL(DIRECTORY 3rdparty/fake_boost DESTINATION include 14 | PATTERN ".svn" EXCLUDE) 15 | 16 | INSTALL(DIRECTORY 3rdparty/msinttypes DESTINATION include 17 | PATTERN ".svn" EXCLUDE) 18 | 19 | SET(MOCKCPP_XUNIT "testngpp" CACHE STRING "Set to gtest/cpputest/cppunit to use other testframeworks.") 20 | 21 | 22 | -------------------------------------------------------------------------------- /ExportLite.ps1: -------------------------------------------------------------------------------- 1 | # export mockcpp without boost 2 | 3 | $env:path=$env:path+";D:\Tools\CMD\SubversionClient" 4 | 5 | $dest_dir="D:\tools_release\mockcpp_exported" 6 | 7 | function export_subdir($subdir) 8 | { 9 | if (!(test-path $dest_dir\$subdir)) { mkdir $dest_dir\$subdir } 10 | svn export $subdir $dest_dir\$subdir --force 11 | } 12 | 13 | export_subdir 3rdparty\msinttypes 14 | export_subdir include 15 | export_subdir src 16 | export_subdir tests 17 | 18 | svn export --depth=files . $dest_dir --force 19 | 20 | 21 | 22 | -------------------------------------------------------------------------------- /HEADER: -------------------------------------------------------------------------------- 1 | /*** 2 | mockcpp is a C/C++ mock framework. 3 | Copyright [2008] [Darwin Yuan ] 4 | 5 | Licensed under the Apache License, Version 2.0 (the "License"); 6 | you may not use this file except in compliance with the License. 7 | You may obtain a copy of the License at 8 | 9 | http://www.apache.org/licenses/LICENSE-2.0 10 | 11 | Unless required by applicable law or agreed to in writing, software 12 | distributed under the License is distributed on an "AS IS" BASIS, 13 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 | See the License for the specific language governing permissions and 15 | limitations under the License. 16 | ***/ 17 | -------------------------------------------------------------------------------- /ProjectVar.txt: -------------------------------------------------------------------------------- 1 | 2 | SET(PACKAGE_NAME \"mockcpp\") 3 | SET(PACKAGE_STRING \"mockcpp\") 4 | SET(PACKAGE_BUGREPORT \"dev.mockcpp@gmail.com\") 5 | SET(PACKAGE_URL \"http://code.google.com/p/mockcpp\") 6 | SET(PACKAGE \"mockcpp\") 7 | SET(VERSION \"2.7\") 8 | 9 | -------------------------------------------------------------------------------- /clean.bat: -------------------------------------------------------------------------------- 1 | del include\mockcpp\MethodIndiceCheckerDef.h.rule 2 | del include\mockcpp\DestructorAddrGetterDef.h.rule 3 | del include\mockcpp\MethodTypeTraitsDef.h.rule 4 | del include\mockcpp\DelegatedMethodGetDef.h 5 | del include\mockcpp\DelegatedMethodDef.h.rule 6 | del include\mockcpp\MethodIndiceCheckerDef.h 7 | del include\mockcpp\DelegatedMethodGetByVptrDef.h.rule 8 | del include\mockcpp\MethodTypeTraitsDef.h 9 | del include\mockcpp\DelegatedMethodGetByVptrDef.h 10 | del include\mockcpp\DestructorAddrGetterDef.h 11 | del include\mockcpp\ArgumentsListDef.h.rule 12 | del include\mockcpp\DelegatedMethodDef.h 13 | del include\mockcpp\DelegatedMethodGetDef.h.rule 14 | del include\mockcpp\DefaultMethodAddrGetterDef.h 15 | del include\mockcpp\ArgumentsListDef.h 16 | del include\mockcpp\DefaultMethodAddrGetterDef.h.rule 17 | del tests\ut\*.cpp 18 | -------------------------------------------------------------------------------- /docs/Installation.md: -------------------------------------------------------------------------------- 1 | While configure mock++ with cmake, follow variables could be specified: 2 | 3 | | Variable | Type | Default Value | Scope | Notes | 4 | |:----------|:-----|:--------------|:------|:------| 5 | | MOCKCPP\_ALLOW\_MI | BOOL | TRUE | TRUE/FALSE | Allow multi-inheritance or not | 6 | | MOCKCPP\_MAX\_INHERITANCE | STRING | 2 | 2~5 |maximum parents number of an interface | 7 | | MOCKCPP\_NO\_NAMESPACE | BOOL | FALSE | TRUE/FALSE | using mockpp namespace or not | 8 | | MOCKCPP\_MAX\_VTBL\_SIZE | STRING | 20 | 2~50 | maximum virtual table size | 9 | | MOCKCPP\_MAX\_PARAMETERS | STRING | 12 | 1~12 | maximum number of parameters of a function/method | 10 | | MOCKCPP\_INSTALL\_BOOST | BOOL | FALSE | TRUE/FALSE | install boost library or not while running "make install" | -------------------------------------------------------------------------------- /docs/OnGoingFeatures.md: -------------------------------------------------------------------------------- 1 | # On-going features # 2 | 3 | * 64-bit x86 arch 4 | * `__stdcall` functions for MSVC 5 | * static member functions 6 | * spy() constraint. 7 | * non-mockable way on Linux & Mac 8 | * working with various xUnit frameworks, including googleTest, CppUTest. -------------------------------------------------------------------------------- /docs/SoftwareArchitecture.md: -------------------------------------------------------------------------------- 1 | # 软件架构 2 | 3 | ## mockcpp 4 | 5 | ## testngpp 6 | 7 | ## 项目目录结构 8 | 9 | | 序号 | 名称 | 路径 | 用途 | 10 | | ---- | ---- | ----- | ---- | 11 | | 1 | mockcpp | mockcpp | mockcpp源码 | 12 | | 2 | testngpp | mockcpp/tests/3rdparty/testngpp | testngpp源码,也用来测试 1 mockcpp | 13 | | 3 | testngppst | mockcpp/tests/3rdparty/testngpp/tests/3rdparty/testngppst | 测试testngpp的测试框架 | 14 | | 4 | mockcpp | mockcpp/tests/3rdparty/testngpp/tests/3rdparty/mockcpp | 测试testngpp的mock框架 | 15 | -------------------------------------------------------------------------------- /docs/images/2021-03-14-09-55-56.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sinojelly/mockcpp/7b7eb8b8a7837813d91ee1ae9354f352605fc270/docs/images/2021-03-14-09-55-56.png -------------------------------------------------------------------------------- /include/mockcpp/ApiHookHolder.h: -------------------------------------------------------------------------------- 1 | /*** 2 | mockcpp is a C/C++ mock framework. 3 | Copyright [2008] [Darwin Yuan ] 4 | 5 | Licensed under the Apache License, Version 2.0 (the "License"); 6 | you may not use this file except in compliance with the License. 7 | You may obtain a copy of the License at 8 | 9 | http://www.apache.org/licenses/LICENSE-2.0 10 | 11 | Unless required by applicable law or agreed to in writing, software 12 | distributed under the License is distributed on an "AS IS" BASIS, 13 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 | See the License for the specific language governing permissions and 15 | limitations under the License. 16 | ***/ 17 | 18 | #ifndef __MOCKCPP_API_HOOK_HOLDER_H__ 19 | #define __MOCKCPP_API_HOOK_HOLDER_H__ 20 | 21 | #include 22 | 23 | MOCKCPP_NS_START 24 | 25 | struct ApiHookHolder 26 | { 27 | virtual void * getApiHook() const = 0; 28 | 29 | virtual ~ApiHookHolder() {} 30 | }; 31 | 32 | MOCKCPP_NS_END 33 | 34 | #endif 35 | 36 | -------------------------------------------------------------------------------- /include/mockcpp/CallerMatchBuilder.tcc: -------------------------------------------------------------------------------- 1 | 2 | #include 3 | #include 4 | 5 | 6 | MOCKCPP_NS_START 7 | 8 | 9 | ////////////////////////////////////////////////////////////////////// 10 | template 11 | Builder& 12 | CallerMatchBuilder::caller(const std::string& nameOfCaller) 13 | { 14 | getMocker()->addMatcher(new CallerMatcher(nameOfCaller)); 15 | return *this; 16 | } 17 | 18 | ////////////////////////////////////////////////////////////////////// 19 | 20 | MOCKCPP_NS_END 21 | -------------------------------------------------------------------------------- /include/mockcpp/CodeModifier.h: -------------------------------------------------------------------------------- 1 | /*** 2 | mockcpp is a C/C++ mock framework. 3 | Copyright [2008] [Darwin Yuan ] 4 | 5 | Licensed under the Apache License, Version 2.0 (the "License"); 6 | you may not use this file except in compliance with the License. 7 | You may obtain a copy of the License at 8 | 9 | http://www.apache.org/licenses/LICENSE-2.0 10 | 11 | Unless required by applicable law or agreed to in writing, software 12 | distributed under the License is distributed on an "AS IS" BASIS, 13 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 | See the License for the specific language governing permissions and 15 | limitations under the License. 16 | ***/ 17 | 18 | #ifndef __MOCKCPP_CODEMODIFIER_H__ 19 | #define __MOCKCPP_CODEMODIFIER_H__ 20 | 21 | #include 22 | 23 | MOCKCPP_NS_START 24 | 25 | struct CodeModifier 26 | { 27 | static bool modify(void *dest, const void *src, size_t size); 28 | }; 29 | 30 | MOCKCPP_NS_END 31 | 32 | #endif 33 | 34 | -------------------------------------------------------------------------------- /include/mockcpp/DummyBuilder.h: -------------------------------------------------------------------------------- 1 | /*** 2 | mockcpp is a C/C++ mock framework. 3 | Copyright [2008] [Darwin Yuan ] 4 | 5 | Licensed under the Apache License, Version 2.0 (the "License"); 6 | you may not use this file except in compliance with the License. 7 | You may obtain a copy of the License at 8 | 9 | http://www.apache.org/licenses/LICENSE-2.0 10 | 11 | Unless required by applicable law or agreed to in writing, software 12 | distributed under the License is distributed on an "AS IS" BASIS, 13 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 | See the License for the specific language governing permissions and 15 | limitations under the License. 16 | ***/ 17 | 18 | #ifndef __MOCKCPP_DUMMY_BUILDER_H 19 | #define __MOCKCPP_DUMMY_BUILDER_H 20 | 21 | #include 22 | 23 | MOCKCPP_NS_START 24 | 25 | struct DummyBuilder {}; 26 | 27 | MOCKCPP_NS_END 28 | 29 | #endif 30 | 31 | -------------------------------------------------------------------------------- /include/mockcpp/Ignore.h: -------------------------------------------------------------------------------- 1 | /*** 2 | mockcpp is a C/C++ mock framework. 3 | Copyright [2008] [Darwin Yuan ] 4 | 5 | Licensed under the Apache License, Version 2.0 (the "License"); 6 | you may not use this file except in compliance with the License. 7 | You may obtain a copy of the License at 8 | 9 | http://www.apache.org/licenses/LICENSE-2.0 10 | 11 | Unless required by applicable law or agreed to in writing, software 12 | distributed under the License is distributed on an "AS IS" BASIS, 13 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 | See the License for the specific language governing permissions and 15 | limitations under the License. 16 | ***/ 17 | 18 | #ifndef __MOCKCPP_IGNORE_H 19 | #define __MOCKCPP_IGNORE_H 20 | 21 | #include 22 | 23 | MOCKCPP_NS_START 24 | 25 | struct Ignore 26 | { 27 | bool operator==(const Ignore& rhs) const 28 | { 29 | return true; 30 | } 31 | }; 32 | 33 | struct Any; 34 | 35 | Any& getIgnore(); 36 | 37 | MOCKCPP_NS_END 38 | 39 | #endif 40 | 41 | -------------------------------------------------------------------------------- /include/mockcpp/InvocationMockBuilder.tcc: -------------------------------------------------------------------------------- 1 | 2 | #include 3 | 4 | MOCKCPP_NS_START 5 | 6 | ////////////////////////////////////////////////////// 7 | template 8 | InvocationMockBuilder::InvocationMockBuilder(InvocationMocker* mocker) 9 | : invocationMocker(mocker) 10 | { 11 | } 12 | 13 | ////////////////////////////////////////////////////// 14 | template 15 | InvocationMocker* 16 | InvocationMockBuilder::getMocker() const 17 | { 18 | return invocationMocker; 19 | } 20 | 21 | MOCKCPP_NS_END 22 | 23 | 24 | -------------------------------------------------------------------------------- /include/mockcpp/InvokedTimesReader.h: -------------------------------------------------------------------------------- 1 | /*** 2 | mockcpp is a C/C++ mock framework. 3 | Copyright [2008] [Darwin Yuan ] 4 | 5 | Licensed under the Apache License, Version 2.0 (the "License"); 6 | you may not use this file except in compliance with the License. 7 | You may obtain a copy of the License at 8 | 9 | http://www.apache.org/licenses/LICENSE-2.0 10 | 11 | Unless required by applicable law or agreed to in writing, software 12 | distributed under the License is distributed on an "AS IS" BASIS, 13 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 | See the License for the specific language governing permissions and 15 | limitations under the License. 16 | ***/ 17 | 18 | #ifndef __MOCKCPP_INVOKED_TIMES_READER_H 19 | #define __MOCKCPP_INVOKED_TIMES_READER_H 20 | 21 | #include 22 | 23 | MOCKCPP_NS_START 24 | 25 | struct InvokedTimesReader 26 | { 27 | virtual ~InvokedTimesReader() {} 28 | 29 | virtual unsigned int getInvokedTimes() const = 0; 30 | }; 31 | 32 | MOCKCPP_NS_END 33 | 34 | #endif 35 | 36 | -------------------------------------------------------------------------------- /include/mockcpp/IsAnythingHelper.h: -------------------------------------------------------------------------------- 1 | /*** 2 | mockcpp is a C/C++ mock framework. 3 | Copyright [2008] [Darwin Yuan ] 4 | 5 | Licensed under the Apache License, Version 2.0 (the "License"); 6 | you may not use this file except in compliance with the License. 7 | You may obtain a copy of the License at 8 | 9 | http://www.apache.org/licenses/LICENSE-2.0 10 | 11 | Unless required by applicable law or agreed to in writing, software 12 | distributed under the License is distributed on an "AS IS" BASIS, 13 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 | See the License for the specific language governing permissions and 15 | limitations under the License. 16 | ***/ 17 | 18 | #ifndef __MOCKCPP_IS_ANYTHING_HELPER_H 19 | #define __MOCKCPP_IS_ANYTHING_HELPER_H 20 | 21 | #include 22 | 23 | MOCKCPP_NS_START 24 | 25 | struct Constraint; 26 | 27 | Constraint* any(); 28 | 29 | //static const Constraint* _ = 0; 30 | 31 | bool isAnyConstraint(Constraint* c); 32 | 33 | MOCKCPP_NS_END 34 | 35 | #endif 36 | 37 | -------------------------------------------------------------------------------- /include/mockcpp/MoreStubBuilder.tcc: -------------------------------------------------------------------------------- 1 | 2 | #include 3 | #include 4 | 5 | MOCKCPP_NS_START 6 | 7 | template 8 | MoreStubBuilder& 9 | MoreStubBuilder::then(Stub* stub) 10 | { 11 | getMocker()->addStub(new ThenStub(stub)); 12 | return *this; 13 | } 14 | 15 | MOCKCPP_NS_END 16 | 17 | -------------------------------------------------------------------------------- /include/mockcpp/ObjNameGetter.h: -------------------------------------------------------------------------------- 1 | /*** 2 | mockcpp is a C/C++ mock framework. 3 | Copyright [2008] [Darwin Yuan ] 4 | 5 | Licensed under the Apache License, Version 2.0 (the "License"); 6 | you may not use this file except in compliance with the License. 7 | You may obtain a copy of the License at 8 | 9 | http://www.apache.org/licenses/LICENSE-2.0 10 | 11 | Unless required by applicable law or agreed to in writing, software 12 | distributed under the License is distributed on an "AS IS" BASIS, 13 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 | See the License for the specific language governing permissions and 15 | limitations under the License. 16 | ***/ 17 | 18 | #ifndef __MOCKCPP_OBJ_NAME_GETTER_H 19 | #define __MOCKCPP_OBJ_NAME_GETTER_H 20 | 21 | #include 22 | 23 | #include 24 | 25 | MOCKCPP_NS_START 26 | 27 | struct ObjectNameGetter 28 | { 29 | virtual const std::string& getName() const = 0; 30 | 31 | virtual ~ObjectNameGetter() {} 32 | }; 33 | 34 | MOCKCPP_NS_END 35 | 36 | #endif 37 | 38 | -------------------------------------------------------------------------------- /include/mockcpp/OutputStringStream.h: -------------------------------------------------------------------------------- 1 | /*** 2 | mockcpp is a C/C++ mock framework. 3 | Copyright [2008] [Darwin Yuan ] 4 | 5 | Licensed under the Apache License, Version 2.0 (the "License"); 6 | you may not use this file except in compliance with the License. 7 | You may obtain a copy of the License at 8 | 9 | http://www.apache.org/licenses/LICENSE-2.0 10 | 11 | Unless required by applicable law or agreed to in writing, software 12 | distributed under the License is distributed on an "AS IS" BASIS, 13 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 | See the License for the specific language governing permissions and 15 | limitations under the License. 16 | ***/ 17 | #ifndef __MOCKCPP_OUTPUT_STRING_STREAM_H 18 | #define __MOCKCPP_OUTPUT_STRING_STREAM_H 19 | 20 | #include 21 | 22 | typedef std::ostringstream oss_t; 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /include/mockcpp/SelfDescribe.h: -------------------------------------------------------------------------------- 1 | /*** 2 | mockcpp is a C/C++ mock framework. 3 | Copyright [2008] [Darwin Yuan ] 4 | 5 | Licensed under the Apache License, Version 2.0 (the "License"); 6 | you may not use this file except in compliance with the License. 7 | You may obtain a copy of the License at 8 | 9 | http://www.apache.org/licenses/LICENSE-2.0 10 | 11 | Unless required by applicable law or agreed to in writing, software 12 | distributed under the License is distributed on an "AS IS" BASIS, 13 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 | See the License for the specific language governing permissions and 15 | limitations under the License. 16 | ***/ 17 | 18 | #ifndef __MOCKCPP_SELF_DESCRIBE_H 19 | #define __MOCKCPP_SELF_DESCRIBE_H 20 | 21 | #include 22 | #include 23 | 24 | MOCKCPP_NS_START 25 | 26 | struct SelfDescribe 27 | { 28 | virtual ~SelfDescribe() {} 29 | virtual std::string toString() const = 0; 30 | }; 31 | 32 | MOCKCPP_NS_END 33 | 34 | #endif 35 | 36 | -------------------------------------------------------------------------------- /include/mockcpp/StubBuilder.tcc: -------------------------------------------------------------------------------- 1 | 2 | #include 3 | #include 4 | 5 | MOCKCPP_NS_START 6 | 7 | template 8 | Builder& StubBuilder::will(Stub* stub) 9 | { 10 | getMocker()->addStub(new WillStub(stub)); 11 | return *this; 12 | } 13 | 14 | MOCKCPP_NS_END 15 | 16 | 17 | -------------------------------------------------------------------------------- /include/mockcpp/Void.h: -------------------------------------------------------------------------------- 1 | /*** 2 | mockcpp is a C/C++ mock framework. 3 | Copyright [2008] [Darwin Yuan ] 4 | 5 | Licensed under the Apache License, Version 2.0 (the "License"); 6 | you may not use this file except in compliance with the License. 7 | You may obtain a copy of the License at 8 | 9 | http://www.apache.org/licenses/LICENSE-2.0 10 | 11 | Unless required by applicable law or agreed to in writing, software 12 | distributed under the License is distributed on an "AS IS" BASIS, 13 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 | See the License for the specific language governing permissions and 15 | limitations under the License. 16 | ***/ 17 | 18 | #ifndef __MOCKCPP_VOID_H 19 | #define __MOCKCPP_VOID_H 20 | 21 | #include 22 | 23 | MOCKCPP_NS_START 24 | 25 | struct Void {}; 26 | 27 | MOCKCPP_NS_END 28 | 29 | #endif 30 | 31 | -------------------------------------------------------------------------------- /include/mockcpp/mockcpp.hpp: -------------------------------------------------------------------------------- 1 | /*** 2 | mockcpp is a generic C/C++ mock framework. 3 | Copyright (C) <2009> 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 | (at your option) 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 | 19 | #ifndef __MOCKCPP_HPP_ 20 | #define __MOCKCPP_HPP_ 21 | 22 | #include 23 | #include 24 | #include 25 | #include 26 | 27 | #endif 28 | 29 | -------------------------------------------------------------------------------- /src/IdentityBuilder.cpp: -------------------------------------------------------------------------------- 1 | /*** 2 | mockcpp is a C/C++ mock framework. 3 | Copyright [2008] [Darwin Yuan ] 4 | 5 | Licensed under the Apache License, Version 2.0 (the "License"); 6 | you may not use this file except in compliance with the License. 7 | You may obtain a copy of the License at 8 | 9 | http://www.apache.org/licenses/LICENSE-2.0 10 | 11 | Unless required by applicable law or agreed to in writing, software 12 | distributed under the License is distributed on an "AS IS" BASIS, 13 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 | See the License for the specific language governing permissions and 15 | limitations under the License. 16 | ***/ 17 | 18 | #include 19 | #include 20 | #include 21 | 22 | MOCKCPP_NS_START 23 | 24 | void IdentityBuilder::id(const std::string& id) 25 | { 26 | getMocker()->setId(new InvocationId(id)); 27 | } 28 | 29 | 30 | MOCKCPP_NS_END 31 | 32 | 33 | -------------------------------------------------------------------------------- /src/Ignore.cpp: -------------------------------------------------------------------------------- 1 | /*** 2 | mockcpp is a C/C++ mock framework. 3 | Copyright [2008] [Darwin Yuan ] 4 | 5 | Licensed under the Apache License, Version 2.0 (the "License"); 6 | you may not use this file except in compliance with the License. 7 | You may obtain a copy of the License at 8 | 9 | http://www.apache.org/licenses/LICENSE-2.0 10 | 11 | Unless required by applicable law or agreed to in writing, software 12 | distributed under the License is distributed on an "AS IS" BASIS, 13 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 | See the License for the specific language governing permissions and 15 | limitations under the License. 16 | ***/ 17 | 18 | #include 19 | #include 20 | 21 | MOCKCPP_NS_START 22 | 23 | /////////////////////////////////////////////// 24 | 25 | const Any ignore = Any(Ignore()); 26 | 27 | Any& getIgnore() 28 | { 29 | return const_cast(ignore); 30 | } 31 | 32 | /////////////////////////////////////////////// 33 | 34 | MOCKCPP_NS_END 35 | 36 | 37 | 38 | -------------------------------------------------------------------------------- /src/JmpCodeArch.h: -------------------------------------------------------------------------------- 1 | /*** 2 | mockcpp is a C/C++ mock framework. 3 | Copyright [2008] [Darwin Yuan ] 4 | 5 | Licensed under the Apache License, Version 2.0 (the "License"); 6 | you may not use this file except in compliance with the License. 7 | You may obtain a copy of the License at 8 | 9 | http://www.apache.org/licenses/LICENSE-2.0 10 | 11 | Unless required by applicable law or agreed to in writing, software 12 | distributed under the License is distributed on an "AS IS" BASIS, 13 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 | See the License for the specific language governing permissions and 15 | limitations under the License. 16 | ***/ 17 | #ifndef __MOCKCPP_JMP_CODE_ARCH_H__ 18 | #define __MOCKCPP_JMP_CODE_ARCH_H__ 19 | 20 | #include 21 | 22 | #if BUILD_FOR_X64 23 | # include "JmpCodeX64.h" 24 | #elif BUILD_FOR_X86 25 | # include "JmpCodeX86.h" 26 | #endif 27 | 28 | #endif 29 | 30 | -------------------------------------------------------------------------------- /src/JmpCodeX86.h: -------------------------------------------------------------------------------- 1 | /*** 2 | mockcpp is a C/C++ mock framework. 3 | Copyright [2008] [Darwin Yuan ] 4 | 5 | Licensed under the Apache License, Version 2.0 (the "License"); 6 | you may not use this file except in compliance with the License. 7 | You may obtain a copy of the License at 8 | 9 | http://www.apache.org/licenses/LICENSE-2.0 10 | 11 | Unless required by applicable law or agreed to in writing, software 12 | distributed under the License is distributed on an "AS IS" BASIS, 13 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 | See the License for the specific language governing permissions and 15 | limitations under the License. 16 | ***/ 17 | #ifndef __MOCKCPP_JMP_CODE_X32_H__ 18 | #define __MOCKCPP_JMP_CODE_X32_H__ 19 | 20 | const unsigned char jmpCodeTemplate[] = { 0xE9, 0x00, 0x00, 0x00, 0x00 }; 21 | #define SET_JMP_CODE(base, from, to) do { \ 22 | *(unsigned long*)(base + 1) = \ 23 | (unsigned long long)to - (unsigned long long)from - sizeof(jmpCodeTemplate); \ 24 | } while(0) 25 | 26 | #endif 27 | 28 | -------------------------------------------------------------------------------- /src/get_long_opt.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/python 2 | 3 | import getopt, sys 4 | 5 | class LongOptString: 6 | def __init__(self, optString, example): 7 | self.optString = optString 8 | self.example = example 9 | 10 | def toAssignable(self): 11 | return self.optString + '=' 12 | 13 | def toLongOptString(self): 14 | return '--' + self.optString 15 | 16 | def toLongAssignable(self): 17 | return '--' + self.optString + '=' 18 | 19 | def toUsage(self): 20 | return self.toLongAssignable() + self.example 21 | 22 | def getAssignableOptStrings(longOpts): 23 | return [i.toAssignable() for i in longOpts] 24 | 25 | def getUsageString(longOpts): 26 | return " ".join([i.toUsage() for i in longOpts]) 27 | 28 | def usage(longOpts): 29 | print(sys.argv[0], getUsageString(longOpts)) 30 | 31 | def getOpt(longOpts): 32 | try: 33 | return getopt.getopt(sys.argv[1:], '', getAssignableOptStrings(longOpts)) 34 | except (getopt.GetoptError, err): 35 | print(str(err), file=sys.stderr) 36 | usage(longOpts) 37 | sys.exit(2) 38 | 39 | def getContent(lines): 40 | return "\n".join(lines) + "\n" 41 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/COPYING: -------------------------------------------------------------------------------- 1 | 2 | /** 3 | TestNG++ is a practical, easy-to-use C/C++ xUnit framework. 4 | Copyright (C) <2009> 5 | 6 | TestNG++ is free software: you can redistribute it and/or modify 7 | it under the terms of the GNU General Public License as published by 8 | the Free Software Foundation, either version 3 of the License, or 9 | (at your option) any later version. 10 | 11 | TestNG++ is distributed in the hope that it will be useful, 12 | but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 | GNU General Public License for more details. 15 | 16 | You should have received a copy of the GNU General Public License 17 | along with TestNG++. If not, see . 18 | **/ 19 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/ExportLite.ps1: -------------------------------------------------------------------------------- 1 | # export mockcpp without boost 2 | 3 | $env:path=$env:path+";D:\Tools\CMD\SubversionClient" 4 | 5 | $dest_dir="D:\tools_release\testngpp_exported" 6 | 7 | function export_subdir($subdir) 8 | { 9 | if (!(test-path $dest_dir\$subdir)) { mkdir $dest_dir\$subdir } 10 | svn export $subdir $dest_dir\$subdir --force 11 | } 12 | 13 | export_subdir 3rdparty\msinttypes 14 | export_subdir 3rdparty\mem_checker 15 | export_subdir 3rdparty\portable 16 | export_subdir include 17 | export_subdir samples 18 | export_subdir scripts 19 | export_subdir src 20 | export_subdir tests 21 | 22 | svn export --depth=files . $dest_dir --force 23 | 24 | 25 | 26 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/ProjectVar.txt: -------------------------------------------------------------------------------- 1 | 2 | SET(PACKAGE_NAME \"testngpp\") 3 | SET(PACKAGE_STRING \"testngpp\") 4 | SET(PACKAGE_BUGREPORT \"arthur.ii.yuan@gmail.com\") 5 | SET(PACKAGE_URL \"http://code.google.com/p/test-ng-pp\") 6 | SET(PACKAGE \"testngpp\") 7 | SET(VERSION \"1.1\") 8 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/change-name.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | all_headers=`find ./src ./include ./samples -name *.h*` 4 | all_srcs=`find ./src -name *.c*` 5 | all_makes=`find . -name CMakeLists.txt` 6 | all_scripts=`find ./scripts -name *.py` 7 | all_files="${all_headers} ${all_srcs} ${all_scripts} ${all_makes}" 8 | 9 | temp_suffix=.temp 10 | for file in ${all_files}; do 11 | sed s/TESTNGPP/TESTNGPPST/g < ${file} > ${file}.${temp_suffix} 12 | sed s/testngpp/testngppst/g < ${file}.${temp_suffix} > ${file} 13 | rm -f ${file}.${temp_suffix} 14 | done 15 | 16 | mv include/testngpp/testngpp.h include/testngpp/testngppst.h 17 | mv include/testngpp/testngpp.hpp include/testngpp/testngppst.hpp 18 | mv include/testngpp include/testngppst 19 | mv scripts/testngppgen scripts/testngppstgen 20 | mv scripts/testngppgen.py scripts/testngppstgen.py 21 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/docs/BuildGuide: -------------------------------------------------------------------------------- 1 | 2 | as a user 3 | ========= 4 | Linux(cygwin included) 5 | ------ 6 | run build_install.sh . (maybe you need to modify some variable in the script first) 7 | 8 | Windows 9 | ------- 10 | One way: 11 | Run build_install.ps1 . (maybe you need to modify some variable in the script first) 12 | The other way: 13 | Run cmake-gui.exe, choose the test-ng-pp root dir as source dir, and any other (nonexist) dir as binaries dir. 14 | Then hit configure button, it will show you some variables that should be set, you can modify them or let it be default, hit configure again. 15 | And then hit the generate button. 16 | At last, open the vcproj with Visual Studio and compile. 17 | 18 | 19 | as a testngpp developer 20 | ======================= 21 | Linux(cygwin included) 22 | ------ 23 | run build.sh . 24 | 25 | Windows 26 | ------- 27 | run the PowerShell script build.ps1 . 28 | maybe you should modify some variables defined in the script first, such as the path of vcbuild/cmake, etc. 29 | 30 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/docs/InstallationMSVC.md: -------------------------------------------------------------------------------- 1 | This manual guides how to configure, build, install and use TestNG++ with Microsoft Visual Studio. 2 | 3 | Please download the [PDF version](http://test-ng-pp.googlecode.com/files/testngpp-msvc.pdf) -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/docs/testngpp-msvc.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sinojelly/mockcpp/7b7eb8b8a7837813d91ee1ae9354f352605fc270/tests/3rdparty/testngpp/docs/testngpp-msvc.pdf -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/docs/testngpp中文指导.docx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sinojelly/mockcpp/7b7eb8b8a7837813d91ee1ae9354f352605fc270/tests/3rdparty/testngpp/docs/testngpp中文指导.docx -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/include/cxxtest/TestSuite.h: -------------------------------------------------------------------------------- 1 | /** 2 | TestNG++ is a practical, easy-to-use C/C++ xUnit framework. 3 | Copyright (C) <2009> 4 | 5 | TestNG++ 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 | (at your option) any later version. 9 | 10 | TestNG++ 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 TestNG++. If not, see . 17 | **/ 18 | 19 | #ifndef __TESTNGPP_TESTSUITE_H__ 20 | #define __TESTNGPP_TESTSUITE_H__ 21 | 22 | #include 23 | 24 | // backward-compatible 25 | #define CxxTest TESTNGPP_NS 26 | #define TestSuite TestFixture 27 | 28 | #endif 29 | 30 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/include/mem_checker/interface_4xunit.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Add by Chen Guodong 3 | * 4 | * This file is included in xUnit. 5 | */ 6 | 7 | /** 8 | * @file interface_4xunit.h 9 | * 10 | * xUnit use the interfaces declared in this file to support memory leak checking. 11 | * 12 | * When using this library in xUnit, it's no need to use __debug_new_counter to find the proper time to check memory leaks. 13 | * But it still can not be used in .c files, because of using new/delete to simulate malloc/free. 14 | * 15 | * Modify nvwa-0.8.2 to support xUnit. 16 | * 17 | * @version 1.0, 2010/9/22 18 | * @author sinojelly 19 | * 20 | */ 21 | 22 | #ifndef __INTERFACE_4XUNIT_H__ 23 | #define __INTERFACE_4XUNIT_H__ 24 | 25 | #include 26 | 27 | 28 | #endif 29 | 30 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/include/testngpp/internal/Taggable.h: -------------------------------------------------------------------------------- 1 | #ifndef __TESTNGPP_TAGGABLE_H 2 | #define __TESTNGPP_TAGGABLE_H 3 | 4 | #include 5 | 6 | #include 7 | 8 | TESTNGPP_NS_START 9 | 10 | //////////////////////////////////////////////////// 11 | struct Taggable 12 | { 13 | virtual 14 | unsigned int numberOfTags() const = 0; 15 | 16 | virtual 17 | const char** getTags() const = 0; 18 | 19 | virtual ~Taggable() {} 20 | }; 21 | 22 | //////////////////////////////////////////////////// 23 | 24 | TESTNGPP_NS_END 25 | 26 | #endif 27 | 28 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/include/testngpp/internal/TagsFilterRule.h: -------------------------------------------------------------------------------- 1 | #ifndef __TESTNGPP_TAGS_FILTER_RULE_H 2 | #define __TESTNGPP_TAGS_FILTER_RULE_H 3 | 4 | #include 5 | 6 | #include 7 | 8 | TESTNGPP_NS_START 9 | 10 | //////////////////////////////////////////////////// 11 | struct TagsFilterRule 12 | { 13 | virtual std::string toString() const = 0; 14 | 15 | virtual ~TagsFilterRule() {} 16 | }; 17 | 18 | //////////////////////////////////////////////////// 19 | 20 | TESTNGPP_NS_END 21 | 22 | #endif 23 | 24 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/include/testngpp/listener/MemLeakCountCollector.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef __TESTNGPP_TEST_CASE_MEM_LEAK_COUNT_COLLECTOR_H 3 | #define __TESTNGPP_TEST_CASE_MEM_LEAK_COUNT_COLLECTOR_H 4 | 5 | #include 6 | 7 | TESTNGPP_NS_START 8 | 9 | struct AssertionFailure; 10 | 11 | struct MemLeakCountCollector : public TestCaseResultCollector 12 | { 13 | MemLeakCountCollector() : memLeakCount(0) {} 14 | 15 | void addCaseFailure(const TestCaseInfoReader*, const AssertionFailure&) { memLeakCount++; } 16 | 17 | void endTestCase 18 | ( const TestCaseInfoReader* 19 | , unsigned int secs 20 | , unsigned int uSecs) {} 21 | 22 | 23 | int getMemLeakCount() { return memLeakCount; } 24 | 25 | private: 26 | int memLeakCount; 27 | }; 28 | 29 | 30 | struct EmptyCollector : public TestCaseResultCollector 31 | { 32 | EmptyCollector() {} 33 | 34 | void endTestCase 35 | ( const TestCaseInfoReader* 36 | , unsigned int secs 37 | , unsigned int uSecs) {} 38 | }; 39 | 40 | 41 | TESTNGPP_NS_END 42 | 43 | #endif 44 | 45 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/include/testngpp/listener/TagsFilterResultCollector.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef __TESTNGPP_TAGS_FILTER_RESULT_COLLECTOR_H 3 | #define __TESTNGPP_TAGS_FILTER_RESULT_COLLECTOR_H 4 | 5 | #include 6 | 7 | #include 8 | 9 | #include 10 | 11 | TESTNGPP_NS_START 12 | 13 | struct TagsFilterRule; 14 | 15 | struct TagsFilterResultCollector 16 | : public TestSuiteResultCollector 17 | { 18 | virtual void startTagsFiltering(const TagsFilterRule*) {} 19 | virtual void endTagsFiltering(const TagsFilterRule*) {} 20 | 21 | virtual ~TagsFilterResultCollector() {} 22 | }; 23 | 24 | TESTNGPP_NS_END 25 | 26 | #endif 27 | 28 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/include/testngpp/listener/TestCaseListener.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef __TESTNGPP_TEST_CASE_LISTENER_H 3 | #define __TESTNGPP_TEST_CASE_LISTENER_H 4 | 5 | #include 6 | 7 | #include 8 | 9 | TESTNGPP_NS_START 10 | 11 | struct TestCaseListener 12 | : public TestCaseResultCollector 13 | { 14 | virtual ~TestCaseListener() {} 15 | }; 16 | 17 | TESTNGPP_NS_END 18 | 19 | #endif 20 | 21 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/include/testngpp/listener/TestCaseResultReporter.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef __TESTNGPP_TEST_CASE_RESULT_REPORTER_H 3 | #define __TESTNGPP_TEST_CASE_RESULT_REPORTER_H 4 | 5 | #include 6 | 7 | TESTNGPP_NS_START 8 | 9 | struct TestCaseInfoReader; 10 | 11 | struct TestCaseResultReporter 12 | { 13 | enum { 14 | TR_SUCCESS = 0, 15 | TR_FAILED = 1, 16 | TR_ERROR = 2, 17 | TR_CRASHED = 3, 18 | TR_SKIPPED = 4, 19 | TR_UNKNOWN = 5 20 | }; 21 | 22 | virtual unsigned int getTestCaseResult(const TestCaseInfoReader*) const = 0; 23 | 24 | virtual ~TestCaseResultReporter() {} 25 | }; 26 | 27 | TESTNGPP_NS_END 28 | 29 | #endif 30 | 31 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/include/testngpp/listener/TestFixtureResultCollector.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef __TESTNGPP_TEST_FIXTURE_RESULT_COLLECTOR_H 3 | #define __TESTNGPP_TEST_FIXTURE_RESULT_COLLECTOR_H 4 | 5 | #include 6 | 7 | #include 8 | 9 | TESTNGPP_NS_START 10 | 11 | struct TestFixtureInfoReader; 12 | 13 | struct TestFixtureResultCollector 14 | : public TestCaseResultCollector 15 | { 16 | virtual void startTestFixture(TestFixtureInfoReader*) = 0; 17 | virtual void endTestFixture(TestFixtureInfoReader*) = 0; 18 | 19 | virtual void addFixtureError(TestFixtureInfoReader*, const std::string&) = 0; 20 | virtual void addFixtureFailure(TestFixtureInfoReader*, const AssertionFailure&) = 0; 21 | 22 | virtual ~TestFixtureResultCollector() {} 23 | }; 24 | 25 | TESTNGPP_NS_END 26 | 27 | #endif 28 | 29 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/include/testngpp/listener/TestListener.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef __TESTNGPP_TEST_LISTENER_H 3 | #define __TESTNGPP_TEST_LISTENER_H 4 | 5 | #include 6 | 7 | #include 8 | 9 | TESTNGPP_NS_START 10 | 11 | struct TestListener 12 | : public TestResultCollector 13 | { 14 | virtual ~TestListener() {} 15 | }; 16 | 17 | TESTNGPP_NS_END 18 | 19 | #endif 20 | 21 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/include/testngpp/listener/TestResultCollector.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef __TESTNGPP_TEST_RESULT_COLLECTOR_H 3 | #define __TESTNGPP_TEST_RESULT_COLLECTOR_H 4 | 5 | #include 6 | 7 | #include 8 | 9 | #include 10 | 11 | TESTNGPP_NS_START 12 | 13 | struct TestResultCollector 14 | : public TagsFilterResultCollector 15 | { 16 | virtual void startTest() {} 17 | virtual void endTest(unsigned int, unsigned int) {} 18 | 19 | virtual void addError(const std::string&) {} 20 | 21 | virtual ~TestResultCollector() {} 22 | }; 23 | 24 | TESTNGPP_NS_END 25 | 26 | #endif 27 | 28 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/include/testngpp/listener/TestResultReporter.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef __TESTNGPP_TEST_RESULT_REPORTER_H 3 | #define __TESTNGPP_TEST_RESULT_REPORTER_H 4 | 5 | #include 6 | 7 | TESTNGPP_NS_START 8 | 9 | struct TestResultReporter 10 | { 11 | virtual unsigned int getNumberOfTestCases() const = 0; 12 | virtual unsigned int getNumberOfSuccessfulTestCases() const = 0; 13 | virtual unsigned int getNumberOfUnsuccessfulTestCases() const = 0; 14 | virtual unsigned int getNumberOfFailedTestCases() const = 0; 15 | virtual unsigned int getNumberOfErrorTestCases() const = 0; 16 | virtual unsigned int getNumberOfCrashedTestCases() const = 0; 17 | virtual unsigned int getNumberOfSkippedTestCases() const = 0; 18 | virtual unsigned int getNumberOfLoadedSuites() const = 0; 19 | virtual unsigned int getNumberOfUnloadableSuites() const = 0; 20 | virtual unsigned int getNumberOfErrorFixtures() const = 0; 21 | 22 | virtual ~TestResultReporter() {} 23 | }; 24 | 25 | TESTNGPP_NS_END 26 | 27 | #endif 28 | 29 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/include/testngpp/listener/TestSuiteListener.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef __TESTNGPP_TEST_SUITE_LISTENER_H 3 | #define __TESTNGPP_TEST_SUITE_LISTENER_H 4 | 5 | #include 6 | 7 | #include 8 | 9 | TESTNGPP_NS_START 10 | 11 | struct TestSuiteListener 12 | : public TestSuiteResultCollector 13 | { 14 | virtual ~TestSuiteListener() {} 15 | }; 16 | 17 | TESTNGPP_NS_END 18 | 19 | #endif 20 | 21 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/include/testngpp/listener/TestSuiteResultCollector.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef __TESTNGPP_TEST_SUITE_RESULT_COLLECTOR_H 3 | #define __TESTNGPP_TEST_SUITE_RESULT_COLLECTOR_H 4 | 5 | #include 6 | 7 | #include 8 | 9 | TESTNGPP_NS_START 10 | 11 | struct TestSuiteInfoReader; 12 | 13 | struct TestSuiteResultCollector 14 | : public TestFixtureResultCollector 15 | { 16 | virtual void startTestSuite(TestSuiteInfoReader*) = 0; 17 | virtual void endTestSuite(TestSuiteInfoReader*) = 0; 18 | virtual void addSuiteError(TestSuiteInfoReader*, const std::string&) = 0; 19 | 20 | virtual ~TestSuiteResultCollector() {} 21 | }; 22 | 23 | TESTNGPP_NS_END 24 | 25 | #endif 26 | 27 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/include/testngpp/runner/AndCompositeTaggableFilter.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef __TESTNGPP_AND_COMPOSITE_TESTCASE_FILTER_H 3 | #define __TESTNGPP_AND_COMPOSITE_TESTCASE_FILTER_H 4 | 5 | #include 6 | #include 7 | 8 | TESTNGPP_NS_START 9 | 10 | struct Taggable; 11 | struct TaggableObjFilter; 12 | struct AndCompositeTaggableFilterImpl; 13 | 14 | //////////////////////////////////////////////////////// 15 | struct AndCompositeTaggableFilter 16 | : public TaggableObjFilter 17 | { 18 | AndCompositeTaggableFilter(); 19 | ~AndCompositeTaggableFilter(); 20 | 21 | void addFilter(const TaggableObjFilter* filter, bool isComposite=true); 22 | bool matches(const Taggable*) const; 23 | 24 | std::string toString() const; 25 | 26 | private: 27 | AndCompositeTaggableFilterImpl * This; 28 | 29 | }; 30 | 31 | //////////////////////////////////////////////////////// 32 | 33 | TESTNGPP_NS_END 34 | 35 | #endif 36 | 37 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/include/testngpp/runner/EOFError.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef __TEST_CPP_EOF_ERROR_H 3 | #define __TEST_CPP_EOF_ERROR_H 4 | 5 | #include 6 | 7 | TESTNGPP_NS_START 8 | 9 | struct EOFError {}; 10 | 11 | TESTNGPP_NS_END 12 | 13 | #endif 14 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/include/testngpp/runner/EmptyTagsFilter.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef __TESTNGPP_EMPTY_TAGS_FILTER_H 3 | #define __TESTNGPP_EMPTY_TAGS_FILTER_H 4 | 5 | #include 6 | #include 7 | 8 | TESTNGPP_NS_START 9 | 10 | struct EmptyTagsFilter 11 | : public TaggableObjFilter 12 | { 13 | bool matches(const Taggable* ) const; 14 | 15 | std::string toString() const; 16 | }; 17 | 18 | TESTNGPP_NS_END 19 | 20 | #endif 21 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/include/testngpp/runner/EnvironmentCleaner.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef __TESTNGPP_ENVIRONMENT_CLEANER_H 3 | #define __TESTNGPP_ENVIRONMENT_CLEANER_H 4 | 5 | #include 6 | 7 | TESTNGPP_NS_START 8 | 9 | struct EnvironmentCleaner 10 | { 11 | virtual void cleanUp() = 0; 12 | 13 | virtual ~EnvironmentCleaner() {} 14 | }; 15 | 16 | TESTNGPP_NS_END 17 | 18 | #endif 19 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/include/testngpp/runner/FixtureTagsFilter.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef __TESTNGPP_FIXTURE_TAGS_FILTER_H 3 | #define __TESTNGPP_FIXTURE_TAGS_FILTER_H 4 | 5 | #include 6 | 7 | TESTNGPP_NS_START 8 | 9 | struct TestCase; 10 | struct TagsFilters; 11 | struct FixtureTagsFilterImpl; 12 | 13 | //////////////////////////////////////////////////////// 14 | struct FixtureTagsFilter 15 | { 16 | FixtureTagsFilter(TagsFilters* filter); 17 | ~FixtureTagsFilter(); 18 | 19 | void startUp(); 20 | 21 | bool shouldRun(const TestCase* testcase) const; 22 | bool shouldReport(const TestCase* testcase) const; 23 | 24 | bool hasSucceeded(const TestCase* testcase) const; 25 | bool hasFailed(const TestCase* testcase) const; 26 | 27 | void testDone(const TestCase* testcase, bool); 28 | 29 | private: 30 | FixtureTagsFilterImpl* This; 31 | 32 | }; 33 | 34 | TESTNGPP_NS_END 35 | 36 | #endif 37 | 38 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/include/testngpp/runner/GeneralTagsFilter.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef __TESTNGPP_GENERAL_TAGS_FILTER_H 3 | #define __TESTNGPP_GENERAL_TAGS_FILTER_H 4 | 5 | #include 6 | #include 7 | 8 | TESTNGPP_NS_START 9 | 10 | struct NameMatcher; 11 | 12 | struct GeneralTagsFilterImpl; 13 | 14 | //////////////////////////////////////////////////////// 15 | struct GeneralTagsFilter 16 | : public TaggableObjFilter 17 | { 18 | GeneralTagsFilter(NameMatcher*); 19 | ~GeneralTagsFilter(); 20 | 21 | bool matches(const Taggable* ) const; 22 | 23 | std::string toString() const; 24 | 25 | private: 26 | GeneralTagsFilterImpl * This; 27 | 28 | }; 29 | 30 | //////////////////////////////////////////////////////// 31 | 32 | TESTNGPP_NS_END 33 | 34 | #endif 35 | 36 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/include/testngpp/runner/GeneralTestFilter.h: -------------------------------------------------------------------------------- 1 | #ifndef __TESTNGPP_GENERAL_TEST_FILTER_H 2 | #define __TESTNGPP_GENERAL_TEST_FILTER_H 3 | 4 | #include 5 | #include 6 | 7 | TESTNGPP_NS_START 8 | 9 | struct NameMatcher; 10 | struct GeneralTestFilterImpl; 11 | 12 | //////////////////////////////////////////////////// 13 | struct GeneralTestFilter 14 | : public TestFilter 15 | { 16 | GeneralTestFilter(NameMatcher* fixtureMatcher, NameMatcher* caseMatcher); 17 | ~GeneralTestFilter(); 18 | 19 | bool isFixtureMatch(const TestFixtureInfoReader* fixture) const; 20 | bool isCaseMatch(const TestCase* testcase) const; 21 | 22 | private: 23 | GeneralTestFilterImpl * This; 24 | }; 25 | 26 | //////////////////////////////////////////////////// 27 | 28 | TESTNGPP_NS_END 29 | 30 | #endif 31 | 32 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/include/testngpp/runner/MatchAllTagsFilter.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef __TESTNGPP_MATCH_ALL_TAGS_FILTER_H 3 | #define __TESTNGPP_MATCH_ALL_TAGS_FILTER_H 4 | 5 | #include 6 | #include 7 | 8 | TESTNGPP_NS_START 9 | 10 | //////////////////////////////////////////////////////// 11 | struct MatchAllTagsFilter 12 | : public TaggableObjFilter 13 | { 14 | bool matches(const Taggable* ) const; 15 | 16 | std::string toString() const; 17 | }; 18 | 19 | //////////////////////////////////////////////////////// 20 | 21 | TESTNGPP_NS_END 22 | 23 | #endif 24 | 25 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/include/testngpp/runner/NameMatcher.h: -------------------------------------------------------------------------------- 1 | #ifndef __TESTNGPP_NAME_MATCHER_H 2 | #define __TESTNGPP_NAME_MATCHER_H 3 | 4 | #include 5 | 6 | #include 7 | 8 | TESTNGPP_NS_START 9 | 10 | //////////////////////////////////////////////////// 11 | struct NameMatcher 12 | { 13 | virtual bool matches(const std::string& name) const = 0; 14 | 15 | virtual std::string getPattern() const = 0; 16 | 17 | virtual ~NameMatcher() {} 18 | }; 19 | 20 | //////////////////////////////////////////////////// 21 | 22 | TESTNGPP_NS_END 23 | 24 | #endif 25 | 26 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/include/testngpp/runner/NotCompositeTaggableFilter.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef __TESTNGPP_NOT_COMPOSITE_TAGGABLE_H 3 | #define __TESTNGPP_NOT_COMPOSITE_TAGGABLE_H 4 | 5 | #include 6 | #include 7 | 8 | TESTNGPP_NS_START 9 | 10 | struct NotCompositeTaggableFilterImpl; 11 | 12 | //////////////////////////////////////////////////////// 13 | struct NotCompositeTaggableFilter 14 | : public TaggableObjFilter 15 | { 16 | NotCompositeTaggableFilter(const TaggableObjFilter*, bool composite=true); 17 | ~NotCompositeTaggableFilter(); 18 | 19 | bool matches(const Taggable*) const; 20 | 21 | std::string toString() const; 22 | 23 | private: 24 | NotCompositeTaggableFilterImpl * This; 25 | 26 | }; 27 | 28 | //////////////////////////////////////////////////////// 29 | 30 | TESTNGPP_NS_END 31 | 32 | #endif 33 | 34 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/include/testngpp/runner/OrCompositeTaggableFilter.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef __TESTNGPP_OR_COMPOSITE_TAGGABLE_FILTER_H 3 | #define __TESTNGPP_OR_COMPOSITE_TAGGABLE_FILTER_H 4 | 5 | #include 6 | 7 | #include 8 | #include 9 | 10 | TESTNGPP_NS_START 11 | 12 | struct Taggable; 13 | struct OrCompositeTaggableFilterImpl; 14 | 15 | //////////////////////////////////////////////////////// 16 | struct OrCompositeTaggableFilter 17 | : public TaggableObjFilter 18 | { 19 | OrCompositeTaggableFilter(); 20 | ~OrCompositeTaggableFilter(); 21 | 22 | void addFilter(const TaggableObjFilter* filter, bool isComposite=true); 23 | 24 | bool isMalform() const; 25 | bool isEmpty() const; 26 | 27 | std::pair fetch(); 28 | 29 | bool matches(const Taggable* ) const; 30 | 31 | std::string toString() const; 32 | 33 | private: 34 | OrCompositeTaggableFilterImpl * This; 35 | 36 | }; 37 | 38 | //////////////////////////////////////////////////////// 39 | 40 | TESTNGPP_NS_END 41 | 42 | #endif 43 | 44 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/include/testngpp/runner/OrCompositeTestFilter.h: -------------------------------------------------------------------------------- 1 | #ifndef __TESTNGPP_OR_COMPOSITE_TEST_FILTER_H 2 | #define __TESTNGPP_OR_COMPOSITE_TEST_FILTER_H 3 | 4 | #include 5 | #include 6 | 7 | TESTNGPP_NS_START 8 | 9 | struct OrCompositeTestFilterImpl; 10 | 11 | //////////////////////////////////////////////////// 12 | struct OrCompositeTestFilter 13 | : public TestFilter 14 | { 15 | OrCompositeTestFilter(); 16 | ~OrCompositeTestFilter(); 17 | 18 | void addFilter(const TestFilter* filter, bool isComposite = false); 19 | 20 | bool isFixtureMatch(const TestFixtureInfoReader* fixture) const; 21 | bool isCaseMatch(const TestCase* testcase) const; 22 | 23 | private: 24 | OrCompositeTestFilterImpl * This; 25 | }; 26 | 27 | //////////////////////////////////////////////////// 28 | 29 | TESTNGPP_NS_END 30 | 31 | #endif 32 | 33 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/include/testngpp/runner/PosixFNMatcher.h: -------------------------------------------------------------------------------- 1 | #ifndef __TESTNGPP_POSIX_FN_MATCHER_H 2 | #define __TESTNGPP_POSIX_FN_MATCHER_H 3 | 4 | #include 5 | 6 | #include 7 | 8 | TESTNGPP_NS_START 9 | 10 | //////////////////////////////////////////////////// 11 | struct PosixFNMatcher 12 | : public NameMatcher 13 | { 14 | PosixFNMatcher(const std::string& namePattern); 15 | 16 | bool matches(const std::string& name) const; 17 | 18 | std::string getPattern() const; 19 | private: 20 | 21 | std::string pattern; 22 | }; 23 | 24 | //////////////////////////////////////////////////// 25 | 26 | TESTNGPP_NS_END 27 | 28 | #endif 29 | 30 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/include/testngpp/runner/Sandbox.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef __TESTNGPP_SANDBOX_H 3 | #define __TESTNGPP_SANDBOX_H 4 | 5 | #include 6 | #include 7 | 8 | TESTNGPP_NS_START 9 | 10 | struct EnvironmentCleaner; 11 | struct SandboxImpl; 12 | struct SandboxHandler; 13 | 14 | struct Sandbox 15 | { 16 | SandboxId getSandboxId() const; 17 | ChannelId getChannelId() const; 18 | 19 | bool isDead() const; 20 | void die(); 21 | 22 | void cleanup(); 23 | 24 | ~Sandbox(); 25 | 26 | static Sandbox* 27 | createInstance(EnvironmentCleaner* cleaner, SandboxHandler* childHandler); 28 | 29 | private: 30 | Sandbox(); 31 | 32 | private: 33 | SandboxImpl* This; 34 | }; 35 | 36 | TESTNGPP_NS_END 37 | 38 | #endif 39 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/include/testngpp/runner/SandboxHandler.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef __TESTNGPP_SANDBOX_HANDLER_H 3 | #define __TESTNGPP_SANDBOX_HANDLER_H 4 | 5 | #include 6 | #include 7 | 8 | TESTNGPP_NS_START 9 | 10 | struct SandboxHandler 11 | { 12 | virtual void handle(ChannelId channelId) = 0; 13 | 14 | virtual ~SandboxHandler() {} 15 | }; 16 | 17 | TESTNGPP_NS_END 18 | 19 | #endif 20 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/include/testngpp/runner/SandboxProcessor.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef __TESTNGPP_SANDBOX_PROCESSOR_H 3 | #define __TESTNGPP_SANDBOX_PROCESSOR_H 4 | 5 | #include 6 | #include 7 | 8 | TESTNGPP_NS_START 9 | 10 | struct EnvironmentCleaner; 11 | struct SandboxHandler; 12 | 13 | struct SandboxProcessor 14 | { 15 | static void process(ChannelId rChannel, ChannelId wChannel, 16 | EnvironmentCleaner* cleaner, SandboxHandler* handler); 17 | }; 18 | 19 | TESTNGPP_NS_END 20 | 21 | #endif 22 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/include/testngpp/runner/SandboxTypedef.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef __SANDBOX_TYPEDEF_H 3 | #define __SANDBOX_TYPEDEF_H 4 | 5 | #if !defined(_MSC_VER) 6 | #include 7 | #endif 8 | #endif 9 | 10 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/include/testngpp/runner/SandboxTypedefUnix.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef __SANDBOX_TYPEDEF_UNIX_H 3 | #define __SANDBOX_TYPEDEF_UNIX_H 4 | 5 | #include 6 | 7 | #include 8 | 9 | TESTNGPP_NS_START 10 | 11 | typedef pid_t SandboxId; 12 | typedef int ChannelId; 13 | 14 | TESTNGPP_NS_END 15 | 16 | #endif 17 | 18 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/include/testngpp/runner/SimpleTestCaseRunner.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef __TESTNGPP_SIMPLE_TEST_CASE_RUNNER_H 3 | #define __TESTNGPP_SIMPLE_TEST_CASE_RUNNER_H 4 | 5 | #include 6 | #include 7 | 8 | TESTNGPP_NS_START 9 | 10 | struct SimpleTestCaseRunner 11 | : public TestCaseRunner 12 | { 13 | bool run(TestCase*, TestCaseResultCollector*, bool reportSuccess=true); 14 | }; 15 | 16 | TESTNGPP_NS_END 17 | 18 | #endif 19 | 20 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/include/testngpp/runner/SimpleTestHierarchyRunner.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef __TESTNGPP_SIMPLE_TEST_HIERARCHY_RUNNER_H 3 | #define __TESTNGPP_SIMPLE_TEST_HIERARCHY_RUNNER_H 4 | 5 | #include 6 | 7 | TESTNGPP_NS_START 8 | 9 | /////////////////////////////////////////////////////// 10 | 11 | struct TestHierarchyHandler; 12 | struct TestFixtureResultCollector; 13 | struct TestCaseRunner; 14 | 15 | struct SimpleTestHierarchyRunnerImpl; 16 | 17 | struct SimpleTestHierarchyRunner : public TestHierarchyRunner 18 | { 19 | SimpleTestHierarchyRunner(TestCaseRunner* runner); 20 | ~SimpleTestHierarchyRunner(); 21 | 22 | void run( TestHierarchyHandler* 23 | , TestFixtureResultCollector*); 24 | 25 | private: 26 | SimpleTestHierarchyRunnerImpl * This; 27 | }; 28 | 29 | /////////////////////////////////////////////////////// 30 | 31 | TESTNGPP_NS_END 32 | 33 | #endif 34 | 35 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/include/testngpp/runner/SimpleTestResultManager.h: -------------------------------------------------------------------------------- 1 | #ifndef __TESTNGPP_SIMPLE_TEST_RESULT_MANAGER_H__ 2 | #define __TESTNGPP_SIMPLE_TEST_RESULT_MANAGER_H__ 3 | 4 | #include 5 | 6 | #include 7 | 8 | TESTNGPP_NS_START 9 | 10 | struct SimpleTestResultManagerImpl; 11 | 12 | struct SimpleTestResultManager : public TestResultManager 13 | { 14 | void load( const StringList& searchingPaths 15 | , const StringList& clOfListners); 16 | 17 | bool hasFailure() const; 18 | 19 | void startTest(); 20 | void endTest(unsigned int, unsigned int); 21 | 22 | TestResultCollector* getResultCollector() const; 23 | 24 | SimpleTestResultManager(TestListenerLoaderFactory* ); 25 | ~SimpleTestResultManager(); 26 | 27 | private: 28 | SimpleTestResultManagerImpl* This; 29 | 30 | }; 31 | 32 | TESTNGPP_NS_END 33 | 34 | #endif 35 | 36 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/include/testngpp/runner/TaggableObjFilter.h: -------------------------------------------------------------------------------- 1 | #ifndef __TESTNGPP_TAGGABLE_OBJ_FILTER_H 2 | #define __TESTNGPP_TAGGABLE_OBJ_FILTER_H 3 | 4 | #include 5 | 6 | #include 7 | #include 8 | 9 | TESTNGPP_NS_START 10 | 11 | struct Taggable; 12 | 13 | //////////////////////////////////////////////////// 14 | struct TaggableObjFilter : public TagsFilterRule 15 | { 16 | virtual bool matches(const Taggable*) const = 0; 17 | 18 | virtual ~TaggableObjFilter() {} 19 | }; 20 | 21 | //////////////////////////////////////////////////// 22 | 23 | TESTNGPP_NS_END 24 | 25 | #endif 26 | 27 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/include/testngpp/runner/TagsFilters.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef __TESTNGPP_TAGS_FILTERS_H 3 | #define __TESTNGPP_TAGS_FILTERS_H 4 | 5 | #include 6 | 7 | TESTNGPP_NS_START 8 | 9 | struct Taggable; 10 | struct TaggableObjFilter; 11 | struct TagsFiltersImpl; 12 | 13 | //////////////////////////////////////////////////////// 14 | struct TagsFilters 15 | { 16 | TagsFilters(); 17 | ~TagsFilters(); 18 | 19 | void addNextFilter(const TaggableObjFilter*); 20 | 21 | const TaggableObjFilter* startOnNext(); 22 | 23 | bool shouldBeFilteredThisTime(const Taggable* ) const; 24 | bool shouldBeFiltered(const Taggable* ) const; 25 | bool isPreFiltered(const Taggable* ) const; 26 | bool hasBeenFiltered(const Taggable* ) const; 27 | 28 | void dump() const; 29 | private: 30 | TagsFiltersImpl * This; 31 | }; 32 | 33 | //////////////////////////////////////////////////////// 34 | 35 | TESTNGPP_NS_END 36 | 37 | #endif 38 | 39 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/include/testngpp/runner/TagsParser.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef __TESTNGPP_TAGS_PARSER_H 3 | #define __TESTNGPP_TAGS_PARSER_H 4 | 5 | #include 6 | 7 | TESTNGPP_NS_START 8 | 9 | struct TagsFilters; 10 | 11 | struct TagsParser 12 | { 13 | static TagsFilters* parse(const std::string& tagsSpec); 14 | }; 15 | 16 | TESTNGPP_NS_END 17 | 18 | #endif 19 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/include/testngpp/runner/TestCaseContainer.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef __TESTNGPP_TESTCASE_CONTAINER_H 3 | #define __TESTNGPP_TESTCASE_CONTAINER_H 4 | 5 | #include 6 | 7 | TESTNGPP_NS_START 8 | 9 | struct TestCase; 10 | 11 | struct TestCaseContainer 12 | { 13 | virtual void 14 | addTestCase( const TestCase* testcase 15 | , bool useSpecified) = 0; 16 | 17 | virtual ~TestCaseContainer() {} 18 | }; 19 | 20 | TESTNGPP_NS_END 21 | 22 | #endif 23 | 24 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/include/testngpp/runner/TestCaseFilter.h: -------------------------------------------------------------------------------- 1 | #ifndef __TESTNGPP_TEST_CASE_FILTER_H 2 | #define __TESTNGPP_TEST_CASE_FILTER_H 3 | 4 | #include 5 | 6 | TESTNGPP_NS_START 7 | 8 | struct TestCase; 9 | 10 | //////////////////////////////////////////////////// 11 | struct TestCaseFilter 12 | { 13 | virtual bool isCaseMatch(const TestCase* testcase) const = 0; 14 | 15 | virtual ~TestCaseFilter() {} 16 | }; 17 | 18 | //////////////////////////////////////////////////// 19 | 20 | TESTNGPP_NS_END 21 | 22 | #endif 23 | 24 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/include/testngpp/runner/TestCaseHierarchy.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef __TESTNGPP_TESTCASE_HEIRARCHY_H 3 | #define __TESTNGPP_TESTCASE_HEIRARCHY_H 4 | 5 | #include 6 | 7 | TESTNGPP_NS_START 8 | 9 | struct TestCaseHierarchyImpl; 10 | struct TestFixtureDesc; 11 | struct TestCaseFilter; 12 | struct TestCaseContainer; 13 | 14 | struct TestCaseHierarchy 15 | { 16 | public: 17 | 18 | TestCaseHierarchy 19 | ( const TestFixtureDesc* fixture 20 | , const TestCaseFilter* filter); 21 | 22 | ~TestCaseHierarchy(); 23 | 24 | void 25 | getDirectSuccessors 26 | ( const TestCase* testcase 27 | , TestCaseContainer* container); 28 | 29 | void 30 | getSuccessors 31 | ( const TestCase* testcase 32 | , TestCaseContainer* container); 33 | private: 34 | TestCaseHierarchyImpl *This; 35 | }; 36 | 37 | TESTNGPP_NS_END 38 | 39 | #endif 40 | 41 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/include/testngpp/runner/TestCaseResultDispatcher.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef __TESTNGPP_TEST_CASE_RESULT_DISPATCHER_H 3 | #define __TESTNGPP_TEST_CASE_RESULT_DISPATCHER_H 4 | 5 | #include 6 | 7 | TESTNGPP_NS_START 8 | 9 | struct TestCaseListener; 10 | 11 | struct TestCaseResultDispatcher 12 | { 13 | virtual void registerTestCaseListener(TestCaseListener* listener) = 0; 14 | virtual TestCaseListener* unregisterTestCaseListener(TestCaseListener* listener) = 0; 15 | 16 | virtual ~TestCaseResultDispatcher() {} 17 | }; 18 | 19 | TESTNGPP_NS_END 20 | 21 | #endif 22 | 23 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/include/testngpp/runner/TestCaseRunner.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef __TESTNGPP_TEST_CASE_RUNNER_H 3 | #define __TESTNGPP_TEST_CASE_RUNNER_H 4 | 5 | #include 6 | 7 | TESTNGPP_NS_START 8 | 9 | struct TestFixtureDesc; 10 | struct TestCase; 11 | struct TestCaseResultCollector; 12 | 13 | struct TestCaseRunner 14 | { 15 | virtual bool run(TestCase*, TestCaseResultCollector*, bool reportSuccess=true) = 0; 16 | 17 | virtual ~TestCaseRunner() {} 18 | }; 19 | 20 | TESTNGPP_NS_END 21 | 22 | #endif 23 | 24 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/include/testngpp/runner/TestCaseRunnerFactory.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef __TESTNGPP_TESTCASE_RUNNER_FACTORY_H 3 | #define __TESTNGPP_TESTCASE_RUNNER_FACTORY_H 4 | 5 | #include 6 | 7 | TESTNGPP_NS_START 8 | 9 | struct TestCaseRunner; 10 | 11 | struct TestCaseRunnerFactory 12 | { 13 | static TestCaseRunner* createInstance(); 14 | static void releaseInstance(TestCaseRunner* runner); 15 | }; 16 | 17 | TESTNGPP_NS_END 18 | 19 | #endif 20 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/include/testngpp/runner/TestCaseSandboxHandler.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef __TESTNGPP_TESTCASE_SANDBOX_HANDLER_H 3 | #define __TESTNGPP_TESTCASE_SANDBOX_HANDLER_H 4 | 5 | #include 6 | 7 | #include 8 | 9 | TESTNGPP_NS_START 10 | 11 | struct TestCase; 12 | struct TestCaseRunner; 13 | struct TestCaseSandboxHandlerImpl; 14 | 15 | struct TestCaseSandboxHandler : public SandboxHandler 16 | { 17 | TestCaseSandboxHandler 18 | ( const TestCase* testcase 19 | , TestCaseRunner* runner); 20 | 21 | ~TestCaseSandboxHandler(); 22 | 23 | void handle(ChannelId channelId); 24 | 25 | private: 26 | 27 | TestCaseSandboxHandlerImpl* This; 28 | }; 29 | 30 | TESTNGPP_NS_END 31 | 32 | #endif 33 | 34 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/include/testngpp/runner/TestCaseSandboxResultDecoder.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef __TESTNGPP_TESTCASE_SANDBOX_RESULT_DECODER_H 3 | #define __TESTNGPP_TESTCASE_SANDBOX_RESULT_DECODER_H 4 | 5 | #include 6 | 7 | TESTNGPP_NS_START 8 | 9 | struct TestCaseInfoReader; 10 | struct TestCaseResultCollector; 11 | struct ReadableChannel; 12 | struct TestCaseSandboxResultDecoderImpl; 13 | 14 | struct TestCaseSandboxResultDecoder 15 | { 16 | TestCaseSandboxResultDecoder 17 | ( ReadableChannel* 18 | , const TestCaseInfoReader* 19 | , TestCaseResultCollector* 20 | , bool); 21 | 22 | ~TestCaseSandboxResultDecoder(); 23 | 24 | bool hasError() const; 25 | 26 | bool decode(); 27 | 28 | void flush(bool crashed); 29 | 30 | private: 31 | 32 | TestCaseSandboxResultDecoderImpl* This; 33 | 34 | }; 35 | 36 | TESTNGPP_NS_END 37 | 38 | #endif 39 | 40 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/include/testngpp/runner/TestFilter.h: -------------------------------------------------------------------------------- 1 | #ifndef __TESTNGPP_TEST_FILTER_H 2 | #define __TESTNGPP_TEST_FILTER_H 3 | 4 | #include 5 | #include 6 | 7 | TESTNGPP_NS_START 8 | 9 | struct TestFixtureInfoReader; 10 | 11 | //////////////////////////////////////////////////// 12 | struct TestFilter : public TestCaseFilter 13 | { 14 | virtual bool isFixtureMatch(const TestFixtureInfoReader* fixture) const = 0; 15 | 16 | virtual ~TestFilter() {} 17 | }; 18 | 19 | //////////////////////////////////////////////////// 20 | 21 | TESTNGPP_NS_END 22 | 23 | #endif 24 | 25 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/include/testngpp/runner/TestFilterFactory.h: -------------------------------------------------------------------------------- 1 | #ifndef __TESTNGPP_TEST_FILTER_FACTORY_H 2 | #define __TESTNGPP_TEST_FILTER_FACTORY_H 3 | 4 | #include 5 | #include 6 | 7 | TESTNGPP_NS_START 8 | 9 | struct TestFilter; 10 | 11 | //////////////////////////////////////////////////// 12 | struct TestFilterFactory 13 | { 14 | static const TestFilter* getFilter(const StringList& filterOptions); 15 | static void returnFilter(const TestFilter* filter); 16 | }; 17 | 18 | //////////////////////////////////////////////////// 19 | 20 | TESTNGPP_NS_END 21 | 22 | #endif 23 | 24 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/include/testngpp/runner/TestFixtureContext.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef __TESTNGPP_TEST_FIXTURE_CONTEXT_H 3 | #define __TESTNGPP_TEST_FIXTURE_CONTEXT_H 4 | 5 | #include 6 | 7 | TESTNGPP_NS_START 8 | 9 | struct TestFixtureDesc; 10 | struct TagsFilters; 11 | struct FixtureTagsFilter; 12 | struct TestFixtureContextImpl; 13 | 14 | ///////////////////////////////////////////////////////////////// 15 | struct TestFixtureContext 16 | { 17 | TestFixtureContext(TestFixtureDesc* desc, TagsFilters* filters); 18 | ~TestFixtureContext(); 19 | 20 | TestFixtureDesc* getFixture() const; 21 | 22 | FixtureTagsFilter* getTagsFilter() const; 23 | private: 24 | 25 | TestFixtureContextImpl * This; 26 | 27 | }; 28 | 29 | ///////////////////////////////////////////////////////////////// 30 | 31 | TESTNGPP_NS_END 32 | 33 | #endif 34 | 35 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/include/testngpp/runner/TestFixtureRunner.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef __TESTNGPP_TEST_FIXTURE_RUNNER_H__ 3 | #define __TESTNGPP_TEST_FIXTURE_RUNNER_H__ 4 | 5 | #include 6 | 7 | #include 8 | 9 | TESTNGPP_NS_START 10 | 11 | struct TestFixtureContext; 12 | struct TestFixtureResultCollector; 13 | struct TestHierarchyRunner; 14 | struct TestCaseFilter; 15 | struct TestFixtureRunnerImpl; 16 | 17 | struct TestFixtureRunner 18 | { 19 | TestFixtureRunner(TestHierarchyRunner* runner); 20 | ~TestFixtureRunner(); 21 | 22 | void run ( TestFixtureContext * 23 | , TestFixtureResultCollector* 24 | , const TestCaseFilter* 25 | , const std::string&); 26 | 27 | private: 28 | TestFixtureRunnerImpl* This; 29 | }; 30 | 31 | TESTNGPP_NS_END 32 | 33 | #endif 34 | 35 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/include/testngpp/runner/TestFixtureRunnerFactory.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef __TESTNGPP_TEST_FIXTURE_RUNNER_FACTORY_H 3 | #define __TESTNGPP_TEST_FIXTURE_RUNNER_FACTORY_H 4 | 5 | #include 6 | 7 | TESTNGPP_NS_START 8 | 9 | struct TestFixtureRunner; 10 | 11 | struct TestFixtureRunnerFactory 12 | { 13 | static 14 | TestFixtureRunner* createInstance(bool useSandbox 15 | , unsigned int maxConcurrent); 16 | 17 | static 18 | void destroyInstance(TestFixtureRunner* instance); 19 | 20 | private: 21 | 22 | TestFixtureRunnerFactory(); 23 | }; 24 | 25 | TESTNGPP_NS_END 26 | 27 | #endif 28 | 29 | 30 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/include/testngpp/runner/TestHierarchyRunner.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef __TESTNGPP_TEST_HIERARCHY_RUNNER_H 3 | #define __TESTNGPP_TEST_HIERARCHY_RUNNER_H 4 | 5 | #include 6 | 7 | TESTNGPP_NS_START 8 | 9 | struct TestHierarchyHandler; 10 | struct TestFixtureResultCollector; 11 | 12 | struct TestHierarchyRunner 13 | { 14 | virtual void run 15 | ( TestHierarchyHandler* 16 | , TestFixtureResultCollector*) = 0; 17 | 18 | virtual ~TestHierarchyRunner() {} 19 | }; 20 | 21 | TESTNGPP_NS_END 22 | 23 | #endif 24 | 25 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/include/testngpp/runner/TestHierarchySandboxRunner.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef __TESTNGPP_TEST_HIERARCHY_SANDBOX_RUNNER_H 3 | #define __TESTNGPP_TEST_HIERARCHY_SANDBOX_RUNNER_H 4 | 5 | #include 6 | #include 7 | 8 | TESTNGPP_NS_START 9 | 10 | struct TestCaseRunner; 11 | struct TestHierarchySandboxRunnerImpl; 12 | 13 | struct TestHierarchySandboxRunner 14 | : public TestHierarchyRunner 15 | { 16 | TestHierarchySandboxRunner 17 | ( unsigned int maxCurrentProcess 18 | , TestCaseRunner*); 19 | 20 | ~TestHierarchySandboxRunner(); 21 | 22 | void run ( TestHierarchyHandler* 23 | , TestFixtureResultCollector*); 24 | 25 | private: 26 | TestHierarchySandboxRunnerImpl* This; 27 | }; 28 | 29 | TESTNGPP_NS_END 30 | 31 | #endif 32 | 33 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/include/testngpp/runner/TestResultDispatcher.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef __TESTNGPP_TEST_RESULT_DISPATCHER_H 3 | #define __TESTNGPP_TEST_RESULT_DISPATCHER_H 4 | 5 | #include 6 | 7 | TESTNGPP_NS_START 8 | 9 | struct TestListener; 10 | 11 | struct TestResultDispatcher 12 | { 13 | virtual void registerListener(TestListener* listener) = 0; 14 | virtual ~TestResultDispatcher() {} 15 | }; 16 | 17 | TESTNGPP_NS_END 18 | 19 | #endif 20 | 21 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/include/testngpp/runner/TestResultManager.h: -------------------------------------------------------------------------------- 1 | #ifndef __TESTNGPP_TEST_RESULT_MANAGER_H__ 2 | #define __TESTNGPP_TEST_RESULT_MANAGER_H__ 3 | 4 | #include 5 | #include 6 | 7 | TESTNGPP_NS_START 8 | 9 | struct TestResultCollector; 10 | 11 | struct TestResultManager 12 | { 13 | virtual void load 14 | ( const StringList& searchingPaths 15 | , const StringList& clOfListners) = 0; 16 | 17 | virtual bool hasFailure() const = 0; 18 | 19 | virtual void startTest() = 0; 20 | virtual void endTest(unsigned int, unsigned int) = 0; 21 | 22 | virtual TestResultCollector* getResultCollector() const = 0; 23 | 24 | virtual ~TestResultManager() {} 25 | }; 26 | 27 | TESTNGPP_NS_END 28 | 29 | #endif 30 | 31 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/include/testngpp/runner/TestRunner.h: -------------------------------------------------------------------------------- 1 | #ifndef __TESTNGPP_TEST_RUNNER_H 2 | #define __TESTNGPP_TEST_RUNNER_H 3 | 4 | #include 5 | 6 | #include 7 | 8 | #include 9 | 10 | TESTNGPP_NS_START 11 | 12 | struct TestRunnerImpl; 13 | 14 | struct TestRunner 15 | { 16 | public: 17 | TestRunner(); 18 | ~TestRunner(); 19 | 20 | int runTests( bool useSandboxRunner 21 | , unsigned int maxConcurrent 22 | , const StringList& suitePaths 23 | , const StringList& listenerNames 24 | , const StringList& searchingPathsOfListeners 25 | , const StringList& fixtures 26 | , const std::string& tagsFilterOption); 27 | 28 | private: 29 | TestRunnerImpl * This; 30 | 31 | }; 32 | 33 | TESTNGPP_NS_END 34 | 35 | #endif 36 | 37 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/include/testngpp/runner/TestRunnerContext.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef __TESTNGPP_TEST_RUNNER_CONTEXT_H 3 | #define __TESTNGPP_TEST_RUNNER_CONTEXT_H 4 | 5 | #include 6 | #include 7 | 8 | TESTNGPP_NS_START 9 | 10 | struct TestSuiteContext; 11 | struct TestFilter; 12 | struct TagsFilters; 13 | struct TestResultCollector; 14 | 15 | struct TestRunnerContextImpl; 16 | 17 | ///////////////////////////////////////////////////////////////// 18 | struct TestRunnerContext 19 | { 20 | TestRunnerContext 21 | ( const StringList& nameOfSuites 22 | , TestResultCollector* collector 23 | , TagsFilters* tagsFilter 24 | , const TestFilter* filter); 25 | 26 | ~TestRunnerContext(); 27 | 28 | TestSuiteContext* getSuite(unsigned int index) const; 29 | unsigned int numberOfSuites() const; 30 | 31 | private: 32 | 33 | TestRunnerContextImpl * This; 34 | 35 | }; 36 | 37 | ///////////////////////////////////////////////////////////////// 38 | 39 | TESTNGPP_NS_END 40 | 41 | #endif 42 | 43 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/include/testngpp/runner/TestSuiteDescEntryNameGetter.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef __TESTNGPP_TEST_SUITE_DESC_ENTRY_NAME_GETTER_H 3 | #define __TESTNGPP_TEST_SUITE_DESC_ENTRY_NAME_GETTER_H 4 | 5 | #include 6 | 7 | #include 8 | 9 | TESTNGPP_NS_START 10 | 11 | struct TestSuiteDescEntryNameGetter 12 | { 13 | virtual std::string getDescEntryName() const = 0; 14 | virtual ~TestSuiteDescEntryNameGetter() {} 15 | }; 16 | 17 | TESTNGPP_NS_END 18 | 19 | #endif 20 | 21 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/include/testngpp/runner/TestSuiteResultDispatcher.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef __TESTNGPP_TEST_SUITE_RESULT_DISPATCHER_H 3 | #define __TESTNGPP_TEST_SUITE_RESULT_DISPATCHER_H 4 | 5 | #include 6 | 7 | TESTNGPP_NS_START 8 | 9 | struct TestSuiteListener; 10 | 11 | struct TestSuiteResultDispatcher 12 | { 13 | virtual void registerTestSuiteListener(TestSuiteListener* listener) = 0; 14 | virtual TestSuiteListener* unregisterTestSuiteListener(TestSuiteListener* listener) = 0; 15 | 16 | virtual ~TestSuiteResultDispatcher() {} 17 | }; 18 | 19 | TESTNGPP_NS_END 20 | 21 | #endif 22 | 23 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/include/testngpp/runner/TestSuiteRunner.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef __TESTNGPP_TEST_SUITE_RUNNER_H 3 | #define __TESTNGPP_TEST_SUITE_RUNNER_H 4 | 5 | #include 6 | 7 | #include 8 | 9 | TESTNGPP_NS_START 10 | 11 | struct TestSuiteContext; 12 | struct TestCaseFilter; 13 | struct TestFixtureRunner; 14 | struct TestResultCollector; 15 | 16 | struct TestSuiteRunnerImpl; 17 | 18 | struct TestSuiteRunner 19 | { 20 | TestSuiteRunner( TestFixtureRunner* 21 | , TestResultCollector* ); 22 | ~TestSuiteRunner(); 23 | 24 | void run(TestSuiteContext* suite 25 | , const TestCaseFilter* filter); 26 | private: 27 | TestSuiteRunnerImpl* This; 28 | 29 | }; 30 | 31 | TESTNGPP_NS_END 32 | 33 | #endif 34 | 35 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/include/testngpp/runner/WildcardTestFilter.h: -------------------------------------------------------------------------------- 1 | #ifndef __TESTNGPP_WILDCARD_TEST_FILTER_H 2 | #define __TESTNGPP_WILDCARD_TEST_FILTER_H 3 | 4 | #include 5 | #include 6 | 7 | TESTNGPP_NS_START 8 | 9 | 10 | //////////////////////////////////////////////////// 11 | struct WildcardTestFilter 12 | : public TestFilter 13 | { 14 | bool isFixtureMatch(const TestFixtureInfoReader* fixture) const; 15 | bool isCaseMatch(const TestCase* testcase) const; 16 | }; 17 | 18 | //////////////////////////////////////////////////// 19 | 20 | TESTNGPP_NS_END 21 | 22 | #endif 23 | 24 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/include/testngpp/runner/loaders/DLModuleLoader.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef __TESTNGPP_DL_MODULE_LOADER_H 3 | #define __TESTNGPP_DL_MODULE_LOADER_H 4 | 5 | #include 6 | #include 7 | 8 | TESTNGPP_NS_START 9 | 10 | struct DLModuleLoaderImpl; 11 | 12 | struct DLModuleLoader : public ModuleLoader 13 | { 14 | DLModuleLoader(); 15 | ~DLModuleLoader(); 16 | 17 | void load( const StringList& searchingPaths \ 18 | , const std::string& modulePath); 19 | void unload(); 20 | 21 | void* findSymbol(const std::string& symbol); 22 | 23 | private: 24 | 25 | DLModuleLoaderImpl* This; 26 | }; 27 | 28 | TESTNGPP_NS_END 29 | 30 | #endif 31 | 32 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/include/testngpp/runner/loaders/LTModuleLoader.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef __TESTNGPP_LT_MODULE_LOADER_H 3 | #define __TESTNGPP_LT_MODULE_LOADER_H 4 | 5 | #include 6 | #include 7 | 8 | TESTNGPP_NS_START 9 | 10 | struct LTModuleLoaderImpl; 11 | 12 | struct LTModuleLoader : public ModuleLoader 13 | { 14 | LTModuleLoader(); 15 | 16 | ~LTModuleLoader(); 17 | 18 | void load( const StringList& searchingPaths \ 19 | , const std::string& modulePath); 20 | void unload(); 21 | 22 | void* findSymbol(const std::string& symbol); 23 | 24 | private: 25 | 26 | LTModuleLoaderImpl* This; 27 | }; 28 | 29 | TESTNGPP_NS_END 30 | 31 | #endif 32 | 33 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/include/testngpp/runner/loaders/ModuleLoader.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef __TESTNGPP_MODULE_LOADER_H 3 | #define __TESTNGPP_MODULE_LOADER_H 4 | 5 | #include 6 | 7 | #include 8 | 9 | TESTNGPP_NS_START 10 | 11 | struct ModuleLoader 12 | { 13 | virtual void load( const StringList& searchingPaths 14 | , const std::string& modulePath) = 0; 15 | 16 | virtual void unload() = 0; 17 | 18 | virtual void* findSymbol(const std::string& symbol) = 0; 19 | 20 | virtual ~ModuleLoader() {} 21 | }; 22 | 23 | TESTNGPP_NS_END 24 | 25 | #endif 26 | 27 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/include/testngpp/runner/loaders/ModuleLoaderFactory.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef __TESTNGPP_MODULE_LOADER_FACTORY_H 3 | #define __TESTNGPP_MODULE_LOADER_FACTORY_H 4 | 5 | #include 6 | 7 | 8 | TESTNGPP_NS_START 9 | 10 | struct ModuleLoader; 11 | 12 | struct ModuleLoaderFactory 13 | { 14 | static ModuleLoader* create(); 15 | }; 16 | 17 | TESTNGPP_NS_END 18 | 19 | #endif 20 | 21 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/include/testngpp/runner/loaders/ModuleTestListenerLoader.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef __TESTNGPP_MODULE_TEST_LISTENER_LOADER_H 3 | #define __TESTNGPP_MODULE_TEST_LISTENER_LOADER_H 4 | 5 | #include 6 | 7 | #include 8 | 9 | #include 10 | 11 | TESTNGPP_NS_START 12 | 13 | struct ModuleLoader; 14 | struct ModuleTestListenerLoaderImpl; 15 | 16 | struct ModuleTestListenerLoader : public TestListenerLoader 17 | { 18 | ModuleTestListenerLoader(ModuleLoader* loader); 19 | ~ModuleTestListenerLoader(); 20 | 21 | TestListener* 22 | load( const StringList& SearchingPaths 23 | , const std::string& commandLine 24 | , TestResultReporter* resultReporter 25 | , TestSuiteResultReporter* suiteResultReporter 26 | , TestCaseResultReporter* caseResultReporter); 27 | 28 | private: 29 | 30 | ModuleTestListenerLoaderImpl* This; 31 | 32 | }; 33 | 34 | TESTNGPP_NS_END 35 | 36 | #endif 37 | 38 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/include/testngpp/runner/loaders/ModuleTestListenerLoaderFactory.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef __TESTNGPP_MODULE_LISTENER_LOADER_FACTORY_H 3 | #define __TESTNGPP_MODULE_LISTENER_LOADER_FACTORY_H 4 | 5 | #include 6 | 7 | #include 8 | 9 | TESTNGPP_NS_START 10 | 11 | struct ModuleTestListenerLoaderFactory 12 | : public TestListenerLoaderFactory 13 | { 14 | TestListenerLoader* create(); 15 | }; 16 | 17 | TESTNGPP_NS_END 18 | 19 | #endif 20 | 21 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/include/testngpp/runner/loaders/ModuleTestSuiteLoader.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef __TESTNGPP_MODULE_TEST_SUITE_LOADER_H 3 | #define __TESTNGPP_MODULE_TEST_SUITE_LOADER_H 4 | 5 | #include 6 | 7 | #include 8 | 9 | TESTNGPP_NS_START 10 | 11 | struct ModuleLoader; 12 | struct TestSuiteDesc; 13 | struct TestSuiteDescEntryNameGetter; 14 | struct ModuleTestSuiteLoaderImpl; 15 | 16 | struct ModuleTestSuiteLoader : public TestSuiteLoader 17 | { 18 | ModuleTestSuiteLoader(ModuleLoader* loader); 19 | ~ModuleTestSuiteLoader(); 20 | 21 | TestSuiteDesc* 22 | load( const StringList& searchingPaths 23 | , const std::string& path 24 | , TestSuiteDescEntryNameGetter* nameGetter); 25 | 26 | void unload(); 27 | 28 | private: 29 | ModuleTestSuiteLoaderImpl* This; 30 | }; 31 | 32 | TESTNGPP_NS_END 33 | 34 | #endif 35 | 36 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/include/testngpp/runner/loaders/ModuleTestSuiteLoaderFactory.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef __TESTNGPP_MODULE_SUITE_LOADER_FACTORY_H 3 | #define __TESTNGPP_MODULE_SUITE_LOADER_FACTORY_H 4 | 5 | #include 6 | 7 | #include 8 | 9 | TESTNGPP_NS_START 10 | 11 | struct ModuleTestSuiteLoaderFactory 12 | : public TestSuiteLoaderFactory 13 | { 14 | TestSuiteLoader* create(); 15 | }; 16 | 17 | TESTNGPP_NS_END 18 | 19 | #endif 20 | 21 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/include/testngpp/runner/loaders/TestListenerLoader.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef __TESTNGPP_TEST_LISTENER_LOADER_H 3 | #define __TESTNGPP_TEST_LISTENER_LOADER_H 4 | 5 | #include 6 | 7 | #include 8 | #include 9 | 10 | TESTNGPP_NS_START 11 | 12 | struct TestListener; 13 | struct TestResultReporter; 14 | struct TestSuiteResultReporter; 15 | struct TestCaseResultReporter; 16 | 17 | struct TestListenerLoader 18 | { 19 | virtual 20 | TestListener* 21 | load( const StringList& searchingPaths 22 | , const std::string& commandLine 23 | , TestResultReporter* resultReporter 24 | , TestSuiteResultReporter* suiteResultReporter 25 | , TestCaseResultReporter* caseResultReporter) = 0; 26 | 27 | virtual ~TestListenerLoader() {} 28 | }; 29 | 30 | TESTNGPP_NS_END 31 | 32 | #endif 33 | 34 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/include/testngpp/runner/loaders/TestListenerLoaderFactory.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef __TESTNGPP_TEST_LISTENER_LOADER_FACTORY_H 3 | #define __TESTNGPP_TEST_LISTENER_LOADER_FACTORY_H 4 | 5 | #include 6 | 7 | TESTNGPP_NS_START 8 | 9 | struct TestListenerLoader; 10 | struct TestResultReporter; 11 | struct TestSuiteResultReporter; 12 | struct TestCaseResultReporter; 13 | 14 | struct TestListenerLoaderFactory 15 | { 16 | virtual TestListenerLoader* create() = 0; 17 | 18 | virtual ~TestListenerLoaderFactory() {} 19 | }; 20 | 21 | TESTNGPP_NS_END 22 | 23 | #endif 24 | 25 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/include/testngpp/runner/loaders/TestSuiteLoader.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef __TESTNGPP_TEST_SUITE_LOADER_H 3 | #define __TESTNGPP_TEST_SUITE_LOADER_H 4 | 5 | #include 6 | #include 7 | 8 | TESTNGPP_NS_START 9 | 10 | struct TestSuiteDesc; 11 | struct TestSuiteDescEntryNameGetter; 12 | 13 | struct TestSuiteLoader 14 | { 15 | virtual TestSuiteDesc* 16 | load( const StringList& searchingPaths 17 | , const std::string& path 18 | , TestSuiteDescEntryNameGetter* nameGetter) = 0; 19 | 20 | virtual void unload() = 0; 21 | 22 | virtual ~TestSuiteLoader() {} 23 | }; 24 | 25 | TESTNGPP_NS_END 26 | 27 | #endif 28 | 29 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/include/testngpp/runner/loaders/TestSuiteLoaderFactory.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef __TESTNGPP_TEST_SUITE_LOADER_FACTORY_H 3 | #define __TESTNGPP_TEST_SUITE_LOADER_FACTORY_H 4 | 5 | #include 6 | 7 | TESTNGPP_NS_START 8 | 9 | struct TestSuiteLoader; 10 | 11 | struct TestSuiteLoaderFactory 12 | { 13 | virtual TestSuiteLoader* create() = 0; 14 | 15 | virtual ~TestSuiteLoaderFactory() {} 16 | }; 17 | 18 | TESTNGPP_NS_END 19 | 20 | #endif 21 | 22 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/include/testngpp/runner/loaders/Win32DllModuleLoader.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef __TESTNGPP_WIN32_DLL_MODULE_LOADER_H 3 | #define __TESTNGPP_WIN32_DLL_MODULE_LOADER_H 4 | 5 | #include 6 | #include 7 | 8 | TESTNGPP_NS_START 9 | 10 | struct Win32DllModuleLoaderImpl; 11 | 12 | struct Win32DllModuleLoader : public ModuleLoader 13 | { 14 | Win32DllModuleLoader(); 15 | ~Win32DllModuleLoader(); 16 | 17 | void load( const StringList& searchingPaths 18 | , const std::string& modulePath); 19 | 20 | void unload(); 21 | 22 | void* findSymbol(const std::string& symbol); 23 | 24 | private: 25 | 26 | Win32DllModuleLoaderImpl* This; 27 | }; 28 | 29 | TESTNGPP_NS_END 30 | 31 | #endif 32 | 33 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/include/testngpp/utils/InternalError.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef __TESTNGPP_INTERNAL_ERROR_H 3 | #define __TESTNGPP_INTERNAL_ERROR_H 4 | 5 | #define TESTNGPP_INTERNAL_ERROR(code) "testngpp internal error(" #code "), please report bug to " PACKAGE_BUGREPORT 6 | 7 | #endif 8 | -------------------------------------------------------------------------------- /tests/3rdparty/testngpp/include/testngpp/utils/OptionList.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef __TESTNGPP_OPTION_LIST_H 3 | #define __TESTNGPP_OPTION_LIST_H 4 | 5 | #include 6 | #include 7 | 8 | #include 9 | #include 10 | 11 | TESTNGPP_NS_START 12 | 13 | struct OptionList 14 | { 15 | typedef std::pair Option; 16 | typedef std::list