├── .github
    ├── ISSUE_TEMPLATE
    │   ├── bug_report.md
    │   └── feature_request.md
    └── workflows
    │   └── php.yml
├── .gitignore
├── CHANGELOG.md
├── CODE_OF_CONDUCT.md
├── CONTRIBUTING.md
├── LICENSE
├── README.md
├── SECURITY.md
├── acme_src
    ├── ErrorConditions
    │   ├── AfterAllAttributeOnNotTestCaseOrTestSuite
    │   │   └── BadTestCase.php
    │   ├── AfterAllNonStaticMethod
    │   │   └── BadTestCase.php
    │   ├── AfterEachAttributeOnNotTestCaseOrTestSuite
    │   │   └── BadTestCase.php
    │   ├── BadNamespaceTest
    │   │   └── MyTestCase.php
    │   ├── BadNamespaceTestCaseAfterAll
    │   │   └── MyTestCase.php
    │   ├── BadNamespaceTestCaseAfterEach
    │   │   └── MyTestCase.php
    │   ├── BadNamespaceTestCaseBeforeAll
    │   │   └── MyTestCase.php
    │   ├── BadNamespaceTestCaseBeforeEach
    │   │   └── MyTestCase.php
    │   ├── BadNamespaceTestSuiteAfterAll
    │   │   └── MyTestSuite.php
    │   ├── BadNamespaceTestSuiteAfterEach
    │   │   └── MyTestSuite.php
    │   ├── BadNamespaceTestSuiteAfterEachTest
    │   │   └── MyTestSuite.php
    │   ├── BadNamespaceTestSuiteBeforeAll
    │   │   └── MyTestSuite.php
    │   ├── BadNamespaceTestSuiteBeforeEach
    │   │   └── MyTestSuite.php
    │   ├── BadNamespaceTestSuiteBeforeEachTest
    │   │   └── MyTestSuite.php
    │   ├── BeforeAllAttributeOnNotTestCaseOrTestSuite
    │   │   └── BadTestCase.php
    │   ├── BeforeAllNonStaticMethod
    │   │   └── BadTestCase.php
    │   ├── BeforeEachAttributeOnNotTestCaseOrTestSuite
    │   │   └── BadTestCase.php
    │   ├── NoTestsTestCase
    │   │   └── BadTestCase.php
    │   └── TestAttributeOnNotTestCase
    │   │   └── BadTestCase.php
    ├── ExplicitTestSuite
    │   ├── AfterAllTestSuiteHook
    │   │   ├── FirstTestCase.php
    │   │   ├── MyTestSuite.php
    │   │   └── SecondTestCase.php
    │   ├── AfterEachTestSuiteHook
    │   │   ├── FirstTestCase.php
    │   │   ├── MyTestSuite.php
    │   │   ├── SecondTestCase.php
    │   │   └── ThirdTestCase.php
    │   ├── AfterEachTestTestSuiteHook
    │   │   ├── FirstTestCase.php
    │   │   ├── MyTestSuite.php
    │   │   ├── SecondTestCase.php
    │   │   └── ThirdTestCase.php
    │   ├── AnnotatedDefaultTestSuite
    │   │   ├── MyTestCase.php
    │   │   └── MyTestSuite.php
    │   ├── BeforeAllTestSuiteHook
    │   │   ├── FirstTestCase.php
    │   │   ├── MyTestSuite.php
    │   │   └── SecondTestCase.php
    │   ├── BeforeEachTestSuiteHook
    │   │   ├── FirstTestCase.php
    │   │   ├── MyTestSuite.php
    │   │   ├── SecondTestCase.php
    │   │   └── ThirdTestCase.php
    │   ├── BeforeEachTestTestSuiteHook
    │   │   ├── FirstTestCase.php
    │   │   ├── MyTestSuite.php
    │   │   ├── SecondTestCase.php
    │   │   └── ThirdTestCase.php
    │   ├── ExceptionThrowingTestSuiteAfterAll
    │   │   ├── FirstTestCase.php
    │   │   └── MyTestSuite.php
    │   ├── ExceptionThrowingTestSuiteAfterEach
    │   │   ├── MyTestCase.php
    │   │   └── MyTestSuite.php
    │   ├── ExceptionThrowingTestSuiteAfterEachTest
    │   │   ├── MyTestCase.php
    │   │   └── MyTestSuite.php
    │   ├── ExceptionThrowingTestSuiteBeforeAll
    │   │   ├── FirstTestCase.php
    │   │   └── MyTestSuite.php
    │   ├── ExceptionThrowingTestSuiteBeforeEach
    │   │   ├── MyTestCase.php
    │   │   └── MyTestSuite.php
    │   ├── ExceptionThrowingTestSuiteBeforeEachTest
    │   │   ├── MyTestCase.php
    │   │   └── MyTestSuite.php
    │   ├── TestCaseAfterAllHasTestSuiteState
    │   │   ├── MyTestCase.php
    │   │   └── MyTestSuite.php
    │   ├── TestCaseBeforeAllHasTestSuiteState
    │   │   ├── MyTestCase.php
    │   │   └── MyTestSuite.php
    │   ├── TestCaseDefinedAndImplicitDefaultTestSuite
    │   │   ├── FirstTestCase.php
    │   │   ├── MyTestSuite.php
    │   │   └── SecondTestCase.php
    │   ├── TestCaseDefinesTestSuite
    │   │   ├── FirstTestCase.php
    │   │   ├── MyFirstTestSuite.php
    │   │   ├── MySecondTestSuite.php
    │   │   ├── SecondTestCase.php
    │   │   └── ThirdTestCase.php
    │   ├── TestSuiteDefinesNamespaceToAttach
    │   │   ├── HasExplicitTestSuite
    │   │   │   └── MyTestCase.php
    │   │   ├── HasImplicitTestSuite
    │   │   │   └── MyTestCase.php
    │   │   ├── MyTestCase.php
    │   │   └── MyTestSuite.php
    │   ├── TestSuiteDisabled
    │   │   ├── FirstTestCase.php
    │   │   ├── MyTestSuite.php
    │   │   └── SecondTestCase.php
    │   ├── TestSuiteDisabledCustomMessage
    │   │   ├── MyTestCase.php
    │   │   └── MyTestSuite.php
    │   ├── TestSuiteDisabledHookNotInvoked
    │   │   ├── MyTestCase.php
    │   │   └── MyTestSuite.php
    │   ├── TestSuiteHasTimeout
    │   │   ├── FirstTestCase.php
    │   │   ├── MyTestSuite.php
    │   │   └── SecondTestCase.php
    │   ├── TestSuiteHookPriority
    │   │   ├── MyTestCase.php
    │   │   └── MyTestSuite.php
    │   └── TestSuiteStateBeforeAll
    │   │   ├── FirstTestCase.php
    │   │   └── MyTestSuite.php
    └── ImplicitDefaultTestSuite
    │   ├── CustomAssertions
    │       └── MyTestCase.php
    │   ├── ExceptionThrowingAfterAll
    │       └── MyTestCase.php
    │   ├── ExceptionThrowingAfterEach
    │       └── MyTestCase.php
    │   ├── ExceptionThrowingBeforeAll
    │       └── MyTestCase.php
    │   ├── ExceptionThrowingBeforeEach
    │       └── MyTestCase.php
    │   ├── ExceptionThrowingTest
    │       ├── MyTestCase.php
    │       └── async-unit.json
    │   ├── ExceptionThrowingTestWithAfterEachHook
    │       └── MyTestCase.php
    │   ├── ExtendedTestCases
    │       ├── AbstractFourthTestCase.php
    │       ├── AbstractSecondTestCase.php
    │       ├── FifthTestCase.php
    │       ├── FirstTestCase.php
    │       └── ThirdTestCase.php
    │   ├── FailedAssertion
    │       └── MyTestCase.php
    │   ├── FailedNotAssertion
    │       └── MyTestCase.php
    │   ├── HandleNonPhpFiles
    │       ├── MyTestCase.php
    │       ├── something-else.xml
    │       └── something.json
    │   ├── HasAssertionPlugin
    │       ├── MyCustomAssertionPlugin.php
    │       ├── MyOtherCustomAssertionPlugin.php
    │       └── MyTestCase.php
    │   ├── HasDataProvider
    │       └── MyTestCase.php
    │   ├── HasNotTestCaseObject
    │       ├── MyTestCase.php
    │       └── NotTestCase.php
    │   ├── HasResultPrinterPlugin
    │       ├── MyResultPrinterPlugin.php
    │       └── MyTestCase.php
    │   ├── HasSingleAfterAllHook
    │       └── MyTestCase.php
    │   ├── HasSingleAfterEachHook
    │       └── MyTestCase.php
    │   ├── HasSingleBeforeAllHook
    │       └── MyTestCase.php
    │   ├── HasSingleBeforeEachHook
    │       └── MyTestCase.php
    │   ├── KitchenSink
    │       ├── FirstTestCase.php
    │       ├── FirstTestSuite.php
    │       ├── SecondBreakfast
    │       │   ├── BadTestCase.php
    │       │   └── FoodAndBeverageTestCase.php
    │       ├── SecondTestCase.php
    │       └── WhatAbout
    │       │   ├── BilboTestCase.php
    │       │   ├── FrodoTestCase.php
    │       │   ├── PotatoTestSuite.php
    │       │   └── SamwiseTestCase.php
    │   ├── MockeryTestNoAssertion
    │       └── MyTestCase.php
    │   ├── MultipleBeforeAllHooks
    │       ├── FirstTestCase.php
    │       └── SecondTestCase.php
    │   ├── MultipleTest
    │       └── MyTestCase.php
    │   ├── MultipleTestCase
    │       ├── BarTestCase.php
    │       ├── BazTestCase.php
    │       └── FooTestCase.php
    │   ├── MultipleTestsKnownDuration
    │       ├── FirstTestCase.php
    │       ├── SecondTestCase.php
    │       └── ThirdTestCase.php
    │   ├── NoAssertions
    │       └── MyTestCase.php
    │   ├── RecursiveTestLayout
    │       ├── TestOne.php
    │       └── Two
    │       │   ├── TestTwo.php
    │       │   └── Three
    │       │       ├── Four
    │       │           ├── Five
    │       │           │   └── TestFive.php
    │       │           └── TestFour.php
    │       │       └── TestThree.php
    │   ├── SingleMockTest
    │       └── MyTestCase.php
    │   ├── SingleTest
    │       ├── MyTestCase.php
    │       └── async-unit.json
    │   ├── SingleTestAsyncAssertion
    │       └── MyTestCase.php
    │   ├── SingleTestDisabled
    │       └── MyTestCase.php
    │   ├── TestCaseDisabled
    │       └── MyTestCase.php
    │   ├── TestCaseDisabledCustomMessage
    │       └── MyTestCase.php
    │   ├── TestCaseDisabledHookNotInvoked
    │       └── MyTestCase.php
    │   ├── TestCaseHasTimeout
    │       └── MyTestCase.php
    │   ├── TestCaseHooksPriority
    │       └── MyTestCase.php
    │   ├── TestDisabled
    │       └── MyTestCase.php
    │   ├── TestDisabledCustomMessage
    │       └── MyTestCase.php
    │   ├── TestDisabledEvents
    │       └── MyTestCase.php
    │   ├── TestDisabledHookNotInvoked
    │       └── MyTestCase.php
    │   ├── TestExpectsExceptionDoesNotThrow
    │       └── MyTestCase.php
    │   ├── TestExpectsExceptionMessage
    │       └── MyTestCase.php
    │   ├── TestExpectsExceptionOnly
    │       └── MyTestCase.php
    │   ├── TestExpectsExceptionWrongMessage
    │       └── MyTestCase.php
    │   ├── TestExpectsExceptionWrongType
    │       └── MyTestCase.php
    │   ├── TestExpectsNoAssertions
    │       └── MyTestCase.php
    │   ├── TestExpectsNoAssertionsAssertMade
    │       └── MyTestCase.php
    │   ├── TestExpectsNoAsyncAssertionsAssertMade
    │       └── MyTestCase.php
    │   ├── TestFailedExceptionThrowingTest
    │       └── MyTestCase.php
    │   ├── TestHasOutput
    │       └── MyTestCase.php
    │   ├── TestHasTimeout
    │       └── MyTestCase.php
    │   ├── TestKnownRunTime
    │       └── MyTestCase.php
    │   └── WithAsyncUnitConfig
    │       ├── async-unit.json
    │       └── tests
    │           ├── Bar
    │               └── FooTestCase.php
    │           └── Foo
    │               └── BarTestCase.php
├── bin
    └── asyncunit
├── cli_src
    ├── AsyncUnitConsoleApplication.php
    ├── Command
    │   ├── AbstractCommand.php
    │   ├── GenerateConfigurationCommand.php
    │   └── RunTestsCommand.php
    ├── Exception
    │   └── Exception.php
    └── TerminalResultPrinter.php
├── cli_test
    ├── Command
    │   ├── BaseCommandTest.php
    │   ├── GenerateConfigurationCommandTest.php
    │   └── RunTestsCommandTest.php
    └── Integration
    │   ├── error_test_output.phpt
    │   ├── helpers.php
    │   └── single_test_output.phpt
├── composer.json
├── composer.lock
├── examples
    ├── blog_introduction_src
    │   ├── ExampleFour
    │   │   └── MyTestCase.php
    │   ├── ExampleOne
    │   │   └── MyTestCase.php
    │   ├── ExampleThree
    │   │   └── MyTestCase.php
    │   └── ExampleTwo
    │   │   └── MyTestCase.php
    ├── custom_assertion_src
    │   ├── MyAssertion.php
    │   ├── MyAssertionPlugin.php
    │   └── TestCaseUsesMyAssertion.php
    └── simple_equals_src
    │   └── StringEqualsTest.php
├── framework_src
    ├── Assertion.php
    ├── Assertion
    │   ├── AbstractAssertion.php
    │   ├── AbstractAsyncAssertion.php
    │   ├── AssertArrayEquals.php
    │   ├── AssertCountEquals.php
    │   ├── AssertFloatEquals.php
    │   ├── AssertInstanceOf.php
    │   ├── AssertIntEquals.php
    │   ├── AssertIsEmpty.php
    │   ├── AssertIsFalse.php
    │   ├── AssertIsNull.php
    │   ├── AssertIsTrue.php
    │   ├── AssertStringEquals.php
    │   ├── AssertionMessage
    │   │   ├── BinaryOperandDetails.php
    │   │   ├── BinaryOperandSummary.php
    │   │   ├── CountEqualsMessage.php
    │   │   ├── EmptyUnaryOperandDetails.php
    │   │   ├── EmptyUnaryOperandSummary.php
    │   │   ├── FalseUnaryOperandDetails.php
    │   │   ├── FalseUnaryOperandSummary.php
    │   │   ├── InstanceOfMessage.php
    │   │   ├── NullUnaryOperandDetails.php
    │   │   ├── NullUnaryOperandSummary.php
    │   │   ├── TrueUnaryOperandDetails.php
    │   │   ├── TrueUnaryOperandSummary.php
    │   │   ├── UnaryOperandDetails.php
    │   │   └── UnaryOperandSummary.php
    │   ├── AssertionResultFactory.php
    │   ├── AsyncAssertArrayEquals.php
    │   ├── AsyncAssertCountEquals.php
    │   ├── AsyncAssertFloatEquals.php
    │   ├── AsyncAssertInstanceOf.php
    │   ├── AsyncAssertIntEquals.php
    │   ├── AsyncAssertIsEmpty.php
    │   ├── AsyncAssertIsFalse.php
    │   ├── AsyncAssertIsNull.php
    │   ├── AsyncAssertIsTrue.php
    │   └── AsyncAssertStringEquals.php
    ├── AssertionMessage.php
    ├── AssertionResult.php
    ├── AsyncAssertion.php
    ├── AsyncUnitApplication.php
    ├── AsyncUnitApplicationObjectGraph.php
    ├── AsyncUnitConfigurationValidator.php
    ├── AsyncUnitFrameworkRunner.php
    ├── Attribute
    │   ├── AfterAll.php
    │   ├── AfterEach.php
    │   ├── AfterEachTest.php
    │   ├── AttachToTestSuite.php
    │   ├── BeforeAll.php
    │   ├── BeforeEach.php
    │   ├── BeforeEachTest.php
    │   ├── DataProvider.php
    │   ├── DefaultTestSuite.php
    │   ├── Disabled.php
    │   ├── Prototype.php
    │   ├── PrototypeRequiresAttribute.php
    │   ├── Test.php
    │   └── Timeout.php
    ├── Configuration.php
    ├── ConfigurationFactory.php
    ├── ConfigurationValidationResults.php
    ├── ConfigurationValidator.php
    ├── Context
    │   ├── AssertionContext.php
    │   ├── AsyncAssertionContext.php
    │   ├── CustomAssertionContext.php
    │   ├── ExpectationContext.php
    │   ├── LastAssertionCalledTrait.php
    │   ├── SharedAssertionContextTrait.php
    │   └── TestExpector.php
    ├── CustomAssertionPlugin.php
    ├── Event
    │   ├── ProcessingFinishedEvent.php
    │   ├── ProcessingStartedEvent.php
    │   ├── TestCaseFinishedEvent.php
    │   ├── TestCaseStartedEvent.php
    │   ├── TestDisabledEvent.php
    │   ├── TestErroredEvent.php
    │   ├── TestFailedEvent.php
    │   ├── TestPassedEvent.php
    │   ├── TestProcessedEvent.php
    │   ├── TestSuiteFinishedEvent.php
    │   └── TestSuiteStartedEvent.php
    ├── Events.php
    ├── Exception
    │   ├── AssertionFailedException.php
    │   ├── Exception.php
    │   ├── InvalidArgumentException.php
    │   ├── InvalidConfigurationException.php
    │   ├── InvalidStateException.php
    │   ├── MockFailureException.php
    │   ├── TestCaseSetUpException.php
    │   ├── TestCaseTearDownException.php
    │   ├── TestCompilationException.php
    │   ├── TestDisabledException.php
    │   ├── TestErrorException.php
    │   ├── TestFailedException.php
    │   ├── TestOutputException.php
    │   ├── TestSetupException.php
    │   ├── TestSuiteSetUpException.php
    │   ├── TestSuiteTearDownException.php
    │   ├── TestTearDownException.php
    │   └── UnsupportedOperationException.php
    ├── HookType.php
    ├── ImplicitTestSuite.php
    ├── JsonConfigurationFactory.php
    ├── MockBridge.php
    ├── MockBridge
    │   ├── MockeryMockBridge.php
    │   └── ProphecyMockBridge.php
    ├── MockBridgeFactory.php
    ├── Model
    │   ├── CanBeDisabledTrait.php
    │   ├── CanHaveTimeoutTrait.php
    │   ├── HookAware.php
    │   ├── HookModel.php
    │   ├── MethodModelTrait.php
    │   ├── PluginModel.php
    │   ├── TestCaseModel.php
    │   ├── TestModel.php
    │   └── TestSuiteModel.php
    ├── NullRandomizer.php
    ├── Parser
    │   ├── AsyncUnitModelCollector.php
    │   ├── AsyncUnitModelNodeVisitor.php
    │   ├── AttributeGroupTraverser.php
    │   ├── Parser.php
    │   ├── ParserResult.php
    │   └── StaticAnalysisParser.php
    ├── Prototype
    │   ├── AfterEachPrototype.php
    │   ├── BeforeEachPrototype.php
    │   ├── DataProviderTestPrototype.php
    │   ├── TestCaseAfterAllPrototype.php
    │   ├── TestCaseBeforeAllPrototype.php
    │   ├── TestPrototype.php
    │   ├── TestSuiteAfterAllPrototype.php
    │   └── TestSuiteBeforeAllPrototype.php
    ├── Randomizer.php
    ├── ResultPrinterPlugin.php
    ├── ShuffleRandomizer.php
    ├── Statistics
    │   ├── AggregateSummary.php
    │   ├── ProcessedAggregateSummary.php
    │   ├── ProcessedSummaryBuilder.php
    │   ├── ProcessedTestCaseSummary.php
    │   ├── ProcessedTestSuiteSummary.php
    │   ├── SummaryCalculator.php
    │   ├── TestCaseSummary.php
    │   └── TestSuiteSummary.php
    ├── SupportedMockBridgeFactory.php
    ├── TestCase.php
    ├── TestResult.php
    ├── TestState.php
    ├── TestSuite.php
    └── TestSuiteRunner.php
├── framework_test
    ├── Assertion
    │   ├── AbstractAssertionTestCase.php
    │   ├── AbstractAsyncAssertionTestCase.php
    │   ├── AssertArrayEqualsTest.php
    │   ├── AssertCountEqualsTest.php
    │   ├── AssertFloatEqualsTest.php
    │   ├── AssertInstanceOfTest.php
    │   ├── AssertIntEqualsTest.php
    │   ├── AssertIsEmptyTest.php
    │   ├── AssertIsFalseTest.php
    │   ├── AssertIsNullTest.php
    │   ├── AssertIsTrueTest.php
    │   ├── AssertStringEqualsTest.php
    │   ├── AssertionMessage
    │   │   ├── BinaryOperandDetailsTest.php
    │   │   ├── BinaryOperandSummaryTest.php
    │   │   ├── CountEqualsMessageTest.php
    │   │   ├── EmptyUnaryOperandDetailsTest.php
    │   │   ├── EmptyUnaryOperandSummaryTest.php
    │   │   ├── FalseUnaryOperandDetailsTest.php
    │   │   ├── FalseUnaryOperandTest.php
    │   │   ├── InstanceOfSummaryTest.php
    │   │   ├── NullUnaryOperandDetailsTest.php
    │   │   ├── NullUnaryOperandTest.php
    │   │   ├── TrueUnaryOperandDetailsTest.php
    │   │   └── TrueUnaryOperandTest.php
    │   ├── AsyncAssertArrayEqualsTest.php
    │   ├── AsyncAssertCountEqualsTest.php
    │   ├── AsyncAssertFloatEqualsTest.php
    │   ├── AsyncAssertInstanceOfTest.php
    │   ├── AsyncAssertIntEqualsTest.php
    │   ├── AsyncAssertIsEmptyTest.php
    │   ├── AsyncAssertIsFalseTest.php
    │   ├── AsyncAssertIsNullTest.php
    │   ├── AsyncAssertIsTrueTest.php
    │   └── AsyncAssertStringEqualsTest.php
    ├── AsyncUnitApplicationTest.php
    ├── AsyncUnitAssertions.php
    ├── AsyncUnitConfigurationValidatorTest.php
    ├── AsyncUnitFrameworkRunnerTest.php
    ├── Constraint
    │   ├── TestCaseModelHasTestMethod.php
    │   ├── TestCaseModelHasTestMethodTest.php
    │   ├── TestSuiteModelHasTestCaseModel.php
    │   └── TestSuiteModelHasTestCaseModelTest.php
    ├── Context
    │   └── CustomAssertionContextTest.php
    ├── JsonConfigurationFactoryTest.php
    ├── MockBridge
    │   ├── MockeryMockBridgeTest.php
    │   └── ProphecyMockBridgeTest.php
    ├── Resources
    │   └── dummy_configs
    │   │   ├── bad_keys.json
    │   │   ├── empty_object.json
    │   │   ├── good_keys_bad_types.json
    │   │   ├── good_keys_but_extra.json
    │   │   ├── has_mock_bridge.json
    │   │   ├── has_plugins.json
    │   │   ├── minimally_valid.json
    │   │   ├── mock_bridge_empty_string.json
    │   │   ├── plugins_empty.json
    │   │   ├── plugins_empty_string.json
    │   │   ├── plugins_non_string.json
    │   │   ├── result_printer_empty.json
    │   │   ├── result_printer_null.json
    │   │   ├── test_dirs_empty.json
    │   │   ├── test_dirs_empty_string.json
    │   │   └── test_dirs_non_string.json
    ├── ShuffleRandomizerTest.php
    ├── StaticAnalysisParserTest.php
    ├── Statistics
    │   └── SummaryCalculatorTest.php
    ├── Stub
    │   ├── AssertNotTestCase.php
    │   ├── BarAssertionPlugin.php
    │   ├── CountableStub.php
    │   ├── CustomAssertionTestCase.php
    │   ├── FailingMockBridgeFactory.php
    │   ├── FailingMockBridgeStub.php
    │   ├── FailingTestCase.php
    │   ├── FooAssertionPlugin.php
    │   ├── MockAwareTestCase.php
    │   ├── MockBridgeStub.php
    │   └── TestConfiguration.php
    ├── TestCaseTest.php
    ├── TestSuiteErrorsTest.php
    ├── TestSuiteRunnerScaffolding.php
    ├── TestSuiteRunnerStatisticsTest.php
    ├── TestSuiteRunnerTest.php
    └── UsesAcmeSrc.php
├── phpunit.xml
└── resources
    └── schema
        └── cli-config.json


/.github/ISSUE_TEMPLATE/bug_report.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | name: Bug report
 3 | about: Create a report to help us improve
 4 | title: ''
 5 | labels: bug
 6 | assignees: ''
 7 | 
 8 | ---
 9 | 
10 | **Describe the bug**
11 | A clear and concise description of what the bug is.
12 | 
13 | **To Reproduce**
14 | Steps to reproduce the behavior:
15 | 1. ...
16 | 
17 | **Expected behavior**
18 | A clear and concise description of what you expected to happen.
19 | 
20 | **Screenshots**
21 | If applicable, add screenshots to help explain your problem.
22 | 
23 | **Desktop (please complete the following information):**
24 |  - OS: [e.g. Linux, macOS, etc]
25 |  - PHP Version 
26 |  - Version [the tag or commit hash]
27 | 
28 | **Additional context**
29 | Add any other context about the problem here.
30 | 


--------------------------------------------------------------------------------
/.github/ISSUE_TEMPLATE/feature_request.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | name: Feature request
 3 | about: Suggest an idea for this project
 4 | title: ''
 5 | labels: enhancement
 6 | assignees: ''
 7 | 
 8 | ---
 9 | 
10 | **Is your feature request related to a problem? Please describe.**
11 | A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
12 | 
13 | **Describe the solution you'd like**
14 | A clear and concise description of what you want to happen.
15 | 
16 | **Describe alternatives you've considered**
17 | A clear and concise description of any alternative solutions or features you've considered.
18 | 
19 | **Additional context**
20 | Add any other context or screenshots about the feature request here.
21 | 


--------------------------------------------------------------------------------
/.github/workflows/php.yml:
--------------------------------------------------------------------------------
 1 | name: 'Unit Tests'
 2 | 
 3 | on:
 4 |   push:
 5 |     branches: [ main ]
 6 |   pull_request:
 7 |     branches: [ main ]
 8 | 
 9 | jobs:
10 |   build-test:
11 | 
12 |     runs-on: ubuntu-latest
13 | 
14 |     steps:
15 |       - name: Checkout
16 |         uses: actions/checkout@v2
17 |       - name: Composer 8
18 |         uses: php-actions/composer@v5
19 |         with:
20 |           php_version: 8.2
21 |       - name: PHP 8 tests
22 |         uses: php-actions/phpunit@v2
23 |         with:
24 |           version: 9
25 |           php_version: 8.2
26 |           memory_limit: 1G
27 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | .
2 | ..
3 | build
4 | vendor
5 | .phpunit.cache
6 | .phpunit.result.cache


--------------------------------------------------------------------------------
/CODE_OF_CONDUCT.md:
--------------------------------------------------------------------------------
1 | # Code of Conduct
2 | 
3 | All Labrador packages adhere to the same [Code of Conduct] found in the [Labrador Governance repo].
4 | 
5 | [Code of Conduct]: https://github.com/labrador-kennel/governance/blob/master/CODE_OF_CONDUCT.md
6 | [Labrador Governance repo]: https://github.com/labrador-kennel/governance


--------------------------------------------------------------------------------
/CONTRIBUTING.md:
--------------------------------------------------------------------------------
1 | # Contributing
2 | 
3 | Please check out the [Contributing guide] at the [Labrador Governance repo] for more
4 | information on contributing source code to this repository.
5 | 
6 | [Contributing guide]: https://github.com/labrador-kennel/governance/blob/master/CONTRIBUTING.md
7 | [Labrador Governance repo]: https://github.com/labrador-kennel/governance
8 | 
9 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2021 Charles Sprayberry
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in
13 | all copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
21 | THE SOFTWARE.


--------------------------------------------------------------------------------
/SECURITY.md:
--------------------------------------------------------------------------------
1 | # Security
2 | 
3 | All Labrador packages adhere to the same [Security Guidelines] found in the [Labrador Governance repo].
4 | 
5 | [Security Guidelines]: https://github.com/labrador-kennel/governance/blob/master/SECURITY.md
6 | [Labrador Governance repo]: https://github.com/labrador-kennel/governance
7 | 


--------------------------------------------------------------------------------
/acme_src/ErrorConditions/AfterAllAttributeOnNotTestCaseOrTestSuite/BadTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ErrorConditions\AfterAllAttributeOnNotTestCaseOrTestSuite;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\AfterAll;
 6 | 
 7 | class BadTestCase {
 8 | 
 9 |     // We forgot to implement TestCase
10 | 
11 |     #[AfterAll]
12 |     public static function ensureSomething() {
13 | 
14 |     }
15 | 
16 | }


--------------------------------------------------------------------------------
/acme_src/ErrorConditions/AfterAllNonStaticMethod/BadTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ErrorConditions\AfterAllNonStaticMethod;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\AfterAll;
 6 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 7 | use Cspray\Labrador\AsyncUnit\TestCase;
 8 | 
 9 | class BadTestCase extends TestCase {
10 | 
11 |     #[AfterAll]
12 |     public function badAfterAllMustBeStatic() {
13 | 
14 |     }
15 | 
16 |     #[Test]
17 |     public function ensureSomething() {
18 | 
19 |     }
20 | 
21 |     public function getName() : string {
22 |         return self::class;
23 |     }
24 | }


