Skip to content

Commit 65e1d37

Browse files
stevleibeltstevleibelt
committed
migrated test to phpunit 6
1 parent e0afd61 commit 65e1d37

File tree

10 files changed

+124
-69
lines changed

10 files changed

+124
-69
lines changed

‎test/AbstractTestCase.php

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -15,13 +15,13 @@
1515
use Net\Bazzline\Component\Toolbox\Scalar\Text;
1616
use Net\Bazzline\Component\Toolbox\Time\Stopwatch;
1717
use Net\Bazzline\Component\Toolbox\Time\Timestamp;
18-
use PHPUnit_Framework_TestCase;
18+
use PHPUnit\Framework\TestCase;
1919

2020
/**
2121
* Class AbstractTestCase
2222
* @package Test\Net\Bazzline\Component\Toolbox
2323
*/
24-
abstract class AbstractTestCase extends PHPUnit_Framework_TestCase
24+
abstract class AbstractTestCase extends TestCase
2525
{
2626
/**
2727
* @param int $maximum

‎test/Collection/Chunk/ChunkIteratorTest.php

Lines changed: 16 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -35,13 +35,13 @@ public function testWithJustOneItemInAChunk()
3535
$chunkIterator->initialize(0, 0, 1);
3636

3737
foreach ($chunkIterator as $chunk) {
38-
$this->assertEquals(0, $chunk->maximum());
39-
$this->assertEquals(0, $chunk->minimum());
38+
self::assertEquals(0, $chunk->maximum());
39+
self::assertEquals(0, $chunk->minimum());
4040

4141
++$numberOfChunks;
4242
}
4343

44-
$this->assertEquals($expectedNumberOfChunks, $numberOfChunks);
44+
self::assertEquals($expectedNumberOfChunks, $numberOfChunks);
4545
}
4646

4747
public function testInitializeWithEqualMinimumAndMaximum()
@@ -55,8 +55,8 @@ public function testInitializeWithEqualMinimumAndMaximum()
5555

5656
$currentChunk = $chunkIterator->current();
5757

58-
$this->assertEquals($maximum, $currentChunk->maximum());
59-
$this->assertEquals($minimum, $currentChunk->minimum());
58+
self::assertEquals($maximum, $currentChunk->maximum());
59+
self::assertEquals($minimum, $currentChunk->minimum());
6060
}
6161

6262
public function testWithMultipleSteps()
@@ -68,13 +68,13 @@ public function testWithMultipleSteps()
6868
$chunkIterator = $this->getNewCollectionChunkIterator($maximum, $minimum, $stepSize);
6969

7070
foreach ($chunkIterator as $chunk) {
71-
$this->assertTrue(($maximum > $chunk->minimum()));
72-
$this->assertTrue(($minimum <= $chunk->minimum()));
73-
$this->assertTrue(($maximum >= $chunk->maximum()));
71+
self::assertTrue(($maximum > $chunk->minimum()));
72+
self::assertTrue(($minimum <= $chunk->minimum()));
73+
self::assertTrue(($maximum >= $chunk->maximum()));
7474
++$numberOfChunks;
7575
}
7676

77-
$this->assertEquals(3, $numberOfChunks);
77+
self::assertEquals(3, $numberOfChunks);
7878
}
7979

8080
public function testWithMultipleStepsByCallingInitialize()
@@ -88,13 +88,13 @@ public function testWithMultipleStepsByCallingInitialize()
8888
$chunkIterator->initialize($maximum, $minimum, $stepSize);
8989

9090
foreach ($chunkIterator as $chunk) {
91-
$this->assertTrue(($maximum > $chunk->minimum()));
92-
$this->assertTrue(($minimum <= $chunk->minimum()));
93-
$this->assertTrue(($maximum >= $chunk->maximum()));
91+
self::assertTrue(($maximum > $chunk->minimum()));
92+
self::assertTrue(($minimum <= $chunk->minimum()));
93+
self::assertTrue(($maximum >= $chunk->maximum()));
9494
++$numberOfChunks;
9595
}
9696

97-
$this->assertEquals(3, $numberOfChunks);
97+
self::assertEquals(3, $numberOfChunks);
9898
}
9999

100100
public function testWithJustOneItem()
@@ -121,12 +121,12 @@ public function testThatNoChunkIsEverProcessedMoreThanOnce()
121121
$expectedMaximum = $expectedChunks[$index][1];
122122
$expectedMinimum = $expectedChunks[$index][0];
123123

124-
$this->assertEquals($expectedMaximum, $chunk->maximum());
125-
$this->assertEquals($expectedMinimum, $chunk->minimum());
124+
self::assertEquals($expectedMaximum, $chunk->maximum());
125+
self::assertEquals($expectedMinimum, $chunk->minimum());
126126

127127
++$numberOfChunks;
128128
}
129129

130-
$this->assertEquals($expectedNumberOfChunks, $numberOfChunks);
130+
self::assertEquals($expectedNumberOfChunks, $numberOfChunks);
131131
}
132132
}

‎test/HashMap/CombineTest.php

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -62,6 +62,6 @@ public function testCombine(
6262
) {
6363
$combine = $this->getHashMapCombine();
6464

65-
$this->assertEquals($expectedResult, $combine($keys, $values));
65+
self::assertEquals($expectedResult, $combine($keys, $values));
6666
}
6767
}

‎test/HashMap/MergeTest.php

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -153,7 +153,7 @@ public function testMergeAsInvokable(
153153
) {
154154
$merger = $this->getHashMapMerge();
155155

156-
$this->assertEquals(
156+
self::assertEquals(
157157
$expectedMergeResult,
158158
$merger(
159159
$arrayToMergeInto,

‎test/Process/EnumerableDeferredTest.php

Lines changed: 8 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -41,11 +41,11 @@ public function testIncrease()
4141
//we have to unset the process to trigger the destructor method
4242
unset($processor);
4343

44-
$this->assertEquals(5, $finisherIterator);
45-
$this->assertEquals(5, $initializerIterator);
46-
$this->assertEquals(44, $processIterator);
44+
self::assertEquals(5, $finisherIterator);
45+
self::assertEquals(5, $initializerIterator);
46+
self::assertEquals(44, $processIterator);
4747
foreach ($argumentCollection as $arguments) {
48-
$this->assertEquals($arguments, ['foo', 'bar']);
48+
self::assertEquals($arguments, ['foo', 'bar']);
4949
}
5050
}
5151

@@ -81,11 +81,11 @@ public function testInvoke()
8181
//we have to unset the process to trigger the destructor method
8282
unset($processor);
8383

84-
$this->assertEquals(5, $finisherIterator);
85-
$this->assertEquals(5, $initializerIterator);
86-
$this->assertEquals(44, $processIterator);
84+
self::assertEquals(5, $finisherIterator);
85+
self::assertEquals(5, $initializerIterator);
86+
self::assertEquals(44, $processIterator);
8787
foreach ($argumentCollection as $arguments) {
88-
$this->assertEquals($arguments, ['foo', 'bar']);
88+
self::assertEquals($arguments, ['foo', 'bar']);
8989
}
9090
}
9191
}

‎test/Process/ExperimentTest.php

Lines changed: 57 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -15,6 +15,9 @@
1515
*/
1616
class ExperimentTest extends AbstractTestCase
1717
{
18+
/**
19+
* @throws \InvalidArgumentException
20+
*/
1821
public function testIsSuccessfulOnLastRun()
1922
{
2023
$iterator = 0;
@@ -35,9 +38,21 @@ public function testIsSuccessfulOnLastRun()
3538
};
3639
$expectedWasSuccessful = true;
3740

38-
$this->tryOutExperiment($trial, $times, $wait, $onSuccess, $onFailure, $expectedWasSuccessful, $successfulExecuted, $fallbackExecuted);
41+
$this->tryOutExperiment(
42+
$trial,
43+
$times,
44+
$wait,
45+
$onSuccess,
46+
$onFailure,
47+
$expectedWasSuccessful,
48+
$successfulExecuted,
49+
$fallbackExecuted
50+
);
3951
}
4052

53+
/**
54+
* @throws \InvalidArgumentException
55+
*/
4156
public function testIsSuccessfulOnFirstRun()
4257
{
4358
$iterator = 0;
@@ -58,9 +73,21 @@ public function testIsSuccessfulOnFirstRun()
5873
};
5974
$expectedWasSuccessful = true;
6075

61-
$this->tryOutExperiment($trial, $times, $wait, $onSuccess, $onFailure, $expectedWasSuccessful, $successfulExecuted, $fallbackExecuted);
76+
$this->tryOutExperiment(
77+
$trial,
78+
$times,
79+
$wait,
80+
$onSuccess,
81+
$onFailure,
82+
$expectedWasSuccessful,
83+
$successfulExecuted,
84+
$fallbackExecuted
85+
);
6286
}
6387

