simplify test names

spawnia · spawnia · commit d82f7cf58367 · 2024-09-11T12:26:18.000+02:00
diff --git a/src/Microplate/Scalars/Column12.php b/src/Microplate/Scalars/Column12.php
@@ -8,13 +8,13 @@ class Column12 extends IntRange
 {
     public ?string $description = 'Represents a column in a coordinate system with 12 columns. Allowed values range from 1-12.';
 
-    protected static function max(): int
+    protected static function min(): int
     {
-        return 12;
+        return 1;
     }
 
-    protected static function min(): int
+    protected static function max(): int
     {
-        return 1;
+        return 12;
     }
 }
diff --git a/tests/Microplate/Scalars/Column12Test.php b/tests/Microplate/Scalars/Column12Test.php
@@ -18,38 +18,38 @@ protected function setUp(): void
         }
     }
 
-    public function testSerializeThrowsIfColumn12IsNotAnInt(): void
+    public function testSerializeThrowsIfNotAnInt(): void
     {
         $this->expectException(\InvalidArgumentException::class);
         $this->expectExceptionMessage('Value not in range 1-12: "12".');
 
         (new Column12())->serialize('12');
     }
 
-    public function testSerializeThrowsIfColumn12IsInvalid(): void
+    public function testSerializeThrowsIfInvalid(): void
     {
         $this->expectException(\InvalidArgumentException::class);
         $this->expectExceptionMessage('Value not in range 1-12: 13.');
 
         (new Column12())->serialize(13);
     }
 
-    public function testSerializePassesWhenColumn12IsValid(): void
+    public function testSerializePassesValid(): void
     {
         $serializedResult = (new Column12())->serialize(12);
 
         self::assertSame(12, $serializedResult);
     }
 
-    public function testParseValueThrowsIfColumn12IsInvalid(): void
+    public function testParseValueThrowsIfInvalid(): void
     {
         $this->expectException(Error::class);
         $this->expectExceptionMessage('Value not in range 1-12: 13.');
 
         (new Column12())->parseValue(13);
     }
 
-    public function testParseValuePassesIfColumn12IsValid(): void
+    public function testParseValuePassesIfValid(): void
     {
         self::assertSame(
             12,
diff --git a/tests/Microplate/Scalars/Column2Test.php b/tests/Microplate/Scalars/Column2Test.php
@@ -18,38 +18,38 @@ protected function setUp(): void
         }
     }
 
-    public function testSerializeThrowsIfColumn2WellIsNotAnInt(): void
+    public function testSerializeThrowsIfNotAnInt(): void
     {
         $this->expectException(\InvalidArgumentException::class);
         $this->expectExceptionMessage('Value not in range 1-2: "3".');
 
         (new Column2())->serialize('3');
     }
 
-    public function testSerializeThrowsIfColumn2WellIsInvalid(): void
+    public function testSerializeThrowsIfInvalid(): void
     {
         $this->expectException(\InvalidArgumentException::class);
         $this->expectExceptionMessage('Value not in range 1-2: 3.');
 
         (new Column2())->serialize(3);
     }
 
-    public function testSerializePassesWhenColumn2WellIsValid(): void
+    public function testSerializePassesWhenValid(): void
     {
         $serializedResult = (new Column2())->serialize(2);
 
         self::assertSame(2, $serializedResult);
     }
 
-    public function testParseValueThrowsIfColumn2WellIsInvalid(): void
+    public function testParseValueThrowsIfInvalid(): void
     {
         $this->expectException(Error::class);
         $this->expectExceptionMessage('Value not in range 1-2: 3.');
 
         (new Column2())->parseValue(3);
     }
 
-    public function testParseValuePassesIfColumn2WellIsValid(): void
+    public function testParseValuePassesIfValid(): void
     {
         self::assertSame(
             2,
diff --git a/tests/Microplate/Scalars/Row16Test.php b/tests/Microplate/Scalars/Row16Test.php
@@ -19,46 +19,46 @@ protected function setUp(): void
         }
     }
 
-    public function testSerializeThrowsIfRow16IsInvalid(): void
+    public function testSerializeThrowsIfInvalid(): void
     {
         $this->expectException(InvariantViolation::class);
         $this->expectExceptionMessage('The given value "W" did not match the regex /^[A-P]$/.');
 
         (new Row16())->serialize('W');
     }
 
-    public function testSerializeThrowsIfRow16IsNonCapital(): void
+    public function testSerializeThrowsIfNonCapital(): void
     {
         $this->expectException(InvariantViolation::class);
         $this->expectExceptionMessage('The given value "b" did not match the regex /^[A-P]$/.');
 
         (new Row16())->serialize('b');
     }
 