--------------------------------------------------------------------------------
/acme_src/ErrorConditions/AfterEachAttributeOnNotTestCaseOrTestSuite/BadTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ErrorConditions\AfterEachAttributeOnNotTestCaseOrTestSuite;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\AfterAll;
 6 | use Cspray\Labrador\AsyncUnit\Attribute\AfterEach;
 7 | 
 8 | class BadTestCase {
 9 | 
10 |     // We forgot to implement TestCase
11 | 
12 |     #[AfterEach]
13 |     public function ensureSomething() {
14 | 
15 |     }
16 | 
17 | }


--------------------------------------------------------------------------------
/acme_src/ErrorConditions/BadNamespaceTest/MyTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ErrorConditions\BadNamespaceTest\IntentionallyBad;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 6 | use Cspray\Labrador\AsyncUnit\TestCase;
 7 | 
 8 | class MyTestCase extends TestCase {
 9 | 
10 |     #[Test]
11 |     public function checkSomething() : void {
12 | 
13 |     }
14 | 
15 | }


--------------------------------------------------------------------------------
/acme_src/ErrorConditions/BadNamespaceTestCaseAfterAll/MyTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ErrorConditions\BadNamespaceTestCaseAfterAll\IntentionallyBad;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\AfterAll;
 6 | use Cspray\Labrador\AsyncUnit\TestCase;
 7 | 
 8 | class MyTestCase extends TestCase {
 9 | 
10 |     #[AfterAll]
11 |     public static function checkSomething() {
12 | 
13 |     }
14 | 
15 | }


--------------------------------------------------------------------------------
/acme_src/ErrorConditions/BadNamespaceTestCaseAfterEach/MyTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ErrorConditions\BadNamespaceTestCaseAfterEach\IntentionallyBad;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\AfterEach;
 6 | use Cspray\Labrador\AsyncUnit\TestCase;
 7 | 
 8 | class MyTestCase extends TestCase {
 9 | 
10 |     #[AfterEach]
11 |     public function afterEach() {
12 | 
13 |     }
14 | 
15 | }


--------------------------------------------------------------------------------
/acme_src/ErrorConditions/BadNamespaceTestCaseBeforeAll/MyTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ErrorConditions\BadNamespaceTestCaseBeforeAll\IntentionallyBad;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\BeforeAll;
 6 | use Cspray\Labrador\AsyncUnit\TestCase;
 7 | 
 8 | class MyTestCase extends TestCase {
 9 | 
10 |     #[BeforeAll]
11 |     public static function checkBefore() {
12 | 
13 |     }
14 | 
15 | }


--------------------------------------------------------------------------------
/acme_src/ErrorConditions/BadNamespaceTestCaseBeforeEach/MyTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ErrorConditions\BadNamespaceTestCaseBeforeEach\IntentionallyBad;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\BeforeEach;
 6 | use Cspray\Labrador\AsyncUnit\TestCase;
 7 | 
 8 | class MyTestCase extends TestCase {
 9 | 
10 |     #[BeforeEach]
11 |     public function checkEach() {
12 | 
13 |     }
14 | 
15 | }


--------------------------------------------------------------------------------
/acme_src/ErrorConditions/BadNamespaceTestSuiteAfterAll/MyTestSuite.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ErrorConditions\BadNamespaceTestSuiteAfterAll\IntentionallyBad;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\AfterAll;
 6 | use Cspray\Labrador\AsyncUnit\TestSuite;
 7 | 
 8 | class MyTestSuite extends TestSuite {
 9 | 
10 |     #[AfterAll]
11 |     public function checkAll() {
12 | 
13 |     }
14 | 
15 | }


--------------------------------------------------------------------------------
/acme_src/ErrorConditions/BadNamespaceTestSuiteAfterEach/MyTestSuite.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ErrorConditions\BadNamespaceTestSuiteAfterEach\IntentionallyBad;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\AfterEach;
 6 | use Cspray\Labrador\AsyncUnit\TestSuite;
 7 | 
 8 | class MyTestSuite extends TestSuite {
 9 | 
10 |     #[AfterEach]
11 |     public function checkEach() {
12 | 
13 |     }
14 | 
15 | }


--------------------------------------------------------------------------------
/acme_src/ErrorConditions/BadNamespaceTestSuiteAfterEachTest/MyTestSuite.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ErrorConditions\BadNamespaceTestSuiteAfterEachTest\IntentionallyBad;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\AfterEachTest;
 6 | use Cspray\Labrador\AsyncUnit\TestSuite;
 7 | 
 8 | class MyTestSuite extends TestSuite {
 9 | 
10 |     #[AfterEachTest]
11 |     public function checkEach() {
12 | 
13 |     }
14 | 
15 | }


--------------------------------------------------------------------------------
/acme_src/ErrorConditions/BadNamespaceTestSuiteBeforeAll/MyTestSuite.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ErrorConditions\BadNamespaceTestSuiteBeforeAll\IntentionallyBad;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\BeforeAll;
 6 | use Cspray\Labrador\AsyncUnit\TestSuite;
 7 | 
 8 | class MyTestSuite extends TestSuite {
 9 | 
10 |     #[BeforeAll]
11 |     public function checkBefore() {
12 | 
13 |     }
14 | 
15 | }


--------------------------------------------------------------------------------
/acme_src/ErrorConditions/BadNamespaceTestSuiteBeforeEach/MyTestSuite.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ErrorConditions\BadNamespaceTestSuiteBeforeEach\IntentionallyBad;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\BeforeEach;
 6 | use Cspray\Labrador\AsyncUnit\TestSuite;
 7 | 
 8 | class MyTestSuite extends TestSuite {
 9 | 
10 |     #[BeforeEach]
11 |     public function checkEach() {
12 | 
13 |     }
14 | 
15 | }


--------------------------------------------------------------------------------
/acme_src/ErrorConditions/BadNamespaceTestSuiteBeforeEachTest/MyTestSuite.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ErrorConditions\BadNamespaceTestSuiteBeforeEachTest\IntentionallyBad;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\BeforeEachTest;
 6 | use Cspray\Labrador\AsyncUnit\TestSuite;
 7 | 
 8 | class MyTestSuite extends TestSuite {
 9 | 
10 |     #[BeforeEachTest]
11 |     public function checkEach() {
12 | 
13 |     }
14 | 
15 | }


--------------------------------------------------------------------------------
/acme_src/ErrorConditions/BeforeAllAttributeOnNotTestCaseOrTestSuite/BadTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ErrorConditions\BeforeAllAttributeOnNotTestCaseOrTestSuite;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\BeforeAll;
 6 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 7 | 
 8 | class BadTestCase {
 9 | 
10 |     // We forgot to implement TestCase
11 | 
12 |     #[BeforeAll]
13 |     public static function ensureSomething() {
14 | 
15 |     }
16 | 
17 | }


--------------------------------------------------------------------------------
/acme_src/ErrorConditions/BeforeAllNonStaticMethod/BadTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ErrorConditions\BeforeAllNonStaticMethod;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\BeforeAll;
 6 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 7 | use Cspray\Labrador\AsyncUnit\TestCase;
 8 | 
 9 | class BadTestCase extends TestCase {
10 | 
11 |     #[BeforeAll]
12 |     public function badBeforeAllMustBeStatic() {
13 | 
14 |     }
15 | 
16 |     #[Test]
17 |     public function ensureSomething() {
18 | 
19 |     }
20 | 
21 |     public function getName() {
22 |         return self::class;
23 |     }
24 | }


--------------------------------------------------------------------------------
/acme_src/ErrorConditions/BeforeEachAttributeOnNotTestCaseOrTestSuite/BadTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ErrorConditions\BeforeEachAttributeOnNotTestCaseOrTestSuite;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\BeforeAll;
 6 | use Cspray\Labrador\AsyncUnit\Attribute\BeforeEach;
 7 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 8 | 
 9 | class BadTestCase {
10 | 
11 |     // We forgot to implement TestCase
12 | 
13 |     #[BeforeEach]
14 |     public function ensureSomething() {
15 | 
16 |     }
17 | 
18 | }


--------------------------------------------------------------------------------
/acme_src/ErrorConditions/NoTestsTestCase/BadTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ErrorConditions\NoTestsTestCase;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\TestCase;
 6 | 
 7 | class BadTestCase extends TestCase {
 8 | 
 9 |     public function getName() {
10 |         return self::class;
11 |     }
12 | 
13 |     // We forgot to mark this as a Test
14 |     public function ensureSomethingHappens() {
15 | 
16 |     }
17 | }


--------------------------------------------------------------------------------
/acme_src/ErrorConditions/TestAttributeOnNotTestCase/BadTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ErrorConditions\TestAttributeOnNotTestCase;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 6 | 
 7 | class BadTestCase {
 8 | 
 9 |     // We forgot to implement TestCase
10 | 
11 |     #[Test]
12 |     public function ensureSomething() {
13 | 
14 |     }
15 | 
16 | }


--------------------------------------------------------------------------------
/acme_src/ExplicitTestSuite/AfterAllTestSuiteHook/FirstTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ExplicitTestSuite\AfterAllTestSuiteHook;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 6 | use Cspray\Labrador\AsyncUnit\TestCase;
 7 | 
 8 | class FirstTestCase extends TestCase {
 9 | 
10 |     #[Test]
11 |     public function ensureSuiteCounter() : void {
12 |         $this->assert()->intEquals(0, $this->testSuite()->getCounter());
13 |     }
14 | 
15 |     #[Test]
16 |     public function ensureSuiteCounterAgain() : void {
17 |         $this->assert()->intEquals(0, $this->testSuite()->getCounter());
18 |     }
19 | 
20 | }


--------------------------------------------------------------------------------
/acme_src/ExplicitTestSuite/AfterAllTestSuiteHook/MyTestSuite.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ExplicitTestSuite\AfterAllTestSuiteHook;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\AfterAll;
 6 | use Cspray\Labrador\AsyncUnit\Attribute\DefaultTestSuite;
 7 | use Cspray\Labrador\AsyncUnit\TestSuite;
 8 | 
 9 | #[DefaultTestSuite]
10 | class MyTestSuite extends TestSuite {
11 | 
12 |     private int $counter = 0;
13 | 
14 |     #[AfterAll]
15 |     public function incrementCounter() : void {
16 |         $this->counter++;
17 |     }
18 | 
19 |     public function getCounter() : int {
20 |         return $this->counter;
21 |     }
22 | 
23 | }


--------------------------------------------------------------------------------
/acme_src/ExplicitTestSuite/AfterAllTestSuiteHook/SecondTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ExplicitTestSuite\AfterAllTestSuiteHook;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 6 | use Cspray\Labrador\AsyncUnit\TestCase;
 7 | 
 8 | class SecondTestCase extends TestCase {
 9 | 
10 |     #[Test]
11 |     public function ensureSuiteCounter() : void {
12 |         $this->assert()->intEquals(0, $this->testSuite()->getCounter());
13 |     }
14 | 
15 | }


--------------------------------------------------------------------------------
/acme_src/ExplicitTestSuite/AfterEachTestSuiteHook/FirstTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ExplicitTestSuite\AfterEachTestSuiteHook;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 6 | use Cspray\Labrador\AsyncUnit\TestCase;
 7 | 
 8 | class FirstTestCase extends TestCase {
 9 | 
10 |     #[Test]
11 |     public function testSomething() : void {
12 |         $this->assert()->arrayEquals([], $this->testSuite()->getState());
13 |     }
14 | 
15 |     #[Test]
16 |     public function testSomethingElse() : void {
17 |         $this->assert()->arrayEquals([], $this->testSuite()->getState());
18 |     }
19 | 
20 |     #[Test]
21 |     public function testItAgain() : void {
22 |         $this->assert()->arrayEquals([], $this->testSuite()->getState());
23 |     }
24 | 
25 | }


--------------------------------------------------------------------------------
/acme_src/ExplicitTestSuite/AfterEachTestSuiteHook/MyTestSuite.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ExplicitTestSuite\AfterEachTestSuiteHook;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\AfterEach;
 6 | use Cspray\Labrador\AsyncUnit\Attribute\DefaultTestSuite;
 7 | use Cspray\Labrador\AsyncUnit\TestSuite;
 8 | 
 9 | #[DefaultTestSuite]
10 | class MyTestSuite extends TestSuite {
11 | 
12 |     private array $state = [];
13 | 
14 |     #[AfterEach]
15 |     public function addToState() : void {
16 |         $this->state[] = 'AsyncUnit';
17 |     }
18 | 
19 |     public function getState() : array {
20 |         return $this->state;
21 |     }
22 | 
23 | }


--------------------------------------------------------------------------------
/acme_src/ExplicitTestSuite/AfterEachTestSuiteHook/SecondTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ExplicitTestSuite\AfterEachTestSuiteHook;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 6 | use Cspray\Labrador\AsyncUnit\TestCase;
 7 | 
 8 | class SecondTestCase extends TestCase {
 9 | 
10 |     #[Test]
11 |     public function ensureIntEquals() : void {
12 |         $this->assert()->arrayEquals([], $this->testSuite()->getState());
13 |     }
14 | 
15 | }


--------------------------------------------------------------------------------
/acme_src/ExplicitTestSuite/AfterEachTestSuiteHook/ThirdTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ExplicitTestSuite\AfterEachTestSuiteHook;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 6 | use Cspray\Labrador\AsyncUnit\TestCase;
 7 | 
 8 | class ThirdTestCase extends TestCase {
 9 | 
10 |     #[Test]
11 |     public function testFoo() : void {
12 |         $this->assert()->arrayEquals([], $this->testSuite()->getState());
13 |     }
14 | 
15 |     #[Test]
16 |     public function testBar() : void {
17 |         $this->assert()->arrayEquals([], $this->testSuite()->getState());
18 |     }
19 | 
20 | }


--------------------------------------------------------------------------------
/acme_src/ExplicitTestSuite/AfterEachTestTestSuiteHook/FirstTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ExplicitTestSuite\AfterEachTestTestSuiteHook;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 6 | use Cspray\Labrador\AsyncUnit\TestCase;
 7 | 
 8 | class FirstTestCase extends TestCase {
 9 | 
10 |     #[Test]
11 |     public function testSomething() : void {
12 |         $this->assert()->arrayEquals([], $this->testSuite()->getState());
13 |     }
14 | 
15 |     #[Test]
16 |     public function testSomethingElse() : void {
17 |         $this->assert()->arrayEquals([], $this->testSuite()->getState());
18 |     }
19 | 
20 |     #[Test]
21 |     public function testItAgain() : void {
22 |         $this->assert()->arrayEquals([], $this->testSuite()->getState());
23 |     }
24 | 
25 | }


--------------------------------------------------------------------------------
/acme_src/ExplicitTestSuite/AfterEachTestTestSuiteHook/MyTestSuite.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ExplicitTestSuite\AfterEachTestTestSuiteHook;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\AfterEachTest;
 6 | use Cspray\Labrador\AsyncUnit\Attribute\DefaultTestSuite;
 7 | use Cspray\Labrador\AsyncUnit\TestSuite;
 8 | 
 9 | #[DefaultTestSuite]
10 | class MyTestSuite extends TestSuite {
11 | 
12 |     private array $state = [];
13 | 
14 |     #[AfterEachTest]
15 |     public function addToState() : void {
16 |         $this->state[] = 'AsyncUnit';
17 |     }
18 | 
19 |     public function getState() : array {
20 |         return $this->state;
21 |     }
22 | 
23 | }


--------------------------------------------------------------------------------
/acme_src/ExplicitTestSuite/AfterEachTestTestSuiteHook/SecondTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ExplicitTestSuite\AfterEachTestTestSuiteHook;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 6 | use Cspray\Labrador\AsyncUnit\TestCase;
 7 | 
 8 | class SecondTestCase extends TestCase {
 9 | 
10 |     #[Test]
11 |     public function ensureIntEquals() : void {
12 |         $this->assert()->arrayEquals([], $this->testSuite()->getState());
13 |     }
14 | 
15 | }


--------------------------------------------------------------------------------
/acme_src/ExplicitTestSuite/AfterEachTestTestSuiteHook/ThirdTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ExplicitTestSuite\AfterEachTestTestSuiteHook;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 6 | use Cspray\Labrador\AsyncUnit\TestCase;
 7 | 
 8 | class ThirdTestCase extends TestCase {
 9 | 
10 |     #[Test]
11 |     public function testFoo() : void {
12 |         $this->assert()->arrayEquals([], $this->testSuite()->getState());
13 |     }
14 | 
15 |     #[Test]
16 |     public function testBar() : void {
17 |         $this->assert()->arrayEquals([], $this->testSuite()->getState());
18 |     }
19 | 
20 | }


--------------------------------------------------------------------------------
/acme_src/ExplicitTestSuite/AnnotatedDefaultTestSuite/MyTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ExplicitTestSuite\AnnotatedDefaultTestSuite;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 6 | use Cspray\Labrador\AsyncUnit\TestCase;
 7 | 
 8 | class MyTestCase extends TestCase {
 9 | 
10 |     private ?string $testSuiteName = null;
11 | 
12 |     public function getTestSuiteName() : ?string {
13 |         return $this->testSuiteName;
14 |     }
15 | 
16 |     #[Test]
17 |     public function ensureSomething() {
18 |         $this->testSuiteName = $this->testSuite()->getName();
19 |         $this->assert()->stringEquals(MyTestSuite::class, $this->testSuiteName);
20 |     }
21 | 
22 | 
23 | }


--------------------------------------------------------------------------------
/acme_src/ExplicitTestSuite/AnnotatedDefaultTestSuite/MyTestSuite.php:
--------------------------------------------------------------------------------
1 | <?php declare(strict_types=1);
2 | 
3 | namespace Acme\DemoSuites\ExplicitTestSuite\AnnotatedDefaultTestSuite;
4 | 
5 | use Cspray\Labrador\AsyncUnit\Attribute\DefaultTestSuite;
6 | use Cspray\Labrador\AsyncUnit\TestSuite;
7 | 
8 | #[DefaultTestSuite]
9 | class MyTestSuite extends TestSuite {}


--------------------------------------------------------------------------------
/acme_src/ExplicitTestSuite/BeforeAllTestSuiteHook/FirstTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ExplicitTestSuite\BeforeAllTestSuiteHook;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 6 | use Cspray\Labrador\AsyncUnit\TestCase;
 7 | 
 8 | class FirstTestCase extends TestCase {
 9 | 
10 |     #[Test]
11 |     public function ensureSuiteCounter() : void {
12 |         $this->assert()->intEquals(1, $this->testSuite()->getCounter());
13 |     }
14 | 
15 |     #[Test]
16 |     public function ensureSuiteCounterAgain() : void {
17 |         $this->assert()->intEquals(1, $this->testSuite()->getCounter());
18 |     }
19 | 
20 | }


--------------------------------------------------------------------------------
/acme_src/ExplicitTestSuite/BeforeAllTestSuiteHook/MyTestSuite.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ExplicitTestSuite\BeforeAllTestSuiteHook;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\BeforeAll;
 6 | use Cspray\Labrador\AsyncUnit\Attribute\DefaultTestSuite;
 7 | use Cspray\Labrador\AsyncUnit\TestSuite;
 8 | 
 9 | #[DefaultTestSuite]
10 | class MyTestSuite extends TestSuite {
11 | 
12 |     private int $counter = 0;
13 | 
14 |     #[BeforeAll]
15 |     public function incrementCounter() : void {
16 |         $this->counter++;
17 |     }
18 | 
19 |     public function getCounter() : int {
20 |         return $this->counter;
21 |     }
22 | 
23 | }


--------------------------------------------------------------------------------
/acme_src/ExplicitTestSuite/BeforeAllTestSuiteHook/SecondTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ExplicitTestSuite\BeforeAllTestSuiteHook;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 6 | use Cspray\Labrador\AsyncUnit\TestCase;
 7 | 
 8 | class SecondTestCase extends TestCase {
 9 | 
10 |     #[Test]
11 |     public function ensureSuiteCounter() : void {
12 |         $this->assert()->intEquals(1, $this->testSuite()->getCounter());
13 |     }
14 | 
15 | }


--------------------------------------------------------------------------------
/acme_src/ExplicitTestSuite/BeforeEachTestSuiteHook/FirstTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ExplicitTestSuite\BeforeEachTestSuiteHook;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 6 | use Cspray\Labrador\AsyncUnit\TestCase;
 7 | 
 8 | class FirstTestCase extends TestCase {
 9 | 
10 |     #[Test]
11 |     public function testSomething() : void {
12 |         $this->assert()->stringEquals('foo', 'foo');
13 |     }
14 | 
15 |     #[Test]
16 |     public function testSomethingElse() : void {
17 |         $this->assert()->stringEquals('bar', 'bar');
18 |     }
19 | 
20 |     /**
21 |      *
22 |      */
23 |     #[Test]
24 |     public function testItAgain() : void {
25 |         $this->assert()->stringEquals('baz', 'baz');
26 |     }
27 | 
28 | }


--------------------------------------------------------------------------------
/acme_src/ExplicitTestSuite/BeforeEachTestSuiteHook/MyTestSuite.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ExplicitTestSuite\BeforeEachTestSuiteHook;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\BeforeEach;
 6 | use Cspray\Labrador\AsyncUnit\Attribute\DefaultTestSuite;
 7 | use Cspray\Labrador\AsyncUnit\TestSuite;
 8 | 
 9 | #[DefaultTestSuite]
10 | class MyTestSuite extends TestSuite {
11 | 
12 |     private array $state = [];
13 | 
14 |     #[BeforeEach]
15 |     public function addToState() : void {
16 |         $this->state[] = 'AsyncUnit';
17 |     }
18 | 
19 |     public function getState() : array {
20 |         return $this->state;
21 |     }
22 | 
23 | }


--------------------------------------------------------------------------------
/acme_src/ExplicitTestSuite/BeforeEachTestSuiteHook/SecondTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ExplicitTestSuite\BeforeEachTestSuiteHook;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 6 | use Cspray\Labrador\AsyncUnit\TestCase;
 7 | 
 8 | class SecondTestCase extends TestCase {
 9 | 
10 |     #[Test]
11 |     public function ensureIntEquals() : void {
12 |         $this->assert()->intEquals(1, 1);
13 |     }
14 | 
15 | }


--------------------------------------------------------------------------------
/acme_src/ExplicitTestSuite/BeforeEachTestSuiteHook/ThirdTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ExplicitTestSuite\BeforeEachTestSuiteHook;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 6 | use Cspray\Labrador\AsyncUnit\TestCase;
 7 | 
 8 | class ThirdTestCase extends TestCase {
 9 | 
10 |     #[Test]
11 |     public function testFoo() : void {
12 |         $this->assert()->isNull(null);
13 |     }
14 | 
15 |     #[Test]
16 |     public function testBar() : void {
17 |         $this->assert()->isTrue(true);
18 |     }
19 | 
20 | }


--------------------------------------------------------------------------------
/acme_src/ExplicitTestSuite/BeforeEachTestTestSuiteHook/FirstTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ExplicitTestSuite\BeforeEachTestTestSuiteHook;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 6 | use Cspray\Labrador\AsyncUnit\TestCase;
 7 | 
 8 | class FirstTestCase extends TestCase {
 9 | 
10 |     #[Test]
11 |     public function testSomething() : void {
12 |         $this->assert()->arrayEquals('foo', 'foo');
13 |     }
14 | 
15 |     #[Test]
16 |     public function testSomethingElse() : void {
17 |         $this->assert()->stringEquals('bar', 'bar');
18 |     }
19 | 
20 |     #[Test]
21 |     public function testItAgain() : void {
22 |         $this->assert()->stringEquals('baz', 'baz');
23 |     }
24 | 
25 | }


--------------------------------------------------------------------------------
/acme_src/ExplicitTestSuite/BeforeEachTestTestSuiteHook/MyTestSuite.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ExplicitTestSuite\BeforeEachTestTestSuiteHook;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\BeforeEachTest;
 6 | use Cspray\Labrador\AsyncUnit\Attribute\DefaultTestSuite;
 7 | use Cspray\Labrador\AsyncUnit\TestSuite;
 8 | 
 9 | #[DefaultTestSuite]
10 | class MyTestSuite extends TestSuite {
11 | 
12 |     private array $state = [];
13 | 
14 |     #[BeforeEachTest]
15 |     public function addToState() : void {
16 |         $this->state[] = 'AsyncUnit';
17 |     }
18 | 
19 |     public function getState() : array {
20 |         return $this->state;
21 |     }
22 | 
23 | }


--------------------------------------------------------------------------------
/acme_src/ExplicitTestSuite/BeforeEachTestTestSuiteHook/SecondTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ExplicitTestSuite\BeforeEachTestTestSuiteHook;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 6 | use Cspray\Labrador\AsyncUnit\TestCase;
 7 | 
 8 | class SecondTestCase extends TestCase {
 9 | 
10 |     #[Test]
11 |     public function ensureIntEquals() : void {
12 |         $this->assert()->intEquals(1, 1);
13 |     }
14 | 
15 | }


--------------------------------------------------------------------------------
/acme_src/ExplicitTestSuite/BeforeEachTestTestSuiteHook/ThirdTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ExplicitTestSuite\BeforeEachTestTestSuiteHook;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 6 | use Cspray\Labrador\AsyncUnit\TestCase;
 7 | 
 8 | class ThirdTestCase extends TestCase {
 9 | 
10 |     #[Test]
11 |     public function testFoo() : void {
12 |         $this->assert()->isNull(null);
13 |     }
14 | 
15 |     #[Test]
16 |     public function testBar() : void {
17 |         $this->assert()->isTrue(true);
18 |     }
19 | 
20 | }


--------------------------------------------------------------------------------
/acme_src/ExplicitTestSuite/ExceptionThrowingTestSuiteAfterAll/FirstTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ExplicitTestSuite\ExceptionThrowingTestSuiteAfterAll;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 6 | use Cspray\Labrador\AsyncUnit\TestCase;
 7 | 
 8 | class FirstTestCase extends TestCase {
 9 | 
10 |     #[Test]
11 |     public function ensureSomething() {
12 |         $this->assert()->isTrue(true);
13 |     }
14 | 
15 | }


--------------------------------------------------------------------------------
/acme_src/ExplicitTestSuite/ExceptionThrowingTestSuiteAfterAll/MyTestSuite.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ExplicitTestSuite\ExceptionThrowingTestSuiteAfterAll;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\AfterAll;
 6 | use Cspray\Labrador\AsyncUnit\Attribute\DefaultTestSuite;
 7 | use Cspray\Labrador\AsyncUnit\TestSuite;
 8 | use RuntimeException;
 9 | 
10 | #[DefaultTestSuite]
11 | class MyTestSuite extends TestSuite {
12 | 
13 |     #[AfterAll]
14 |     public function throwException() {
15 |         throw new RuntimeException('AttachToTestSuite AfterAll');
16 |     }
17 | 
18 | }


--------------------------------------------------------------------------------
/acme_src/ExplicitTestSuite/ExceptionThrowingTestSuiteAfterEach/MyTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ExplicitTestSuite\ExceptionThrowingTestSuiteAfterEach;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 6 | use Cspray\Labrador\AsyncUnit\TestCase;
 7 | 
 8 | class MyTestCase extends TestCase {
 9 | 
10 |     #[Test]
11 |     public function checkSomething() {
12 | 
13 |     }
14 | 
15 | }


--------------------------------------------------------------------------------
/acme_src/ExplicitTestSuite/ExceptionThrowingTestSuiteAfterEach/MyTestSuite.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ExplicitTestSuite\ExceptionThrowingTestSuiteAfterEach;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\AfterEach;
 6 | use Cspray\Labrador\AsyncUnit\Attribute\DefaultTestSuite;
 7 | use Cspray\Labrador\AsyncUnit\TestSuite;
 8 | 
 9 | #[DefaultTestSuite]
10 | class MyTestSuite extends TestSuite {
11 | 
12 |     #[AfterEach]
13 |     public function throwEachException() {
14 |         throw new \RuntimeException('AttachToTestSuite AfterEach');
15 |     }
16 | 
17 | }


--------------------------------------------------------------------------------
/acme_src/ExplicitTestSuite/ExceptionThrowingTestSuiteAfterEachTest/MyTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ExplicitTestSuite\ExceptionThrowingTestSuiteAfterEachTest;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 6 | use Cspray\Labrador\AsyncUnit\TestCase;
 7 | 
 8 | class MyTestCase extends TestCase {
 9 | 
10 |     #[Test]
11 |     public function checkSomething() {
12 | 
13 |     }
14 | 
15 | }


--------------------------------------------------------------------------------
/acme_src/ExplicitTestSuite/ExceptionThrowingTestSuiteAfterEachTest/MyTestSuite.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ExplicitTestSuite\ExceptionThrowingTestSuiteAfterEachTest;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\AfterEachTest;
 6 | use Cspray\Labrador\AsyncUnit\Attribute\DefaultTestSuite;
 7 | use Cspray\Labrador\AsyncUnit\TestSuite;
 8 | 
 9 | #[DefaultTestSuite]
10 | class MyTestSuite extends TestSuite {
11 | 
12 |     #[AfterEachTest]
13 |     public function throwEachTestException() {
14 |         throw new \RuntimeException('AttachToTestSuite AfterEachTest');
15 |     }
16 | 
17 | }


--------------------------------------------------------------------------------
/acme_src/ExplicitTestSuite/ExceptionThrowingTestSuiteBeforeAll/FirstTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ExplicitTestSuite\ExceptionThrowingTestSuiteBeforeAll;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 6 | use Cspray\Labrador\AsyncUnit\TestCase;
 7 | 
 8 | class FirstTestCase extends TestCase {
 9 | 
10 |     #[Test]
11 |     public function ensureSomething() {
12 |         $this->assert()->isTrue(true);
13 |     }
14 | 
15 | }