88+
/**
89+
* @throws \InvalidArgumentException
90+
*/
6491
public function testIsNeverSuccessfulByReturningFalse()
6592
{
6693
$successfulExecuted = false;
@@ -79,9 +106,21 @@ public function testIsNeverSuccessfulByReturningFalse()
79106
};
80107
$expectedWasSuccessful = false;
81108

82-
$this->tryOutExperiment($trial, $times, $wait, $onSuccess, $onFailure, $expectedWasSuccessful, $successfulExecuted, $fallbackExecuted);
109+
$this->tryOutExperiment(
110+
$trial,
111+
$times,
112+
$wait,
113+
$onSuccess,
114+
$onFailure,
115+
$expectedWasSuccessful,
116+
$successfulExecuted,
117+
$fallbackExecuted
118+
);
83119
}
84120

121+
/**
122+
* @throws \InvalidArgumentException
123+
*/
85124
public function testIsNeverSuccessfulByThrowingException()
86125
{
87126
$successfulExecuted = false;
@@ -102,7 +141,16 @@ public function testIsNeverSuccessfulByThrowingException()
102141
};
103142
$expectedWasSuccessful = false;
104143

105-
$this->tryOutExperiment($trial, $times, $wait, $onSuccess, $onFailure, $expectedWasSuccessful, $successfulExecuted, $fallbackExecuted);
144+
$this->tryOutExperiment(
145+
$trial,
146+
$times,
147+
$wait,
148+
$onSuccess,
149+
$onFailure,
150+
$expectedWasSuccessful,
151+
$successfulExecuted,
152+
$fallbackExecuted
153+
);
106154
}
107155

