traderinteractive / util-string-php

tests/StringsTest.php

<?php

namespace TraderInteractive\Util;

use TraderInteractive\Util\Strings as S;
use PHPUnit\Framework\TestCase;

/**
 * @coversDefaultClass \TraderInteractive\Util\Strings
 * @covers ::<private>
 */
final class StringsTest extends TestCase
{
    /**
     * Verify bahavior of format() with argument cannot be casted to a string.
     *
     * @test
     * @covers ::format
     *
     * @return void
     */
    public function formatNonStringCastableObject()
    {
        $this->expectException(\TypeError::class);
        S::format('{0} and {1}', new \StdClass(), 'Jill');

new StdClass() of type StdClass is incompatible with the type string expected by parameter $arguments of TraderInteractive\Util\Strings::format().

    }

    /**
     * Verify bahavior of format() with object argument casted to a string.
     *
     * @test
     * @covers ::format
     *
     * @return void
     */
    public function formatStringCastableObject()
    {
        $e = new \Exception();
        $this->assertSame(
            "Exception {$e} was thrown",
            S::format('Exception {0} was thrown', $e)
        );
    }

    /**
     * Verify bahavior of format() with repeated key.
     *
     * @test
     * @covers ::format
     *
     * @return void
     */
    public function formatKeysAreRepeatable()
    {
        $this->assertSame('AAA', S::format('{0}{0}{0}', 'A'));
    }

    /**
     * Verify bahavior of format() with repeated unordered keys.
     *
     * @test
     * @covers ::format
     *
     * @return void
     */
    public function formatKeyOrderDoesNotMatter()
    {
        $this->assertSame('ABC', S::format('{2}{1}{0}', 'C', 'B', 'A'));
    }

    /**
     * Verify bahavior of format() with non-string $format.
     *
     * @test
     * @covers ::format
     *
     * @return void
     */
    public function formatNonStringFormat()
    {
        $this->expectException(\TypeError::class);
        S::format([], 'C', 'B', 'A');

array() of type array is incompatible with the type string expected by parameter $format of TraderInteractive\Util\Strings::format().

    }

    /**
     * @test
     * @covers ::endsWith
     *
     * @return void
     */
    public function endsWithEmptyString()
    {
        $nonSuffix = null;
        $this->assertFalse(S::endsWith('', 'suffix', $nonSuffix));
        $this->assertSame('', $nonSuffix);
    }

    /**
     * Verify matching bahavior of endsWith().
     *
     * @test
     * @covers ::endsWith
     *
     * @return void
     */
    public function endsWithMatches()
    {
        $nonSuffix = null;
        $this->assertTrue(S::endsWith('bah', 'h', $nonSuffix));
        $this->assertSame('ba', $nonSuffix);
    }

    /**
     * Verify non-matching bahavior of endsWith().
     *
     * @test
     * @covers ::endsWith
     *
     * @return void
     */
    public function endsWithNoMatches()
    {
        $nonSuffix = null;
        $this->assertFalse(S::endsWith('bah', 'z', $nonSuffix));
        $this->assertSame('bah', $nonSuffix);
    }

    /**
     * Verify non-matching bahavior of endsWith().
     *
     * @test
     * @covers ::endsWith
     *
     * @return void
     */
    public function endsWithBadTypeForSubject()
    {
        $this->expectException(\TypeError::class);
        S::endsWith(new \StdClass(), '');

new StdClass() of type StdClass is incompatible with the type string expected by parameter $string of TraderInteractive\Util\Strings::endsWith().

    }

    /**
     * Verify behavior of endsWith() with non-string $suffix.
     *
     * @test
     * @covers ::endsWith
     *
     * @return void
     */
    public function endsWithBadTypeForSuffix()
    {
        $this->expectException(\TypeError::class);
        S::endsWith('', new \StdClass());

new StdClass() of type StdClass is incompatible with the type string expected by parameter $suffix of TraderInteractive\Util\Strings::endsWith().

    }