--------------------------------------------------------------------------------
/acme_src/ExplicitTestSuite/ExceptionThrowingTestSuiteBeforeAll/MyTestSuite.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ExplicitTestSuite\ExceptionThrowingTestSuiteBeforeAll;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\DefaultTestSuite;
 6 | use Cspray\Labrador\AsyncUnit\TestSuite;
 7 | use Cspray\Labrador\AsyncUnit\Attribute\BeforeAll;
 8 | 
 9 | #[DefaultTestSuite]
10 | class MyTestSuite extends TestSuite {
11 | 
12 |     #[BeforeAll]
13 |     public function throwException() {
14 |         throw new \RuntimeException('Thrown in AttachToTestSuite');
15 |     }
16 | 
17 | }


--------------------------------------------------------------------------------
/acme_src/ExplicitTestSuite/ExceptionThrowingTestSuiteBeforeEach/MyTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ExplicitTestSuite\ExceptionThrowingTestSuiteBeforeEach;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 6 | use Cspray\Labrador\AsyncUnit\TestCase;
 7 | 
 8 | class MyTestCase extends TestCase {
 9 | 
10 |     #[Test]
11 |     public function checkSomething() {
12 | 
13 |     }
14 | 
15 | }


--------------------------------------------------------------------------------
/acme_src/ExplicitTestSuite/ExceptionThrowingTestSuiteBeforeEach/MyTestSuite.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ExplicitTestSuite\ExceptionThrowingTestSuiteBeforeEach;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\BeforeEach;
 6 | use Cspray\Labrador\AsyncUnit\Attribute\DefaultTestSuite;
 7 | use Cspray\Labrador\AsyncUnit\TestSuite;
 8 | 
 9 | #[DefaultTestSuite]
10 | class MyTestSuite extends TestSuite {
11 | 
12 |     #[BeforeEach]
13 |     public function throwEachException() {
14 |         throw new \RuntimeException('AttachToTestSuite BeforeEach');
15 |     }
16 | 
17 | }


--------------------------------------------------------------------------------
/acme_src/ExplicitTestSuite/ExceptionThrowingTestSuiteBeforeEachTest/MyTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ExplicitTestSuite\ExceptionThrowingTestSuiteBeforeEachTest;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 6 | use Cspray\Labrador\AsyncUnit\TestCase;
 7 | 
 8 | class MyTestCase extends TestCase {
 9 | 
10 |     #[Test]
11 |     public function checkSomething() {
12 | 
13 |     }
14 | 
15 | }


--------------------------------------------------------------------------------
/acme_src/ExplicitTestSuite/ExceptionThrowingTestSuiteBeforeEachTest/MyTestSuite.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ExplicitTestSuite\ExceptionThrowingTestSuiteBeforeEachTest;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\BeforeEach;
 6 | use Cspray\Labrador\AsyncUnit\Attribute\BeforeEachTest;
 7 | use Cspray\Labrador\AsyncUnit\Attribute\DefaultTestSuite;
 8 | use Cspray\Labrador\AsyncUnit\TestSuite;
 9 | 
10 | #[DefaultTestSuite]
11 | class MyTestSuite extends TestSuite {
12 | 
13 |     #[BeforeEachTest]
14 |     public function throwEachTestException() {
15 |         throw new \RuntimeException('AttachToTestSuite BeforeEachTest');
16 |     }
17 | 
18 | }


--------------------------------------------------------------------------------
/acme_src/ExplicitTestSuite/TestCaseAfterAllHasTestSuiteState/MyTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ExplicitTestSuite\TestCaseAfterAllHasTestSuiteState;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\AfterAll;
 6 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 7 | use Cspray\Labrador\AsyncUnit\TestCase;
 8 | use Cspray\Labrador\AsyncUnit\TestSuite;
 9 | 
10 | class MyTestCase extends TestCase {
11 | 
12 |     private static ?string $state = null;
13 | 
14 |     #[AfterAll]
15 |     public static function setState(TestSuite $testSuite) {
16 |         self::$state = $testSuite->get('state');
17 |     }
18 | 
19 |     #[Test]
20 |     public function checkState() {
21 |         $this->assert()->isNull(self::$state);
22 |     }
23 | 
24 |     public function getState() : ?string {
25 |         return self::$state;
26 |     }
27 | 
28 | }


--------------------------------------------------------------------------------
/acme_src/ExplicitTestSuite/TestCaseAfterAllHasTestSuiteState/MyTestSuite.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ExplicitTestSuite\TestCaseAfterAllHasTestSuiteState;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\BeforeAll;
 6 | use Cspray\Labrador\AsyncUnit\Attribute\DefaultTestSuite;
 7 | use Cspray\Labrador\AsyncUnit\TestSuite;
 8 | 
 9 | #[DefaultTestSuite]
10 | class MyTestSuite extends TestSuite {
11 | 
12 |     #[BeforeAll]
13 |     public function setState() {
14 |         $this->set('state', 'AsyncUnit');
15 |     }
16 | 
17 | }


--------------------------------------------------------------------------------
/acme_src/ExplicitTestSuite/TestCaseBeforeAllHasTestSuiteState/MyTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ExplicitTestSuite\TestCaseBeforeAllHasTestSuiteState;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\BeforeAll;
 6 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 7 | use Cspray\Labrador\AsyncUnit\TestCase;
 8 | use Cspray\Labrador\AsyncUnit\TestSuite;
 9 | 
10 | class MyTestCase extends TestCase {
11 | 
12 |     private static string $state;
13 | 
14 |     #[BeforeAll]
15 |     public static function setState(TestSuite $testSuite) {
16 |         self::$state = $testSuite->get('state');
17 |     }
18 | 
19 |     #[Test]
20 |     public function checkState() {
21 |         $this->assert()->stringEquals('AsyncUnit', self::$state);
22 |     }
23 | 
24 | }


--------------------------------------------------------------------------------
/acme_src/ExplicitTestSuite/TestCaseBeforeAllHasTestSuiteState/MyTestSuite.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ExplicitTestSuite\TestCaseBeforeAllHasTestSuiteState;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\BeforeAll;
 6 | use Cspray\Labrador\AsyncUnit\Attribute\DefaultTestSuite;
 7 | use Cspray\Labrador\AsyncUnit\TestSuite;
 8 | 
 9 | #[DefaultTestSuite]
10 | class MyTestSuite extends TestSuite {
11 | 
12 |     #[BeforeAll]
13 |     public function setState() {
14 |         $this->set('state', 'AsyncUnit');
15 |     }
16 | 
17 | }


--------------------------------------------------------------------------------
/acme_src/ExplicitTestSuite/TestCaseDefinedAndImplicitDefaultTestSuite/FirstTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | 
 4 | namespace Acme\DemoSuites\ExplicitTestSuite\TestCaseDefinedAndImplicitDefaultTestSuite;
 5 | 
 6 | 
 7 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 8 | use Cspray\Labrador\AsyncUnit\TestCase;
 9 | 
10 | class FirstTestCase extends TestCase {
11 | 
12 |     #[Test]
13 |     public function ensureSomething() {
14 |         $this->assert()->stringEquals('AsyncUnit', 'AsyncUnit');
15 |     }
16 | 
17 | }


--------------------------------------------------------------------------------
/acme_src/ExplicitTestSuite/TestCaseDefinedAndImplicitDefaultTestSuite/MyTestSuite.php:
--------------------------------------------------------------------------------
1 | <?php declare(strict_types=1);
2 | 
3 | namespace Acme\DemoSuites\ExplicitTestSuite\TestCaseDefinedAndImplicitDefaultTestSuite;
4 | 
5 | use Cspray\Labrador\AsyncUnit\TestSuite;
6 | 
7 | class MyTestSuite extends TestSuite {}


--------------------------------------------------------------------------------
/acme_src/ExplicitTestSuite/TestCaseDefinedAndImplicitDefaultTestSuite/SecondTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | 
 4 | namespace Acme\DemoSuites\ExplicitTestSuite\TestCaseDefinedAndImplicitDefaultTestSuite;
 5 | 
 6 | 
 7 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 8 | use Cspray\Labrador\AsyncUnit\Attribute\AttachToTestSuite;
 9 | use Cspray\Labrador\AsyncUnit\TestCase;
10 | 
11 | #[AttachToTestSuite(MyTestSuite::class)]
12 | class SecondTestCase extends TestCase {
13 | 
14 |     #[Test]
15 |     public function ensureSomething() {
16 |         $this->assert()->isFalse(false);
17 |     }
18 | 
19 | }


--------------------------------------------------------------------------------
/acme_src/ExplicitTestSuite/TestCaseDefinesTestSuite/FirstTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ExplicitTestSuite\TestCaseDefinesTestSuite;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 6 | use Cspray\Labrador\AsyncUnit\Attribute\AttachToTestSuite as TestSuiteAttribute;
 7 | use Cspray\Labrador\AsyncUnit\TestCase;
 8 | 
 9 | #[TestSuiteAttribute(MyFirstTestSuite::class)]
10 | class FirstTestCase extends TestCase {
11 | 
12 |     #[Test]
13 |     public function ensureIntEquals() {
14 |         $this->assert()->intEquals(42, 42);
15 |     }
16 | }


--------------------------------------------------------------------------------
/acme_src/ExplicitTestSuite/TestCaseDefinesTestSuite/MyFirstTestSuite.php:
--------------------------------------------------------------------------------
1 | <?php declare(strict_types=1);
2 | 
3 | namespace Acme\DemoSuites\ExplicitTestSuite\TestCaseDefinesTestSuite;
4 | 
5 | use Cspray\Labrador\AsyncUnit\TestSuite;
6 | 
7 | class MyFirstTestSuite extends TestSuite {}


--------------------------------------------------------------------------------
/acme_src/ExplicitTestSuite/TestCaseDefinesTestSuite/MySecondTestSuite.php:
--------------------------------------------------------------------------------
1 | <?php declare(strict_types=1);
2 | 
3 | namespace Acme\DemoSuites\ExplicitTestSuite\TestCaseDefinesTestSuite;
4 | 
5 | use Cspray\Labrador\AsyncUnit\TestSuite;
6 | 
7 | class MySecondTestSuite extends TestSuite {}


--------------------------------------------------------------------------------
/acme_src/ExplicitTestSuite/TestCaseDefinesTestSuite/SecondTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ExplicitTestSuite\TestCaseDefinesTestSuite;
 4 | 
 5 | use Amp\Success;
 6 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 7 | use Cspray\Labrador\AsyncUnit\TestCase;
 8 | use Cspray\Labrador\AsyncUnit\Attribute\AttachToTestSuite as TestSuiteAttribute;
 9 | use Generator;
10 | 
11 | #[TestSuiteAttribute(MySecondTestSuite::class)]
12 | class SecondTestCase extends TestCase {
13 | 
14 |     #[Test]
15 |     public function ensureSomethingIsNull() : Generator {
16 |         yield $this->asyncAssert()->isNull(new Success(null));
17 |     }
18 | 
19 | }


--------------------------------------------------------------------------------
/acme_src/ExplicitTestSuite/TestCaseDefinesTestSuite/ThirdTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ExplicitTestSuite\TestCaseDefinesTestSuite;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 6 | use Cspray\Labrador\AsyncUnit\Attribute\AttachToTestSuite as TestSuiteAttribute;
 7 | use Cspray\Labrador\AsyncUnit\TestCase;
 8 | 
 9 | #[TestSuiteAttribute(MySecondTestSuite::class)]
10 | class ThirdTestCase extends TestCase {
11 | 
12 |     #[Test]
13 |     public function ensureStringEquals() {
14 |         $this->assert()->stringEquals('AsyncUnit', 'AsyncUnit');
15 |     }
16 | 
17 | }


--------------------------------------------------------------------------------
/acme_src/ExplicitTestSuite/TestSuiteDefinesNamespaceToAttach/HasExplicitTestSuite/MyTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Acme\DemoSuites\ExplicitTestSuite\TestSuiteDefinesNamespaceToAttach\HasExplicitTestSuite;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 6 | use Cspray\Labrador\AsyncUnit\TestCase;
 7 | 
 8 | class MyTestCase extends TestCase {
 9 | 
10 |     #[Test]
11 |     public function testSomething() {
12 |         $this->assert()->isFalse(false);
13 |     }
14 | 
15 | }


--------------------------------------------------------------------------------
/acme_src/ExplicitTestSuite/TestSuiteDefinesNamespaceToAttach/HasImplicitTestSuite/MyTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Acme\DemoSuites\ExplicitTestSuite\TestSuiteDefinesNamespaceToAttach\HasImplicitTestSuite;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 6 | use Cspray\Labrador\AsyncUnit\TestCase;
 7 | 
 8 | class MyTestCase extends TestCase {
 9 | 
10 |     #[Test]
11 |     public function testSomething() {
12 |         $this->assert()->isTrue(true);
13 |     }
14 | 
15 | }


--------------------------------------------------------------------------------
/acme_src/ExplicitTestSuite/TestSuiteDefinesNamespaceToAttach/MyTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Acme\DemoSuites\ExplicitTestSuite\TestSuiteDefinesNamespaceToAttach;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 6 | use Cspray\Labrador\AsyncUnit\TestCase;
 7 | 
 8 | class MyTestCase extends TestCase {
 9 | 
10 |     #[Test]
11 |     public function testSomething() {
12 |         $this->assert()->stringEquals('AsyncUnit', 'AsyncUnit');
13 |     }
14 | 
15 | }


--------------------------------------------------------------------------------
/acme_src/ExplicitTestSuite/TestSuiteDefinesNamespaceToAttach/MyTestSuite.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Acme\DemoSuites\ExplicitTestSuite\TestSuiteDefinesNamespaceToAttach;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\TestSuite;
 6 | 
 7 | class MyTestSuite extends TestSuite {
 8 | 
 9 |     public static function getNamespacesToAttach(): array {
10 |         return [
11 |             'Acme\\\\DemoSuites\\\\ExplicitTestSuite\\\\TestSuiteDefinesNamespaceToAttach\\\\HasExplicitTestSuite'
12 |         ];
13 |     }
14 | 
15 | }


--------------------------------------------------------------------------------
/acme_src/ExplicitTestSuite/TestSuiteDisabled/FirstTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | 
 4 | namespace Acme\DemoSuites\ExplicitTestSuite\TestSuiteDisabled;
 5 | 
 6 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 7 | use Cspray\Labrador\AsyncUnit\Attribute\AttachToTestSuite;
 8 | use Cspray\Labrador\AsyncUnit\TestCase;
 9 | 
10 | #[AttachToTestSuite(MyTestSuite::class)]
11 | class FirstTestCase extends TestCase {
12 | 
13 |     #[Test]
14 |     public function testOne() {
15 |         throw new \RuntimeException();
16 |     }
17 | 
18 |     #[Test]
19 |     public function testTwo() {
20 |         throw new \RuntimeException();
21 |     }
22 | 
23 | 
24 | 
25 | }


--------------------------------------------------------------------------------
/acme_src/ExplicitTestSuite/TestSuiteDisabled/MyTestSuite.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ExplicitTestSuite\TestSuiteDisabled;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\Disabled;
 6 | use Cspray\Labrador\AsyncUnit\TestSuite;
 7 | 
 8 | #[Disabled]
 9 | class MyTestSuite extends TestSuite {
10 | 
11 | }


--------------------------------------------------------------------------------
/acme_src/ExplicitTestSuite/TestSuiteDisabled/SecondTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ExplicitTestSuite\TestSuiteDisabled;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 6 | use Cspray\Labrador\AsyncUnit\Attribute\AttachToTestSuite;
 7 | use Cspray\Labrador\AsyncUnit\TestCase;
 8 | 
 9 | #[AttachToTestSuite(MyTestSuite::class)]
10 | class SecondTestCase extends TestCase {
11 | 
12 |     #[Test]
13 |     public function testOne() {
14 |         throw new \RuntimeException();
15 |     }
16 | 
17 | }


--------------------------------------------------------------------------------
/acme_src/ExplicitTestSuite/TestSuiteDisabledCustomMessage/MyTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | 
 4 | namespace Acme\DemoSuites\ExplicitTestSuite\TestSuiteDisabledCustomMessage;
 5 | 
 6 | 
 7 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 8 | use Cspray\Labrador\AsyncUnit\Attribute\AttachToTestSuite;
 9 | use Cspray\Labrador\AsyncUnit\TestCase;
10 | 
11 | #[AttachToTestSuite(MyTestSuite::class)]
12 | class MyTestCase extends TestCase {
13 | 
14 |     #[Test]
15 |     public function testOne() {
16 | 
17 |     }
18 | 
19 | }


--------------------------------------------------------------------------------
/acme_src/ExplicitTestSuite/TestSuiteDisabledCustomMessage/MyTestSuite.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ExplicitTestSuite\TestSuiteDisabledCustomMessage;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\Disabled;
 6 | use Cspray\Labrador\AsyncUnit\TestSuite;
 7 | 
 8 | #[Disabled('The AttachToTestSuite is disabled')]
 9 | class MyTestSuite extends TestSuite {
10 | 
11 | }


--------------------------------------------------------------------------------
/acme_src/ExplicitTestSuite/TestSuiteDisabledHookNotInvoked/MyTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ExplicitTestSuite\TestSuiteDisabledHookNotInvoked;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 6 | use Cspray\Labrador\AsyncUnit\Attribute\AttachToTestSuite;
 7 | use Cspray\Labrador\AsyncUnit\TestCase;
 8 | 
 9 | #[AttachToTestSuite(MyTestSuite::class)]
10 | class MyTestCase extends TestCase {
11 | 
12 |     #[Test]
13 |     public function testSomething() {
14 | 
15 |     }
16 | 
17 | }


--------------------------------------------------------------------------------
/acme_src/ExplicitTestSuite/TestSuiteHasTimeout/FirstTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ExplicitTestSuite\TestSuiteHasTimeout;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 6 | use Cspray\Labrador\AsyncUnit\TestCase;
 7 | 
 8 | class FirstTestCase extends TestCase {
 9 | 
10 |     #[Test]
11 |     public function testOne() {
12 | 
13 |     }
14 | 
15 | }


--------------------------------------------------------------------------------
/acme_src/ExplicitTestSuite/TestSuiteHasTimeout/MyTestSuite.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ExplicitTestSuite\TestSuiteHasTimeout;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\DefaultTestSuite;
 6 | use Cspray\Labrador\AsyncUnit\Attribute\Timeout;
 7 | use Cspray\Labrador\AsyncUnit\TestSuite;
 8 | 
 9 | #[Timeout(125)]
10 | #[DefaultTestSuite]
11 | class MyTestSuite extends TestSuite {
12 | 
13 | }


--------------------------------------------------------------------------------
/acme_src/ExplicitTestSuite/TestSuiteHasTimeout/SecondTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ExplicitTestSuite\TestSuiteHasTimeout;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 6 | use Cspray\Labrador\AsyncUnit\TestCase;
 7 | 
 8 | class SecondTestCase extends TestCase {
 9 | 
10 |     #[Test]
11 |     public function testTwo() {
12 | 
13 |     }
14 | 
15 | }


--------------------------------------------------------------------------------
/acme_src/ExplicitTestSuite/TestSuiteHookPriority/MyTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Acme\DemoSuites\ExplicitTestSuite\TestSuiteHookPriority;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\AttachToTestSuite;
 6 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 7 | use Cspray\Labrador\AsyncUnit\TestCase;
 8 | 
 9 | #[AttachToTestSuite(MyTestSuite::class)]
10 | class MyTestCase extends TestCase {
11 | 
12 |     #[Test]
13 |     public function testSomething() {
14 |         $this->assert()->isTrue(true);
15 |     }
16 | 
17 | }


--------------------------------------------------------------------------------
/acme_src/ExplicitTestSuite/TestSuiteStateBeforeAll/FirstTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ExplicitTestSuite\TestSuiteStateBeforeAll;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 6 | use Cspray\Labrador\AsyncUnit\TestCase;
 7 | 
 8 | class FirstTestCase extends TestCase {
 9 | 
10 |     #[Test]
11 |     public function checkTestSuiteData() {
12 |         $this->assert()->stringEquals('bar', $this->testSuite()->get('foo'));
13 |     }
14 | 
15 | }


--------------------------------------------------------------------------------
/acme_src/ExplicitTestSuite/TestSuiteStateBeforeAll/MyTestSuite.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ExplicitTestSuite\TestSuiteStateBeforeAll;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\BeforeAll;
 6 | use Cspray\Labrador\AsyncUnit\Attribute\DefaultTestSuite;
 7 | use Cspray\Labrador\AsyncUnit\TestSuite;
 8 | 
 9 | #[DefaultTestSuite]
10 | class MyTestSuite extends TestSuite {
11 | 
12 |     #[BeforeAll]
13 |     public function setInitialState() {
14 |         $this->set('foo', 'bar');
15 |     }
16 | 
17 | }


--------------------------------------------------------------------------------
/acme_src/ImplicitDefaultTestSuite/CustomAssertions/MyTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ImplicitDefaultTestSuite\CustomAssertions;
 4 | 
 5 | use Amp\Success;
 6 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 7 | use Cspray\Labrador\AsyncUnit\TestCase;
 8 | 
 9 | class MyTestCase extends TestCase {
10 | 
11 |     #[Test]
12 |     public function ensureCustomAssertionsPass() {
13 |         $this->assert()->theCustomAssertion('foo', 'bar');
14 |         yield $this->asyncAssert()->theCustomAssertion('foo', new Success('bar'));
15 |     }
16 | 
17 | }


--------------------------------------------------------------------------------
/acme_src/ImplicitDefaultTestSuite/ExceptionThrowingAfterAll/MyTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | 
 4 | namespace Acme\DemoSuites\ImplicitDefaultTestSuite\ExceptionThrowingAfterAll;
 5 | 
 6 | 
 7 | use Cspray\Labrador\AsyncUnit\Attribute\AfterAll;
 8 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 9 | use Cspray\Labrador\AsyncUnit\TestCase;
10 | 
11 | class MyTestCase extends TestCase {
12 | 
13 |     #[AfterAll]
14 |     public static function afterAll() {
15 |         throw new \RuntimeException('Thrown in the class afterAll');
16 |     }
17 | 
18 |     #[Test]
19 |     public static function ensureSomething() {
20 | 
21 |     }
22 | 
23 | }


--------------------------------------------------------------------------------
/acme_src/ImplicitDefaultTestSuite/ExceptionThrowingAfterEach/MyTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | 
 4 | namespace Acme\DemoSuites\ImplicitDefaultTestSuite\ExceptionThrowingAfterEach;
 5 | 
 6 | 
 7 | use Cspray\Labrador\AsyncUnit\Attribute\AfterEach;
 8 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 9 | use Cspray\Labrador\AsyncUnit\TestCase;
10 | 
11 | class MyTestCase extends TestCase {
12 | 
13 |     #[AfterEach]
14 |     public function afterEach() {
15 |         throw new \RuntimeException('Thrown in the object afterEach');
16 |     }
17 | 
18 |     #[Test]
19 |     public static function ensureSomething() {
20 | 
21 |     }
22 | 
23 | 
24 | }


--------------------------------------------------------------------------------
/acme_src/ImplicitDefaultTestSuite/ExceptionThrowingBeforeAll/MyTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | 
 4 | namespace Acme\DemoSuites\ImplicitDefaultTestSuite\ExceptionThrowingBeforeAll;
 5 | 
 6 | 
 7 | use Cspray\Labrador\AsyncUnit\Attribute\BeforeAll;
 8 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 9 | use Cspray\Labrador\AsyncUnit\TestCase;
10 | 
11 | class MyTestCase extends TestCase {
12 | 
13 |     #[BeforeAll]
14 |     public static function beforeAll() {
15 |         throw new \RuntimeException('Thrown in the class beforeAll');
16 |     }
17 | 
18 |     #[Test]
19 |     public static function ensureSomething() {
20 | 
21 |     }
22 | 
23 | 
24 | }


--------------------------------------------------------------------------------
/acme_src/ImplicitDefaultTestSuite/ExceptionThrowingBeforeEach/MyTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | 
 4 | namespace Acme\DemoSuites\ImplicitDefaultTestSuite\ExceptionThrowingBeforeEach;
 5 | 
 6 | 
 7 | use Cspray\Labrador\AsyncUnit\Attribute\BeforeEach;
 8 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 9 | use Cspray\Labrador\AsyncUnit\TestCase;
10 | 
11 | class MyTestCase extends TestCase {
12 | 
13 |     #[BeforeEach]
14 |     public function beforeEach() {
15 |         throw new \RuntimeException('Thrown in the object beforeEach');
16 |     }
17 | 
18 |     #[Test]
19 |     public static function ensureSomething() {
20 | 
21 |     }
22 | 
23 | 
24 | }


--------------------------------------------------------------------------------
/acme_src/ImplicitDefaultTestSuite/ExceptionThrowingTest/MyTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ImplicitDefaultTestSuite\ExceptionThrowingTest;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 6 | use Cspray\Labrador\AsyncUnit\TestCase;
 7 | 
 8 | class MyTestCase extends TestCase {
 9 | 
10 |     #[Test]
11 |     public function throwsException() {
12 |         throw new \Exception('Test failure');
13 |     }
14 | 
15 | }


--------------------------------------------------------------------------------
/acme_src/ImplicitDefaultTestSuite/ExceptionThrowingTest/async-unit.json:
--------------------------------------------------------------------------------
1 | {
2 |   "testDirs": ["./acme_src/ImplicitDefaultTestSuite/ExceptionThrowingTest"],
3 |   "resultPrinter": "Cspray\\Labrador\\AsyncUnitCli\\TerminalResultPrinter"
4 | }


--------------------------------------------------------------------------------
/acme_src/ImplicitDefaultTestSuite/ExceptionThrowingTestWithAfterEachHook/MyTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ImplicitDefaultTestSuite\ExceptionThrowingTestWithAfterEachHook;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\AfterEach;
 6 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 7 | use Cspray\Labrador\AsyncUnit\TestCase;
 8 | 
 9 | class MyTestCase extends TestCase {
10 | 
11 |     private bool $afterHookCalled = false;
12 | 
13 |     #[Test]
14 |     public function throwsException() {
15 |         throw new \Exception('Test failure');
16 |     }
17 | 
18 |     #[AfterEach]
19 |     public function afterExceptionThrown() {
20 |         $this->afterHookCalled = true;
21 |     }
22 | 
23 |     public function getAfterHookCalled() {
24 |         return $this->afterHookCalled;
25 |     }
26 | 
27 | }


--------------------------------------------------------------------------------
/acme_src/ImplicitDefaultTestSuite/ExtendedTestCases/AbstractFourthTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ImplicitDefaultTestSuite\ExtendedTestCases;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 6 | 
 7 | abstract class AbstractFourthTestCase extends ThirdTestCase {
 8 | 
 9 |     #[Test]
10 |     public function fourthEnsureSomething() {
11 |         $this->assert()->isNull(null);
12 |         $this->assert()->isFalse(false);
13 |         $this->assert()->isTrue(true);
14 |         $this->assert()->stringEquals('AsyncUnit', 'AsyncUnit');
15 |     }
16 | 
17 | }


--------------------------------------------------------------------------------
/acme_src/ImplicitDefaultTestSuite/ExtendedTestCases/AbstractSecondTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | 
 4 | namespace Acme\DemoSuites\ImplicitDefaultTestSuite\ExtendedTestCases;
 5 | 
 6 | 
 7 | use Amp\Success;
 8 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 9 | 
10 | abstract class AbstractSecondTestCase extends FirstTestCase {
11 | 
12 |     #[Test]
13 |     public function secondEnsureSomething() {
14 |         $this->assert()->intEquals(42, 42);
15 |         yield $this->asyncAssert()->isFalse(new Success(false));
16 |     }
17 | 
18 | }


--------------------------------------------------------------------------------
/acme_src/ImplicitDefaultTestSuite/ExtendedTestCases/FifthTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ImplicitDefaultTestSuite\ExtendedTestCases;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 6 | 
 7 | class FifthTestCase extends AbstractFourthTestCase {
 8 | 
 9 |     #[Test]
10 |     public function fifthEnsureSomething() {
11 |         $this->assert()->isFalse(false);
12 |         $this->assert()->not()->stringEquals('AsyncUnit', 'PHPUnit');
13 |         $this->assert()->intEquals(1, 1);
14 |         $this->assert()->floatEquals(3.14, 3.14);
15 |         $this->assert()->isTrue(false);
16 |     }
17 | 
18 | }


--------------------------------------------------------------------------------
/acme_src/ImplicitDefaultTestSuite/ExtendedTestCases/FirstTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ImplicitDefaultTestSuite\ExtendedTestCases;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 6 | use Cspray\Labrador\AsyncUnit\TestCase;
 7 | 
 8 | class FirstTestCase extends TestCase {
 9 | 
10 |     #[Test]
11 |     public function firstEnsureSomething() {
12 |         $this->assert()->stringEquals('foo', 'foo');
13 |     }
14 | 
15 | }


--------------------------------------------------------------------------------
/acme_src/ImplicitDefaultTestSuite/ExtendedTestCases/ThirdTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ImplicitDefaultTestSuite\ExtendedTestCases;
 4 | 
 5 | use Amp\Success;
 6 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 7 | 
 8 | class ThirdTestCase extends AbstractSecondTestCase {
 9 | 
10 |     #[Test]
11 |     public function thirdEnsureSomething() {
12 |         yield $this->asyncAssert()->arrayEquals([1,2,3], new Success([1,2,3]));
13 |         $this->assert()->stringEquals('bar', 'bar');
14 |         $this->assert()->isNull(null);
15 |     }
16 | 
17 | }


