Assert value is an array.

@param mixed  $actual
@param string $message
558389
public static function assertArray($actual, string $message = '')
    {
        self::assertTypeOfScalar($actual, $message, 'assertArray', new ScalarConstraint(ScalarConstraint::TYPE_ARRAY));
    }
2163
public static function assertNotBool($actual, string $message = '')
    {
        self::assertTypeOfScalar($actual, $message, 'assertNotBool', new LogicalNot(new ScalarConstraint(ScalarConstraint::TYPE_BOOL)));
    }
396357
public function assertNotCount($expectedCount, $message = '')
    {
        Assert::assertNotCount($expectedCount, $this->getData(), $message);

        return $this;
    }
505779
public function assertJsonStringNotEqualsJsonString($expectedJson, $message = '')
    {
        Assert::assertJsonStringNotEqualsJsonString($expectedJson, $this->getData(), $message);

        return $this;
    }
176418
static function assertLooselyIdenticalIterable(iterable $expected, $actual, bool $canonicalizeKeys = false, string $message = '')
    {
        static::assertThat($actual, static::looselyIdenticalIterable($expected, $canonicalizeKeys), $message);
    }
706577
static function assertSameIterable(iterable $expected, $actual, string $message = ''): void
    {
        static::assertThat($actual, static::identicalIterable($expected), $message);
    }
739767
protected function assertNotSame($expected, $actual, $message = '')
    {
        \PHPUnit\Framework\Assert::assertNotSame($expected, $actual, $message);
    }
968004
static function isArraySame($expected, $actual) {

		if (Arrays::isNumeric($actual) and Arrays::isNumeric($expected)) {
			sort($expected);
			sort($actual);
		} else {
			asort($expected);
			asort($actual);
		}
		
		return $expected === $actual;
	}
631683
public static function assertNumberNotInRange($lowerBoundary, $upperBoundary, $actual, string $message = '')
    {
        self::assertNumberRangeMatch($lowerBoundary, $upperBoundary, $actual, $message, 'assertNumberNotInRange', false, true);
    }
611155
protected function matchArrayIndex($actual)
    {
        if (isset($actual[$this->getKey()])) {
            $this->assertion->setActual($actual[$this->getKey()]);

            return $this->isExpected($actual[$this->getKey()]);
        }

        return false;
    }
873188
public static function assertNotFloat($actual, string $message = '')
    {
        self::assertTypeOfScalar($actual, $message, 'assertNotFloat', new LogicalNot(new ScalarConstraint(ScalarConstraint::TYPE_FLOAT)));
    }
827509
public function assertGreaterThan($expected, $message = '')
    {
        Assert::assertGreaterThan($expected, $this->getData(), $message);

        return $this;
    }
72541
function (actual, message) {
        YUITest.Assert._increment();
        if (typeof actual != "boolean"){
            throw new YUITest.UnexpectedValue(YUITest.Assert._formatMessage(message, "Value should be a Boolean."), actual);
        }
    }
747082
public function assert($assertion, $message)
    {
        // Increment the assertion count
        $this->test->incrementAssertionCount();

        $assertion = $this->negative ? !((bool) $assertion) : (bool) $assertion;

        if ($assertion === false) {
            return call_user_func_array([$this, 'fail'], $message);
        }

        return true;
    }
378758
public function notStrictEqual($actual, $expected, $message = '')
    {
        $this->assertion->setActual($actual);

        return $this->assertion->to->not->equal($expected, $message);
    }
861588
public static function assertStringMatchIgnoreWhitespace(
        $expected, $actual, $message='') {
          Assert::assertThat(
            $actual,
            new StringMatchIgnoreWhitespace($expected),
            $message);
    }
471286
public static function assertNotString($actual, string $message = '')
    {
        self::assertTypeOfScalar($actual, $message, 'assertNotString', new LogicalNot(new ScalarConstraint(ScalarConstraint::TYPE_STRING)));
    }