Merge branch '11.5'

Author: sebastianbergmann

ChangeLog-12.0.md

@@ -13,6 +13,7 @@ All notable changes of the PHPUnit 12.0 release series are documented in this fi
 * [#6053](https://github.com/sebastianbergmann/phpunit/issues/6053): `Assert::isType()` (was soft-deprecated in PHPUnit 11.5)
 * [#6056](https://github.com/sebastianbergmann/phpunit/issues/6056): `assertContainsOnly()` (was soft-deprecated in PHPUnit 11.5)
 * [#6056](https://github.com/sebastianbergmann/phpunit/issues/6056): `assertNotContainsOnly()` (was soft-deprecated in PHPUnit 11.5)
+* [#6060](https://github.com/sebastianbergmann/phpunit/issues/6060): `containsOnly()` (was soft-deprecated in PHPUnit 11.5)
 
 ### Removed
 

DEPRECATIONS.md

@@ -13,3 +13,4 @@ This functionality is currently [hard-deprecated](https://phpunit.de/backward-co
 | [#6052](https://github.com/sebastianbergmann/phpunit/issues/6052) | `Assert::isType()`                | 11.5.0 | Use `isArray()`, `isBool()`, `isCallable()`, `isFloat()`, `isInt()`, `isIterable()`, `isNull()`, `isNumeric()`, `isObject()`, `isResource()`, `isClosedResource()`, `isScalar()`, or `isString()` instead                                                                                                                                                                                                                         |
 | [#6055](https://github.com/sebastianbergmann/phpunit/issues/6055) | `Assert::assertContainsOnly()`    | 11.5.0 | Use `assertContainsOnlyArray()`, `assertContainsOnlyBool()`, `assertContainsOnlyCallable()`, `assertContainsOnlyFloat()`, `assertContainsOnlyInt()`, `assertContainsOnlyIterable()`, `assertContainsOnlyNumeric()`, `assertContainsOnlyObject()`, `assertContainsOnlyResource()`, `assertContainsOnlyClosedResource()`, `assertContainsOnlyScalar()`, or `assertContainsOnlyString()` instead                                     |
 | [#6055](https://github.com/sebastianbergmann/phpunit/issues/6055) | `Assert::assertNotContainsOnly()` | 11.5.0 | Use `assertContainsNotOnlyArray()`, `assertContainsNotOnlyBool()`, `assertContainsNotOnlyCallable()`, `assertContainsNotOnlyFloat()`, `assertContainsNotOnlyInt()`, `assertContainsNotOnlyIterable()`, `assertContainsNotOnlyNumeric()`, `assertContainsNotOnlyObject()`, `assertContainsNotOnlyResource()`, `assertContainsNotOnlyClosedResource()`, `assertContainsNotOnlyScalar()`, or `assertContainsNotOnlyString()` instead |
+| [#6059](https://github.com/sebastianbergmann/phpunit/issues/6059) | `Assert::containsOnly()`          | 11.5.0 | Use `containsOnlyArray()`, `containsOnlyBool()`, `containsOnlyCallable()`, `containsOnlyFloat()`, `containsOnlyInt()`, `containsOnlyIterable()`, `containsOnlyNumeric()`, `containsOnlyObject()`, `containsOnlyResource()`, `containsOnlyClosedResource()`, `containsOnlyScalar()`, or `containsOnlyString()`  instead                                                                                                            |

src/Framework/Assert.php

@@ -2764,11 +2764,80 @@ final public static function containsIdentical(mixed $value): TraversableContain
     }
 
     /**
+     * @param 'array'|'bool'|'boolean'|'callable'|'double'|'float'|'int'|'integer'|'iterable'|'null'|'numeric'|'object'|'real'|'resource (closed)'|'resource'|'scalar'|'string' $type
+     *
      * @throws Exception
+     *
+     * @deprecated https://github.com/sebastianbergmann/phpunit/issues/6060
      */
-    final public static function containsOnly(NativeType $type): TraversableContainsOnly
+    final public static function containsOnly(string $type): TraversableContainsOnly
+    {
+        return TraversableContainsOnly::forNativeType(self::mapNativeType($type));
+    }
+
+    final public static function containsOnlyArray(): TraversableContainsOnly
+    {
+        return TraversableContainsOnly::forNativeType(NativeType::Array);
+    }
+
+    final public static function containsOnlyBool(): TraversableContainsOnly
+    {
+        return TraversableContainsOnly::forNativeType(NativeType::Bool);
+    }
+
+    final public static function containsOnlyCallable(): TraversableContainsOnly
+    {
+        return TraversableContainsOnly::forNativeType(NativeType::Callable);
+    }
+
+    final public static function containsOnlyFloat(): TraversableContainsOnly
+    {
+        return TraversableContainsOnly::forNativeType(NativeType::Float);
+    }
+
+    final public static function containsOnlyInt(): TraversableContainsOnly
+    {
+        return TraversableContainsOnly::forNativeType(NativeType::Int);
+    }
+
+    final public static function containsOnlyIterable(): TraversableContainsOnly
+    {
+        return TraversableContainsOnly::forNativeType(NativeType::Iterable);
+    }
+
+    final public static function containsOnlyNull(): TraversableContainsOnly
+    {
+        return TraversableContainsOnly::forNativeType(NativeType::Null);
+    }
+
+    final public static function containsOnlyNumeric(): TraversableContainsOnly
+    {
+        return TraversableContainsOnly::forNativeType(NativeType::Numeric);
+    }
+
+    final public static function containsOnlyObject(): TraversableContainsOnly
+    {
+        return TraversableContainsOnly::forNativeType(NativeType::Object);
+    }
+
+    final public static function containsOnlyResource(): TraversableContainsOnly
+    {
+        return TraversableContainsOnly::forNativeType(NativeType::Resource);
+    }
+
+    final public static function containsOnlyClosedResource(): TraversableContainsOnly
+    {
+        return TraversableContainsOnly::forNativeType(NativeType::ClosedResource);
+    }
+
+    final public static function containsOnlyScalar(): TraversableContainsOnly
+    {
+        return TraversableContainsOnly::forNativeType(NativeType::Scalar);
+    }
+
+    final public static function containsOnlyString(): TraversableContainsOnly
     {
-        return TraversableContainsOnly::forNativeType($type);
+        return TraversableContainsOnly::forNativeType(NativeType::String);
     }
 
     /**

src/Framework/Assert/Functions.php

@@ -2910,12 +2910,103 @@ function containsIdentical(mixed $value): TraversableContainsIdentical
 }
 
 if (!function_exists('PHPUnit\Framework\containsOnly')) {
-    function containsOnly(NativeType $type): TraversableContainsOnly
+    function containsOnly(string $type): TraversableContainsOnly
     {
         return Assert::containsOnly(...func_get_args());
     }
 }
 
+if (!function_exists('PHPUnit\Framework\containsOnlyArray')) {
+    function containsOnlyArray(): TraversableContainsOnly
+    {
+        return Assert::containsOnlyArray(...func_get_args());
+    }
+}
+
+if (!function_exists('PHPUnit\Framework\containsOnlyBool')) {
+    function containsOnlyBool(): TraversableContainsOnly
+    {
+        return Assert::containsOnlyBool(...func_get_args());
+    }
+}
+
+if (!function_exists('PHPUnit\Framework\containsOnlyCallable')) {
+    function containsOnlyCallable(): TraversableContainsOnly
+    {
+        return Assert::containsOnlyCallable(...func_get_args());
+    }
+}
+
+if (!function_exists('PHPUnit\Framework\containsOnlyFloat')) {
+    function containsOnlyFloat(): TraversableContainsOnly
+    {
+        return Assert::containsOnlyFloat(...func_get_args());
+    }
+}
+
+if (!function_exists('PHPUnit\Framework\containsOnlyInt')) {
+    function containsOnlyInt(): TraversableContainsOnly
+    {
+        return Assert::containsOnlyInt(...func_get_args());
+    }
+}
+
+if (!function_exists('PHPUnit\Framework\containsOnlyIterable')) {
+    function containsOnlyIterable(): TraversableContainsOnly
+    {
+        return Assert::containsOnlyIterable(...func_get_args());
+    }
+}
+
+if (!function_exists('PHPUnit\Framework\containsOnlyNull')) {
+    function containsOnlyNull(): TraversableContainsOnly
+    {
+        return Assert::containsOnlyNull(...func_get_args());
+    }
+}
+
+if (!function_exists('PHPUnit\Framework\containsOnlyNumeric')) {
+    function containsOnlyNumeric(): TraversableContainsOnly
+    {
+        return Assert::containsOnlyNumeric(...func_get_args());
+    }
+}
+
+if (!function_exists('PHPUnit\Framework\containsOnlyObject')) {
+    function containsOnlyObject(): TraversableContainsOnly
+    {
+        return Assert::containsOnlyObject(...func_get_args());
+    }
+}
+
+if (!function_exists('PHPUnit\Framework\containsOnlyResource')) {
+    function containsOnlyResource(): TraversableContainsOnly
+    {
+        return Assert::containsOnlyResource(...func_get_args());
+    }
+}
+
+if (!function_exists('PHPUnit\Framework\containsOnlyClosedResource')) {
+    function containsOnlyClosedResource(): TraversableContainsOnly
+    {
+        return Assert::containsOnlyClosedResource(...func_get_args());
+    }
+}
+
+if (!function_exists('PHPUnit\Framework\containsOnlyScalar')) {
+    function containsOnlyScalar(): TraversableContainsOnly
+    {
+        return Assert::containsOnlyScalar(...func_get_args());
+    }
+}
+
+if (!function_exists('PHPUnit\Framework\containsOnlyString')) {
+    function containsOnlyString(): TraversableContainsOnly
+    {
+        return Assert::containsOnlyString(...func_get_args());
+    }
+}
+
 if (!function_exists('PHPUnit\Framework\containsOnlyInstancesOf')) {
     function containsOnlyInstancesOf(string $className): TraversableContainsOnly
     {

tests/unit/Framework/Assert/assertThatTest.php

@@ -121,7 +121,81 @@ public function testAssertThatStringEqualsStringIgnoringLineEndings(): void
 
     public function testAssertThatContainsOnly(): void
     {
-        $this->assertThat(['foo'], $this->containsOnly(NativeType::String));
+        $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