--------------------------------------------------------------------------------
/acme_src/ImplicitDefaultTestSuite/FailedAssertion/MyTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ImplicitDefaultTestSuite\FailedAssertion;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 6 | use Cspray\Labrador\AsyncUnit\TestCase;
 7 | 
 8 | class MyTestCase extends TestCase {
 9 | 
10 |     #[Test]
11 |     public function alwaysFails() {
12 |         $this->assert()->stringEquals('foo', 'bar');
13 |     }
14 | 
15 | }


--------------------------------------------------------------------------------
/acme_src/ImplicitDefaultTestSuite/FailedNotAssertion/MyTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ImplicitDefaultTestSuite\FailedNotAssertion;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 6 | use Cspray\Labrador\AsyncUnit\TestCase;
 7 | 
 8 | class MyTestCase extends TestCase {
 9 | 
10 |     #[Test]
11 |     public function checkFailedNotAssertion() {
12 |         $this->assert()->not()->stringEquals('foo', 'foo');
13 |     }
14 | 
15 | }


--------------------------------------------------------------------------------
/acme_src/ImplicitDefaultTestSuite/HandleNonPhpFiles/MyTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ImplicitDefaultTestSuite\HandleNonPhpFiles;
 4 | 
 5 | use Amp\Success;
 6 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 7 | use Cspray\Labrador\AsyncUnit\TestCase;
 8 | 
 9 | class MyTestCase extends TestCase {
10 | 
11 |     #[Test]
12 |     public function checkAsyncNull() {
13 |         yield $this->asyncAssert()->isNull(new Success(null));
14 |     }
15 | 
16 | }


--------------------------------------------------------------------------------
/acme_src/ImplicitDefaultTestSuite/HandleNonPhpFiles/something-else.xml:
--------------------------------------------------------------------------------
1 | <some>
2 |     <xml>
3 |         <document>Something</document>
4 |     </xml>
5 | </some>


--------------------------------------------------------------------------------
/acme_src/ImplicitDefaultTestSuite/HandleNonPhpFiles/something.json:
--------------------------------------------------------------------------------
1 | {
2 |   "foo": "bar"
3 | }


--------------------------------------------------------------------------------
/acme_src/ImplicitDefaultTestSuite/HasAssertionPlugin/MyCustomAssertionPlugin.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | 
 4 | namespace Acme\DemoSuites\ImplicitDefaultTestSuite\HasAssertionPlugin;
 5 | 
 6 | use Amp\Promise;
 7 | use Amp\Success;
 8 | use Cspray\Labrador\AsyncUnit\Context\CustomAssertionContext;
 9 | use Cspray\Labrador\AsyncUnit\CustomAssertionPlugin;
10 | 
11 | class MyCustomAssertionPlugin implements CustomAssertionPlugin {
12 | 
13 |     public function registerCustomAssertions(CustomAssertionContext $customAssertionContext) : Promise {
14 |         return new Success();
15 |     }
16 | 
17 | }


--------------------------------------------------------------------------------
/acme_src/ImplicitDefaultTestSuite/HasAssertionPlugin/MyOtherCustomAssertionPlugin.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ImplicitDefaultTestSuite\HasAssertionPlugin;
 4 | 
 5 | use Amp\Promise;
 6 | use Amp\Success;
 7 | use Countable;
 8 | use Cspray\Labrador\AsyncUnit\Assertion\AssertIsTrue;
 9 | use Cspray\Labrador\AsyncUnit\Context\CustomAssertionContext;
10 | use Cspray\Labrador\AsyncUnit\CustomAssertionPlugin;
11 | use Stringable;
12 | 
13 | class MyOtherCustomAssertionPlugin implements Countable, Stringable, CustomAssertionPlugin {
14 | 
15 |     public function registerCustomAssertions(CustomAssertionContext $customAssertionContext) : Promise {
16 |         $customAssertionContext->registerAssertion('myOtherCustomAssertion', function() {
17 |             return new AssertIsTrue(true);
18 |         });
19 |         return new Success();
20 |     }
21 | 
22 |     public function __toString() {
23 |         return '';
24 |     }
25 | 
26 |     public function count() {
27 |         return 0;
28 |     }
29 | }


--------------------------------------------------------------------------------
/acme_src/ImplicitDefaultTestSuite/HasAssertionPlugin/MyTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ImplicitDefaultTestSuite\HasAssertionPlugin;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 6 | use Cspray\Labrador\AsyncUnit\TestCase;
 7 | 
 8 | class MyTestCase extends TestCase {
 9 | 
10 |     #[Test]
11 |     public function ensureSomething() {
12 |         $this->assert()->myOtherCustomAssertion();
13 |     }
14 | 
15 | }


--------------------------------------------------------------------------------
/acme_src/ImplicitDefaultTestSuite/HasDataProvider/MyTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ImplicitDefaultTestSuite\HasDataProvider;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\DataProvider;
 6 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 7 | use Cspray\Labrador\AsyncUnit\TestCase;
 8 | 
 9 | class MyTestCase extends TestCase {
10 | 
11 |     private int $counter = 0;
12 | 
13 |     public function myDataProvider() : array {
14 |         return [
15 |             ['foo', 'foo'],
16 |             ['bar', 'bar'],
17 |             ['baz', 'baz']
18 |         ];
19 |     }
20 | 
21 |     #[Test]
22 |     #[DataProvider('myDataProvider')]
23 |     public function ensureStringsEqual(string $expected, string $actual) : void {
24 |         $this->counter++;
25 |         $this->assert()->stringEquals($expected, $actual);
26 |     }
27 | 
28 |     public function getCounter() : int {
29 |         return $this->counter;
30 |     }
31 | }


--------------------------------------------------------------------------------
/acme_src/ImplicitDefaultTestSuite/HasNotTestCaseObject/MyTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ImplicitDefaultTestSuite\HasNotTestCaseObject;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 6 | use Cspray\Labrador\AsyncUnit\TestCase;
 7 | 
 8 | class MyTestCase extends TestCase {
 9 | 
10 |     public function getName() {
11 |         return self::class;
12 |     }
13 | 
14 |     #[Test]
15 |     public function ensureSomethingHappens() {
16 | 
17 |     }
18 | }


--------------------------------------------------------------------------------
/acme_src/ImplicitDefaultTestSuite/HasNotTestCaseObject/NotTestCase.php:
--------------------------------------------------------------------------------
1 | <?php declare(strict_types=1);
2 | 
3 | namespace Acme\DemoSuites\ImplicitDefaultTestSuite\HasNotTestCaseObject;
4 | 
5 | class NotTestCase {
6 | 
7 | }


--------------------------------------------------------------------------------
/acme_src/ImplicitDefaultTestSuite/HasResultPrinterPlugin/MyResultPrinterPlugin.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ImplicitDefaultTestSuite\HasResultPrinterPlugin;
 4 | 
 5 | use Amp\ByteStream\OutputStream;
 6 | use Cspray\Labrador\AsyncEvent\EventEmitter;
 7 | use Cspray\Labrador\AsyncUnit\ResultPrinterPlugin;
 8 | use Cspray\Labrador\AsyncUnit\Event\TestProcessedEvent;
 9 | use Cspray\Labrador\AsyncUnit\Events;
10 | 
11 | class MyResultPrinterPlugin implements ResultPrinterPlugin {
12 | 
13 |     public function registerEvents(EventEmitter $emitter, OutputStream $output) : void {
14 |         $emitter->on(Events::TEST_PROCESSED, function(TestProcessedEvent $event) use($output) {
15 |             yield $output->write($event->getTarget()->getTestCase()::class . "\n");
16 |             yield $output->write($event->getTarget()->getTestMethod() . "\n");
17 |         });
18 |     }
19 | 
20 | }


--------------------------------------------------------------------------------
/acme_src/ImplicitDefaultTestSuite/HasResultPrinterPlugin/MyTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ImplicitDefaultTestSuite\HasResultPrinterPlugin;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 6 | use Cspray\Labrador\AsyncUnit\TestCase;
 7 | 
 8 | class MyTestCase extends TestCase {
 9 | 
10 |     #[Test]
11 |     public function checkSomething() {
12 |         $this->assert()->stringEquals('foo', 'foo');
13 |     }
14 | 
15 | }


--------------------------------------------------------------------------------
/acme_src/ImplicitDefaultTestSuite/HasSingleAfterAllHook/MyTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ImplicitDefaultTestSuite\HasSingleAfterAllHook;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\AfterAll;
 6 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 7 | use Cspray\Labrador\AsyncUnit\TestCase;
 8 | 
 9 | class MyTestCase extends TestCase {
10 | 
11 |     private static array $classData = [];
12 |     private array $objectData = [];
13 | 
14 |     #[AfterAll]
15 |     public static function afterAll() {
16 |         self::$classData[] = 'afterAll';
17 |     }
18 | 
19 |     #[Test]
20 |     public function ensureSomething() {
21 |         $this->objectData[] = 'ensureSomething';
22 |     }
23 | 
24 |     #[Test]
25 |     public function ensureSomethingTwice() {
26 |         $this->objectData[] = 'ensureSomethingTwice';
27 |     }
28 | 
29 |     public function getCombinedData() : array {
30 |         return array_merge([], self::$classData, $this->objectData);
31 |     }
32 | }


--------------------------------------------------------------------------------
/acme_src/ImplicitDefaultTestSuite/HasSingleAfterEachHook/MyTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ImplicitDefaultTestSuite\HasSingleAfterEachHook;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\AfterEach;
 6 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 7 | use Cspray\Labrador\AsyncUnit\TestCase;
 8 | 
 9 | class MyTestCase extends TestCase {
10 | 
11 |     private array $data = [];
12 | 
13 |     #[AfterEach]
14 |     public function afterEach() {
15 |         $this->data[] = 'afterEach';
16 |     }
17 | 
18 |     #[Test]
19 |     public function ensureSomething() {
20 |         $this->data[] = 'ensureSomething';
21 |     }
22 | 
23 |     #[Test]
24 |     public function ensureSomethingTwice() {
25 |         $this->data[] = 'ensureSomethingTwice';
26 |     }
27 | 
28 |     public function getData() : array {
29 |         return $this->data;
30 |     }
31 | }


--------------------------------------------------------------------------------
/acme_src/ImplicitDefaultTestSuite/HasSingleBeforeEachHook/MyTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ImplicitDefaultTestSuite\HasSingleBeforeEachHook;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\BeforeAll;
 6 | use Cspray\Labrador\AsyncUnit\Attribute\BeforeEach;
 7 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 8 | use Cspray\Labrador\AsyncUnit\TestCase;
 9 | 
10 | class MyTestCase extends TestCase {
11 | 
12 |     private array $data = [];
13 | 
14 |     #[BeforeEach]
15 |     public function beforeEach() {
16 |         $this->data[]  = 'beforeEach';
17 |     }
18 | 
19 |     #[Test]
20 |     public function ensureSomething() {
21 |         $this->data[] = 'ensureSomething';
22 |     }
23 | 
24 |     #[Test]
25 |     public function ensureSomethingTwice() {
26 |         $this->data[] = 'ensureSomethingTwice';
27 |     }
28 | 
29 |     public function getData() : array {
30 |         return $this->data;
31 |     }
32 | }


--------------------------------------------------------------------------------
/acme_src/ImplicitDefaultTestSuite/KitchenSink/FirstTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ImplicitDefaultTestSuite\KitchenSink;
 4 | 
 5 | use Amp\Success;
 6 | use Cspray\Labrador\AsyncUnit\Attribute\AttachToTestSuite;
 7 | use Cspray\Labrador\AsyncUnit\Attribute\Disabled;
 8 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 9 | use Cspray\Labrador\AsyncUnit\TestCase;
10 | 
11 | #[AttachToTestSuite(FirstTestSuite::class)]
12 | class FirstTestCase extends TestCase {
13 | 
14 |     #[Test]
15 |     public function testOne() {
16 |         $this->assert()->countEquals(3, [1, 2, 3]);
17 |     }
18 | 
19 |     #[Test]
20 |     public function testTwo() {
21 |         yield $this->asyncAssert()->countEquals(4, new Success(['a', 'b', 'c', 'd']));
22 |     }
23 | 
24 |     #[Test]
25 |     #[Disabled]
26 |     public function disabledTest() {
27 |         throw new \RuntimeException('We should not run this');
28 |     }
29 | 
30 | }


--------------------------------------------------------------------------------
/acme_src/ImplicitDefaultTestSuite/KitchenSink/FirstTestSuite.php:
--------------------------------------------------------------------------------
1 | <?php declare(strict_types=1);
2 | 
3 | namespace Acme\DemoSuites\ImplicitDefaultTestSuite\KitchenSink;
4 | 
5 | use Cspray\Labrador\AsyncUnit\TestSuite;
6 | 
7 | class FirstTestSuite extends TestSuite {
8 | 
9 | }


--------------------------------------------------------------------------------
/acme_src/ImplicitDefaultTestSuite/KitchenSink/SecondBreakfast/BadTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ImplicitDefaultTestSuite\KitchenSink\SecondBreakfast;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 6 | use Cspray\Labrador\AsyncUnit\TestCase;
 7 | 
 8 | class BadTestCase extends TestCase {
 9 | 
10 |     #[Test]
11 |     public function throwException() {
12 |         throw new \RuntimeException(__METHOD__);
13 |     }
14 | 
15 | }


--------------------------------------------------------------------------------
/acme_src/ImplicitDefaultTestSuite/KitchenSink/SecondBreakfast/FoodAndBeverageTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ImplicitDefaultTestSuite\KitchenSink\SecondBreakfast;
 4 | 
 5 | use Amp\Success;
 6 | use Cspray\Labrador\AsyncUnit\Attribute\DataProvider;
 7 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 8 | use Cspray\Labrador\AsyncUnit\TestCase;
 9 | 
10 | class FoodAndBeverageTestCase extends TestCase {
11 | 
12 |     public function foodProvider() {
13 |         return [
14 |             ['Bacon', 'Bacon'],
15 |             ['Eggs', 'Eggs'],
16 |             ['Hash Browns', 'Hash Browns'],
17 |             ['Grits', 'Grits']
18 |         ];
19 |     }
20 | 
21 |     #[Test]
22 |     #[DataProvider('foodProvider')]
23 |     public function checkFood(string $a, string $b) {
24 |         yield $this->asyncAssert()->stringEquals($a, new Success($b));
25 |     }
26 | 
27 | }


--------------------------------------------------------------------------------
/acme_src/ImplicitDefaultTestSuite/KitchenSink/SecondTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ImplicitDefaultTestSuite\KitchenSink;
 4 | 
 5 | use Amp\Success;
 6 | use Cspray\Labrador\AsyncUnit\Attribute\AttachToTestSuite;
 7 | use Cspray\Labrador\AsyncUnit\Attribute\Disabled;
 8 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 9 | use Cspray\Labrador\AsyncUnit\TestCase;
10 | 
11 | #[AttachToTestSuite(FirstTestSuite::class)]
12 | class SecondTestCase extends TestCase {
13 | 
14 |     #[Test]
15 |     public function checkTwo() {
16 |         $this->assert()->instanceOf(TestCase::class, $this);
17 |         yield $this->asyncAssert()->instanceOf(TestCase::class, new Success($this));
18 |     }
19 | 
20 |     #[Test]
21 |     #[Disabled]
22 |     public function checkTwoDisabled() {
23 |         throw new \RuntimeException('We should not run this');
24 |     }
25 | 
26 | }


--------------------------------------------------------------------------------
/acme_src/ImplicitDefaultTestSuite/KitchenSink/WhatAbout/BilboTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ImplicitDefaultTestSuite\KitchenSink\WhatAbout;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\AttachToTestSuite;
 6 | use Cspray\Labrador\AsyncUnit\Attribute\Disabled;
 7 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 8 | use Cspray\Labrador\AsyncUnit\TestCase;
 9 | 
10 | #[AttachToTestSuite(PotatoTestSuite::class)]
11 | class BilboTestCase extends TestCase {
12 | 
13 |     #[Test]
14 |     #[Disabled]
15 |     public function isBestHobbit() {
16 |         throw new \RuntimeException('Bilbo doesn\'t come on this adventure.');
17 |     }
18 | 
19 | }


--------------------------------------------------------------------------------
/acme_src/ImplicitDefaultTestSuite/KitchenSink/WhatAbout/FrodoTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ImplicitDefaultTestSuite\KitchenSink\WhatAbout;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\AttachToTestSuite;
 6 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 7 | use Cspray\Labrador\AsyncUnit\TestCase;
 8 | 
 9 | #[AttachToTestSuite(PotatoTestSuite::class)]
10 | class FrodoTestCase extends TestCase {
11 | 
12 |     #[Test]
13 |     public function isBestHobbit() {
14 |         $this->assert()->stringEquals('Frodo', $this->testSuite()->get('bestHobbit'));
15 |     }
16 | 
17 | }


--------------------------------------------------------------------------------
/acme_src/ImplicitDefaultTestSuite/KitchenSink/WhatAbout/PotatoTestSuite.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ImplicitDefaultTestSuite\KitchenSink\WhatAbout;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\BeforeAll;
 6 | use Cspray\Labrador\AsyncUnit\TestSuite;
 7 | 
 8 | class PotatoTestSuite extends TestSuite {
 9 | 
10 |     #[BeforeAll]
11 |     public function setBestHobbit() {
12 |         $this->set('bestHobbit', 'Samwise');
13 |     }
14 | 
15 | 
16 | }


--------------------------------------------------------------------------------
/acme_src/ImplicitDefaultTestSuite/KitchenSink/WhatAbout/SamwiseTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | 
 4 | namespace Acme\DemoSuites\ImplicitDefaultTestSuite\KitchenSink\WhatAbout;
 5 | 
 6 | use Cspray\Labrador\AsyncUnit\Attribute\AttachToTestSuite;
 7 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 8 | use Cspray\Labrador\AsyncUnit\TestCase;
 9 | 
10 | #[AttachToTestSuite(PotatoTestSuite::class)]
11 | class SamwiseTestCase extends TestCase {
12 | 
13 |     #[Test]
14 |     public function isBestHobbit() {
15 |         $this->assert()->stringEquals('Samwise', $this->testSuite()->get('bestHobbit'));
16 |     }
17 | 
18 | }


--------------------------------------------------------------------------------
/acme_src/ImplicitDefaultTestSuite/MockeryTestNoAssertion/MyTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ImplicitDefaultTestSuite\MockeryTestNoAssertion;
 4 | 
 5 | use Amp\Success;
 6 | use Cspray\Labrador\Application;
 7 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 8 | use Cspray\Labrador\AsyncUnit\TestCase;
 9 | use Generator;
10 | use Mockery\MockInterface;
11 | 
12 | class MyTestCase extends TestCase {
13 | 
14 |     #[Test]
15 |     public function checkMockExpectations() : Generator {
16 |         /** @var MockInterface $mock */
17 |         $mock = $this->mocks()->createMock(Application::class);
18 | 
19 |         $mock->expects()->start()->andReturn(new Success());
20 | 
21 |         yield $mock->start();
22 |     }
23 | 
24 | }


--------------------------------------------------------------------------------
/acme_src/ImplicitDefaultTestSuite/MultipleBeforeAllHooks/FirstTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ImplicitDefaultTestSuite\MultipleBeforeAllHooks;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\BeforeAll;
 6 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 7 | use Cspray\Labrador\AsyncUnit\TestCase;
 8 | 
 9 | class FirstTestCase extends TestCase {
10 | 
11 |     private static string $state = '';
12 | 
13 |     #[BeforeAll]
14 |     public static function setState() : void {
15 |         self::$state = self::class;
16 |     }
17 | 
18 |     #[Test]
19 |     public function checkState() {
20 |         $this->assert()->stringEquals(self::class, self::$state);
21 |     }
22 | 
23 |     public function getState() : string {
24 |         return self::$state;
25 |     }
26 | 
27 | }


--------------------------------------------------------------------------------
/acme_src/ImplicitDefaultTestSuite/MultipleBeforeAllHooks/SecondTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ImplicitDefaultTestSuite\MultipleBeforeAllHooks;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\BeforeAll;
 6 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 7 | use Cspray\Labrador\AsyncUnit\TestCase;
 8 | 
 9 | class SecondTestCase extends TestCase {
10 | 
11 |     private static string $state = '';
12 | 
13 |     #[BeforeAll]
14 |     public static function setStateAgain() : void {
15 |         self::$state = self::class;
16 |     }
17 | 
18 |     #[Test]
19 |     public function checkState() {
20 |         $this->assert()->stringEquals(self::class, self::$state);
21 |     }
22 | 
23 |     public function getState() : string {
24 |         return self::$state;
25 |     }
26 | 
27 | }


--------------------------------------------------------------------------------
/acme_src/ImplicitDefaultTestSuite/MultipleTestCase/BarTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | 
 4 | namespace Acme\DemoSuites\ImplicitDefaultTestSuite\MultipleTestCase;
 5 | 
 6 | 
 7 | use Amp\Delayed;
 8 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 9 | use Cspray\Labrador\AsyncUnit\TestCase;
10 | 
11 | class BarTestCase extends TestCase {
12 | 
13 |     private bool $testInvoked = false;
14 | 
15 |     #[Test]
16 |     public function ensureSomething() {
17 |         yield new Delayed(100);
18 |         $this->testInvoked = true;
19 |     }
20 | 
21 |     public function getName() : string {
22 |         return self::class;
23 |     }
24 | 
25 |     public function getTestInvoked() : bool {
26 |         return $this->testInvoked;
27 |     }
28 | }


--------------------------------------------------------------------------------
/acme_src/ImplicitDefaultTestSuite/MultipleTestCase/BazTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ImplicitDefaultTestSuite\MultipleTestCase;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 6 | use Cspray\Labrador\AsyncUnit\TestCase;
 7 | 
 8 | class BazTestCase extends TestCase {
 9 | 
10 |     private bool $testInvoked = false;
11 | 
12 |     #[Test]
13 |     public function ensureSomething() {
14 |         $this->testInvoked = true;
15 |     }
16 | 
17 |     public function getName() : string {
18 |         return self::class;
19 |     }
20 | 
21 |     public function getTestInvoked() : bool {
22 |         return $this->testInvoked;
23 |     }
24 | }


--------------------------------------------------------------------------------
/acme_src/ImplicitDefaultTestSuite/MultipleTestCase/FooTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ImplicitDefaultTestSuite\MultipleTestCase;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 6 | use Cspray\Labrador\AsyncUnit\TestCase;
 7 | use function Amp\call;
 8 | 
 9 | class FooTestCase extends TestCase {
10 | 
11 |     private int $testCounter = 0;
12 | 
13 |     public function getName() : string {
14 |         return self::class;
15 |     }
16 | 
17 |     #[Test]
18 |     public function ensureSomething() {
19 |         return call(function() {
20 |             $this->testCounter++;
21 |         });
22 |     }
23 | 
24 |     #[Test]
25 |     public function ensureSomethingTwice() {
26 |         return call(function() {
27 |             $this->testCounter++;
28 |         });
29 |     }
30 | 
31 |     public function getTestCounter() {
32 |         return $this->testCounter;
33 |     }
34 | 
35 | }


--------------------------------------------------------------------------------
/acme_src/ImplicitDefaultTestSuite/MultipleTestsKnownDuration/FirstTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ImplicitDefaultTestSuite\MultipleTestsKnownDuration;
 4 | 
 5 | use Amp\Delayed;
 6 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 7 | use Cspray\Labrador\AsyncUnit\TestCase;
 8 | 
 9 | class FirstTestCase extends TestCase {
10 | 
11 |     #[Test]
12 |     public function checkOne() {
13 |         yield new Delayed(100);
14 |         $this->assert()->arrayEquals([1, 2, 3], [1, 2, 3]);
15 |     }
16 | 
17 | }


--------------------------------------------------------------------------------
/acme_src/ImplicitDefaultTestSuite/MultipleTestsKnownDuration/SecondTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | 
 4 | namespace Acme\DemoSuites\ImplicitDefaultTestSuite\MultipleTestsKnownDuration;
 5 | 
 6 | 
 7 | use Amp\Delayed;
 8 | use Amp\Success;
 9 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
10 | use Cspray\Labrador\AsyncUnit\TestCase;
11 | 
12 | class SecondTestCase extends TestCase {
13 | 
14 |     #[Test]
15 |     public function checkOne() {
16 |         yield new Delayed(100);
17 |         yield $this->asyncAssert()->isEmpty(new Success([]));
18 |     }
19 | 
20 |     #[Test]
21 |     public function checkTwo() {
22 |         yield new Delayed(100);
23 |         $this->assert()->isTrue(true);
24 |     }
25 | 
26 | }


--------------------------------------------------------------------------------
/acme_src/ImplicitDefaultTestSuite/MultipleTestsKnownDuration/ThirdTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ImplicitDefaultTestSuite\MultipleTestsKnownDuration;
 4 | 
 5 | use Amp\Delayed;
 6 | use Amp\Success;
 7 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 8 | use Cspray\Labrador\AsyncUnit\TestCase;
 9 | 
10 | class ThirdTestCase extends TestCase {
11 | 
12 |     #[Test]
13 |     public function checkOne() {
14 |         yield new Delayed(100);
15 |         $this->assert()->floatEquals(3.14, 3.14);
16 |     }
17 | 
18 |     #[Test]
19 |     public function checkTwo() {
20 |         yield new Delayed(100);
21 |         yield $this->asyncAssert()->stringEquals('AsyncUnit', new Success('AsyncUnit'));
22 |     }
23 | 
24 |     #[Test]
25 |     public function checkThree() {
26 |         yield new Delayed(100);
27 |         $this->assert()->countEquals(2, ['a', 0]);
28 |     }
29 | 
30 | }


--------------------------------------------------------------------------------
/acme_src/ImplicitDefaultTestSuite/NoAssertions/MyTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ImplicitDefaultTestSuite\NoAssertions;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 6 | use Cspray\Labrador\AsyncUnit\TestCase;
 7 | 
 8 | class MyTestCase extends TestCase {
 9 | 
10 |     #[Test]
11 |     public function noAssertions() {
12 | 
13 |     }
14 | 
15 | }


--------------------------------------------------------------------------------
/acme_src/ImplicitDefaultTestSuite/RecursiveTestLayout/TestOne.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ImplicitDefaultTestSuite\RecursiveTestLayout;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 6 | use Cspray\Labrador\AsyncUnit\TestCase;
 7 | 
 8 | class TestOne extends TestCase {
 9 | 
10 |     #[Test]
11 |     public function testOne() {
12 | 
13 |     }
14 | 
15 | }


--------------------------------------------------------------------------------
/acme_src/ImplicitDefaultTestSuite/RecursiveTestLayout/Two/TestTwo.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ImplicitDefaultTestSuite\RecursiveTestLayout\Two;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 6 | use Cspray\Labrador\AsyncUnit\TestCase;
 7 | 
 8 | class TestTwo extends TestCase {
 9 | 
10 |     #[Test]
11 |     public function testTwo() {
12 | 
13 |     }
14 | 
15 | }


--------------------------------------------------------------------------------
/acme_src/ImplicitDefaultTestSuite/RecursiveTestLayout/Two/Three/Four/Five/TestFive.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ImplicitDefaultTestSuite\RecursiveTestLayout\Two\Three\Four\Five;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 6 | use Cspray\Labrador\AsyncUnit\TestCase;
 7 | 
 8 | class TestFive extends TestCase {
 9 | 
10 |     #[Test]
11 |     public function testFive() {
12 | 
13 |     }
14 | 
15 | }


--------------------------------------------------------------------------------
/acme_src/ImplicitDefaultTestSuite/RecursiveTestLayout/Two/Three/Four/TestFour.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ImplicitDefaultTestSuite\RecursiveTestLayout\Two\Three\Four;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 6 | use Cspray\Labrador\AsyncUnit\TestCase;
 7 | 
 8 | class TestFour extends TestCase {
 9 | 
10 |     #[Test]
11 |     public function testFour() {
12 | 
13 |     }
14 | 
15 | }


--------------------------------------------------------------------------------
/acme_src/ImplicitDefaultTestSuite/RecursiveTestLayout/Two/Three/TestThree.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ImplicitDefaultTestSuite\RecursiveTestLayout\Two\Three;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 6 | use Cspray\Labrador\AsyncUnit\TestCase;
 7 | 
 8 | class TestThree extends TestCase {
 9 | 
10 |     #[Test]
11 |     public function testThree() {
12 | 
13 |     }
14 | 
15 | }


--------------------------------------------------------------------------------
/acme_src/ImplicitDefaultTestSuite/SingleMockTest/MyTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ImplicitDefaultTestSuite\SingleMockTest;
 4 | 
 5 | use Cspray\Labrador\Application;
 6 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 7 | use Cspray\Labrador\AsyncUnit\TestCase;
 8 | 
 9 | class MyTestCase extends TestCase {
10 | 
11 |     private ?object $createdMock = null;
12 | 
13 |     #[Test]
14 |     public function checkCreatingMockObject() {
15 |         $this->createdMock = $this->mocks()->createMock(Application::class);
16 |         $this->assert()->not()->isNull($this->createdMock);
17 |     }
18 | 
19 |     public function getCreatedMock() : ?object {
20 |         return $this->createdMock;
21 |     }
22 | 
23 | 
24 | }


--------------------------------------------------------------------------------
/acme_src/ImplicitDefaultTestSuite/SingleTest/MyTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | 
 4 | namespace Acme\DemoSuites\ImplicitDefaultTestSuite\SingleTest;
 5 | 
 6 | use Amp\Delayed;
 7 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 8 | use Cspray\Labrador\AsyncUnit\TestCase;
 9 | use Generator;