-    public function testSerializePassesWhenRow16IsValid(): void
+    public function testSerializePassesWhenValid(): void
     {
         $serializedResult = (new Row16())->serialize('H');
 
         self::assertSame('H', $serializedResult);
     }
 
-    public function testParseValueThrowsIfRow16IsInvalid(): void
+    public function testParseValueThrowsIfInvalid(): void
     {
         $this->expectException(Error::class);
         $this->expectExceptionMessage('The given value "W" did not match the regex /^[A-P]$/.');
 
         (new Row16())->parseValue('W');
     }
 
-    public function testParseValueThrowsIfRow16IsNonCapital(): void
+    public function testParseValueThrowsIfNonCapital(): void
     {
         $this->expectException(Error::class);
         $this->expectExceptionMessage('The given value "h" did not match the regex /^[A-P]$/.');
 
         (new Row16())->parseValue('h');
     }
 
-    public function testParseValuePassesIfRow16IsValid(): void
+    public function testParseValuePassesIfValid(): void
     {
         self::assertSame(
             'P',
diff --git a/tests/Microplate/Scalars/Row8Test.php b/tests/Microplate/Scalars/Row8Test.php
@@ -19,46 +19,46 @@ protected function setUp(): void
         }
     }
 
-    public function testSerializeThrowsIfRow8IsInvalid(): void
+    public function testSerializeThrowsIfInvalid(): void
     {
         $this->expectException(InvariantViolation::class);
         $this->expectExceptionMessage('The given value "I" did not match the regex /^[A-H]$/.');
 
         (new Row8())->serialize('I');
     }
 
-    public function testSerializeThrowsIfRow8IsNonCapital(): void
+    public function testSerializeThrowsIfNonCapital(): void
     {
         $this->expectException(InvariantViolation::class);
         $this->expectExceptionMessage('The given value "h" did not match the regex /^[A-H]$/.');
 
         (new Row8())->serialize('h');
     }
 
-    public function testSerializePassesWhenRow8IsValid(): void
+    public function testSerializePassesWhenValid(): void
     {
         $serializedResult = (new Row8())->serialize('H');
 
         self::assertSame('H', $serializedResult);
     }
 
-    public function testParseValueThrowsIfRow8IsInvalid(): void
+    public function testParseValueThrowsIfInvalid(): void
     {
         $this->expectException(Error::class);
         $this->expectExceptionMessage('The given value "I" did not match the regex /^[A-H]$/.');
 
         (new Row8())->parseValue('I');
     }
 
-    public function testParseValueThrowsIfRow8IsNonCapital(): void
+    public function testParseValueThrowsIfNonCapital(): void
     {
         $this->expectException(Error::class);
         $this->expectExceptionMessage('The given value "h" did not match the regex /^[A-H]$/.');
 
         (new Row8())->parseValue('h');
     }
 
