Update README with categorized examples for all new methods; remove named parameters in test assertions

Author: k2gl

README.md

@@ -18,77 +18,175 @@ Write tests as usual, just use fluent assertions short aliases ``` check($x)->..
 
 ```php
 // arrange
-$user = UserFactory::createOne([
-    'phone' => $phoneBefore = faker()->e164PhoneNumber;
-]);
+$user = UserFactory::createOne();
 
 // act
-$user->setPhone(
-    $phoneAfter = faker()->e164PhoneNumber
-);
-
-// assert
+$user->setPhone($e164PhoneNumber = faker()->e164PhoneNumber);
 
 // traditional PHPUnit assertions
-self::assertSame(expected: $phoneAfter, actual: $user->getPhone());
-self::assertNotSame(expected: $phoneBefore, actual: $user->getPhone());
+self::assertSame($e164PhoneNumber, $user->getPhone());
+
+// fluent assertions
+fact($user->getPhone())
+    ->is($e164PhoneNumber)
+    ->isString()
+    ->startsWith('+7')
+    // etc.
+    ;
+```
 
-### Comparison and Equality Methods
+### Array assertions
 ```php
-fact(42)->is(42)->equals(42)->not(43);
+fact([1, 2, 3])->count(3); // Passes
+fact([1, 2])->count(3); // Fails
+
+fact([1, 2])->notCount(3); // Passes
+fact([1, 2, 3])->notCount(3); // Fails
+     
+fact(['a' => ['b' => 'c']])->arrayContainsAssociativeArray(['a' => ['b' => 'c']]); // Passes
+fact(['a' => ['b' => 'd']])->arrayContainsAssociativeArray(['a' => ['b' => 'c']]); // Fails
+
+fact(['a' => 1])->arrayHasKey('a'); // Passes
+fact(['a' => 1])->arrayHasKey('b'); // Fails
+     
+fact(['a' => 1])->arrayNotHasKey('b'); // Passes
+fact(['a' => 1])->arrayNotHasKey('a'); // Fails
+
+fact([1, 2, 3])->contains(2); // Passes
+fact([1, 2])->contains(3); // Fails
+
+fact([1, 2])->doesNotContain(3); // Passes
+fact([1, 2, 3])->doesNotContain(3); // Fails     
+     
+fact([1, 2])->hasSize(2); // Passes
+fact([1, 2, 3])->hasSize(2); // Fails
+
+fact([])->isEmptyArray(); // Passes
+fact([1, 2])->isEmptyArray(); // Fails
+     
+fact([1, 2])->isNotEmptyArray(); // Passes
+fact([])->isNotEmptyArray(); // Fails     
+
 ```
 
-### Boolean Methods
+### Boolean assertions
 ```php
-fact(true)->true()->notFalse();
+fact(true)->true(); // Passes
+fact(1)->true(); // Fails due to strict comparison
+
+fact(false)->notTrue(); // Passes
+fact(true)->notTrue(); // Fails
+
+fact(false)->false(); // Passes
+fact(0)->false(); // Fails due to strict comparison
+
+fact(true)->notFalse(); // Passes
+fact(false)->notFalse(); // Fails
 ```
 
-### Null Methods
+
+### Comparison and Equality assertions
 ```php
-fact(null)->null()->notNull();
+fact(42)->is(42); // Passes
+fact(42)->is('42'); // Fails due to type difference
+
+fact(42)->equals(42); // Passes
+fact(42)->equals('42'); // Passes due to loose comparison
+
+fact(42)->not(43); // Passes
+fact(42)->not(42); // Fails
 ```
 
-### Numeric Methods
+
+### Null assertions
 ```php
-fact(5)->isLowerThan(10)->isGreaterThan(0)->isPositive()->isNegative()->isZero()->isBetween(1, 10);
+fact(null)->null(); // Passes
+fact('')->null(); // Fails
+
+fact(42)->notNull(); // Passes
+fact(null)->notNull(); // Fails
 ```
 
-### String Methods
+### Numeric assertions
 ```php
-fact('hello world')->matchesRegularExpression('/\w+/')->startsWith('hello')->endsWith('world')->hasLength(11)->isEmptyString();
+fact(5)->isLowerThan(10); // Passes
+fact(10)->isLowerThan(5); // Fails
+
+fact(10)->isGreaterThan(5); // Passes
+fact(5)->isGreaterThan(10); // Fails
+     
+fact(5)->isPositive(); // Passes
+fact(-3)->isPositive(); // Fails
+
+fact(-3)->isNegative(); // Passes
+fact(5)->isNegative(); // Fails
+
+fact(0)->isZero(); // Passes
+fact(0.0)->isZero(); // Passes
+fact(1)->isZero(); // Fails
+
+fact(5)->isBetween(1, 10); // Passes
+fact(15)->isBetween(1, 10); // Fails
 ```
 
-### Array Methods
+### Special assertions
 ```php