10 | 
11 | class MyTestCase extends TestCase {
12 | 
13 |     private bool $testInvoked = false;
14 | 
15 |     #[Test]
16 |     public function ensureSomethingHappens() : Generator {
17 |         yield new Delayed(10);
18 |         $this->testInvoked = true;
19 |         $this->assert()->stringEquals('foo', 'foo');
20 |     }
21 | 
22 |     public function getTestInvoked() : bool {
23 |         return $this->testInvoked;
24 |     }
25 | }


--------------------------------------------------------------------------------
/acme_src/ImplicitDefaultTestSuite/SingleTest/async-unit.json:
--------------------------------------------------------------------------------
1 | {
2 |   "testDirs": ["./acme_src/ImplicitDefaultTestSuite/SingleTest"],
3 |   "resultPrinter": "Cspray\\Labrador\\AsyncUnitCli\\TerminalResultPrinter"
4 | }


--------------------------------------------------------------------------------
/acme_src/ImplicitDefaultTestSuite/SingleTestAsyncAssertion/MyTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ImplicitDefaultTestSuite\SingleTestAsyncAssertion;
 4 | 
 5 | use Amp\Success;
 6 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 7 | use Cspray\Labrador\AsyncUnit\TestCase;
 8 | 
 9 | class MyTestCase extends TestCase {
10 | 
11 |     #[Test]
12 |     public function ensureAsyncAssert() {
13 |         yield $this->asyncAssert()->stringEquals('foo', new Success('foo'));
14 |     }
15 | 
16 | }


--------------------------------------------------------------------------------
/acme_src/ImplicitDefaultTestSuite/SingleTestDisabled/MyTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ImplicitDefaultTestSuite\SingleTestDisabled;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\Disabled;
 6 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 7 | use Cspray\Labrador\AsyncUnit\TestCase;
 8 | 
 9 | class MyTestCase extends TestCase {
10 | 
11 |     #[Test]
12 |     #[Disabled]
13 |     public function skippedTest() {
14 |         throw new \RuntimeException('We should not actually execute this function');
15 |     }
16 | 
17 | }


--------------------------------------------------------------------------------
/acme_src/ImplicitDefaultTestSuite/TestCaseDisabled/MyTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ImplicitDefaultTestSuite\TestCaseDisabled;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\Disabled;
 6 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 7 | use Cspray\Labrador\AsyncUnit\TestCase;
 8 | 
 9 | #[Disabled]
10 | class MyTestCase extends TestCase {
11 | 
12 |     private array $data = [];
13 | 
14 |     #[Test]
15 |     public function skippedOne() {
16 |         $this->data[] = '1';
17 |     }
18 | 
19 |     #[Test]
20 |     public function skippedTwo() {
21 |         $this->data[] = '2';
22 |     }
23 | 
24 |     #[Test]
25 |     public function skippedThree() {
26 |         $this->data[] = '3';
27 |     }
28 | 
29 |     public function getData() : array {
30 |         return $this->data;
31 |     }
32 | 
33 | }


--------------------------------------------------------------------------------
/acme_src/ImplicitDefaultTestSuite/TestCaseDisabledCustomMessage/MyTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ImplicitDefaultTestSuite\TestCaseDisabledCustomMessage;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\Disabled;
 6 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 7 | use Cspray\Labrador\AsyncUnit\TestCase;
 8 | 
 9 | #[Disabled('The TestCase is disabled')]
10 | class MyTestCase extends TestCase {
11 | 
12 |     #[Test]
13 |     public function testOne() {
14 | 
15 |     }
16 | 
17 | }


--------------------------------------------------------------------------------
/acme_src/ImplicitDefaultTestSuite/TestCaseHasTimeout/MyTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ImplicitDefaultTestSuite\TestCaseHasTimeout;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 6 | use Cspray\Labrador\AsyncUnit\Attribute\Timeout;
 7 | use Cspray\Labrador\AsyncUnit\TestCase;
 8 | 
 9 | #[Timeout(150)]
10 | class MyTestCase extends TestCase {
11 | 
12 |     #[Test]
13 |     public function testOne() {
14 | 
15 |     }
16 | 
17 |     #[Test]
18 |     public function testTwo() {
19 | 
20 |     }
21 | }


--------------------------------------------------------------------------------
/acme_src/ImplicitDefaultTestSuite/TestDisabled/MyTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ImplicitDefaultTestSuite\TestDisabled;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\Disabled;
 6 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 7 | use Cspray\Labrador\AsyncUnit\TestCase;
 8 | 
 9 | class MyTestCase extends TestCase {
10 | 
11 |     #[Test]
12 |     public function checkSomething() {
13 |         $this->assert()->stringEquals('AsyncUnit', 'AsyncUnit');
14 |     }
15 | 
16 |     #[Test]
17 |     #[Disabled]
18 |     public function skippedTest() {
19 |         throw new \RuntimeException('We should not actually execute this function');
20 |     }
21 | 
22 | }


--------------------------------------------------------------------------------
/acme_src/ImplicitDefaultTestSuite/TestDisabledCustomMessage/MyTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ImplicitDefaultTestSuite\TestDisabledCustomMessage;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\Disabled;
 6 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 7 | use Cspray\Labrador\AsyncUnit\TestCase;
 8 | 
 9 | class MyTestCase extends TestCase {
10 | 
11 |     #[Disabled('Not sure what we should do here yet')]
12 |     #[Test]
13 |     public function testOne() {
14 | 
15 |     }
16 | 
17 | }


--------------------------------------------------------------------------------
/acme_src/ImplicitDefaultTestSuite/TestDisabledEvents/MyTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ImplicitDefaultTestSuite\TestDisabledEvents;
 4 | 
 5 | use Amp\Success;
 6 | use Cspray\Labrador\AsyncUnit\Attribute\Disabled;
 7 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 8 | use Cspray\Labrador\AsyncUnit\TestCase;
 9 | 
10 | class MyTestCase extends TestCase {
11 | 
12 |     #[Test]
13 |     public function testFailingFloatEquals() {
14 |         yield $this->asyncAssert()->not()->floatEquals(3.14, new Success(3.14));
15 |     }
16 | 
17 |     #[Test]
18 |     public function testIsTrue() {
19 |         yield $this->asyncAssert()->isTrue(new Success(true));
20 |     }
21 | 
22 |     #[Test]
23 |     #[Disabled]
24 |     public function testIsDisabled() {
25 | 
26 |     }
27 | 
28 | }


--------------------------------------------------------------------------------
/acme_src/ImplicitDefaultTestSuite/TestExpectsExceptionDoesNotThrow/MyTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ImplicitDefaultTestSuite\TestExpectsExceptionDoesNotThrow;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 6 | use Cspray\Labrador\AsyncUnit\Exception\InvalidArgumentException;
 7 | use Cspray\Labrador\AsyncUnit\TestCase;
 8 | 
 9 | class MyTestCase extends TestCase {
10 | 
11 |     #[Test]
12 |     public function checkDoesNotThrow() {
13 |         $this->expect()->exception(InvalidArgumentException::class);
14 | 
15 |         $this->assert()->isEmpty([]);
16 |     }
17 | 
18 | }


--------------------------------------------------------------------------------
/acme_src/ImplicitDefaultTestSuite/TestExpectsExceptionMessage/MyTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ImplicitDefaultTestSuite\TestExpectsExceptionMessage;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 6 | use Cspray\Labrador\AsyncUnit\Exception\InvalidArgumentException;
 7 | use Cspray\Labrador\AsyncUnit\TestCase;
 8 | 
 9 | class MyTestCase extends TestCase {
10 | 
11 |     #[Test]
12 |     public function checkExceptionMessage() {
13 |         $this->expect()->exception(InvalidArgumentException::class);
14 |         $this->expect()->exceptionMessage('This is the message that I expect');
15 | 
16 |         throw new InvalidArgumentException('This is the message that I expect');
17 |     }
18 | 
19 | }


--------------------------------------------------------------------------------
/acme_src/ImplicitDefaultTestSuite/TestExpectsExceptionOnly/MyTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ImplicitDefaultTestSuite\TestExpectsExceptionOnly;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 6 | use Cspray\Labrador\AsyncUnit\Exception\Exception;
 7 | use Cspray\Labrador\AsyncUnit\Exception\InvalidArgumentException;
 8 | use Cspray\Labrador\AsyncUnit\TestCase;
 9 | 
10 | class MyTestCase extends TestCase {
11 | 
12 |     #[Test]
13 |     public function checkWhenExpectException() {
14 |         $this->expect()->exception(Exception::class);
15 | 
16 |         throw new InvalidArgumentException('The message does not matter');
17 |     }
18 | 
19 | }


--------------------------------------------------------------------------------
/acme_src/ImplicitDefaultTestSuite/TestExpectsExceptionWrongMessage/MyTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ImplicitDefaultTestSuite\TestExpectsExceptionWrongMessage;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 6 | use Cspray\Labrador\AsyncUnit\Exception\InvalidArgumentException;
 7 | use Cspray\Labrador\AsyncUnit\TestCase;
 8 | 
 9 | class MyTestCase extends TestCase {
10 | 
11 |     #[Test]
12 |     public function checkExceptionMessage() {
13 |         $this->expect()->exception(InvalidArgumentException::class);
14 |         $this->expect()->exceptionMessage('This is the message that I expect');
15 | 
16 |         throw new InvalidArgumentException('This is NOT the message that I expect');
17 |     }
18 | 
19 | }


--------------------------------------------------------------------------------
/acme_src/ImplicitDefaultTestSuite/TestExpectsExceptionWrongType/MyTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ImplicitDefaultTestSuite\TestExpectsExceptionWrongType;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 6 | use Cspray\Labrador\AsyncUnit\Exception\InvalidArgumentException;
 7 | use Cspray\Labrador\AsyncUnit\Exception\InvalidStateException;
 8 | use Cspray\Labrador\AsyncUnit\TestCase;
 9 | 
10 | class MyTestCase extends TestCase {
11 | 
12 |     #[Test]
13 |     public function checkWrongExceptionThrown() {
14 |         $this->expect()->exception(InvalidArgumentException::class);
15 | 
16 |         throw new InvalidStateException();
17 |     }
18 | 
19 | }


--------------------------------------------------------------------------------
/acme_src/ImplicitDefaultTestSuite/TestExpectsNoAssertions/MyTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ImplicitDefaultTestSuite\TestExpectsNoAssertions;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 6 | use Cspray\Labrador\AsyncUnit\TestCase;
 7 | 
 8 | class MyTestCase extends TestCase {
 9 | 
10 |     #[Test]
11 |     public function testNoAssertionRequired() : void {
12 |         $this->expect()->noAssertions();
13 |     }
14 | 
15 | }


--------------------------------------------------------------------------------
/acme_src/ImplicitDefaultTestSuite/TestExpectsNoAssertionsAssertMade/MyTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ImplicitDefaultTestSuite\TestExpectsNoAssertionsAssertMade;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 6 | use Cspray\Labrador\AsyncUnit\TestCase;
 7 | 
 8 | class MyTestCase extends TestCase {
 9 | 
10 |     #[Test]
11 |     public function testNoAssertionAssertionMade() : void {
12 |         $this->expect()->noAssertions();
13 |         $this->assert()->isNull(null);
14 |         $this->assert()->isTrue(true);
15 |     }
16 | 
17 | }


--------------------------------------------------------------------------------
/acme_src/ImplicitDefaultTestSuite/TestExpectsNoAsyncAssertionsAssertMade/MyTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ImplicitDefaultTestSuite\TestExpectsNoAsyncAssertionsAssertMade;
 4 | 
 5 | use Amp\Success;
 6 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 7 | use Cspray\Labrador\AsyncUnit\TestCase;
 8 | 
 9 | class MyTestCase extends TestCase {
10 | 
11 |     #[Test]
12 |     public function noAssertionButAsyncAssertionMade() {
13 |         $this->expect()->noAssertions();
14 | 
15 |         yield $this->asyncAssert()->isNull(new Success(null));
16 |         yield $this->asyncAssert()->isEmpty(new Success([]));
17 |     }
18 | 
19 | }


--------------------------------------------------------------------------------
/acme_src/ImplicitDefaultTestSuite/TestFailedExceptionThrowingTest/MyTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ImplicitDefaultTestSuite\TestFailedExceptionThrowingTest;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 6 | use Cspray\Labrador\AsyncUnit\Exception\TestFailedException;
 7 | use Cspray\Labrador\AsyncUnit\TestCase;
 8 | 
 9 | class MyTestCase extends TestCase {
10 | 
11 |     #[Test]
12 |     public function ensureSomethingFails() {
13 |         throw new TestFailedException('Something barfed');
14 |     }
15 | 
16 | }


--------------------------------------------------------------------------------
/acme_src/ImplicitDefaultTestSuite/TestHasOutput/MyTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ImplicitDefaultTestSuite\TestHasOutput;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 6 | use Cspray\Labrador\AsyncUnit\TestCase;
 7 | 
 8 | class MyTestCase extends TestCase {
 9 | 
10 |     #[Test]
11 |     public function testProducesOutput() {
12 |         $this->assert()->stringEquals('something', 'something');
13 |         echo __FUNCTION__;
14 |     }
15 | 
16 | }


--------------------------------------------------------------------------------
/acme_src/ImplicitDefaultTestSuite/TestHasTimeout/MyTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ImplicitDefaultTestSuite\TestHasTimeout;
 4 | 
 5 | use Amp\Delayed;
 6 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 7 | use Cspray\Labrador\AsyncUnit\Attribute\Timeout;
 8 | use Cspray\Labrador\AsyncUnit\TestCase;
 9 | use Generator;
10 | 
11 | class MyTestCase extends TestCase {
12 | 
13 |     #[Test]
14 |     #[Timeout(100)]
15 |     public function timeOutTest() : Generator {
16 |         yield new Delayed(200);
17 |         $this->assert()->stringEquals('a', 'a');
18 |     }
19 | 
20 | }


--------------------------------------------------------------------------------
/acme_src/ImplicitDefaultTestSuite/TestKnownRunTime/MyTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ImplicitDefaultTestSuite\TestKnownRunTime;
 4 | 
 5 | use Amp\Delayed;
 6 | use Amp\Success;
 7 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 8 | use Cspray\Labrador\AsyncUnit\TestCase;
 9 | 
10 | class MyTestCase extends TestCase {
11 | 
12 |     #[Test]
13 |     public function testTiming() {
14 |         yield new Delayed(500);
15 |         yield $this->asyncAssert()->floatEquals(3.14, new Success(3.14));
16 |     }
17 | 
18 | }


--------------------------------------------------------------------------------
/acme_src/ImplicitDefaultTestSuite/WithAsyncUnitConfig/async-unit.json:
--------------------------------------------------------------------------------
1 | {
2 |   "testDirs": ["tests"]
3 | }
4 | 


--------------------------------------------------------------------------------
/acme_src/ImplicitDefaultTestSuite/WithAsyncUnitConfig/tests/Bar/FooTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ImplicitDefaultTestSuite\WithAsyncUnitConfig\tests\Bar;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 6 | use Cspray\Labrador\AsyncUnit\TestCase;
 7 | 
 8 | class FooTestCase extends TestCase {
 9 | 
10 |     #[Test]
11 |     public function testIntEquals() {
12 |         $this->assert()->intEquals(1, 1);
13 |     }
14 | 
15 | }


--------------------------------------------------------------------------------
/acme_src/ImplicitDefaultTestSuite/WithAsyncUnitConfig/tests/Foo/BarTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\DemoSuites\ImplicitDefaultTestSuite\WithAsyncUnitConfig\tests\Foo;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 6 | use Cspray\Labrador\AsyncUnit\TestCase;
 7 | 
 8 | class BarTestCase extends TestCase {
 9 | 
10 |     #[Test]
11 |     public function ensureStringEquals() {
12 |         $this->assert()->not()->stringEquals('foo', 'bar');
13 |     }
14 | 
15 | }


--------------------------------------------------------------------------------
/bin/asyncunit:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/php
 2 | <?php
 3 | 
 4 | namespace Cspray\Labrador\AsyncUnit;
 5 | 
 6 | $cwd = getcwd();
 7 | 
 8 | require_once $cwd . '/vendor/autoload.php';
 9 | 
10 | use Cspray\Labrador\AsyncUnitCli\AsyncUnitConsoleApplication;
11 | use Cspray\Labrador\EnvironmentType;
12 | use Cspray\Labrador\StandardEnvironment;
13 | use Psr\Log\NullLogger;
14 | use function Amp\ByteStream\getStdout;
15 | use function Amp\File\filesystem;
16 | 
17 | $environment = new StandardEnvironment(EnvironmentType::Development());
18 | $logger = new NullLogger();
19 | $configurationFactory = new JsonConfigurationFactory();
20 | 
21 | $application = new AsyncUnitConsoleApplication(
22 |     $environment,
23 |     $logger,
24 |     filesystem(),
25 |     $configurationFactory,
26 |     getStdout(),
27 |     $cwd . '/async-unit.json'
28 | );
29 | 
30 | $application->run();
31 | 


--------------------------------------------------------------------------------
/cli_src/Command/AbstractCommand.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnitCli\Command;
 4 | 
 5 | use Symfony\Component\Console\Command\Command;
 6 | use Symfony\Component\Console\Input\InputInterface;
 7 | use Symfony\Component\Console\Output\OutputInterface;
 8 | use Symfony\Component\Console\Question\ConfirmationQuestion;
 9 | 
10 | abstract class AbstractCommand extends Command {
11 | 
12 |     public function __construct() {
13 |         parent::__construct($this->getCommandName());
14 |     }
15 | 
16 |     protected function confirm(InputInterface $input, OutputInterface $output, string $question, bool $default = false) : bool {
17 |         stream_set_blocking(STDIN, true);
18 |         $answerGuide = $default ? '(Y/n)' : '(y/N)';
19 |         $confirmationQuestion = new ConfirmationQuestion(sprintf("%s %s ", $question, $answerGuide), $default);
20 |         $answer = $this->getHelper('question')->ask($input, $output, $confirmationQuestion);
21 |         stream_set_blocking(STDIN, false);
22 |         return $answer;
23 |     }
24 | 
25 |     abstract protected function getCommandName() : string;
26 | 
27 | }


--------------------------------------------------------------------------------
/cli_src/Exception/Exception.php:
--------------------------------------------------------------------------------
1 | <?php declare(strict_types=1);
2 | 
3 | namespace Cspray\Labrador\AsyncUnitCli\Exception;
4 | 
5 | use Cspray\Labrador\Exception\Exception as LabradorException;
6 | 
7 | class Exception extends LabradorException {
8 | 
9 | }


--------------------------------------------------------------------------------
/cli_test/Integration/error_test_output.phpt:
--------------------------------------------------------------------------------
 1 | --TEST--
 2 | Ensure erroring test shows appropriate output
 3 | --FILE--
 4 | <?php
 5 | 
 6 | use function Cspray\Labrador\AsyncUnitCli\Integration\runTests;
 7 | 
 8 | require_once __DIR__ . '/helpers.php';
 9 | 
10 | runTests('/acme_src/ImplicitDefaultTestSuite/ExceptionThrowingTest/async-unit.json');
11 | ?>
12 | --EXPECTF--
13 | AsyncUnit v%s - %s
14 | 
15 | Runtime: PHP 8.%d.%d
16 | 
17 | %sE%s
18 | 
19 | Time: %d:%f, Memory: %d.%d MB
20 | 
21 | There was 1 error:
22 | 
23 | 1) Acme\DemoSuites\ImplicitDefaultTestSuite\ExceptionThrowingTest\MyTestCase::throwsException
24 | An unexpected exception of type "Exception" with code 0 and message "Test failure" was thrown from #[Test] Acme\DemoSuites\ImplicitDefaultTestSuite\ExceptionThrowingTest\MyTestCase::throwsException
25 | 
26 | %a
27 | 
28 | ERRORS
29 | Tests: 1, Errors: 1, Assertions: 0, Async Assertions: 0
30 | 
31 | Status: 0


--------------------------------------------------------------------------------
/cli_test/Integration/helpers.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnitCli\Integration;
 4 | 
 5 | function runTests(string $configFile) {
 6 |     $root = dirname(__DIR__, 2);
 7 |     $configPath = $root . '/' . $configFile;
 8 |     $command = "cd $root && php $root/bin/asyncunit run --config $configPath";
 9 | 
10 |     passthru($command, $statusCode);
11 |     echo PHP_EOL, 'Status: ', $statusCode, PHP_EOL;
12 | }
13 | 


--------------------------------------------------------------------------------
/cli_test/Integration/single_test_output.phpt:
--------------------------------------------------------------------------------
 1 | --TEST--
 2 | Ensure single passing test shows appropriate output
 3 | --FILE--
 4 | <?php
 5 | 
 6 | use function Cspray\Labrador\AsyncUnitCli\Integration\runTests;
 7 | 
 8 | require_once __DIR__ . '/helpers.php';
 9 | 
10 | runTests('/acme_src/ImplicitDefaultTestSuite/SingleTest/async-unit.json');
11 | ?>
12 | --EXPECTF--
13 | AsyncUnit v%s - %s
14 | 
15 | Runtime: PHP 8.%d.%d
16 | 
17 | %s.%s
18 | 
19 | Time: %d:%f, Memory: %d.%d MB
20 | 
21 | OK!
22 | Tests: 1, Assertions: 1, Async Assertions: 0
23 | 
24 | Status: 0


--------------------------------------------------------------------------------
/examples/blog_introduction_src/ExampleFour/MyTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\Examples\BlogIntroduction\ExampleFour;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 6 | use Cspray\Labrador\AsyncUnit\TestCase;
 7 | use Amp\Delayed;
 8 | use Amp\Promise;
 9 | use Generator;
10 | use function Amp\call;
11 | 
12 | function getAsyncString() : Promise {
13 |     return call(function() {
14 |         yield new Delayed(100); // emulating some interaction with I/O
15 |         return 'AsyncUnit';
16 |     });
17 | }
18 | 
19 | class MyTestCase extends TestCase {
20 | 
21 |     #[Test]
22 |     public function checkStringEquals() : void {
23 |         $this->assert()->stringEquals('AsyncUnit', 'AsyncUnit');
24 |     }
25 | 
26 |     #[Test]
27 |     public function checkAsyncIo() : Generator {
28 |         yield $this->asyncAssert()->stringEquals('AsyncUnit', getAsyncString());
29 |     }
30 | }


--------------------------------------------------------------------------------
/examples/blog_introduction_src/ExampleOne/MyTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\Examples\BlogIntroduction\ExampleOne;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 6 | use Cspray\Labrador\AsyncUnit\TestCase;
 7 | 
 8 | class MyTestCase extends TestCase {
 9 | 
10 |     #[Test]
11 |     public function checkStringEquals() : void {
12 |     }
13 | 
14 | }


--------------------------------------------------------------------------------
/examples/blog_introduction_src/ExampleThree/MyTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\Examples\BlogIntroduction\ExampleThree;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 6 | use Cspray\Labrador\AsyncUnit\TestCase;
 7 | 
 8 | class MyTestCase extends TestCase {
 9 | 
10 |     #[Test]
11 |     public function checkStringEquals() : void {
12 |         $this->assert()->stringEquals('AsyncUnit', 'AsyncUnit');
13 |     }
14 | 
15 | }


--------------------------------------------------------------------------------
/examples/blog_introduction_src/ExampleTwo/MyTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\Examples\BlogIntroduction\ExampleTwo;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 6 | use Cspray\Labrador\AsyncUnit\TestCase;
 7 | 
 8 | class MyTestCase extends TestCase {
 9 | 
10 |     #[Test]
11 |     public function checkStringEquals() : void {
12 |         $this->assert()->stringEquals('AsyncUnit', 'PHPUnit');
13 |     }
14 | 
15 | }


--------------------------------------------------------------------------------
/examples/custom_assertion_src/MyAssertion.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\Examples\CustomAssertion;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Assertion;
 6 | use Cspray\Labrador\AsyncUnit\AssertionResult;
 7 | 
 8 | class MyAssertion implements Assertion {
 9 | 
10 |     public function __construct(private mixed $actual) {}
11 | 
12 |     public function assert() : AssertionResult {
13 |         $assert = new Assertion\AssertStringEquals('AsyncUnit', $this->actual);
14 |         return $assert->assert();
15 |     }
16 | 
17 | }


--------------------------------------------------------------------------------
/examples/custom_assertion_src/MyAssertionPlugin.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\Examples\CustomAssertion;
 4 | 
 5 | use Amp\Promise;
 6 | use Cspray\Labrador\AsyncUnit\Context\CustomAssertionContext;
 7 | use Cspray\Labrador\AsyncUnit\CustomAssertionPlugin;
 8 | use function Amp\call;
 9 | 
10 | class MyAssertionPlugin implements CustomAssertionPlugin {
11 | 
12 |     public function registerCustomAssertions(CustomAssertionContext $customAssertionContext) : Promise {
13 |         return call(function() use($customAssertionContext) {
14 |             $customAssertionContext->registerAssertion('isAsyncUnitString', fn($actual) => new MyAssertion($actual));
15 |         });
16 |     }
17 | 
18 | }


--------------------------------------------------------------------------------
/examples/custom_assertion_src/TestCaseUsesMyAssertion.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Acme\Examples\CustomAssertion;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 6 | use Cspray\Labrador\AsyncUnit\TestCase;
 7 | 
 8 | class TestCaseUsesMyAssertion extends TestCase {
 9 | 
10 |     #[Test]
11 |     public function ensureAsyncUnitStringEquals() {
12 |         $this->assert()->isAsyncUnitString('AsyncUnit');
13 |     }
14 | 
15 |     #[Test]
16 |     public function ensurePhpUnitStringNotEquals() {
17 |         $this->assert()->not()->isAsyncUnitString('PHPUnit');
18 |     }
19 | 
20 | }


--------------------------------------------------------------------------------
/framework_src/Assertion/AbstractAssertion.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit\Assertion;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Assertion;
 6 | use Cspray\Labrador\AsyncUnit\AssertionMessage;
 7 | use Cspray\Labrador\AsyncUnit\AssertionResult;
 8 | 
 9 | abstract class AbstractAssertion implements Assertion {
10 | 
11 |     public function __construct(private mixed $expected, private mixed $actual) {}
12 | 
13 |     final public function assert() : AssertionResult {
14 |         $factoryMethod = $this->expected === $this->actual ? 'validAssertion' : 'invalidAssertion';
15 |         return AssertionResultFactory::$factoryMethod($this->getSummary(), $this->getDetails());
16 |     }
17 | 
18 |     abstract protected function getSummary() : AssertionMessage;
19 | 
20 |     abstract protected function getDetails() : AssertionMessage;
21 | 
22 |     protected function getExpected() : mixed {
23 |         return $this->expected;
24 |     }
25 | 
26 |     protected function getActual() : mixed {
27 |         return $this->actual;
28 |     }
29 | 
30 | }


--------------------------------------------------------------------------------
/framework_src/Assertion/AbstractAsyncAssertion.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit\Assertion;
 4 | 
 5 | use Amp\Coroutine;
 6 | use Amp\Promise;
 7 | use Cspray\Labrador\AsyncUnit\Assertion;
 8 | use Cspray\Labrador\AsyncUnit\AsyncAssertion;
 9 | use Generator;
10 | use function Amp\call;
11 | 
12 | abstract class AbstractAsyncAssertion implements AsyncAssertion {
13 | 
14 |     public function __construct(private Promise|Generator|Coroutine $actual) {}
15 | 
16 |     final public function assert() : Promise {
17 |         return call(function() {
18 |             $actual = yield call(fn() => $this->actual);
19 |             $assertion = $this->getAssertion($actual);
20 |             return $assertion->assert();
21 |         });
22 |     }
23 | 
24 |     abstract protected function getAssertion(mixed $resolvedActual) : Assertion;
25 | }


--------------------------------------------------------------------------------
/framework_src/Assertion/AssertArrayEquals.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit\Assertion;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Assertion;
 6 | use Cspray\Labrador\AsyncUnit\AssertionMessage;
 7 | use Cspray\Labrador\AsyncUnit\Assertion\AssertionMessage\BinaryOperandSummary;
 8 | 
 9 | final class AssertArrayEquals extends AbstractAssertion implements Assertion {
10 | 
11 |     protected function getSummary() : AssertionMessage {
12 |         return new BinaryOperandSummary($this->getExpected(), $this->getActual());
13 |     }
14 | 
15 |     protected function getDetails() : AssertionMessage {
16 |         return new BinaryOperandSummary($this->getExpected(), $this->getActual());
17 |     }
18 | 
19 | }


--------------------------------------------------------------------------------
/framework_src/Assertion/AssertCountEquals.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit\Assertion;
 4 | 
 5 | use Countable;
 6 | use Cspray\Labrador\AsyncUnit\Assertion;
 7 | use Cspray\Labrador\AsyncUnit\AssertionMessage;
 8 | use Cspray\Labrador\AsyncUnit\AssertionResult;
 9 | 
10 | final class AssertCountEquals implements Assertion {
11 | 
12 |     public function __construct(private int $expected, private array|Countable $actual) {}
13 | 
14 |     public function assert() : AssertionResult {
15 |         $factoryMethod = count($this->actual) === $this->expected ? 'validAssertion' : 'invalidAssertion';
16 |         return AssertionResultFactory::$factoryMethod(
17 |             $this->getSummary(),
18 |             $this->getDetails()
19 |         );
20 |     }
21 | 
22 |     private function getSummary() : AssertionMessage {
23 |         return new Assertion\AssertionMessage\CountEqualsMessage($this->expected, $this->actual);
24 |     }
25 | 
26 |     private function getDetails() : AssertionMessage {
27 |         return new Assertion\AssertionMessage\CountEqualsMessage($this->expected, $this->actual);
28 |     }
29 | }