108156

@@ -118,7 +166,6 @@ public function testIsNeverSuccessfulByThrowingException()
118166
* @param bool $fallbackExecuted
119167
* @throws \Exception
120168
* @throws \InvalidArgumentException
121-
* @throws \PHPUnit_Framework_AssertionFailedError
122169
*/
123170
private function tryOutExperiment(
124171
$trial,
@@ -141,17 +188,17 @@ private function tryOutExperiment(
141188
);
142189
$wasSuccessful = $experiment->andTryIt();
143190

144-
$this->assertEquals(
191+
self::assertEquals(
145192
$expectedWasSuccessful,
146193
$wasSuccessful
147194
);
148195

149196
if ($expectedWasSuccessful) {
150-
$this->assertFalse($fallbackExecuted);
151-
$this->assertTrue($successfulExecuted);
197+
self::assertFalse($fallbackExecuted);
198+
self::assertTrue($successfulExecuted);
152199
} else {
153-
$this->assertFalse($successfulExecuted);
154-
$this->assertTrue($fallbackExecuted);
200+
self::assertFalse($successfulExecuted);
201+
self::assertTrue($fallbackExecuted);
155202
}
156203
}
157204
}

‎test/Scalar/RealNumberTest.php

Lines changed: 28 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -24,7 +24,7 @@ public function invalidConstructorArgumentProvider()
2424
'string'
2525
],
2626
'object' => [
27-
new stdClass(__LINE__)
27+
new stdClass()
2828
]
2929
];
3030
}
@@ -48,7 +48,7 @@ public function testConstructorWithInvalidArguments($constructorArgument)
4848
*/
4949
public function validConstructorArgumentProvider()
5050
{
51-
return array(
51+
return [
5252
'int' => [
5353
3,
5454
3
@@ -75,51 +75,59 @@ public function validConstructorArgumentProvider()
7575
* @param int|float|double|number $constructorArgument
7676
* @param int|float|double|number $expectedValue
7777
* @throws \InvalidArgumentException
78-
* @throws \PHPUnit_Framework_AssertionFailedError
78+
* @throws \PHPUnit\Framework\AssertionFailedError
7979
*/
8080
public function testConstructorWithValidArguments($constructorArgument, $expectedValue)
8181
{
8282
$number = new RealNumber($constructorArgument);
8383
$isEqual = ((string) $number == $expectedValue);
8484

85-
$this->assertTrue($isEqual);
85+
self::assertTrue($isEqual);
8686
}
8787

88+
/**
89+
* @throws \InvalidArgumentException
90+
* @throws \PHPUnit\Framework\AssertionFailedError
91+
*/
8892
public function testToScalar()
8993
{
9094
$number = new RealNumber(__LINE__);
9195

9296
$areEqual = ($number->__toString() == $number->toScalar());
9397
$areIdentical = ($number->__toString() === $number->toScalar());
9498

95-
$this->assertTrue($areEqual);
96-
$this->assertFalse($areIdentical);
99+
self::assertTrue($areEqual);
100+
self::assertFalse($areIdentical);
97101
}
98102

103+
/**
104+
* @throws \InvalidArgumentException
105+
* @throws \PHPUnit\Framework\AssertionFailedError
106+
*/
99107
public function testComparison()
100108
{
101109
$three = new RealNumber(3);
102110
$four = new RealNumber(4);
103111

104-
$this->assertFalse($three->isEqual($four));
112+
self::assertFalse($three->isEqual($four));
105113

106-
$this->assertFalse($three->isGreaterThan($four));
107-
$this->assertFalse($three->isGreaterThanOrEqual($four));
114+
self::assertFalse($three->isGreaterThan($four));
115+
self::assertFalse($three->isGreaterThanOrEqual($four));
108116

109-
$this->assertTrue($four->isGreaterThan($three));
110-
$this->assertTrue($four->isGreaterThanOrEqual($three));
117+
self::assertTrue($four->isGreaterThan($three));
118+
self::assertTrue($four->isGreaterThanOrEqual($three));
111119

112-
$this->assertFalse($four->isLessThan($three));
113-
$this->assertFalse($four->isLessThanOrEqual($three));
120+
self::assertFalse($four->isLessThan($three));
121+
self::assertFalse($four->isLessThanOrEqual($three));
114122

115-
$this->assertTrue($three->isLessThan($four));
116-
$this->assertTrue($three->isLessThanOrEqual($four));
123+
self::assertTrue($three->isLessThan($four));
124+
self::assertTrue($three->isLessThanOrEqual($four));
117125

118-
$this->assertTrue($four->isEqual($four));
119-
$this->assertTrue($four->isGreaterThanOrEqual($four));
120-
$this->assertTrue($four->isLessThanOrEqual($four));
126+
self::assertTrue($four->isEqual($four));
127+
self::assertTrue($four->isGreaterThanOrEqual($four));
128+
self::assertTrue($four->isLessThanOrEqual($four));
121129

122-
$this->assertFalse($four->isGreaterThan($four));
123-
$this->assertFalse($four->isLessThan($four));
130+
self::assertFalse($four->isGreaterThan($four));
131+
self::assertFalse($four->isLessThan($four));
124132
}
125133
}

‎test/Scalar/TextTest.php

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -20,7 +20,7 @@ public function testContains($haystack, $needle, $searchCaseInsensitive, $expect
2020
{
2121
$text = $this->getNewText();
2222

23-
$this->assertEquals(
23+
self::assertEquals(
2424
$expectedResult,
2525
$text->contains($haystack, $needle, $searchCaseInsensitive)
2626
);
@@ -37,7 +37,7 @@ public function testEndsWith($haystack, $needle, $searchCaseInsensitive, $expect
3737
{
3838
$text = $this->getNewText();
3939

40-
$this->assertEquals(
40+
self::assertEquals(
4141
$expectedResult,
4242
$text->endsWith($haystack, $needle, $searchCaseInsensitive)
4343
);
@@ -54,7 +54,7 @@ public function testStartsWith($haystack, $needle, $searchCaseInsensitive, $expe
5454
{
5555
$text = $this->getNewText();
5656

57-
$this->assertEquals(
57+
self::assertEquals(
5858
$expectedResult,
5959
$text->startsWith($haystack, $needle, $searchCaseInsensitive)
6060
);

0 commit comments

Comments
 (0)