Implement specialized alternatives for the generic containsOnly() method

Author: sebastianbergmann

ChangeLog-11.5.md

@@ -11,6 +11,7 @@ All notable changes of the PHPUnit 11.5 release series are documented in this fi
 * Method `assertContainsNotOnlyInstancesOf()` in the `PHPUnit\Framework\Assert` class as the inverse of the `assertContainsOnlyInstancesOf()` method
 * Methods `assertContainsOnlyArray()`, `assertContainsOnlyBool()`, `assertContainsOnlyCallable()`, `assertContainsOnlyFloat()`, `assertContainsOnlyInt()`, `assertContainsOnlyIterable()`, `assertContainsOnlyNumeric()`, `assertContainsOnlyObject()`, `assertContainsOnlyResource()`, `assertContainsOnlyClosedResource()`, `assertContainsOnlyScalar()`, and `assertContainsOnlyString()` in the `PHPUnit\Framework\Assert` class as specialized alternatives for the generic `assertContainsOnly()` method
 * Methods `assertContainsNotOnlyArray()`, `assertContainsNotOnlyBool()`, `assertContainsNotOnlyCallable()`, `assertContainsNotOnlyFloat()`, `assertContainsNotOnlyInt()`, `assertContainsNotOnlyIterable()`, `assertContainsNotOnlyNumeric()`, `assertContainsNotOnlyObject()`, `assertContainsNotOnlyResource()`, `assertContainsNotOnlyClosedResource()`, `assertContainsNotOnlyScalar()`, and `assertContainsNotOnlyString()` in the `PHPUnit\Framework\Assert` class as specialized alternatives for the generic `assertNotContainsOnly()` method
+* Methods `containsOnlyArray()`, `containsOnlyBool()`, `containsOnlyCallable()`, `containsOnlyFloat()`, `containsOnlyInt()`, `containsOnlyIterable()`, `containsOnlyNumeric()`, `containsOnlyObject()`, `containsOnlyResource()`, `containsOnlyClosedResource()`, `containsOnlyScalar()`, and `containsOnlyString()` in the `PHPUnit\Framework\Assert` class as specialized alternatives for the generic `containsOnly()` method
 * Methods `isArray()`, `isBool()`, `isCallable()`, `isFloat()`, `isInt()`, `isIterable()`, `isNumeric()`, `isObject()`, `isResource()`, `isClosedResource()`, `isScalar()`, `isString()` in the `PHPUnit\Framework\Assert` class as specialized alternatives for the generic `isType()` method
 * `TestRunner\ChildProcessStarted` and `TestRunner\ChildProcessFinished` events
 

src/Framework/Assert.php

@@ -2750,6 +2750,71 @@ final public static function containsOnly(string $type): TraversableContainsOnly
         return new TraversableContainsOnly($type);
     }
 
+    final public static function containsOnlyArray(): TraversableContainsOnly
+    {
+        return new TraversableContainsOnly(NativeType::Array->value);
+    }
+
+    final public static function containsOnlyBool(): TraversableContainsOnly
+    {
+        return new TraversableContainsOnly(NativeType::Bool->value);
+    }
+
+    final public static function containsOnlyCallable(): TraversableContainsOnly
+    {
+        return new TraversableContainsOnly(NativeType::Callable->value);
+    }
+
+    final public static function containsOnlyFloat(): TraversableContainsOnly
+    {
+        return new TraversableContainsOnly(NativeType::Float->value);
+    }
+
+    final public static function containsOnlyInt(): TraversableContainsOnly
+    {
+        return new TraversableContainsOnly(NativeType::Int->value);
+    }
+
+    final public static function containsOnlyIterable(): TraversableContainsOnly
+    {
+        return new TraversableContainsOnly(NativeType::Iterable->value);
+    }
+
+    final public static function containsOnlyNull(): TraversableContainsOnly
+    {
+        return new TraversableContainsOnly(NativeType::Null->value);
+    }
+
+    final public static function containsOnlyNumeric(): TraversableContainsOnly
+    {
+        return new TraversableContainsOnly(NativeType::Numeric->value);
+    }
+
+    final public static function containsOnlyObject(): TraversableContainsOnly
+    {
+        return new TraversableContainsOnly(NativeType::Object->value);
+    }
+
+    final public static function containsOnlyResource(): TraversableContainsOnly
+    {
+        return new TraversableContainsOnly(NativeType::Resource->value);
+    }
+
+    final public static function containsOnlyClosedResource(): TraversableContainsOnly
+    {
+        return new TraversableContainsOnly(NativeType::ClosedResource->value);
+    }
+
+    final public static function containsOnlyScalar(): TraversableContainsOnly
+    {
+        return new TraversableContainsOnly(NativeType::Scalar->value);
+    }
+
+    final public static function containsOnlyString(): TraversableContainsOnly
+    {
+        return new TraversableContainsOnly(NativeType::String->value);
+    }
+
     /**
      * @param class-string $className
      *

tests/unit/Framework/Assert/assertThatTest.php

@@ -123,6 +123,80 @@ public function testAssertThatContainsOnly(): void
         $this->assertThat(['foo'], $this->containsOnly('string'));
     }
 
+    public function testAssertThatContainsOnlyArray(): void
+    {
+        $this->assertThat([[]], $this->containsOnlyArray());
+    }
+
+    public function testAssertThatContainsOnlyBool(): void
+    {
+        $this->assertThat([true], $this->containsOnlyBool());
+    }
+
+    public function testAssertThatContainsOnlyCallable(): void
+    {
+        $callable = static function (): void
+        {};
+
+        $this->assertThat([$callable], $this->containsOnlyCallable());
+    }
+
+    public function testAssertThatContainsOnlyFloat(): void
+    {
+        $this->assertThat([0.0], $this->containsOnlyFloat());
+    }
+
+    public function testAssertThatContainsOnlyInt(): void
+    {
+        $this->assertThat([0], $this->containsOnlyInt());
+    }
+
+    public function testAssertThatContainsOnlyIterable(): void
+    {
+        $this->assertThat([[]], $this->containsOnlyIterable());
+    }
+
+    public function testAssertThatContainsOnlyNull(): void
+    {
+        $this->assertThat([null], $this->containsOnlyNull());
+    }
+
+    public function testAssertThatContainsOnlyNumeric(): void
+    {
+        $this->assertThat(['0.0'], $this->containsOnlyNumeric());
+    }
+
+    public function testAssertThatContainsOnlyObject(): void
+    {
+        $this->assertThat([new stdClass], $this->containsOnlyObject());
+    }
+
+    public function testAssertThatContainsOnlyResource(): void
+    {
+        $resource = fopen(__FILE__, 'r');
+
+        $this->assertThat([$resource], $this->containsOnlyResource());
+    }
+
+    public function testAssertThatContainsOnlyClosedResource(): void
+    {
+        $resource = fopen(__FILE__, 'r');
+
+        fclose($resource);
+
+        $this->assertThat([$resource], $this->containsOnlyClosedResource());
+    }
+
+    public function testAssertThatContainsOnlyScalar(): void
+    {
+        $this->assertThat(['string'], $this->containsOnlyScalar());
+    }
+
+    public function testAssertThatContainsOnlyString(): void
+    {
+        $this->assertThat(['string'], $this->containsOnlyString());
+    }
+
     public function testAssertThatContainsOnlyInstancesOf(): void
     {
         $this->assertThat([new Book], $this->containsOnlyInstancesOf(Book::class));