--------------------------------------------------------------------------------
/framework_src/Assertion/AssertFloatEquals.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit\Assertion;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Assertion;
 6 | use Cspray\Labrador\AsyncUnit\Assertion\AssertionMessage\BinaryOperandSummary;
 7 | use Cspray\Labrador\AsyncUnit\AssertionMessage;
 8 | 
 9 | final class AssertFloatEquals extends AbstractAssertion implements Assertion {
10 |     protected function getSummary() : AssertionMessage {
11 |         return new BinaryOperandSummary($this->getExpected(), $this->getActual());
12 |     }
13 | 
14 |     protected function getDetails() : AssertionMessage {
15 |         return new BinaryOperandSummary($this->getExpected(), $this->getActual());
16 |     }
17 | }


--------------------------------------------------------------------------------
/framework_src/Assertion/AssertIntEquals.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit\Assertion;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Assertion;
 6 | use Cspray\Labrador\AsyncUnit\Assertion\AssertionMessage\BinaryOperandSummary;
 7 | use Cspray\Labrador\AsyncUnit\AssertionMessage;
 8 | 
 9 | final class AssertIntEquals extends AbstractAssertion implements Assertion {
10 | 
11 |     protected function getSummary() : AssertionMessage {
12 |         return new BinaryOperandSummary($this->getExpected(), $this->getActual());
13 |     }
14 | 
15 |     protected function getDetails() : AssertionMessage {
16 |         return new BinaryOperandSummary($this->getExpected(), $this->getActual());
17 |     }
18 | }


--------------------------------------------------------------------------------
/framework_src/Assertion/AssertIsEmpty.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit\Assertion;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Assertion;
 6 | use Cspray\Labrador\AsyncUnit\AssertionResult;
 7 | 
 8 | final class AssertIsEmpty implements Assertion {
 9 | 
10 |     public function __construct(private mixed $actual) {}
11 | 
12 |     public function assert() : AssertionResult {
13 |         $factoryMethod = empty($this->actual) ? 'validAssertion' : 'invalidAssertion';
14 |         return AssertionResultFactory::$factoryMethod(
15 |             new Assertion\AssertionMessage\EmptyUnaryOperandSummary($this->actual),
16 |             new Assertion\AssertionMessage\EmptyUnaryOperandDetails($this->actual)
17 |         );
18 |     }
19 | }


--------------------------------------------------------------------------------
/framework_src/Assertion/AssertIsFalse.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit\Assertion;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Assertion;
 6 | use Cspray\Labrador\AsyncUnit\Assertion\AssertionMessage\FalseUnaryOperandDetails;
 7 | use Cspray\Labrador\AsyncUnit\Assertion\AssertionMessage\FalseUnaryOperandSummary;
 8 | use Cspray\Labrador\AsyncUnit\AssertionMessage;
 9 | 
10 | final class AssertIsFalse extends AbstractAssertion implements Assertion {
11 | 
12 |     public function __construct(mixed $actual) {
13 |         parent::__construct(false, $actual);
14 |     }
15 | 
16 |     protected function getSummary() : AssertionMessage {
17 |         return new FalseUnaryOperandSummary($this->getActual());
18 |     }
19 | 
20 |     protected function getDetails() : AssertionMessage {
21 |         return new FalseUnaryOperandDetails($this->getActual());
22 |     }
23 | }


--------------------------------------------------------------------------------
/framework_src/Assertion/AssertIsNull.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit\Assertion;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Assertion;
 6 | use Cspray\Labrador\AsyncUnit\Assertion\AssertionMessage\NullUnaryOperandDetails;
 7 | use Cspray\Labrador\AsyncUnit\Assertion\AssertionMessage\NullUnaryOperandSummary;
 8 | use Cspray\Labrador\AsyncUnit\AssertionMessage;
 9 | 
10 | final class AssertIsNull extends AbstractAssertion implements Assertion {
11 |     public function __construct(mixed $actual) {
12 |         parent::__construct(null, $actual);
13 |     }
14 | 
15 |     protected function getSummary() : AssertionMessage {
16 |         return new NullUnaryOperandSummary($this->getActual());
17 |     }
18 | 
19 |     protected function getDetails() : AssertionMessage {
20 |         return new NullUnaryOperandDetails($this->getActual());
21 |     }
22 | 
23 | }


--------------------------------------------------------------------------------
/framework_src/Assertion/AssertIsTrue.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit\Assertion;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Assertion;
 6 | use Cspray\Labrador\AsyncUnit\Assertion\AssertionMessage\TrueUnaryOperandDetails;
 7 | use Cspray\Labrador\AsyncUnit\Assertion\AssertionMessage\TrueUnaryOperandSummary;
 8 | use Cspray\Labrador\AsyncUnit\AssertionMessage;
 9 | 
10 | final class AssertIsTrue extends AbstractAssertion implements Assertion {
11 |     public function __construct(mixed $actual) {
12 |         parent::__construct(true, $actual);
13 |     }
14 | 
15 |     protected function getSummary() : AssertionMessage {
16 |         return new TrueUnaryOperandSummary($this->getActual());
17 |     }
18 | 
19 |     protected function getDetails() : AssertionMessage {
20 |         return new TrueUnaryOperandDetails($this->getActual());
21 |     }
22 | }


--------------------------------------------------------------------------------
/framework_src/Assertion/AssertStringEquals.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit\Assertion;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Assertion;
 6 | use Cspray\Labrador\AsyncUnit\Assertion\AssertionMessage\BinaryOperandDetails;
 7 | use Cspray\Labrador\AsyncUnit\Assertion\AssertionMessage\BinaryOperandSummary;
 8 | use Cspray\Labrador\AsyncUnit\AssertionMessage;
 9 | 
10 | final class AssertStringEquals extends AbstractAssertion implements Assertion {
11 |     protected function getSummary() : AssertionMessage {
12 |         return new BinaryOperandSummary($this->getExpected(), $this->getActual());
13 |     }
14 | 
15 |     protected function getDetails() : AssertionMessage {
16 |         return new BinaryOperandDetails($this->getExpected(), $this->getActual());
17 |     }
18 | }


--------------------------------------------------------------------------------
/framework_src/Assertion/AssertionMessage/BinaryOperandDetails.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit\Assertion\AssertionMessage;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\AssertionMessage;
 6 | 
 7 | final class BinaryOperandDetails implements AssertionMessage {
 8 | 
 9 |     public function __construct(private mixed $expected, private mixed $actual) {}
10 | 
11 |     public function toString() : string {
12 |         return sprintf(
13 |             'comparing actual value %s equals %s',
14 |             var_export($this->actual, true),
15 |             var_export($this->expected, true)
16 |         );
17 |     }
18 | 
19 |     public function toNotString() : string {
20 |         return sprintf(
21 |             'comparing actual value %s does not equal %s',
22 |             var_export($this->actual, true),
23 |             var_export($this->expected, true)
24 |         );
25 |     }
26 | }


--------------------------------------------------------------------------------
/framework_src/Assertion/AssertionMessage/BinaryOperandSummary.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit\Assertion\AssertionMessage;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\AssertionMessage;
 6 | 
 7 | final class BinaryOperandSummary implements AssertionMessage {
 8 | 
 9 |     public function __construct(private mixed $expected, private mixed $actual) {}
10 | 
11 |     public function toString() : string {
12 |         return sprintf(
13 |             'asserting type "%s" equals type "%s"',
14 |             strtolower(gettype($this->expected)),
15 |             strtolower(gettype($this->actual))
16 |         );
17 |     }
18 | 
19 |     public function toNotString() : string {
20 |         return sprintf(
21 |             'asserting type "%s" does not equal type "%s"',
22 |             strtolower(gettype($this->expected)),
23 |             strtolower(gettype($this->actual))
24 |         );
25 |     }
26 | }


--------------------------------------------------------------------------------
/framework_src/Assertion/AssertionMessage/CountEqualsMessage.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit\Assertion\AssertionMessage;
 4 | 
 5 | use Countable;
 6 | use Cspray\Labrador\AsyncUnit\AssertionMessage;
 7 | 
 8 | final class CountEqualsMessage implements AssertionMessage {
 9 | 
10 |     public function __construct(private int $expected, private array|Countable $actual) {}
11 | 
12 |     public function toString() : string {
13 |         return sprintf(
14 |             'asserting %s with count of %d equals expected count of %d',
15 |             is_array($this->actual) ? 'array' : $this->actual::class,
16 |             count($this->actual),
17 |             $this->expected
18 |         );
19 |     }
20 | 
21 |     public function toNotString() : string {
22 |         return sprintf(
23 |             'asserting %s with count of %d does not equal expected count of %d',
24 |             is_array($this->actual) ? 'array': $this->actual::class,
25 |             count($this->actual),
26 |             $this->expected
27 |         );
28 |     }
29 | }


--------------------------------------------------------------------------------
/framework_src/Assertion/AssertionMessage/EmptyUnaryOperandDetails.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit\Assertion\AssertionMessage;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\AssertionMessage;
 6 | 
 7 | final class EmptyUnaryOperandDetails extends UnaryOperandDetails implements AssertionMessage {
 8 | 
 9 |     protected function getExpectedDescriptor() : string {
10 |         return 'empty';
11 |     }
12 | }


--------------------------------------------------------------------------------
/framework_src/Assertion/AssertionMessage/EmptyUnaryOperandSummary.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit\Assertion\AssertionMessage;
 4 | 
 5 | final class EmptyUnaryOperandSummary extends UnaryOperandSummary {
 6 | 
 7 |     protected function getExpectedDescriptor() : string {
 8 |         return 'empty';
 9 |     }
10 | }


--------------------------------------------------------------------------------
/framework_src/Assertion/AssertionMessage/FalseUnaryOperandDetails.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit\Assertion\AssertionMessage;
 4 | 
 5 | final class FalseUnaryOperandDetails extends UnaryOperandDetails {
 6 | 
 7 |     protected function getExpectedDescriptor() : string {
 8 |         return 'false';
 9 |     }
10 | }


--------------------------------------------------------------------------------
/framework_src/Assertion/AssertionMessage/FalseUnaryOperandSummary.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit\Assertion\AssertionMessage;
 4 | 
 5 | final class FalseUnaryOperandSummary extends UnaryOperandSummary {
 6 | 
 7 |     protected function getExpectedDescriptor() : string {
 8 |         return 'false';
 9 |     }
10 | }


--------------------------------------------------------------------------------
/framework_src/Assertion/AssertionMessage/InstanceOfMessage.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit\Assertion\AssertionMessage;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\AssertionMessage;
 6 | 
 7 | final class InstanceOfMessage implements AssertionMessage {
 8 | 
 9 |     public function __construct(
10 |         private string|object $expected,
11 |         private object $actual
12 |     ) {}
13 | 
14 |     public function toString() : string {
15 |         return sprintf(
16 |             'asserting object with type "%s" is an instanceof %s',
17 |             $this->actual::class,
18 |             is_object($this->expected) ? get_class($this->expected) : $this->expected
19 |         );
20 |     }
21 | 
22 |     public function toNotString() : string {
23 |         return sprintf(
24 |             'asserting object with type "%s" is not an instanceof %s',
25 |             $this->actual::class,
26 |             is_object($this->expected) ? get_class($this->expected) : $this->expected
27 |         );
28 |     }
29 | }


--------------------------------------------------------------------------------
/framework_src/Assertion/AssertionMessage/NullUnaryOperandDetails.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit\Assertion\AssertionMessage;
 4 | 
 5 | final class NullUnaryOperandDetails extends UnaryOperandDetails {
 6 | 
 7 |     protected function getExpectedDescriptor() : string {
 8 |         return 'null';
 9 |     }
10 | }


--------------------------------------------------------------------------------
/framework_src/Assertion/AssertionMessage/NullUnaryOperandSummary.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit\Assertion\AssertionMessage;
 4 | 
 5 | final class NullUnaryOperandSummary extends UnaryOperandSummary {
 6 | 
 7 |     protected function getExpectedDescriptor() : string {
 8 |         return 'null';
 9 |     }
10 | }


--------------------------------------------------------------------------------
/framework_src/Assertion/AssertionMessage/TrueUnaryOperandDetails.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit\Assertion\AssertionMessage;
 4 | 
 5 | final class TrueUnaryOperandDetails extends UnaryOperandDetails {
 6 | 
 7 |     protected function getExpectedDescriptor() : string {
 8 |         return 'true';
 9 |     }
10 | }


--------------------------------------------------------------------------------
/framework_src/Assertion/AssertionMessage/TrueUnaryOperandSummary.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit\Assertion\AssertionMessage;
 4 | 
 5 | final class TrueUnaryOperandSummary extends UnaryOperandSummary {
 6 | 
 7 |     protected function getExpectedDescriptor() : string {
 8 |         return 'true';
 9 |     }
10 | }


--------------------------------------------------------------------------------
/framework_src/Assertion/AssertionMessage/UnaryOperandDetails.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit\Assertion\AssertionMessage;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\AssertionMessage;
 6 | 
 7 | abstract class UnaryOperandDetails implements AssertionMessage {
 8 | 
 9 |     public function __construct(private mixed $actual) {}
10 | 
11 |     public function toString() : string {
12 |         $details = var_export($this->actual, true);
13 |         if (is_null($this->actual)) {
14 |             $details = 'null';
15 |         }
16 |         return sprintf(
17 |             'comparing %s is %s',
18 |             $details,
19 |             $this->getExpectedDescriptor()
20 |         );
21 |     }
22 | 
23 |     public function toNotString() : string {
24 |         $details = var_export($this->actual, true);
25 |         if (is_null($this->actual)) {
26 |             $details = 'null';
27 |         }
28 |         return sprintf(
29 |             'comparing %s is not %s',
30 |             $details,
31 |             $this->getExpectedDescriptor()
32 |         );
33 |     }
34 | 
35 |     abstract protected function getExpectedDescriptor() : string;
36 | }


--------------------------------------------------------------------------------
/framework_src/Assertion/AssertionMessage/UnaryOperandSummary.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit\Assertion\AssertionMessage;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\AssertionMessage;
 6 | 
 7 | abstract class UnaryOperandSummary implements AssertionMessage {
 8 | 
 9 |     public function __construct(private mixed $actual) {}
10 | 
11 |     public function toString() : string {
12 |         return sprintf('asserting type "%s" is %s', strtolower(gettype($this->actual)), $this->getExpectedDescriptor());
13 |     }
14 | 
15 |     public function toNotString() : string {
16 |         return sprintf('asserting type "%s" is not %s', strtolower(gettype($this->actual)), $this->getExpectedDescriptor());
17 |     }
18 | 
19 |     abstract protected function getExpectedDescriptor() : string;
20 | 
21 | }


--------------------------------------------------------------------------------
/framework_src/Assertion/AsyncAssertArrayEquals.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit\Assertion;
 4 | 
 5 | use Amp\Coroutine;
 6 | use Amp\Promise;
 7 | use Cspray\Labrador\AsyncUnit\Assertion;
 8 | use Cspray\Labrador\AsyncUnit\AsyncAssertion;
 9 | use Generator;
10 | 
11 | final class AsyncAssertArrayEquals extends AbstractAsyncAssertion implements AsyncAssertion {
12 | 
13 |     public function __construct(private array $expected, Promise|Generator|Coroutine $actual) {
14 |         parent::__construct($actual);
15 |     }
16 | 
17 |     protected function getAssertion(mixed $resolvedActual) : Assertion {
18 |         return new AssertArrayEquals($this->expected, $resolvedActual);
19 |     }
20 | }


--------------------------------------------------------------------------------
/framework_src/Assertion/AsyncAssertCountEquals.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit\Assertion;
 4 | 
 5 | use Amp\Coroutine;
 6 | use Amp\Promise;
 7 | use Cspray\Labrador\AsyncUnit\Assertion;
 8 | use Generator;
 9 | 
10 | final class AsyncAssertCountEquals extends AbstractAsyncAssertion {
11 | 
12 |     public function __construct(private int $expected, Promise|Generator|Coroutine $actual) {
13 |         parent::__construct($actual);
14 |     }
15 | 
16 |     protected function getAssertion(mixed $resolvedActual) : Assertion {
17 |         return new AssertCountEquals($this->expected, $resolvedActual);
18 |     }
19 | }


--------------------------------------------------------------------------------
/framework_src/Assertion/AsyncAssertFloatEquals.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit\Assertion;
 4 | 
 5 | use Amp\Coroutine;
 6 | use Amp\Promise;
 7 | use Cspray\Labrador\AsyncUnit\Assertion;
 8 | use Generator;
 9 | 
10 | final class AsyncAssertFloatEquals extends AbstractAsyncAssertion {
11 | 
12 |     public function __construct(private float $expected, Promise|Generator|Coroutine $actual) {
13 |         parent::__construct($actual);
14 |     }
15 | 
16 |     protected function getAssertion(mixed $actual) : Assertion {
17 |         return new AssertFloatEquals($this->expected, $actual);
18 |     }
19 | }


--------------------------------------------------------------------------------
/framework_src/Assertion/AsyncAssertInstanceOf.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit\Assertion;
 4 | 
 5 | use Amp\Coroutine;
 6 | use Amp\Promise;
 7 | use Cspray\Labrador\AsyncUnit\Assertion;
 8 | use Cspray\Labrador\AsyncUnit\Exception\InvalidArgumentException;
 9 | use Generator;
10 | 
11 | final class AsyncAssertInstanceOf extends AbstractAsyncAssertion {
12 | 
13 |     public function __construct(private string|object $expected, Promise|Coroutine|Generator $actual) {
14 |         if (is_string($expected) && !class_exists($expected) && !interface_exists($expected)) {
15 |             $msg = sprintf(
16 |                 'The expected value must be a valid class but %s was given',
17 |                 var_export($expected, true)
18 |             );
19 |             throw new InvalidArgumentException($msg);
20 |         }
21 |         parent::__construct($actual);
22 |     }
23 | 
24 |     protected function getAssertion(mixed $resolvedActual) : Assertion {
25 |         return new AssertInstanceOf($this->expected, $resolvedActual);
26 |     }
27 | }


--------------------------------------------------------------------------------
/framework_src/Assertion/AsyncAssertIntEquals.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit\Assertion;
 4 | 
 5 | use Amp\Coroutine;
 6 | use Amp\Promise;
 7 | use Cspray\Labrador\AsyncUnit\Assertion;
 8 | use Generator;
 9 | 
10 | final class AsyncAssertIntEquals extends AbstractAsyncAssertion {
11 | 
12 |     public function __construct(private int $expected, Promise|Generator|Coroutine $actual) {
13 |         parent::__construct($actual);
14 |     }
15 | 
16 |     protected function getAssertion(mixed $actual) : Assertion {
17 |         return new AssertIntEquals($this->expected, $actual);
18 |     }
19 | }


--------------------------------------------------------------------------------
/framework_src/Assertion/AsyncAssertIsEmpty.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | 
 4 | namespace Cspray\Labrador\AsyncUnit\Assertion;
 5 | 
 6 | 
 7 | use Cspray\Labrador\AsyncUnit\Assertion;
 8 | 
 9 | final class AsyncAssertIsEmpty extends AbstractAsyncAssertion {
10 | 
11 |     protected function getAssertion(mixed $resolvedActual) : Assertion {
12 |         return new AssertIsEmpty($resolvedActual);
13 |     }
14 | }


--------------------------------------------------------------------------------
/framework_src/Assertion/AsyncAssertIsFalse.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit\Assertion;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Assertion;
 6 | 
 7 | final class AsyncAssertIsFalse extends AbstractAsyncAssertion {
 8 | 
 9 |     protected function getAssertion(mixed $resolvedActual) : Assertion {
10 |         return new AssertIsFalse($resolvedActual);
11 |     }
12 | 
13 | }


--------------------------------------------------------------------------------
/framework_src/Assertion/AsyncAssertIsNull.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit\Assertion;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Assertion;
 6 | 
 7 | final class AsyncAssertIsNull extends AbstractAsyncAssertion {
 8 | 
 9 |     protected function getAssertion(mixed $resolvedActual) : Assertion {
10 |         return new AssertIsNull($resolvedActual);
11 |     }
12 | }


--------------------------------------------------------------------------------
/framework_src/Assertion/AsyncAssertIsTrue.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit\Assertion;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Assertion;
 6 | 
 7 | final class AsyncAssertIsTrue extends AbstractAsyncAssertion {
 8 | 
 9 |     protected function getAssertion(mixed $resolvedActual) : Assertion {
10 |         return new AssertIsTrue($resolvedActual);
11 |     }
12 | }


--------------------------------------------------------------------------------
/framework_src/Assertion/AsyncAssertStringEquals.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit\Assertion;
 4 | 
 5 | use Amp\Coroutine;
 6 | use Amp\Promise;
 7 | use Cspray\Labrador\AsyncUnit\Assertion;
 8 | use Cspray\Labrador\AsyncUnit\AsyncAssertion;
 9 | use Generator;
10 | use function Amp\call;
11 | 
12 | final class AsyncAssertStringEquals extends AbstractAsyncAssertion implements AsyncAssertion {
13 | 
14 |     public function __construct(private string $expected, Promise|Generator|Coroutine $actual) {
15 |         parent::__construct($actual);
16 |     }
17 | 
18 |     protected function getAssertion(mixed $resolvedActual) : Assertion {
19 |         return new AssertStringEquals($this->expected, $resolvedActual);
20 |     }
21 | }


--------------------------------------------------------------------------------
/framework_src/AssertionMessage.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit;
 4 | 
 5 | /**
 6 |  * Represents some information about the results of an Assertion or AsyncAssertion.
 7 |  *
 8 |  * @package Cspray\Labrador\AsyncUnit
 9 |  */
10 | interface AssertionMessage {
11 | 
12 |     /**
13 |      * Provide information for when the Assertion or AsyncAssertion has been processed without the not() modifier.
14 |      *
15 |      * @return string
16 |      */
17 |     public function toString() : string;
18 | 
19 |     /**
20 |      * Provide information for when the Assertion or AsyncAssertion has been processed with the not() modifier.
21 |      *
22 |      * @return string
23 |      */
24 |     public function toNotString() : string;
25 | 
26 | }


--------------------------------------------------------------------------------
/framework_src/AssertionResult.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit;
 4 | 
 5 | /**
 6 |  * Represents the data about a call to {@see Assertion::assert} or {@see AsyncAssertion::assert} that could be a
 7 |  * successful assertion or a failure.
 8 |  */
 9 | interface AssertionResult {
10 | 
11 |     /**
12 |      * Whether or not the Assertion passed without error.
13 |      *
14 |      * @return bool
15 |      */
16 |     public function isSuccessful() : bool;
17 | 
18 |     /**
19 |      * A brief, 1-line summary of the Assertion that was carried out.
20 |      *
21 |      * @return AssertionMessage
22 |      */
23 |     public function getSummary() : AssertionMessage;
24 | 
25 |     /**
26 |      * An exhaustive, descriptive, potentially multi-line detail of the Assertion that was carried out.
27 |      *
28 |      * This is the information that should be displayed to the user when an Assertion has failed and it is important that
29 |      * it has appropriate information and details in it to help in fixing the test to pass.
30 |      *
31 |      * @return AssertionMessage
32 |      */
33 |     public function getDetails() : AssertionMessage;
34 | 
35 | }


--------------------------------------------------------------------------------
/framework_src/Attribute/AfterAll.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | 
 4 | namespace Cspray\Labrador\AsyncUnit\Attribute;
 5 | 
 6 | use Attribute;
 7 | 
 8 | #[Attribute]
 9 | final class AfterAll {
10 | 
11 |     public function __construct(private int $priority = 0) {}
12 | 
13 | }


--------------------------------------------------------------------------------
/framework_src/Attribute/AfterEach.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | 
 4 | namespace Cspray\Labrador\AsyncUnit\Attribute;
 5 | 
 6 | use Attribute;
 7 | 
 8 | #[Attribute]
 9 | final class AfterEach {
10 | 
11 |     public function __construct(private int $priority = 0) {}
12 | 
13 | }


--------------------------------------------------------------------------------
/framework_src/Attribute/AfterEachTest.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | 
 4 | namespace Cspray\Labrador\AsyncUnit\Attribute;
 5 | 
 6 | use Attribute;
 7 | 
 8 | #[Attribute]
 9 | final class AfterEachTest {
10 | 
11 |     public function __construct(private int $priority = 0) {}
12 | 
13 | }


--------------------------------------------------------------------------------
/framework_src/Attribute/AttachToTestSuite.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit\Attribute;
 4 | 
 5 | use Attribute;
 6 | 
 7 | /**
 8 |  * Class AttachToTestSuite
 9 |  * @package Cspray\Labrador\AsyncUnit\Attribute
10 |  * @codeCoverageIgnore
11 |  */
12 | #[Attribute(Attribute::TARGET_CLASS)]
13 | final class AttachToTestSuite {
14 | 
15 |     public function __construct(private string $testSuiteClass) {}
16 | 
17 | }


--------------------------------------------------------------------------------
/framework_src/Attribute/BeforeAll.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | 
 4 | namespace Cspray\Labrador\AsyncUnit\Attribute;
 5 | 
 6 | use Attribute;
 7 | 
 8 | #[Attribute(Attribute::TARGET_METHOD)]
 9 | final class BeforeAll {
10 | 
11 |     public function __construct(private int $priority = 0) {}
12 | 
13 | }


--------------------------------------------------------------------------------
/framework_src/Attribute/BeforeEach.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit\Attribute;
 4 | 
 5 | use Attribute;
 6 | 
 7 | #[Attribute(Attribute::TARGET_METHOD)]
 8 | final class BeforeEach {
 9 | 
10 |     public function __construct(private int $priority = 0) {}
11 | 
12 | }


--------------------------------------------------------------------------------
/framework_src/Attribute/BeforeEachTest.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit\Attribute;
 4 | 
 5 | use Attribute;
 6 | 
 7 | #[Attribute]
 8 | final class BeforeEachTest {
 9 | 
10 |     public function __construct(private int $priority = 0) {}
11 | 
12 | }


--------------------------------------------------------------------------------
/framework_src/Attribute/DataProvider.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit\Attribute;
 4 | 
 5 | use Attribute;
 6 | 
 7 | /**
 8 |  * Class DataProvider
 9 |  * @package Cspray\Labrador\AsyncUnit\Attribute
10 |  * @codeCoverageIgnore
11 |  */
12 | #[Attribute(Attribute::TARGET_METHOD)]
13 | final class DataProvider {
14 | 
15 |     public function __construct(private string $methodName) {}
16 | 
17 | }


--------------------------------------------------------------------------------
/framework_src/Attribute/DefaultTestSuite.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit\Attribute;
 4 | 
 5 | use Attribute;
 6 | 
 7 | #[Attribute(Attribute::TARGET_CLASS)]
 8 | final class DefaultTestSuite {
 9 | 
10 | }


--------------------------------------------------------------------------------
/framework_src/Attribute/Disabled.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | 
 4 | namespace Cspray\Labrador\AsyncUnit\Attribute;
 5 | 
 6 | /**
 7 |  * @package Cspray\Labrador\AsyncUnit\Attribute
 8 |  * @codeCoverageIgnore
 9 |  */
10 | #[\Attribute(\Attribute::TARGET_METHOD | \Attribute::TARGET_CLASS)]
11 | class Disabled {
12 | 
13 |     public function __construct(private ?string $reason = null) {}
14 | 
15 | }


--------------------------------------------------------------------------------
/framework_src/Attribute/Prototype.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit\Attribute;
 4 | 
 5 | use Attribute;
 6 | 
 7 | /**
 8 |  * Class Prototype
 9 |  * @package Cspray\Labrador\AsyncUnit\Attribute
10 |  * @codeCoverageIgnore
11 |  */
12 | #[Attribute(Attribute::TARGET_CLASS)]
13 | final class Prototype {
14 | 
15 |     public function __construct(private array $validTypes) {}
16 | 
17 | }


--------------------------------------------------------------------------------
/framework_src/Attribute/PrototypeRequiresAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | 
 4 | namespace Cspray\Labrador\AsyncUnit\Attribute;
 5 | 
 6 | use Attribute;
 7 | 
 8 | /**
 9 |  * Class PrototypeRequiresAttribute
10 |  * @package Cspray\Labrador\AsyncUnit\Attribute
11 |  * @codeCoverageIgnore
12 |  */
13 | #[Attribute(Attribute::TARGET_CLASS | Attribute::IS_REPEATABLE)]
14 | final class PrototypeRequiresAttribute {
15 | 
16 |     public function __construct(
17 |         private string $requiredAttribute
18 |     ) {}
19 | 
20 | }


--------------------------------------------------------------------------------
/framework_src/Attribute/Test.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit\Attribute;
 4 | 
 5 | use Attribute;
 6 | 
 7 | #[Attribute(Attribute::TARGET_METHOD)]
 8 | final class Test {
 9 | 
10 | }


--------------------------------------------------------------------------------
/framework_src/Attribute/Timeout.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | 
 4 | namespace Cspray\Labrador\AsyncUnit\Attribute;
 5 | 
 6 | use Attribute;
 7 | 
 8 | #[Attribute(Attribute::TARGET_METHOD | Attribute::TARGET_CLASS)]
 9 | class Timeout {
10 | 
11 |     public function __construct(private int $timeoutInMilliseconds) {}
12 | 
13 | }


--------------------------------------------------------------------------------
/framework_src/Configuration.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit;
 4 | 
 5 | interface Configuration {
 6 | 
 7 |     /**
 8 |      * @return string[]
 9 |      */
10 |     public function getTestDirectories() : array;
11 | 
12 |     /**
13 |      * @return string[]
14 |      */
15 |     public function getPlugins() : array;
16 | 
17 |     /**
18 |      * @return string
19 |      */
20 |     public function getResultPrinter() : string;
21 | 
22 |     /**
23 |      * @return string|null
24 |      */
25 |     public function getMockBridge() : ?string;
26 | 
27 | }