-fact([1, 2, 3])->count(3)->contains(2)->doesNotContain(4)->hasSize(3)->isEmptyArray()->isNotEmptyArray();
+fact('01ARZ3NDEKTSV4RRFFQ69G5FAV')->ulid(); // Passes (if valid ULID)
+fact('invalid-ulid')->ulid(); // Fails
 ```
 
-### Type Checking Methods
+### String assertions
 ```php
-fact(42)->isInt()->isString()->instanceOf(int::class)->hasProperty('name')->hasMethod('doSomething');
+fact('abc123')->matchesRegularExpression('/^[a-z]+\d+$/'); // Passes
+fact('123abc')->matchesRegularExpression('/^[a-z]+\d+$/'); // Fails
+
+fact('123abc')->notMatchesRegularExpression('/^[a-z]+\d+$/'); // Passes
+fact('abc123')->notMatchesRegularExpression('/^[a-z]+\d+$/'); // Fails
+
+fact('hello world')->containsString('world'); // Passes
+fact('hello world')->containsString('foo'); // Fails
+
+fact('hello world')->notContainsString('foo'); // Passes
+fact('hello world')->notContainsString('world'); // Fails
+
+fact('Hello World')->containsStringIgnoringCase('world'); // Passes
+fact('Hello World')->containsStringIgnoringCase('foo'); // Fails
+
+fact('Hello World')->notContainsStringIgnoringCase('foo'); // Passes
+fact('Hello World')->notContainsStringIgnoringCase('world'); // Fails
+
+fact('hello world')->startsWith('hello'); // Passes
+fact('world hello')->startsWith('hello'); // Fails
+
+fact('file.txt')->endsWith('.txt'); // Passes
+fact('txt.file')->endsWith('.txt'); // Fails
+
+fact('abc')->hasLength(3); // Passes
+fact('abcd')->hasLength(3); // Fails
+
+fact('')->isEmptyString(); // Passes
+fact('hello')->isEmptyString(); // Fails
 ```
 
-### Special Methods
+### Type Checking assertions
 ```php
-fact('01ARZ3NDEKTSV4RRFFQ69G5FAV')->ulid();
-```
-    ...
-    ;
+fact(new stdClass())->instanceOf(stdClass::class); // Passes
+fact(new stdClass())->instanceOf(Exception::class); // Fails
+
+fact(new stdClass())->notInstanceOf(Exception::class); // Passes
+fact(new stdClass())->notInstanceOf(stdClass::class); // Fails
+
+fact(42)->isInt(); // Passes
+fact('42')->isInt(); // Fails
+
+fact('text')->isString(); // Passes
+fact(42)->isString(); // Fails
 
-fact(
-    [
-        'a' => ['any' => 'thing'],
-        'b' => ['any' => 'thing', 'type' => 'candy', 'color' => 'green'],
-        'c' => ['miss' => 'kiss', 'foo' => 'bar', 'any' => 'thing'],
-        'd' => ['any' => 'thing'],
-    ]
-)->arrayContainsAssociativeArray(
-    [
-        'c' => ['foo' => 'bar', 'miss' => 'kiss'],
-        'b' => ['color' => 'green'],
-    ]
-); // true
+fact((object)['name' => 'John'])->hasProperty('name'); // Passes
+fact((object)['name' => 'John'])->hasProperty('age'); // Fails
 
+fact(new stdClass())->hasMethod('__construct'); // Passes
+fact(new stdClass())->hasMethod('nonExistentMethod'); // Fails
 ```
 
 ## Pull requests are always welcome

tests/FluentAssertions/FluentAssertionsTestCase.php

@@ -11,7 +11,7 @@ abstract class FluentAssertionsTestCase extends TestCase
 {
     protected function hasExpectedVariable(FluentAssertions $fluentAssertions, mixed $expected): void
     {
-        self::assertSame(expected: $expected, actual: $fluentAssertions->variable);
+        self::assertSame($expected, $fluentAssertions->variable);
     }
 
     protected function correctAssertionExecuted(): void
@@ -23,7 +23,7 @@ protected function correctAssertionsExecuted(int $expected = 1): void
     {
         $performedAssertionCounts = Assert::getCount();
 
-        self::assertSame(expected: $expected, actual: $performedAssertionCounts);
+        self::assertSame($expected, $performedAssertionCounts);
     }
 
     protected function incorrectAssertionExpected(): void