-    public function testParseValuePassesIfRow8IsValid(): void
+    public function testParseValuePassesIfValid(): void
     {
         self::assertSame(
             'H',

Original file line number	Diff line number	Diff line change
`@@ -8,13 +8,13 @@ class Column12 extends IntRange`
`8`	`8`	`{`
`9`	`9`	`public ?string $description = 'Represents a column in a coordinate system with 12 columns. Allowed values range from 1-12.';`
`10`	`10`
`11`		`- protected static function max(): int`
	`11`	`+ protected static function min(): int`
`12`	`12`	`{`
`13`		`- return 12;`
	`13`	`+ return 1;`
`14`	`14`	`}`
`15`	`15`
`16`		`- protected static function min(): int`
	`16`	`+ protected static function max(): int`
`17`	`17`	`{`
`18`		`- return 1;`
	`18`	`+ return 12;`
`19`	`19`	`}`
`20`	`20`	`}`
Original file line number	Diff line number	Diff line change
`@@ -18,38 +18,38 @@ protected function setUp(): void`
`18`	`18`	`}`
`19`	`19`	`}`
`20`	`20`
`21`		`- public function testSerializeThrowsIfColumn12IsNotAnInt(): void`
	`21`	`+ public function testSerializeThrowsIfNotAnInt(): void`
`22`	`22`	`{`
`23`	`23`	`$this->expectException(\InvalidArgumentException::class);`
`24`	`24`	`$this->expectExceptionMessage('Value not in range 1-12: "12".');`
`25`	`25`
`26`	`26`	`(new Column12())->serialize('12');`
`27`	`27`	`}`
`28`	`28`
`29`		`- public function testSerializeThrowsIfColumn12IsInvalid(): void`
	`29`	`+ public function testSerializeThrowsIfInvalid(): void`
`30`	`30`	`{`
`31`	`31`	`$this->expectException(\InvalidArgumentException::class);`
`32`	`32`	`$this->expectExceptionMessage('Value not in range 1-12: 13.');`
`33`	`33`
`34`	`34`	`(new Column12())->serialize(13);`
`35`	`35`	`}`
`36`	`36`
`37`		`- public function testSerializePassesWhenColumn12IsValid(): void`
	`37`	`+ public function testSerializePassesValid(): void`
`38`	`38`	`{`
`39`	`39`	`$serializedResult = (new Column12())->serialize(12);`
`40`	`40`
`41`	`41`	`self::assertSame(12, $serializedResult);`
`42`	`42`	`}`
`43`	`43`
`44`		`- public function testParseValueThrowsIfColumn12IsInvalid(): void`
	`44`	`+ public function testParseValueThrowsIfInvalid(): void`
`45`	`45`	`{`
`46`	`46`	`$this->expectException(Error::class);`
`47`	`47`	`$this->expectExceptionMessage('Value not in range 1-12: 13.');`
`48`	`48`
`49`	`49`	`(new Column12())->parseValue(13);`
`50`	`50`	`}`
`51`	`51`
`52`		`- public function testParseValuePassesIfColumn12IsValid(): void`
	`52`	`+ public function testParseValuePassesIfValid(): void`
`53`	`53`	`{`
`54`	`54`	`self::assertSame(`
`55`	`55`	`12,`
Original file line number	Diff line number	Diff line change
`@@ -19,46 +19,46 @@ protected function setUp(): void`
`19`	`19`	`}`
`20`	`20`	`}`
`21`	`21`
`22`		`- public function testSerializeThrowsIfRow16IsInvalid(): void`
	`22`	`+ public function testSerializeThrowsIfInvalid(): void`
`23`	`23`	`{`
`24`	`24`	`$this->expectException(InvariantViolation::class);`
`25`	`25`	`$this->expectExceptionMessage('The given value "W" did not match the regex /^[A-P]$/.');`
`26`	`26`
`27`	`27`	`(new Row16())->serialize('W');`
`28`	`28`	`}`
`29`	`29`
`30`		`- public function testSerializeThrowsIfRow16IsNonCapital(): void`
	`30`	`+ public function testSerializeThrowsIfNonCapital(): void`
`31`	`31`	`{`
`32`	`32`	`$this->expectException(InvariantViolation::class);`
`33`	`33`	`$this->expectExceptionMessage('The given value "b" did not match the regex /^[A-P]$/.');`
`34`	`34`
`35`	`35`	`(new Row16())->serialize('b');`
`36`	`36`	`}`
`37`	`37`
`38`		`- public function testSerializePassesWhenRow16IsValid(): void`
	`38`	`+ public function testSerializePassesWhenValid(): void`
`39`	`39`	`{`
`40`	`40`	`$serializedResult = (new Row16())->serialize('H');`
`41`	`41`
`42`	`42`	`self::assertSame('H', $serializedResult);`
`43`	`43`	`}`
`44`	`44`
`45`		`- public function testParseValueThrowsIfRow16IsInvalid(): void`
	`45`	`+ public function testParseValueThrowsIfInvalid(): void`
`46`	`46`	`{`
`47`	`47`	`$this->expectException(Error::class);`
`48`	`48`	`$this->expectExceptionMessage('The given value "W" did not match the regex /^[A-P]$/.');`
`49`	`49`
`50`	`50`	`(new Row16())->parseValue('W');`
`51`	`51`	`}`
`52`	`52`
`53`		`- public function testParseValueThrowsIfRow16IsNonCapital(): void`
	`53`	`+ public function testParseValueThrowsIfNonCapital(): void`
`54`	`54`	`{`
`55`	`55`	`$this->expectException(Error::class);`
`56`	`56`	`$this->expectExceptionMessage('The given value "h" did not match the regex /^[A-P]$/.');`
`57`	`57`
`58`	`58`	`(new Row16())->parseValue('h');`
`59`	`59`	`}`
`60`	`60`
`61`		`- public function testParseValuePassesIfRow16IsValid(): void`
	`61`	`+ public function testParseValuePassesIfValid(): void`
`62`	`62`	`{`
`63`	`63`	`self::assertSame(`
`64`	`64`	`'P',`