--------------------------------------------------------------------------------
/framework_src/ConfigurationFactory.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | 
 4 | namespace Cspray\Labrador\AsyncUnit;
 5 | 
 6 | 
 7 | use Amp\Promise;
 8 | 
 9 | interface ConfigurationFactory {
10 | 
11 |     /**
12 |      * @param string $path
13 |      * @return Promise<Configuration>
14 |      */
15 |     public function make(string $path) : Promise;
16 | 
17 | }


--------------------------------------------------------------------------------
/framework_src/ConfigurationValidationResults.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit;
 4 | 
 5 | final class ConfigurationValidationResults {
 6 | 
 7 |     public function __construct(
 8 |         private array $validationErrors
 9 |     ) {}
10 | 
11 |     public function isValid() : bool {
12 |         return empty($this->validationErrors);
13 |     }
14 | 
15 |     public function getValidationErrors() : array {
16 |         return $this->validationErrors;
17 |     }
18 | 
19 | 
20 | }


--------------------------------------------------------------------------------
/framework_src/ConfigurationValidator.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit;
 4 | 
 5 | use Amp\Promise;
 6 | 
 7 | interface ConfigurationValidator {
 8 | 
 9 |     public function validate(Configuration $configuration) : Promise;
10 | 
11 | }


--------------------------------------------------------------------------------
/framework_src/Context/LastAssertionCalledTrait.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit\Context;
 4 | 
 5 | /**
 6 |  * @internal
 7 |  */
 8 | trait LastAssertionCalledTrait {
 9 | 
10 |     private ?string $lastAssertionFile = null;
11 | 
12 |     private ?int $lastAssertionLine = null;
13 | 
14 |     public function setLastAssertionFile(string $file) : void {
15 |         $this->lastAssertionFile = $file;
16 |     }
17 | 
18 |     public function getLastAssertionFile() : ?string {
19 |         return $this->lastAssertionFile;
20 |     }
21 | 
22 |     public function setLastAssertionLine(int $line) : void {
23 |         $this->lastAssertionLine = $line;
24 |     }
25 | 
26 |     public function getLastAssertionLine() : int {
27 |         return $this->lastAssertionLine;
28 |     }
29 | 
30 | }


--------------------------------------------------------------------------------
/framework_src/Context/TestExpector.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit\Context;
 4 | 
 5 | interface TestExpector {
 6 | 
 7 |     public function exception(string $type) : void;
 8 | 
 9 |     public function exceptionMessage(string $message) : void;
10 | 
11 |     public function noAssertions() : void;
12 | 
13 | }


--------------------------------------------------------------------------------
/framework_src/CustomAssertionPlugin.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit;
 4 | 
 5 | use Amp\Promise;
 6 | use Cspray\Labrador\AsyncUnit\Context\CustomAssertionContext;
 7 | use Cspray\Labrador\Plugin\Plugin;
 8 | 
 9 | /**
10 |  * Interface CustomAssertionPlugin
11 |  * @package Cspray\Labrador\AsyncUnit
12 |  */
13 | interface CustomAssertionPlugin extends Plugin {
14 | 
15 |     public function registerCustomAssertions(CustomAssertionContext $customAssertionContext) : Promise;
16 | 
17 | }


--------------------------------------------------------------------------------
/framework_src/Event/ProcessingFinishedEvent.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit\Event;
 4 | 
 5 | use Cspray\Labrador\AsyncEvent\StandardEvent;
 6 | use Cspray\Labrador\AsyncUnit\Events;
 7 | use Cspray\Labrador\AsyncUnit\Statistics\ProcessedAggregateSummary;
 8 | 
 9 | final class ProcessingFinishedEvent extends StandardEvent {
10 | 
11 |     public function __construct(ProcessedAggregateSummary $summary) {
12 |         parent::__construct(Events::PROCESSING_FINISHED, $summary);
13 |     }
14 | 
15 |     public function getTarget() : ProcessedAggregateSummary {
16 |         return parent::getTarget();
17 |     }
18 | 
19 | }


--------------------------------------------------------------------------------
/framework_src/Event/ProcessingStartedEvent.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit\Event;
 4 | 
 5 | use Cspray\Labrador\AsyncEvent\StandardEvent;
 6 | use Cspray\Labrador\AsyncUnit\Events;
 7 | use Cspray\Labrador\AsyncUnit\Statistics\AggregateSummary;
 8 | 
 9 | final class ProcessingStartedEvent extends StandardEvent {
10 | 
11 |     public function __construct(AggregateSummary $aggregateSummary) {
12 |         parent::__construct(Events::PROCESSING_STARTED, $aggregateSummary);
13 |     }
14 | 
15 |     public function getTarget() : AggregateSummary {
16 |         return parent::getTarget();
17 |     }
18 | 
19 | }


--------------------------------------------------------------------------------
/framework_src/Event/TestCaseFinishedEvent.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit\Event;
 4 | 
 5 | use Cspray\Labrador\AsyncEvent\Event;
 6 | use Cspray\Labrador\AsyncEvent\StandardEvent;
 7 | use Cspray\Labrador\AsyncUnit\Events;
 8 | use Cspray\Labrador\AsyncUnit\Model\TestCaseModel;
 9 | use Cspray\Labrador\AsyncUnit\Statistics\ProcessedTestCaseSummary;
10 | 
11 | final class TestCaseFinishedEvent extends StandardEvent implements Event {
12 | 
13 |     public function __construct(ProcessedTestCaseSummary $testCaseSummary) {
14 |         parent::__construct(Events::TEST_CASE_FINISHED, $testCaseSummary);
15 |     }
16 | 
17 |     public function getTarget() : ProcessedTestCaseSummary {
18 |         return parent::getTarget(); // TODO: Change the autogenerated stub
19 |     }
20 | 
21 | }


--------------------------------------------------------------------------------
/framework_src/Event/TestCaseStartedEvent.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit\Event;
 4 | 
 5 | use Cspray\Labrador\AsyncEvent\Event;
 6 | use Cspray\Labrador\AsyncEvent\StandardEvent;
 7 | use Cspray\Labrador\AsyncUnit\Events;
 8 | use Cspray\Labrador\AsyncUnit\Statistics\TestCaseSummary;
 9 | 
10 | final class TestCaseStartedEvent extends StandardEvent implements Event {
11 | 
12 |     public function __construct(TestCaseSummary $target) {
13 |         parent::__construct(Events::TEST_CASE_STARTED, $target);
14 |     }
15 | 
16 |     public function getTarget() : TestCaseSummary {
17 |         return parent::getTarget();
18 |     }
19 | 
20 | }


--------------------------------------------------------------------------------
/framework_src/Event/TestDisabledEvent.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit\Event;
 4 | 
 5 | use Cspray\Labrador\AsyncEvent\Event;
 6 | use Cspray\Labrador\AsyncEvent\StandardEvent;
 7 | use Cspray\Labrador\AsyncUnit\Events;
 8 | use Cspray\Labrador\AsyncUnit\TestResult;
 9 | 
10 | final class TestDisabledEvent extends StandardEvent implements Event {
11 | 
12 |     public function __construct(TestResult $testResult) {
13 |         parent::__construct(Events::TEST_DISABLED, $testResult);
14 |     }
15 | 
16 |     public function getTarget() : TestResult {
17 |         return parent::getTarget();
18 |     }
19 | 
20 | }


--------------------------------------------------------------------------------
/framework_src/Event/TestErroredEvent.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit\Event;
 4 | 
 5 | use Cspray\Labrador\AsyncEvent\StandardEvent;
 6 | use Cspray\Labrador\AsyncUnit\Events;
 7 | use Cspray\Labrador\AsyncUnit\TestResult;
 8 | 
 9 | final class TestErroredEvent extends StandardEvent {
10 | 
11 |     public function __construct(TestResult $target, array $data = []) {
12 |         parent::__construct(Events::TEST_ERRORED, $target, $data);
13 |     }
14 | 
15 |     public function getTarget() : TestResult {
16 |         return parent::getTarget();
17 |     }
18 | 
19 | }


--------------------------------------------------------------------------------
/framework_src/Event/TestFailedEvent.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit\Event;
 4 | 
 5 | use Cspray\Labrador\AsyncEvent\StandardEvent;
 6 | use Cspray\Labrador\AsyncUnit\Events;
 7 | use Cspray\Labrador\AsyncUnit\TestResult;
 8 | 
 9 | final class TestFailedEvent extends StandardEvent {
10 | 
11 |     public function __construct(TestResult $target, array $data = []) {
12 |         parent::__construct(Events::TEST_FAILED, $target, $data);
13 |     }
14 | 
15 |     public function getTarget() : TestResult {
16 |         return parent::getTarget();
17 |     }
18 | 
19 | }


--------------------------------------------------------------------------------
/framework_src/Event/TestPassedEvent.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit\Event;
 4 | 
 5 | use Cspray\Labrador\AsyncEvent\StandardEvent;
 6 | use Cspray\Labrador\AsyncUnit\Events;
 7 | use Cspray\Labrador\AsyncUnit\TestResult;
 8 | 
 9 | final class TestPassedEvent extends StandardEvent {
10 | 
11 |     public function __construct(TestResult $target, array $data = []) {
12 |         parent::__construct(Events::TEST_PASSED, $target, $data);
13 |     }
14 | 
15 |     public function getTarget() : TestResult {
16 |         return parent::getTarget();
17 |     }
18 | }


--------------------------------------------------------------------------------
/framework_src/Event/TestProcessedEvent.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit\Event;
 4 | 
 5 | use Cspray\Labrador\AsyncEvent\Event;
 6 | use Cspray\Labrador\AsyncEvent\StandardEvent;
 7 | use Cspray\Labrador\AsyncUnit\Events;
 8 | use Cspray\Labrador\AsyncUnit\Model\InvokedTestCaseTestModel;
 9 | use Cspray\Labrador\AsyncUnit\TestResult;
10 | 
11 | final class TestProcessedEvent extends StandardEvent implements Event {
12 | 
13 |     public function __construct(TestResult $target, array $data = []) {
14 |         parent::__construct(Events::TEST_PROCESSED, $target, $data);
15 |     }
16 | 
17 |     public function getTarget() : TestResult {
18 |         return parent::getTarget();
19 |     }
20 | 
21 | }


--------------------------------------------------------------------------------
/framework_src/Event/TestSuiteFinishedEvent.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit\Event;
 4 | 
 5 | use Cspray\Labrador\AsyncEvent\Event;
 6 | use Cspray\Labrador\AsyncEvent\StandardEvent;
 7 | use Cspray\Labrador\AsyncUnit\Events;
 8 | use Cspray\Labrador\AsyncUnit\Statistics\ProcessedTestSuiteSummary;
 9 | 
10 | final class TestSuiteFinishedEvent extends StandardEvent implements Event {
11 | 
12 |     public function __construct(ProcessedTestSuiteSummary $target) {
13 |         parent::__construct(Events::TEST_SUITE_FINISHED, $target);
14 |     }
15 | 
16 |     public function getTarget() : ProcessedTestSuiteSummary {
17 |         return parent::getTarget();
18 |     }
19 | 
20 | }


--------------------------------------------------------------------------------
/framework_src/Event/TestSuiteStartedEvent.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit\Event;
 4 | 
 5 | use Cspray\Labrador\AsyncEvent\Event;
 6 | use Cspray\Labrador\AsyncEvent\StandardEvent;
 7 | use Cspray\Labrador\AsyncUnit\Events;
 8 | use Cspray\Labrador\AsyncUnit\Model\TestSuiteModel;
 9 | use Cspray\Labrador\AsyncUnit\Statistics\TestSuiteSummary;
10 | use Cspray\Labrador\AsyncUnit\TestSuite;
11 | 
12 | final class TestSuiteStartedEvent extends StandardEvent implements Event {
13 | 
14 |     public function __construct(TestSuiteSummary $testSuiteSummary) {
15 |         parent::__construct(Events::TEST_SUITE_STARTED, $testSuiteSummary);
16 |     }
17 | 
18 |     public function getTarget() : TestSuiteSummary {
19 |         return parent::getTarget();
20 |     }
21 | 
22 | }


--------------------------------------------------------------------------------
/framework_src/Events.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit;
 4 | 
 5 | interface Events {
 6 | 
 7 |     const PROCESSING_STARTED = 'labrador.asyncUnit.processingStarted';
 8 | 
 9 |     const TEST_SUITE_STARTED = 'labrador.asyncUnit.testSuiteStarted';
10 | 
11 |     const TEST_CASE_STARTED = 'labrador.asyncUnit.testCaseStarted';
12 | 
13 |     const TEST_PROCESSED = 'labrador.asyncUnit.testProcessed';
14 | 
15 |     const TEST_PASSED = 'labrador.asyncUnit.testPassed';
16 | 
17 |     const TEST_FAILED = 'labrador.asyncUnit.testFailed';
18 | 
19 |     const TEST_DISABLED = 'labrador.asyncUnit.testDisabled';
20 | 
21 |     const TEST_ERRORED = 'labrador.asyncUnit.testErrored';
22 | 
23 |     const TEST_CASE_FINISHED = 'labrador.asyncUnit.testCaseFinished';
24 | 
25 |     const TEST_SUITE_FINISHED = 'labrador.asyncUnit.testSuiteFinished';
26 | 
27 |     const PROCESSING_FINISHED = 'labrador.asyncUnit.processingFinished';
28 | 
29 | }


--------------------------------------------------------------------------------
/framework_src/Exception/AssertionFailedException.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit\Exception;
 4 | 
 5 | final class AssertionFailedException extends TestFailedException {
 6 | 
 7 |     public function __construct(
 8 |         string $summary,
 9 |         private string $detailedMessage,
10 |         private string $assertionFailureFile,
11 |         private int $assertionFailureLine
12 |     ) {
13 |         parent::__construct($summary);
14 |     }
15 | 
16 |     public function getDetailedMessage() : string {
17 |         return $this->detailedMessage;
18 |     }
19 | 
20 |     public function getAssertionFailureFile() : string {
21 |         return $this->assertionFailureFile;
22 |     }
23 | 
24 |     public function getAssertionFailureLine() : int {
25 |         return $this->assertionFailureLine;
26 |     }
27 | 
28 | }


--------------------------------------------------------------------------------
/framework_src/Exception/Exception.php:
--------------------------------------------------------------------------------
1 | <?php declare(strict_types=1);
2 | 
3 | namespace Cspray\Labrador\AsyncUnit\Exception;
4 | 
5 | use RuntimeException;
6 | 
7 | class Exception extends RuntimeException {
8 | 
9 | }


--------------------------------------------------------------------------------
/framework_src/Exception/InvalidArgumentException.php:
--------------------------------------------------------------------------------
1 | <?php declare(strict_types=1);
2 | 
3 | namespace Cspray\Labrador\AsyncUnit\Exception;
4 | 
5 | class InvalidArgumentException extends Exception {
6 | 
7 | }


--------------------------------------------------------------------------------
/framework_src/Exception/InvalidConfigurationException.php:
--------------------------------------------------------------------------------
1 | <?php declare(strict_types=1);
2 | 
3 | namespace Cspray\Labrador\AsyncUnit\Exception;
4 | 
5 | class InvalidConfigurationException extends Exception {
6 | 
7 | }


--------------------------------------------------------------------------------
/framework_src/Exception/InvalidStateException.php:
--------------------------------------------------------------------------------
1 | <?php declare(strict_types=1);
2 | 
3 | namespace Cspray\Labrador\AsyncUnit\Exception;
4 | 
5 | class InvalidStateException extends Exception {
6 | 
7 | }


--------------------------------------------------------------------------------
/framework_src/Exception/MockFailureException.php:
--------------------------------------------------------------------------------
1 | <?php declare(strict_types=1);
2 | 
3 | namespace Cspray\Labrador\AsyncUnit\Exception;
4 | 
5 | class MockFailureException extends TestFailedException {
6 | 
7 | }


--------------------------------------------------------------------------------
/framework_src/Exception/TestCaseSetUpException.php:
--------------------------------------------------------------------------------
1 | <?php declare(strict_types=1);
2 | 
3 | namespace Cspray\Labrador\AsyncUnit\Exception;
4 | 
5 | class TestCaseSetUpException extends Exception {
6 | 
7 | }


--------------------------------------------------------------------------------
/framework_src/Exception/TestCaseTearDownException.php:
--------------------------------------------------------------------------------
1 | <?php declare(strict_types=1);
2 | 
3 | namespace Cspray\Labrador\AsyncUnit\Exception;
4 | 
5 | class TestCaseTearDownException extends Exception {
6 | 
7 | }


--------------------------------------------------------------------------------
/framework_src/Exception/TestCompilationException.php:
--------------------------------------------------------------------------------
1 | <?php declare(strict_types=1);
2 | 
3 | namespace Cspray\Labrador\AsyncUnit\Exception;
4 | 
5 | class TestCompilationException extends Exception {
6 | 
7 | }


--------------------------------------------------------------------------------
/framework_src/Exception/TestDisabledException.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit\Exception;
 4 | 
 5 | final class TestDisabledException extends Exception {
 6 | 
 7 |     public function __construct($message) {
 8 |         parent::__construct($message);
 9 |     }
10 | 
11 | }


--------------------------------------------------------------------------------
/framework_src/Exception/TestErrorException.php:
--------------------------------------------------------------------------------
1 | <?php declare(strict_types=1);
2 | 
3 | namespace Cspray\Labrador\AsyncUnit\Exception;
4 | 
5 | class TestErrorException extends Exception {
6 | 
7 | }


--------------------------------------------------------------------------------
/framework_src/Exception/TestFailedException.php:
--------------------------------------------------------------------------------
1 | <?php declare(strict_types=1);
2 | 
3 | namespace Cspray\Labrador\AsyncUnit\Exception;
4 | 
5 | class TestFailedException extends Exception {
6 | }


--------------------------------------------------------------------------------
/framework_src/Exception/TestOutputException.php:
--------------------------------------------------------------------------------
1 | <?php declare(strict_types=1);
2 | 
3 | 
4 | namespace Cspray\Labrador\AsyncUnit\Exception;
5 | 
6 | 
7 | class TestOutputException extends TestFailedException {
8 | 
9 | }


--------------------------------------------------------------------------------
/framework_src/Exception/TestSetupException.php:
--------------------------------------------------------------------------------
1 | <?php declare(strict_types=1);
2 | 
3 | namespace Cspray\Labrador\AsyncUnit\Exception;
4 | 
5 | class TestSetupException extends Exception {
6 | 
7 | }


--------------------------------------------------------------------------------
/framework_src/Exception/TestSuiteSetUpException.php:
--------------------------------------------------------------------------------
1 | <?php declare(strict_types=1);
2 | 
3 | namespace Cspray\Labrador\AsyncUnit\Exception;
4 | 
5 | class TestSuiteSetUpException extends Exception {
6 | 
7 | }


--------------------------------------------------------------------------------
/framework_src/Exception/TestSuiteTearDownException.php:
--------------------------------------------------------------------------------
1 | <?php declare(strict_types=1);
2 | 
3 | namespace Cspray\Labrador\AsyncUnit\Exception;
4 | 
5 | class TestSuiteTearDownException extends Exception {
6 | 
7 | }


--------------------------------------------------------------------------------
/framework_src/Exception/TestTearDownException.php:
--------------------------------------------------------------------------------
1 | <?php declare(strict_types=1);
2 | 
3 | namespace Cspray\Labrador\AsyncUnit\Exception;
4 | 
5 | class TestTearDownException extends Exception {
6 | 
7 | }


--------------------------------------------------------------------------------
/framework_src/Exception/UnsupportedOperationException.php:
--------------------------------------------------------------------------------
1 | <?php declare(strict_types=1);
2 | 
3 | namespace Cspray\Labrador\AsyncUnit\Exception;
4 | 
5 | class UnsupportedOperationException extends Exception {
6 | 
7 | }


--------------------------------------------------------------------------------
/framework_src/ImplicitTestSuite.php:
--------------------------------------------------------------------------------
1 | <?php declare(strict_types=1);
2 | 
3 | namespace Cspray\Labrador\AsyncUnit;
4 | 
5 | final class ImplicitTestSuite extends TestSuite {}


--------------------------------------------------------------------------------
/framework_src/MockBridgeFactory.php:
--------------------------------------------------------------------------------
1 | <?php declare(strict_types=1);
2 | 
3 | namespace Cspray\Labrador\AsyncUnit;
4 | 
5 | interface MockBridgeFactory {
6 | 
7 |     public function make(string $mockBridgeClass) : MockBridge;
8 | 
9 | }


--------------------------------------------------------------------------------
/framework_src/Model/CanBeDisabledTrait.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | 
 4 | namespace Cspray\Labrador\AsyncUnit\Model;
 5 | 
 6 | 
 7 | trait CanBeDisabledTrait {
 8 | 
 9 |     private bool $isDisabled = false;
10 |     private ?string $disabledReason = null;
11 | 
12 |     public function isDisabled() : bool {
13 |         return $this->isDisabled;
14 |     }
15 | 
16 |     public function markDisabled(string $disabledReason = null) : void {
17 |         $this->disabledReason = $disabledReason;
18 |         $this->isDisabled = true;
19 |     }
20 | 
21 |     public function getDisabledReason() : ?string {
22 |         return $this->disabledReason;
23 |     }
24 | 
25 | }


--------------------------------------------------------------------------------
/framework_src/Model/CanHaveTimeoutTrait.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit\Model;
 4 | 
 5 | trait CanHaveTimeoutTrait {
 6 | 
 7 |     private ?int $timeout = null;
 8 | 
 9 |     public function setTimeout(int $timeout) : void {
10 |         $this->timeout = $timeout;
11 |     }
12 | 
13 |     public function getTimeout() : ?int {
14 |         return $this->timeout;
15 |     }
16 | 
17 | }


--------------------------------------------------------------------------------
/framework_src/Model/HookAware.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | 
 4 | namespace Cspray\Labrador\AsyncUnit\Model;
 5 | 
 6 | 
 7 | use Cspray\Labrador\AsyncUnit\HookType;
 8 | 
 9 | trait HookAware {
10 | 
11 |     private array $hooks = [];
12 | 
13 |     /**
14 |      * @param HookType $hookType
15 |      * @return HookModel[]
16 |      */
17 |     public function getHooks(HookType $hookType) : array {
18 |         return $this->hooks[$hookType->toString()] ?? [];
19 |     }
20 | 
21 |     public function addHook(HookModel $hook) : void {
22 |         if (!isset($this->hooks[$hook->getType()->toString()])) {
23 |             $this->hooks[$hook->getType()->toString()] = [];
24 |         }
25 |         $this->hooks[$hook->getType()->toString()][] = $hook;
26 |     }
27 | 
28 | }


--------------------------------------------------------------------------------
/framework_src/Model/MethodModelTrait.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit\Model;
 4 | 
 5 | trait MethodModelTrait {
 6 | 
 7 |     public function __construct(
 8 |         private string $class,
 9 |         private string $method
10 |     ) {}
11 | 
12 |     public function getClass() : string {
13 |         return $this->class;
14 |     }
15 | 
16 |     public function getMethod() : string {
17 |         return $this->method;
18 |     }
19 | 
20 | }


--------------------------------------------------------------------------------
/framework_src/Model/PluginModel.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit\Model;
 4 | 
 5 | /**
 6 |  * Represents a Plugin that the library treats as a first-class citizen and will autoregister upon Application
 7 |  * startup.
 8 |  *
 9 |  * @package Cspray\Labrador\AsyncUnit\Model
10 |  */
11 | final class PluginModel {
12 | 
13 |     public function __construct(private string $pluginClass) {}
14 | 
15 |     public function getPluginClass() : string {
16 |         return $this->pluginClass;
17 |     }
18 | 
19 | }


--------------------------------------------------------------------------------
/framework_src/Model/TestModel.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit\Model;
 4 | 
 5 | final class TestModel {
 6 | 
 7 |     use MethodModelTrait;
 8 |     use CanBeDisabledTrait;
 9 |     use CanHaveTimeoutTrait;
10 | 
11 |     private ?string $dataProvider = null;
12 | 
13 |     public function withClass(string $class) : TestModel {
14 |         $new = clone $this;
15 |         $new->class = $class;
16 |         return $new;
17 |     }
18 | 
19 |     public function getDataProvider() : ?string {
20 |         return $this->dataProvider;
21 |     }
22 | 
23 |     public function setDataProvider(string $dataProvider) : void {
24 |         $this->dataProvider = $dataProvider;
25 |     }
26 | 
27 | }


--------------------------------------------------------------------------------
/framework_src/Model/TestSuiteModel.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit\Model;
 4 | 
 5 | final class TestSuiteModel {
 6 | 
 7 |     use HookAware;
 8 |     use CanBeDisabledTrait;
 9 |     use CanHaveTimeoutTrait;
10 | 
11 |     private array $testCaseModels = [];
12 | 
13 |     public function __construct(
14 |         private string $class,
15 |         private bool $isDefaultTestSuite
16 |     ) {}
17 | 
18 |     public function getClass() : string {
19 |         return $this->class;
20 |     }
21 | 
22 |     public function isDefaultTestSuite() : bool {
23 |         return $this->isDefaultTestSuite;
24 |     }
25 | 
26 |     /**
27 |      * @return TestCaseModel[]
28 |      */
29 |     public function getTestCaseModels() : array {
30 |         return $this->testCaseModels;
31 |     }
32 | 
33 |     public function addTestCaseModel(TestCaseModel $testCaseModel) : void {
34 |         $this->testCaseModels[] = $testCaseModel;
35 |     }
36 | 
37 | }


--------------------------------------------------------------------------------
/framework_src/NullRandomizer.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit;
 4 | 
 5 | final class NullRandomizer implements Randomizer {
 6 | 
 7 |     public function randomize(array $items) : array {
 8 |         return $items;
 9 |     }
10 | 
11 | }


--------------------------------------------------------------------------------
/framework_src/Parser/AttributeGroupTraverser.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit\Parser;
 4 | 
 5 | use PhpParser\Node\Attribute;
 6 | use PhpParser\Node\AttributeGroup;
 7 | 
 8 | /**
 9 |  * @internal
10 |  */
11 | trait AttributeGroupTraverser {
12 | 
13 |     private function findAttribute(string $attributeType, AttributeGroup... $attributeGroups) : ?Attribute {
14 |         foreach ($attributeGroups as $attributeGroup) {
15 |             foreach ($attributeGroup->attrs as $attribute) {
16 |                 if ($attribute->name->toString() === $attributeType) {
17 |                     return $attribute;
18 |                 }
19 |             }
20 |         }
21 | 
22 |         return null;
23 |     }
24 | }


--------------------------------------------------------------------------------
/framework_src/Parser/Parser.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit\Parser;
 4 | 
 5 | use Amp\Promise;
 6 | 
 7 | interface Parser {
 8 | 
 9 |     /**
10 |      * @param array|string $dirs
11 |      * @return Promise<ParserResult>
12 |      */
13 |     public function parse(array|string $dirs) : Promise;
14 | 
15 | }


--------------------------------------------------------------------------------
/framework_src/Prototype/AfterEachPrototype.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | 
 4 | namespace Cspray\Labrador\AsyncUnit\Prototype;
 5 | 
 6 | use Amp\Coroutine;
 7 | use Amp\Promise;
 8 | use Cspray\Labrador\AsyncUnit\Attribute\AfterEach;
 9 | use Cspray\Labrador\AsyncUnit\Attribute\Prototype;
10 | use Cspray\Labrador\AsyncUnit\Attribute\PrototypeRequiresAttribute;
11 | use Cspray\Labrador\AsyncUnit\TestCase;
12 | use Cspray\Labrador\AsyncUnit\TestSuite;
13 | use Generator;
14 | 
15 | #[Prototype([TestSuite::class, TestCase::class])]
16 | #[PrototypeRequiresAttribute(AfterEach::class)]
17 | interface AfterEachPrototype {
18 | 
19 |     public function afterEach() : Promise|Generator|Coroutine|null;
20 | 
21 | }


--------------------------------------------------------------------------------
/framework_src/Prototype/BeforeEachPrototype.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | 
 4 | namespace Cspray\Labrador\AsyncUnit\Prototype;
 5 | 
 6 | use Amp\Coroutine;
 7 | use Amp\Promise;
 8 | use Cspray\Labrador\AsyncUnit\Attribute\BeforeEach;
 9 | use Cspray\Labrador\AsyncUnit\Attribute\Prototype;
10 | use Cspray\Labrador\AsyncUnit\Attribute\PrototypeRequiresAttribute;
11 | use Cspray\Labrador\AsyncUnit\TestCase;
12 | use Cspray\Labrador\AsyncUnit\TestSuite;
13 | use Generator;
14 | 
15 | #[Prototype([TestSuite::class, TestCase::class])]
16 | #[PrototypeRequiresAttribute(BeforeEach::class)]
17 | interface BeforeEachPrototype {
18 | 
19 |     public function beforeEach() : Promise|Generator|Coroutine|null;
20 | 
21 | }


--------------------------------------------------------------------------------
/framework_src/Prototype/DataProviderTestPrototype.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit\Prototype;
 4 | 
 5 | use Amp\Coroutine;
 6 | use Amp\Promise;
 7 | use Cspray\Labrador\AsyncUnit\Attribute\DataProvider;
 8 | use Cspray\Labrador\AsyncUnit\Attribute\Prototype;
 9 | use Cspray\Labrador\AsyncUnit\Attribute\PrototypeRequiresAttribute;
10 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
11 | use Cspray\Labrador\AsyncUnit\TestCase;
12 | use Generator;
13 | 
14 | #[Prototype([TestCase::class])]
15 | #[PrototypeRequiresAttribute(DataProvider::class)]
16 | #[PrototypeRequiresAttribute(Test::class)]
17 | interface DataProviderTestPrototype {
18 | 
19 |     public function test(mixed ...$args) : Promise|Generator|Coroutine|null;
20 | 
21 | }


