Merge pull request #1303 from hydephp/update-unit-tests

emmadesilva · web-flow · commit c4006ef23019 · 2023-03-15T19:47:16.000+01:00
Update unit tests
diff --git a/packages/framework/tests/Feature/ConsoleKernelTest.php b/packages/framework/tests/Feature/ConsoleKernelTest.php
@@ -2,7 +2,7 @@
 
 declare(strict_types=1);
 
-namespace Hyde\Framework\Testing\Unit;
+namespace Hyde\Framework\Testing\Feature;
 
 use Hyde\Foundation\Internal\LoadYamlConfiguration;
 use Illuminate\Contracts\Console\Kernel;
diff --git a/packages/framework/tests/Unit/ConfigFileTest.php b/packages/framework/tests/Unit/ConfigFileTest.php
@@ -12,14 +12,17 @@
 use Hyde\Pages\HtmlPage;
 use Hyde\Pages\MarkdownPage;
 use Hyde\Pages\MarkdownPost;
-use Hyde\Testing\TestCase;
+use Hyde\Testing\UnitTestCase;
 use ReflectionClass;
 
 /**
  * @see \Hyde\Framework\Testing\Unit\HydeConfigFilesAreMatchingTest
  */
-class ConfigFileTest extends TestCase
+class ConfigFileTest extends UnitTestCase
 {
+    protected static bool $needsKernel = true;
+    protected static bool $needsConfig = true;
+
     public function test_default_output_directory_value_matches_declared_value()
     {
         expect($this->getConfig('output_directory'))->toBe(Hyde::getOutputDirectory());
diff --git a/packages/framework/tests/Unit/DateStringTest.php b/packages/framework/tests/Unit/DateStringTest.php
@@ -13,37 +13,37 @@
  */
 class DateStringTest extends UnitTestCase
 {
-    public function test_it_can_parse_date_string()
+    public function testItCanParseDateString()
     {
         $dateString = new DateString('2020-01-01');
         $this->assertEquals('2020-01-01', $dateString->string);
     }
 
-    public function test_it_can_parse_date_string_into_datetime_object()
+    public function testItCanParseDateStringIntoDatetimeObject()
     {
         $dateString = new DateString('2020-01-01 UTC');
         $this->assertInstanceOf(DateTime::class, $dateString->dateTimeObject);
     }
 
-    public function test_it_can_format_date_string_into_machine_readable_string()
+    public function testItCanFormatDateStringIntoMachineReadableString()
     {
         $dateString = new DateString('2020-01-01 UTC');
         $this->assertEquals('2020-01-01T00:00:00+00:00', $dateString->datetime);
     }
 
-    public function test_it_can_format_date_string_into_human_readable_string()
+    public function testItCanFormatDateStringIntoHumanReadableString()
     {
         $dateString = new DateString('2020-01-01 UTC');
         $this->assertEquals('Wednesday Jan 1st, 2020, at 12:00am', $dateString->sentence);
     }
 
-    public function test_it_can_format_date_string_into_short_human_readable_string()
+    public function testItCanFormatDateStringIntoShortHumanReadableString()
     {
         $dateString = new DateString('2020-01-01 UTC');
         $this->assertEquals('Jan 1st, 2020', $dateString->short);
     }
 
-    public function test_it_can_format_date_string_into_short_human_readable_string_using_magic_method()
+    public function testItCanFormatDateStringIntoShortHumanReadableStringUsingMagicMethod()
     {
         $dateString = new DateString('2022-01-01 UTC');
         $this->assertEquals('Jan 1st, 2022', (string) $dateString);
diff --git a/packages/framework/tests/Unit/FrontMatterModelTest.php b/packages/framework/tests/Unit/FrontMatterModelTest.php
@@ -5,114 +5,100 @@
 namespace Hyde\Framework\Testing\Unit;
 
 use Hyde\Markdown\Models\FrontMatter;
-use PHPUnit\Framework\TestCase;
+use Hyde\Testing\UnitTestCase;
 
 /**
  * @covers \Hyde\Markdown\Models\FrontMatter
  */
-class FrontMatterModelTest extends TestCase
+class FrontMatterModelTest extends UnitTestCase
 {
-    public function test_constructor_creates_new_front_matter_model()
+    public function testConstructorCreatesNewFrontMatterModel()
     {
-        $matter = new FrontMatter([]);
-        $this->assertInstanceOf(FrontMatter::class, $matter);
+        $this->assertInstanceOf(FrontMatter::class, new FrontMatter([]));
     }
 
-    public function test_constructor_arguments_are_optional()
+    public function testConstructorArgumentsAreOptional()
     {
-        $matter = new FrontMatter();
-        $this->assertInstanceOf(FrontMatter::class, $matter);
+        $this->assertInstanceOf(FrontMatter::class, new FrontMatter());
     }
 
-    public function test_constructor_arguments_are_assigned()
+    public function testConstructorArgumentsAreAssigned()
     {
-        $matter = new FrontMatter(['foo' => 'bar']);
-        $this->assertEquals(['foo' => 'bar'], $matter->toArray());
+        $this->assertEquals(['foo' => 'bar'], (new FrontMatter(['foo' => 'bar']))->toArray());
     }
 
-    public function test_static_from_array_method_creates_new_front_matter_model()
+    public function testStaticFromArrayMethodCreatesNewFrontMatterModel()
     {
         $matter = FrontMatter::fromArray(['foo' => 'bar']);
         $this->assertInstanceOf(FrontMatter::class, $matter);
         $this->assertEquals(['foo' => 'bar'], $matter->toArray());
     }
 
-    public function test_to_string_magic_method_converts_model_array_into_yaml_front_matter()
+    public function testToStringMagicMethodConvertsModelArrayIntoYamlFrontMatter()
     {
         $matter = new FrontMatter(['foo' => 'bar']);
-        $this->assertEquals("---\nfoo: bar\n---\n", (string) $matter);
+        $this->assertEquals("---\nfoo: bar\n---\n", (string) (new FrontMatter(['foo' => 'bar'])));
     }
 
-    public function test_magic_get_method_returns_front_matter_property()
+    public function testMagicGetMethodReturnsFrontMatterProperty()
     {
-        $matter = new FrontMatter(['foo' => 'bar']);
-        $this->assertEquals('bar', $matter->foo);
+        $this->assertEquals('bar', (new FrontMatter(['foo' => 'bar']))->foo);
     }
 
-    public function test_magic_get_method_returns_null_if_property_does_not_exist()
+    public function testMagicGetMethodReturnsNullIfPropertyDoesNotExist()
     {
-        $matter = new FrontMatter();
-        $this->assertNull($matter->foo);
+        $this->assertNull((new FrontMatter())->foo);
     }
 
-    public function test_get_method_returns_data_when_no_argument_is_specified()
+    public function testGetMethodReturnsDataWhenNoArgumentIsSpecified()
     {
-        $matter = new FrontMatter();
-        $this->assertSame([], $matter->get());
+        $this->assertSame([], (new FrontMatter())->get());
     }
 
-    public function test_get_method_returns_data_when_no_argument_is_specified_with_data()
+    public function testGetMethodReturnsDataWhenNoArgumentIsSpecifiedWithData()
     {
-        $matter = new FrontMatter(['foo' => 'bar']);
-        $this->assertSame(['foo' => 'bar'], $matter->get());
+        $this->assertSame(['foo' => 'bar'], (new FrontMatter(['foo' => 'bar']))->get());
     }
 
-    public function test_get_method_returns_null_if_specified_front_matter_key_does_not_exist()
+    public function testGetMethodReturnsNullIfSpecifiedFrontMatterKeyDoesNotExist()
     {
-        $matter = new FrontMatter();
-        $this->assertNull($matter->get('bar'));
+        $this->assertNull((new FrontMatter())->get('bar'));
     }
 
-    public function test_get_method_returns_specified_default_value_if_property_does_not_exist()
+    public function testGetMethodReturnsSpecifiedDefaultValueIfPropertyDoesNotExist()
     {
         $matter = new FrontMatter();
         $this->assertEquals('default', $matter->get('bar', 'default'));
     }
 
-    public function test_get_method_returns_specified_front_matter_value_if_key_is_specified()
+    public function testGetMethodReturnsSpecifiedFrontMatterValueIfKeyIsSpecified()
     {
-        $matter = new FrontMatter(['foo' => 'bar']);
-        $this->assertEquals('bar', $matter->get('foo'));
+        $this->assertEquals('bar', (new FrontMatter(['foo' => 'bar']))->get('foo'));
     }
 
-    public function test_set_method_sets_front_matter_property()
+    public function testSetMethodSetsFrontMatterProperty()
     {
-        $matter = new FrontMatter();
-        $matter->set('foo', 'bar');
-        $this->assertEquals('bar', $matter->get('foo'));
+        $this->assertEquals('bar', (new FrontMatter())->set('foo', 'bar')->get('foo'));
     }
 
-    public function test_set_method_returns_self()
+    public function testSetMethodReturnsSelf()
     {
         $matter = new FrontMatter();
         $this->assertSame($matter, $matter->set('foo', 'bar'));
     }
 
-    public function test_has_method_returns_true_if_property_exists()
+    public function testHasMethodReturnsTrueIfPropertyExists()
     {
-        $matter = new FrontMatter(['foo' => 'bar']);
-        $this->assertTrue($matter->has('foo'));
+        $this->assertTrue((new FrontMatter(['foo' => 'bar']))->has('foo'));
     }
 
-    public function test_has_method_returns_false_if_property_does_not_exist()
+    public function testHasMethodReturnsFalseIfPropertyDoesNotExist()
     {
-        $matter = new FrontMatter();
-        $this->assertFalse($matter->has('foo'));
+        $this->assertFalse((new FrontMatter())->has('foo'));
     }
 
-    public function test_to_array_returns_front_matter_array()
+    public function testToArrayReturnsFrontMatterArray()
     {
-        $matter = new FrontMatter(['foo' => 'bar']);
-        $this->assertEquals(['foo' => 'bar'], $matter->toArray());
+        $this->assertEquals(['foo' => 'bar'], (new FrontMatter(['foo' => 'bar']))->toArray());
     }
 }
diff --git a/packages/framework/tests/Unit/HydeHelperFacadeMakeTitleTest.php b/packages/framework/tests/Unit/HydeHelperFacadeMakeTitleTest.php
@@ -5,43 +5,45 @@
 namespace Hyde\Framework\Testing\Unit;
 
 use Hyde\Hyde;
-use Hyde\Testing\TestCase;
+use Hyde\Testing\UnitTestCase;
 
-class HydeHelperFacadeMakeTitleTest extends TestCase
+class HydeHelperFacadeMakeTitleTest extends UnitTestCase
 {
-    public function test_make_title_helper_parses_kebab_case_into_title()
+    protected static bool $needsKernel = true;
+
+    public function testMakeTitleHelperParsesKebabCaseIntoTitle()
     {
-        $this->assertEquals('Hello World', Hyde::makeTitle('hello-world'));
+        $this->assertSame('Hello World', Hyde::makeTitle('hello-world'));
     }
 
-    public function test_make_title_helper_parses_snake_case_into_title()
+    public function testMakeTitleHelperParsesSnakeCaseIntoTitle()
     {
-        $this->assertEquals('Hello World', Hyde::makeTitle('hello_world'));
+        $this->assertSame('Hello World', Hyde::makeTitle('hello_world'));
     }
 
-    public function test_make_title_helper_parses_camel_case_into_title()
+    public function testMakeTitleHelperParsesCamelCaseIntoTitle()
     {
-        $this->assertEquals('Hello World', Hyde::makeTitle('helloWorld'));
+        $this->assertSame('Hello World', Hyde::makeTitle('helloWorld'));
     }
 
-    public function test_make_title_helper_parses_pascal_case_into_title()
+    public function testMakeTitleHelperParsesPascalCaseIntoTitle()
     {
-        $this->assertEquals('Hello World', Hyde::makeTitle('HelloWorld'));
+        $this->assertSame('Hello World', Hyde::makeTitle('HelloWorld'));
     }
 
-    public function test_make_title_helper_parses_title_case_into_title()
+    public function testMakeTitleHelperParsesTitleCaseIntoTitle()
     {
-        $this->assertEquals('Hello World', Hyde::makeTitle('Hello World'));
+        $this->assertSame('Hello World', Hyde::makeTitle('Hello World'));
     }
 
-    public function test_make_title_helper_parses_title_case_with_spaces_into_title()
+    public function testMakeTitleHelperParsesTitleCaseWithSpacesIntoTitle()
     {
-        $this->assertEquals('Hello World', Hyde::makeTitle('Hello World'));
+        $this->assertSame('Hello World', Hyde::makeTitle('Hello World'));
     }
 
-    public function test_make_title_helper_does_not_capitalize_auxiliary_words()
+    public function testMakeTitleHelperDoesNotCapitalizeAuxiliaryWords()
     {
-        $this->assertEquals('The a an the in on by with of and or but',
+        $this->assertSame('The a an the in on by with of and or but',
             Hyde::makeTitle('the_a_an_the_in_on_by_with_of_and_or_but'));
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -13,37 +13,37 @@`
`13`	`13`	`*/`
`14`	`14`	`class DateStringTest extends UnitTestCase`
`15`	`15`	`{`
`16`		`- public function test_it_can_parse_date_string()`
	`16`	`+ public function testItCanParseDateString()`
`17`	`17`	`{`
`18`	`18`	`$dateString = new DateString('2020-01-01');`
`19`	`19`	`$this->assertEquals('2020-01-01', $dateString->string);`
`20`	`20`	`}`
`21`	`21`
`22`		`- public function test_it_can_parse_date_string_into_datetime_object()`
	`22`	`+ public function testItCanParseDateStringIntoDatetimeObject()`
`23`	`23`	`{`
`24`	`24`	`$dateString = new DateString('2020-01-01 UTC');`
`25`	`25`	`$this->assertInstanceOf(DateTime::class, $dateString->dateTimeObject);`
`26`	`26`	`}`
`27`	`27`
`28`		`- public function test_it_can_format_date_string_into_machine_readable_string()`
	`28`	`+ public function testItCanFormatDateStringIntoMachineReadableString()`
`29`	`29`	`{`
`30`	`30`	`$dateString = new DateString('2020-01-01 UTC');`
`31`	`31`	`$this->assertEquals('2020-01-01T00:00:00+00:00', $dateString->datetime);`
`32`	`32`	`}`
`33`	`33`
`34`		`- public function test_it_can_format_date_string_into_human_readable_string()`
	`34`	`+ public function testItCanFormatDateStringIntoHumanReadableString()`
`35`	`35`	`{`
`36`	`36`	`$dateString = new DateString('2020-01-01 UTC');`
`37`	`37`	`$this->assertEquals('Wednesday Jan 1st, 2020, at 12:00am', $dateString->sentence);`
`38`	`38`	`}`
`39`	`39`
`40`		`- public function test_it_can_format_date_string_into_short_human_readable_string()`
	`40`	`+ public function testItCanFormatDateStringIntoShortHumanReadableString()`
`41`	`41`	`{`
`42`	`42`	`$dateString = new DateString('2020-01-01 UTC');`
`43`	`43`	`$this->assertEquals('Jan 1st, 2020', $dateString->short);`
`44`	`44`	`}`
`45`	`45`
`46`		`- public function test_it_can_format_date_string_into_short_human_readable_string_using_magic_method()`
	`46`	`+ public function testItCanFormatDateStringIntoShortHumanReadableStringUsingMagicMethod()`
`47`	`47`	`{`
`48`	`48`	`$dateString = new DateString('2022-01-01 UTC');`
`49`	`49`	`$this->assertEquals('Jan 1st, 2022', (string) $dateString);`
Original file line number	Diff line number	Diff line change
`@@ -5,114 +5,100 @@`
`5`	`5`	`namespace Hyde\Framework\Testing\Unit;`
`6`	`6`
`7`	`7`	`use Hyde\Markdown\Models\FrontMatter;`
`8`		`-use PHPUnit\Framework\TestCase;`
	`8`	`+use Hyde\Testing\UnitTestCase;`
`9`	`9`
`10`	`10`	`/**`
`11`	`11`	`* @covers \Hyde\Markdown\Models\FrontMatter`
`12`	`12`	`*/`
`13`		`-class FrontMatterModelTest extends TestCase`
	`13`	`+class FrontMatterModelTest extends UnitTestCase`
`14`	`14`	`{`
`15`		`- public function test_constructor_creates_new_front_matter_model()`
	`15`	`+ public function testConstructorCreatesNewFrontMatterModel()`
`16`	`16`	`{`
`17`		`- $matter = new FrontMatter([]);`
`18`		`- $this->assertInstanceOf(FrontMatter::class, $matter);`
	`17`	`+ $this->assertInstanceOf(FrontMatter::class, new FrontMatter([]));`
`19`	`18`	`}`
`20`	`19`
`21`		`- public function test_constructor_arguments_are_optional()`
	`20`	`+ public function testConstructorArgumentsAreOptional()`
`22`	`21`	`{`
`23`		`- $matter = new FrontMatter();`
`24`		`- $this->assertInstanceOf(FrontMatter::class, $matter);`
	`22`	`+ $this->assertInstanceOf(FrontMatter::class, new FrontMatter());`
`25`	`23`	`}`
`26`	`24`
`27`		`- public function test_constructor_arguments_are_assigned()`
	`25`	`+ public function testConstructorArgumentsAreAssigned()`
`28`	`26`	`{`
`29`		`- $matter = new FrontMatter(['foo' => 'bar']);`
`30`		`- $this->assertEquals(['foo' => 'bar'], $matter->toArray());`
	`27`	`+ $this->assertEquals(['foo' => 'bar'], (new FrontMatter(['foo' => 'bar']))->toArray());`
`31`	`28`	`}`
`32`	`29`
`33`		`- public function test_static_from_array_method_creates_new_front_matter_model()`
	`30`	`+ public function testStaticFromArrayMethodCreatesNewFrontMatterModel()`
`34`	`31`	`{`
`35`	`32`	`$matter = FrontMatter::fromArray(['foo' => 'bar']);`
`36`	`33`	`$this->assertInstanceOf(FrontMatter::class, $matter);`
`37`	`34`	`$this->assertEquals(['foo' => 'bar'], $matter->toArray());`
`38`	`35`	`}`
`39`	`36`
`40`		`- public function test_to_string_magic_method_converts_model_array_into_yaml_front_matter()`
	`37`	`+ public function testToStringMagicMethodConvertsModelArrayIntoYamlFrontMatter()`
`41`	`38`	`{`
`42`	`39`	`$matter = new FrontMatter(['foo' => 'bar']);`
`43`		`- $this->assertEquals("---\nfoo: bar\n---\n", (string) $matter);`
	`40`	`+ $this->assertEquals("---\nfoo: bar\n---\n", (string) (new FrontMatter(['foo' => 'bar'])));`
`44`	`41`	`}`
`45`	`42`
`46`		`- public function test_magic_get_method_returns_front_matter_property()`
	`43`	`+ public function testMagicGetMethodReturnsFrontMatterProperty()`
`47`	`44`	`{`
`48`		`- $matter = new FrontMatter(['foo' => 'bar']);`
`49`		`- $this->assertEquals('bar', $matter->foo);`
	`45`	`+ $this->assertEquals('bar', (new FrontMatter(['foo' => 'bar']))->foo);`
`50`	`46`	`}`
`51`	`47`
`52`		`- public function test_magic_get_method_returns_null_if_property_does_not_exist()`
	`48`	`+ public function testMagicGetMethodReturnsNullIfPropertyDoesNotExist()`
`53`	`49`	`{`
`54`		`- $matter = new FrontMatter();`
`55`		`- $this->assertNull($matter->foo);`
	`50`	`+ $this->assertNull((new FrontMatter())->foo);`
`56`	`51`	`}`
`57`	`52`
`58`		`- public function test_get_method_returns_data_when_no_argument_is_specified()`
	`53`	`+ public function testGetMethodReturnsDataWhenNoArgumentIsSpecified()`
`59`	`54`	`{`
`60`		`- $matter = new FrontMatter();`
`61`		`- $this->assertSame([], $matter->get());`
	`55`	`+ $this->assertSame([], (new FrontMatter())->get());`
`62`	`56`	`}`
`63`	`57`
`64`		`- public function test_get_method_returns_data_when_no_argument_is_specified_with_data()`
	`58`	`+ public function testGetMethodReturnsDataWhenNoArgumentIsSpecifiedWithData()`
`65`	`59`	`{`
`66`		`- $matter = new FrontMatter(['foo' => 'bar']);`
`67`		`- $this->assertSame(['foo' => 'bar'], $matter->get());`
	`60`	`+ $this->assertSame(['foo' => 'bar'], (new FrontMatter(['foo' => 'bar']))->get());`
`68`	`61`	`}`
`69`	`62`
`70`		`- public function test_get_method_returns_null_if_specified_front_matter_key_does_not_exist()`
	`63`	`+ public function testGetMethodReturnsNullIfSpecifiedFrontMatterKeyDoesNotExist()`
`71`	`64`	`{`
`72`		`- $matter = new FrontMatter();`
`73`		`- $this->assertNull($matter->get('bar'));`
	`65`	`+ $this->assertNull((new FrontMatter())->get('bar'));`
`74`	`66`	`}`
`75`	`67`
`76`		`- public function test_get_method_returns_specified_default_value_if_property_does_not_exist()`
	`68`	`+ public function testGetMethodReturnsSpecifiedDefaultValueIfPropertyDoesNotExist()`
`77`	`69`	`{`
`78`	`70`	`$matter = new FrontMatter();`
`79`	`71`	`$this->assertEquals('default', $matter->get('bar', 'default'));`
`80`	`72`	`}`
`81`	`73`
`82`		`- public function test_get_method_returns_specified_front_matter_value_if_key_is_specified()`
	`74`	`+ public function testGetMethodReturnsSpecifiedFrontMatterValueIfKeyIsSpecified()`
`83`	`75`	`{`
`84`		`- $matter = new FrontMatter(['foo' => 'bar']);`
`85`		`- $this->assertEquals('bar', $matter->get('foo'));`
	`76`	`+ $this->assertEquals('bar', (new FrontMatter(['foo' => 'bar']))->get('foo'));`
`86`	`77`	`}`
`87`	`78`
`88`		`- public function test_set_method_sets_front_matter_property()`
	`79`	`+ public function testSetMethodSetsFrontMatterProperty()`
`89`	`80`	`{`
`90`		`- $matter = new FrontMatter();`
`91`		`- $matter->set('foo', 'bar');`
`92`		`- $this->assertEquals('bar', $matter->get('foo'));`
	`81`	`+ $this->assertEquals('bar', (new FrontMatter())->set('foo', 'bar')->get('foo'));`
`93`	`82`	`}`
`94`	`83`
`95`		`- public function test_set_method_returns_self()`
	`84`	`+ public function testSetMethodReturnsSelf()`
`96`	`85`	`{`
`97`	`86`	`$matter = new FrontMatter();`
`98`	`87`	`$this->assertSame($matter, $matter->set('foo', 'bar'));`
`99`	`88`	`}`
`100`	`89`
`101`		`- public function test_has_method_returns_true_if_property_exists()`
	`90`	`+ public function testHasMethodReturnsTrueIfPropertyExists()`
`102`	`91`	`{`
`103`		`- $matter = new FrontMatter(['foo' => 'bar']);`
`104`		`- $this->assertTrue($matter->has('foo'));`
	`92`	`+ $this->assertTrue((new FrontMatter(['foo' => 'bar']))->has('foo'));`
`105`	`93`	`}`
`106`	`94`
`107`		`- public function test_has_method_returns_false_if_property_does_not_exist()`
	`95`	`+ public function testHasMethodReturnsFalseIfPropertyDoesNotExist()`
`108`	`96`	`{`
`109`		`- $matter = new FrontMatter();`
`110`		`- $this->assertFalse($matter->has('foo'));`
	`97`	`+ $this->assertFalse((new FrontMatter())->has('foo'));`
`111`	`98`	`}`
`112`	`99`
`113`		`- public function test_to_array_returns_front_matter_array()`
	`100`	`+ public function testToArrayReturnsFrontMatterArray()`
`114`	`101`	`{`
`115`		`- $matter = new FrontMatter(['foo' => 'bar']);`
`116`		`- $this->assertEquals(['foo' => 'bar'], $matter->toArray());`
	`102`	`+ $this->assertEquals(['foo' => 'bar'], (new FrontMatter(['foo' => 'bar']))->toArray());`
`117`	`103`	`}`
`118`	`104`	`}`
Original file line number	Diff line number	Diff line change
`@@ -5,43 +5,45 @@`
`5`	`5`	`namespace Hyde\Framework\Testing\Unit;`
`6`	`6`
`7`	`7`	`use Hyde\Hyde;`
`8`		`-use Hyde\Testing\TestCase;`
	`8`	`+use Hyde\Testing\UnitTestCase;`
`9`	`9`
`10`		`-class HydeHelperFacadeMakeTitleTest extends TestCase`
	`10`	`+class HydeHelperFacadeMakeTitleTest extends UnitTestCase`
`11`	`11`	`{`
`12`		`- public function test_make_title_helper_parses_kebab_case_into_title()`
	`12`	`+ protected static bool $needsKernel = true;`
	`13`	`+`
	`14`	`+ public function testMakeTitleHelperParsesKebabCaseIntoTitle()`
`13`	`15`	`{`
`14`		`- $this->assertEquals('Hello World', Hyde::makeTitle('hello-world'));`
	`16`	`+ $this->assertSame('Hello World', Hyde::makeTitle('hello-world'));`
`15`	`17`	`}`
`16`	`18`
`17`		`- public function test_make_title_helper_parses_snake_case_into_title()`
	`19`	`+ public function testMakeTitleHelperParsesSnakeCaseIntoTitle()`
`18`	`20`	`{`
`19`		`- $this->assertEquals('Hello World', Hyde::makeTitle('hello_world'));`
	`21`	`+ $this->assertSame('Hello World', Hyde::makeTitle('hello_world'));`
`20`	`22`	`}`
`21`	`23`
`22`		`- public function test_make_title_helper_parses_camel_case_into_title()`
	`24`	`+ public function testMakeTitleHelperParsesCamelCaseIntoTitle()`
`23`	`25`	`{`
`24`		`- $this->assertEquals('Hello World', Hyde::makeTitle('helloWorld'));`
	`26`	`+ $this->assertSame('Hello World', Hyde::makeTitle('helloWorld'));`
`25`	`27`	`}`
`26`	`28`
`27`		`- public function test_make_title_helper_parses_pascal_case_into_title()`
	`29`	`+ public function testMakeTitleHelperParsesPascalCaseIntoTitle()`
`28`	`30`	`{`
`29`		`- $this->assertEquals('Hello World', Hyde::makeTitle('HelloWorld'));`
	`31`	`+ $this->assertSame('Hello World', Hyde::makeTitle('HelloWorld'));`
`30`	`32`	`}`
`31`	`33`
`32`		`- public function test_make_title_helper_parses_title_case_into_title()`
	`34`	`+ public function testMakeTitleHelperParsesTitleCaseIntoTitle()`
`33`	`35`	`{`
`34`		`- $this->assertEquals('Hello World', Hyde::makeTitle('Hello World'));`
	`36`	`+ $this->assertSame('Hello World', Hyde::makeTitle('Hello World'));`
`35`	`37`	`}`
`36`	`38`
`37`		`- public function test_make_title_helper_parses_title_case_with_spaces_into_title()`
	`39`	`+ public function testMakeTitleHelperParsesTitleCaseWithSpacesIntoTitle()`
`38`	`40`	`{`
`39`		`- $this->assertEquals('Hello World', Hyde::makeTitle('Hello World'));`
	`41`	`+ $this->assertSame('Hello World', Hyde::makeTitle('Hello World'));`
`40`	`42`	`}`
`41`	`43`
`42`		`- public function test_make_title_helper_does_not_capitalize_auxiliary_words()`
	`44`	`+ public function testMakeTitleHelperDoesNotCapitalizeAuxiliaryWords()`
`43`	`45`	`{`
`44`		`- $this->assertEquals('The a an the in on by with of and or but',`
	`46`	`+ $this->assertSame('The a an the in on by with of and or but',`
`45`	`47`	`Hyde::makeTitle('the_a_an_the_in_on_by_with_of_and_or_but'));`
`46`	`48`	`}`
`47`	`49`	`}`