    /**
     * Verify behavior of endsWith() with all arguments as empty strings.
     *
     * @test
     * @covers ::endsWith
     *
     * @return void
     */
    public function endsWithEmptyBoth()
    {
        $nonSuffix = null;
        $this->assertTrue(S::endsWith('', '', $nonSuffix));
        $this->assertSame('', $nonSuffix);
    }

    /**
     * Verify behavior of endsWith() with empty string $suffix.
     *
     * @test
     * @covers ::endsWith
     *
     * @return void
     */
    public function endsWithEmptySuffix()
    {
        $nonSuffix = null;
        $this->assertTrue(S::endsWith('a', '', $nonSuffix));
        $this->assertSame('a', $nonSuffix);
    }

    /**
     * Verify behavior of endsWith() with empty string $subject.
     *
     * @test
     * @covers ::endsWith
     *
     * @return void
     */
    public function endsWithEmptySubject()
    {
        $nonSuffix = null;
        $this->assertFalse(S::endsWith('', 'b', $nonSuffix));
        $this->assertSame('', $nonSuffix);
    }

    /**
     * Verify basic behavior of ellipsize().
     *
     * @test
     * @covers ::ellipsize
     *
     * @return void
     */
    public function ellipsize()
    {
        $input = 'Short text is an arbitrary thing.';
        $this->assertSame('', S::ellipsize($input, 0));
        $this->assertSame('.', S::ellipsize($input, 1));
        $this->assertSame('...', S::ellipsize($input, 3));
        $this->assertSame('S...', S::ellipsize($input, 4));
        $this->assertSame('Short text...', S::ellipsize($input, 13));
        $this->assertSame('Short text is an arbitrary th...', S::ellipsize($input, 32));
        $this->assertSame($input, S::ellipsize($input, 33));
        $this->assertSame($input, S::ellipsize($input, 34));
        $this->assertSame($input, S::ellipsize($input, 35));
        $this->assertSame($input, S::ellipsize($input, 50));
    }

    /**
     * Verify behavior of ellipsize() with negative max length.
     *
     * @test
     * @covers ::ellipsize
     *
     * @return void
     */
    public function ellipsizeNegativeMaxLength()
    {
        $this->expectException(\InvalidArgumentException::class);
        $this->expectExceptionMessage('$maxLength is negative');
        S::ellipsize('foo', -1);
    }

    /**
     * Tests that ellipsize works with a custom suffix.
     *
     * @test
     * @covers ::ellipsize
     *
     * @return void
     */
    public function ellipsizeCustomSuffix()
    {
        $this->assertSame('Test!', S::ellipsize('Testing', 5, '!'));
    }

    /**
     * Tests that ellipsize fails with an integer instead of a string.
     *
     * @test
     * @covers ::ellipsize
     *
     * @return void
     */
    public function ellipsizeIntegerInsteadOfString()
    {
        $this->expectException(\TypeError::class);
        S::ellipsize(null, 10);

null of type null is incompatible with the type string expected by parameter $string of TraderInteractive\Util\Strings::ellipsize().

    }

    /**
     * Tests that ellipsize fails with a string for $maxLength.
     *
     * @test
     * @covers ::ellipsize
     *
     * @return void
     */
    public function ellipsizeStringMaxLength()
    {
        $this->expectException(\TypeError::class);
        S::ellipsize('test', 'a');

'a' of type string is incompatible with the type integer expected by parameter $maxLength of TraderInteractive\Util\Strings::ellipsize().

    }

    /**
     * @test
     * @covers ::ellipsize
     *
     * @return void
     */
    public function ellipsizeNonStringSuffix()
    {
        $this->expectException(\TypeError::class);
        S::ellipsize('test', 10, new \StdClass());

new StdClass() of type StdClass is incompatible with the type string expected by parameter $suffix of TraderInteractive\Util\Strings::ellipsize().

    }
}