--------------------------------------------------------------------------------
/framework_src/Prototype/TestCaseAfterAllPrototype.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | 
 4 | namespace Cspray\Labrador\AsyncUnit\Prototype;
 5 | 
 6 | use Amp\Coroutine;
 7 | use Amp\Promise;
 8 | use Cspray\Labrador\AsyncUnit\Attribute\AfterAll;
 9 | use Cspray\Labrador\AsyncUnit\Attribute\Prototype;
10 | use Cspray\Labrador\AsyncUnit\Attribute\PrototypeRequiresAttribute;
11 | use Cspray\Labrador\AsyncUnit\TestCase;
12 | use Cspray\Labrador\AsyncUnit\TestSuite;
13 | use Generator;
14 | 
15 | #[Prototype([TestCase::class])]
16 | #[PrototypeRequiresAttribute(AfterAll::class)]
17 | interface TestCaseAfterAllPrototype {
18 | 
19 |     public static function afterAll(TestSuite $testSuite) : Promise|Generator|Coroutine|null;
20 | 
21 | }


--------------------------------------------------------------------------------
/framework_src/Prototype/TestCaseBeforeAllPrototype.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | 
 4 | namespace Cspray\Labrador\AsyncUnit\Prototype;
 5 | 
 6 | use Amp\Coroutine;
 7 | use Amp\Promise;
 8 | use Cspray\Labrador\AsyncUnit\Attribute\BeforeAll;
 9 | use Cspray\Labrador\AsyncUnit\Attribute\Prototype;
10 | use Cspray\Labrador\AsyncUnit\Attribute\PrototypeRequiresAttribute;
11 | use Cspray\Labrador\AsyncUnit\TestCase;
12 | use Cspray\Labrador\AsyncUnit\TestSuite;
13 | 
14 | #[Prototype([TestCase::class])]
15 | #[PrototypeRequiresAttribute(BeforeAll::class)]
16 | interface TestCaseBeforeAllPrototype {
17 | 
18 |     public static function beforeAll(TestSuite $testSuite) : Promise|\Generator|Coroutine|null;
19 | 
20 | }


--------------------------------------------------------------------------------
/framework_src/Prototype/TestPrototype.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit\Prototype;
 4 | 
 5 | use Amp\Coroutine;
 6 | use Amp\Promise;
 7 | use Cspray\Labrador\AsyncUnit\Attribute\Prototype;
 8 | use Cspray\Labrador\AsyncUnit\Attribute\PrototypeRequiresAttribute;
 9 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
10 | use Cspray\Labrador\AsyncUnit\TestCase;
11 | use Generator;
12 | 
13 | #[Prototype([TestCase::class])]
14 | #[PrototypeRequiresAttribute(Test::class)]
15 | interface TestPrototype {
16 | 
17 |     public function test() : Promise|Generator|Coroutine|null;
18 | 
19 | }


--------------------------------------------------------------------------------
/framework_src/Prototype/TestSuiteAfterAllPrototype.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | 
 4 | namespace Cspray\Labrador\AsyncUnit\Prototype;
 5 | 
 6 | 
 7 | use Amp\Coroutine;
 8 | use Amp\Promise;
 9 | use Cspray\Labrador\AsyncUnit\Attribute\AfterAll;
10 | use Cspray\Labrador\AsyncUnit\Attribute\Prototype;
11 | use Cspray\Labrador\AsyncUnit\Attribute\PrototypeRequiresAttribute;
12 | use Cspray\Labrador\AsyncUnit\TestSuite;
13 | use Generator;
14 | 
15 | #[Prototype([TestSuite::class])]
16 | #[PrototypeRequiresAttribute(AfterAll::class)]
17 | interface TestSuiteAfterAllPrototype {
18 | 
19 |     public function afterAll() : Promise|Generator|Coroutine|null;
20 | 
21 | }


--------------------------------------------------------------------------------
/framework_src/Prototype/TestSuiteBeforeAllPrototype.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | 
 4 | namespace Cspray\Labrador\AsyncUnit\Prototype;
 5 | 
 6 | 
 7 | use Amp\Coroutine;
 8 | use Amp\Promise;
 9 | use Cspray\Labrador\AsyncUnit\Attribute\BeforeAll;
10 | use Cspray\Labrador\AsyncUnit\Attribute\Prototype;
11 | use Cspray\Labrador\AsyncUnit\Attribute\PrototypeRequiresAttribute;
12 | use Cspray\Labrador\AsyncUnit\TestSuite;
13 | use Generator;
14 | 
15 | #[Prototype([TestSuite::class])]
16 | #[PrototypeRequiresAttribute(BeforeAll::class)]
17 | interface TestSuiteBeforeAllPrototype {
18 | 
19 |     public function beforeAll() : Promise|Generator|Coroutine|null;
20 | 
21 | }


--------------------------------------------------------------------------------
/framework_src/Randomizer.php:
--------------------------------------------------------------------------------
1 | <?php declare(strict_types=1);
2 | 
3 | namespace Cspray\Labrador\AsyncUnit;
4 | 
5 | interface Randomizer {
6 | 
7 |     public function randomize(array $items) : array;
8 | 
9 | }


--------------------------------------------------------------------------------
/framework_src/ResultPrinterPlugin.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit;
 4 | 
 5 | use Cspray\Labrador\AsyncEvent\EventEmitter;
 6 | use Amp\ByteStream\OutputStream;
 7 | use Cspray\Labrador\Plugin\Plugin;
 8 | 
 9 | interface ResultPrinterPlugin extends Plugin {
10 | 
11 |     public function registerEvents(EventEmitter $emitter, OutputStream $output) : void;
12 | 
13 | }


--------------------------------------------------------------------------------
/framework_src/ShuffleRandomizer.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit;
 4 | 
 5 | final class ShuffleRandomizer implements Randomizer {
 6 | 
 7 |     public function randomize(array $items) : array {
 8 |         shuffle($items);
 9 |         return $items;
10 |     }
11 | }


--------------------------------------------------------------------------------
/framework_src/Statistics/AggregateSummary.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit\Statistics;
 4 | 
 5 | /**
 6 |  */
 7 | interface AggregateSummary {
 8 | 
 9 |     public function getTestSuiteNames() : array;
10 | 
11 |     public function getTotalTestSuiteCount() : int;
12 | 
13 |     public function getDisabledTestSuiteCount() : int;
14 | 
15 |     public function getTotalTestCaseCount() : int;
16 | 
17 |     public function getDisabledTestCaseCount() : int;
18 | 
19 |     public function getTotalTestCount() : int;
20 | 
21 |     public function getDisabledTestCount() : int;
22 | 
23 | }


--------------------------------------------------------------------------------
/framework_src/Statistics/ProcessedAggregateSummary.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | 
 4 | namespace Cspray\Labrador\AsyncUnit\Statistics;
 5 | 
 6 | 
 7 | use SebastianBergmann\Timer\Duration;
 8 | 
 9 | interface ProcessedAggregateSummary {
10 | 
11 |     public function getTestSuiteNames() : array;
12 | 
13 |     public function getTotalTestSuiteCount() : int;
14 | 
15 |     public function getDisabledTestSuiteCount() : int;
16 | 
17 |     public function getTotalTestCaseCount() : int;
18 | 
19 |     public function getDisabledTestCaseCount() : int;
20 | 
21 |     public function getTotalTestCount() : int;
22 | 
23 |     public function getDisabledTestCount() : int;
24 | 
25 |     public function getPassedTestCount() : int;
26 | 
27 |     public function getFailedTestCount() : int;
28 | 
29 |     public function getErroredTestCount() : int;
30 | 
31 |     public function getAssertionCount() : int;
32 | 
33 |     public function getAsyncAssertionCount() : int;
34 | 
35 |     public function getDuration() : Duration;
36 | 
37 |     public function getMemoryUsageInBytes() : int;
38 | 
39 | }


--------------------------------------------------------------------------------
/framework_src/Statistics/ProcessedTestCaseSummary.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | 
 4 | namespace Cspray\Labrador\AsyncUnit\Statistics;
 5 | 
 6 | 
 7 | use SebastianBergmann\Timer\Duration;
 8 | 
 9 | interface ProcessedTestCaseSummary {
10 | 
11 |     public function getTestSuiteName() : string;
12 | 
13 |     public function getTestCaseName() : string;
14 | 
15 |     public function getTestNames() : array;
16 | 
17 |     public function getTestCount() : int;
18 | 
19 |     public function getDisabledTestCount() : int;
20 | 
21 |     public function getPassedTestCount() : int;
22 | 
23 |     public function getFailedTestCount() : int;
24 | 
25 |     public function getErroredTestCount() : int;
26 | 
27 |     public function getAssertionCount() : int;
28 | 
29 |     public function getAsyncAssertionCount() : int;
30 | 
31 |     public function getDuration() : Duration;
32 | 
33 | }


--------------------------------------------------------------------------------
/framework_src/Statistics/ProcessedTestSuiteSummary.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit\Statistics;
 4 | 
 5 | use SebastianBergmann\Timer\Duration;
 6 | 
 7 | interface ProcessedTestSuiteSummary {
 8 | 
 9 |     public function getTestSuiteName() : string;
10 | 
11 |     public function getTestCaseNames() : array;
12 | 
13 |     public function getTestCaseCount() : int;
14 | 
15 |     public function getDisabledTestCaseCount() : int;
16 | 
17 |     public function getTestCount() : int;
18 | 
19 |     public function getDisabledTestCount() : int;
20 | 
21 |     public function getPassedTestCount() : int;
22 | 
23 |     public function getFailedTestCount() : int;
24 | 
25 |     public function getErroredTestCount() : int;
26 | 
27 |     public function getAssertionCount() : int;
28 | 
29 |     public function getAsyncAssertionCount() : int;
30 | 
31 |     public function getDuration() : Duration;
32 | 
33 | }


--------------------------------------------------------------------------------
/framework_src/Statistics/TestCaseSummary.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit\Statistics;
 4 | 
 5 | interface TestCaseSummary {
 6 | 
 7 |     public function getTestSuiteName() : string;
 8 | 
 9 |     public function getTestCaseName() : string;
10 | 
11 |     public function getTestNames() : array;
12 | 
13 |     public function getTestCount() : int;
14 | 
15 |     public function getDisabledTestCount() : int;
16 | }


--------------------------------------------------------------------------------
/framework_src/Statistics/TestSuiteSummary.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit\Statistics;
 4 | 
 5 | interface TestSuiteSummary {
 6 | 
 7 |     public function getTestSuiteName() : string;
 8 | 
 9 |     public function getTestCaseNames() : array;
10 | 
11 |     public function getTestCaseCount() : int;
12 | 
13 |     public function getDisabledTestCaseCount() : int;
14 | 
15 |     public function getTestCount() : int;
16 | 
17 |     public function getDisabledTestCount() : int;
18 | 
19 | }


--------------------------------------------------------------------------------
/framework_src/SupportedMockBridgeFactory.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit;
 4 | 
 5 | use Auryn\Injector;
 6 | 
 7 | final class SupportedMockBridgeFactory implements MockBridgeFactory {
 8 | 
 9 |     private Injector $injector;
10 | 
11 |     public function __construct(Injector $injector) {
12 |         $this->injector = $injector;
13 |     }
14 | 
15 |     public function make(string $mockBridgeClass): MockBridge {
16 |         return $this->injector->make($mockBridgeClass);
17 |     }
18 | 
19 | }


--------------------------------------------------------------------------------
/framework_src/TestState.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit;
 4 | 
 5 | use Cspray\Yape\Enum;
 6 | use Cspray\Yape\EnumTrait;
 7 | 
 8 | final class TestState implements Enum {
 9 | 
10 |     use EnumTrait;
11 | 
12 |     public static function Passed() : self {
13 |         return self::getSingleton(__FUNCTION__);
14 |     }
15 | 
16 |     public static function Failed() : self {
17 |         return self::getSingleton(__FUNCTION__);
18 |     }
19 | 
20 |     public static function Disabled() : self {
21 |         return self::getSingleton(__FUNCTION__);
22 |     }
23 | 
24 |     public static function Errored() : self {
25 |         return self::getSingleton(__FUNCTION__);
26 |     }
27 | 
28 |     static protected function getAllowedValues() : array {
29 |         return ['Passed', 'Failed', 'Disabled', 'Error'];
30 |     }
31 | }


--------------------------------------------------------------------------------
/framework_src/TestSuite.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit;
 4 | 
 5 | abstract class TestSuite {
 6 | 
 7 |     private array $data = [];
 8 | 
 9 |     private function __construct() {}
10 | 
11 |     public static function getNamespacesToAttach() : array {
12 |         return [];
13 |     }
14 | 
15 |     final public function getName() : string {
16 |         return static::class;
17 |     }
18 | 
19 |     final public function set(string $key, mixed $value) : void {
20 |         $this->data[$key] = $value;
21 |     }
22 | 
23 |     final public function get(string $key) : mixed {
24 |         return $this->data[$key] ?? null;
25 |     }
26 | 
27 | }


--------------------------------------------------------------------------------
/framework_test/Assertion/AssertIsNullTest.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit\Assertion;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Assertion;
 6 | 
 7 | class AssertIsNullTest extends AbstractAssertionTestCase {
 8 | 
 9 |     protected function getAssertion($expected, $actual) : Assertion {
10 |         return new AssertIsNull($actual);
11 |     }
12 | 
13 |     public function getGoodActual() : array {
14 |         return [
15 |             [null]
16 |         ];
17 |     }
18 | 
19 |     protected function getExpected() : mixed {
20 |         return null;
21 |     }
22 | 
23 |     public function getBadActual() : array {
24 |         return [
25 |             ['not null'],
26 |             [1],
27 |             [false],
28 |             [0],
29 |             [[]]
30 |         ];
31 |     }
32 | 
33 |     protected function getSummaryAssertionMessageClass() : string {
34 |         return Assertion\AssertionMessage\NullUnaryOperandSummary::class;
35 |     }
36 | 
37 |     protected function getDetailsAssertionMessageClass() : string {
38 |         return Assertion\AssertionMessage\NullUnaryOperandDetails::class;
39 |     }
40 | }


--------------------------------------------------------------------------------
/framework_test/AsyncUnitAssertions.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Constraint\TestCaseModelHasTestMethod;
 6 | use Cspray\Labrador\AsyncUnit\Constraint\TestSuiteModelHasTestCaseModel;
 7 | use Cspray\Labrador\AsyncUnit\Model\TestCaseModel;
 8 | use Cspray\Labrador\AsyncUnit\Model\TestSuiteModel;
 9 | 
10 | trait AsyncUnitAssertions {
11 | 
12 |     public function assertTestCaseClassBelongsToTestSuite(string $expected, TestSuiteModel $actual) {
13 |         $constraint = new TestSuiteModelHasTestCaseModel($expected);
14 |         $this->assertThat($actual, $constraint);
15 |     }
16 | 
17 |     public function assertTestMethodBelongsToTestCase(string $methodSignature, TestCaseModel $actual) {
18 |         [$testClass, $method] = explode('::', $methodSignature);
19 |         $constraint = new TestCaseModelHasTestMethod($testClass, $method);
20 |         $this->assertThat($actual, $constraint);
21 |     }
22 | 
23 | }


--------------------------------------------------------------------------------
/framework_test/Resources/dummy_configs/bad_keys.json:
--------------------------------------------------------------------------------
1 | {
2 |   "foo": "bar",
3 |   "bar": "baz"
4 | }


--------------------------------------------------------------------------------
/framework_test/Resources/dummy_configs/empty_object.json:
--------------------------------------------------------------------------------
1 | {}


--------------------------------------------------------------------------------
/framework_test/Resources/dummy_configs/good_keys_bad_types.json:
--------------------------------------------------------------------------------
1 | {
2 |   "$schema": "https://labrador-kennel.io/dev/async-unit/schema/cli",
3 |   "testDirs": "something",
4 |   "plugins": "something"
5 | }


--------------------------------------------------------------------------------
/framework_test/Resources/dummy_configs/good_keys_but_extra.json:
--------------------------------------------------------------------------------
1 | {
2 |   "testDirs": ["foo"],
3 |   "plugins": [],
4 |   "something": "else"
5 | }


--------------------------------------------------------------------------------
/framework_test/Resources/dummy_configs/has_mock_bridge.json:
--------------------------------------------------------------------------------
1 | {
2 |   "testDirs": ["."],
3 |   "resultPrinter": "Cspray\\Labrador\\AsyncUnitCli\\DefaultResultPrinter",
4 |   "mockBridge": "Cspray\\Labrador\\AsyncUnit\\MockBridge\\MockeryMockBridge"
5 | }
6 | 


--------------------------------------------------------------------------------
/framework_test/Resources/dummy_configs/has_plugins.json:
--------------------------------------------------------------------------------
1 | {
2 |   "testDirs": ["."],
3 |   "resultPrinter": "Cspray\\Labrador\\AsyncUnitCli\\DefaultResultPrinter",
4 |   "plugins": ["FooBar"]
5 | }


--------------------------------------------------------------------------------
/framework_test/Resources/dummy_configs/minimally_valid.json:
--------------------------------------------------------------------------------
1 | {
2 |   "testDirs": ["."],
3 |   "resultPrinter": "Cspray\\Labrador\\AsyncUnitCli\\TerminalResultPrinter",
4 |   "mockBridge": "Cspray\\Labrador\\AsyncUnit\\Stub\\MockBridgeStub"
5 | }


--------------------------------------------------------------------------------
/framework_test/Resources/dummy_configs/mock_bridge_empty_string.json:
--------------------------------------------------------------------------------
1 | {
2 |   "testDirs": ["."],
3 |   "resultPrinter": "SomeClass",
4 |   "mockBridge": ""
5 | }


--------------------------------------------------------------------------------
/framework_test/Resources/dummy_configs/plugins_empty.json:
--------------------------------------------------------------------------------
1 | {
2 |   "testDirs": ["foo"],
3 |   "plugins": []
4 | }


--------------------------------------------------------------------------------
/framework_test/Resources/dummy_configs/plugins_empty_string.json:
--------------------------------------------------------------------------------
1 | {
2 |   "testDirs": ["foo"],
3 |   "plugins": ["FooBar", ""]
4 | }


--------------------------------------------------------------------------------
/framework_test/Resources/dummy_configs/plugins_non_string.json:
--------------------------------------------------------------------------------
1 | {
2 |   "testDirs": ["foo"],
3 |   "plugins": [1, 3.4, []]
4 | }


--------------------------------------------------------------------------------
/framework_test/Resources/dummy_configs/result_printer_empty.json:
--------------------------------------------------------------------------------
1 | {
2 |   "testDirs": ["."],
3 |   "resultPrinter": ""
4 | }


--------------------------------------------------------------------------------
/framework_test/Resources/dummy_configs/result_printer_null.json:
--------------------------------------------------------------------------------
1 | {
2 |   "testDirs": ["."],
3 |   "resultPrinter": null
4 | }


--------------------------------------------------------------------------------
/framework_test/Resources/dummy_configs/test_dirs_empty.json:
--------------------------------------------------------------------------------
1 | {
2 |   "testDirs": [],
3 |   "plugins": []
4 | }


--------------------------------------------------------------------------------
/framework_test/Resources/dummy_configs/test_dirs_empty_string.json:
--------------------------------------------------------------------------------
1 | {
2 |   "testDirs": ["foo", ""],
3 |   "plugins": []
4 | }


--------------------------------------------------------------------------------
/framework_test/Resources/dummy_configs/test_dirs_non_string.json:
--------------------------------------------------------------------------------
1 | {
2 |   "testDirs": [1],
3 |   "plugins": []
4 | }


--------------------------------------------------------------------------------
/framework_test/ShuffleRandomizerTest.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit;
 4 | 
 5 | use PHPUnit\Framework\TestCase as PHPUnitTestCase;
 6 | 
 7 | class ShuffleRandomizerTest extends PHPUnitTestCase {
 8 | 
 9 |     public function testShuffleRandomizerReturnsArrayWithSameElements() : void {
10 |         $subject = new ShuffleRandomizer();
11 | 
12 |         $expected = ['a', 'b', 'c', 'd'];
13 |         $actual = $subject->randomize(['d', 'b', 'c', 'a']);
14 | 
15 |         $this->assertEqualsCanonicalizing($expected, $actual);
16 |     }
17 | 
18 | }


--------------------------------------------------------------------------------
/framework_test/Stub/AssertNotTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit\Stub;
 4 | 
 5 | use Amp\Success;
 6 | use Cspray\Labrador\AsyncUnit\TestCase;
 7 | 
 8 | class AssertNotTestCase extends TestCase {
 9 | 
10 |     public function doNotAssertion() {
11 |         $this->assert()->not()->stringEquals('foo', 'bar');
12 |     }
13 | 
14 |     public function doFailingNotAssertions() {
15 |         $this->assert()->not()->stringEquals('foo', 'foo');
16 |     }
17 | 
18 |     public function doBothAssertions() {
19 |         $this->assert()->stringEquals('bar', 'bar');
20 |         $this->assert()->not()->stringEquals('foo', 'bar');
21 |         $this->assert()->stringEquals('foo', 'foo');
22 |     }
23 | 
24 |     public function doAsyncNotAssertion() {
25 |         yield $this->asyncAssert()->not()->intEquals(1, new Success(2));
26 |     }
27 | 
28 | }


--------------------------------------------------------------------------------
/framework_test/Stub/BarAssertionPlugin.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit\Stub;
 4 | 
 5 | use Amp\Promise;
 6 | use Amp\Success;
 7 | use Cspray\Labrador\AsyncUnit\Context\CustomAssertionContext;
 8 | use Cspray\Labrador\AsyncUnit\CustomAssertionPlugin;
 9 | 
10 | class BarAssertionPlugin implements CustomAssertionPlugin {
11 | 
12 |     private ?CustomAssertionContext $context = null;
13 | 
14 |     public function registerCustomAssertions(CustomAssertionContext $customAssertionContext) : Promise {
15 |         $this->context = $customAssertionContext;
16 |         return new Success();
17 |     }
18 | 
19 |     public function getCustomAssertionContext() : ?CustomAssertionContext {
20 |         return $this->context;
21 |     }
22 | }


--------------------------------------------------------------------------------
/framework_test/Stub/CountableStub.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit\Stub;
 4 | 
 5 | class CountableStub implements \Countable {
 6 | 
 7 |     private int $count;
 8 | 
 9 |     public function __construct(int $count) {
10 |         $this->count = $count;
11 |     }
12 | 
13 |     public function count() : int {
14 |         return $this->count;
15 |     }
16 | }


--------------------------------------------------------------------------------
/framework_test/Stub/CustomAssertionTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit\Stub;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\TestCase;
 6 | 
 7 | class CustomAssertionTestCase extends TestCase {
 8 | 
 9 |     public function doCustomAssertion() {
10 |         $this->assert()->myCustomAssertion(1, 2, 3);
11 |     }
12 | 
13 |     public function doCustomAsyncAssertion() {
14 |         yield $this->asyncAssert()->myCustomAssertion(1, 2, 3);
15 |     }
16 | 
17 | }


--------------------------------------------------------------------------------
/framework_test/Stub/FailingMockBridgeFactory.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit\Stub;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\MockBridge;
 6 | use Cspray\Labrador\AsyncUnit\MockBridgeFactory;
 7 | 
 8 | class FailingMockBridgeFactory implements MockBridgeFactory {
 9 | 
10 |     public function make(string $mockBridgeClass): MockBridge {
11 |         return new FailingMockBridgeStub();
12 |     }
13 | }


--------------------------------------------------------------------------------
/framework_test/Stub/FailingMockBridgeStub.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit\Stub;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Exception\MockFailureException;
 6 | use Cspray\Labrador\AsyncUnit\MockBridge;
 7 | 
 8 | class FailingMockBridgeStub implements MockBridge {
 9 | 
10 |     public function initialize(): void {
11 |         // TODO: Implement initialize() method.
12 |     }
13 | 
14 |     public function finalize(): void {
15 |         throw new MockFailureException('Thrown from the FailingMockBridgeStub');
16 |     }
17 | 
18 |     public function createMock(string $class): object {
19 |         return new \stdClass();
20 |     }
21 | 
22 |     public function getAssertionCount(): int {
23 |         return 0;
24 |     }
25 | }


--------------------------------------------------------------------------------
/framework_test/Stub/FailingTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit\Stub;
 4 | 
 5 | use Amp\Success;
 6 | use Cspray\Labrador\AsyncUnit\TestCase;
 7 | 
 8 | class FailingTestCase extends TestCase {
 9 | 
10 |     public function doFailure() {
11 |         $this->assert()->stringEquals('foo', 'bar');
12 |     }
13 | 
14 |     public function doAsyncFailure() {
15 |         yield $this->asyncAssert()->stringEquals('foo', new Success('bar'));
16 |     }
17 | 
18 |     public function doFailureWithCustomMessage() {
19 |         $this->assert()->stringEquals('foo', 'bar', 'my custom message');
20 |     }
21 | 
22 | }


--------------------------------------------------------------------------------
/framework_test/Stub/FooAssertionPlugin.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit\Stub;
 4 | 
 5 | use Amp\Promise;
 6 | use Amp\Success;
 7 | use Cspray\Labrador\AsyncUnit\Context\CustomAssertionContext;
 8 | use Cspray\Labrador\AsyncUnit\CustomAssertionPlugin;
 9 | 
10 | class FooAssertionPlugin implements CustomAssertionPlugin {
11 | 
12 |     private ?CustomAssertionContext $context = null;
13 | 
14 |     public function registerCustomAssertions(CustomAssertionContext $customAssertionContext) : Promise {
15 |         $this->context = $customAssertionContext;
16 |         return new Success();
17 |     }
18 | 
19 |     public function getCustomAssertionContext() : ?CustomAssertionContext {
20 |         return $this->context;
21 |     }
22 | }


--------------------------------------------------------------------------------
/framework_test/Stub/MockAwareTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit\Stub;
 4 | 
 5 | use Cspray\Labrador\AsyncUnit\Attribute\Test;
 6 | use Cspray\Labrador\AsyncUnit\TestCase;
 7 | use Psr\Log\LoggerInterface;
 8 | use stdClass;
 9 | 
10 | class MockAwareTestCase extends TestCase {
11 | 
12 |     private ?object $createdMock = null;
13 | 
14 |     #[Test]
15 |     public function checkCreatingMock() {
16 |         $this->createdMock = $this->mocks()->createMock(LoggerInterface::class);
17 |         $this->assert()->not()->isNull($this->createdMock);
18 |     }
19 | 
20 |     public function getCreatedMock() : ?object {
21 |         return $this->createdMock;
22 |     }
23 | 
24 | }


--------------------------------------------------------------------------------
/framework_test/Stub/MockBridgeStub.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | 
 4 | namespace Cspray\Labrador\AsyncUnit\Stub;
 5 | 
 6 | use Cspray\Labrador\AsyncUnit\MockBridge;
 7 | use stdClass;
 8 | 
 9 | class MockBridgeStub implements MockBridge {
10 | 
11 |     private array $calls = [];
12 | 
13 |     public function initialize(): void {
14 |         $this->calls[] = __FUNCTION__;
15 |     }
16 | 
17 |     public function createMock(string $class): object {
18 |         $this->calls[] = __FUNCTION__ . ' ' . $class;
19 |         $object = new stdClass();
20 |         $object->class = $class;
21 |         return $object;
22 |     }
23 | 
24 |     public function getAssertionCount(): int {
25 |         return count($this->calls);
26 |     }
27 | 
28 |     public function finalize(): void {
29 |         $this->calls[] = __FUNCTION__;
30 |     }
31 | 
32 |     public function getCalls() : array {
33 |         return $this->calls;
34 |     }
35 | }


--------------------------------------------------------------------------------
/framework_test/UsesAcmeSrc.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Cspray\Labrador\AsyncUnit;
 4 | 
 5 | trait UsesAcmeSrc {
 6 | 
 7 |     private function path(string $path) : string {
 8 |         return dirname(__DIR__) . '/acme_src/' . $path;
 9 |     }
10 | 
11 |     private function implicitDefaultTestSuitePath(string $path) : string {
12 |         return $this->path('ImplicitDefaultTestSuite/' . $path);
13 |     }
14 | 
15 |     private function explicitTestSuitePath(string $path) : string {
16 |         return $this->path('ExplicitTestSuite/' . $path);
17 |     }
18 | 
19 | }


--------------------------------------------------------------------------------
/resources/schema/cli-config.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "$schema": "https://json-schema.org/draft/2020-12/schema",
 3 |   "$id": "https://labrador-kennel.io/dev/async-unit/schema/cli-config.json",
 4 |   "title": "AsyncUnitCliConfig",
 5 |   "description": "Declares the format of a valid asyncunit.json file to run AsyncUnit tests.",
 6 |   "type": "object",
 7 |   "properties": {
 8 |     "testDirs": {
 9 |       "type": "array",
10 |       "minItems": 1,
11 |       "items": {
12 |         "type": "string",
13 |         "minLength": 1
14 |       }
15 |     },
16 |     "resultPrinter": {
17 |       "type": "string",
18 |       "minLength": 1
19 |     },
20 |     "mockBridge": {
21 |       "type": "string",
22 |       "minLength": 1
23 |     },
24 |     "plugins": {
25 |       "type": "array",
26 |       "minItems": 1,
27 |       "items": {
28 |         "type": "string",
29 |         "minLength": 1
30 |       }
31 |     }
32 |   },
33 |   "required": ["testDirs", "resultPrinter"],
34 |   "additionalProperties": false
35 | }


--------------------------------------------------------------------------------