php-school / learn-you-php

    /**

     * @dataProvider delimitProvider()

     */

    public function testDelimit($expected, $str, $delimiter, $encoding = null)

    {

        $stringy = S::create($str, $encoding);

        $result = $stringy->delimit($delimiter);

        $this->assertStringy($result);

        $this->assertEquals($expected, $result);

        $this->assertEquals($str, $stringy);

    }

    public function delimitProvider()

    {

    /**

     * @dataProvider padProvider()

     */

    public function testPad($expected, $str, $length, $padStr = ' ',

                            $padType = 'right', $encoding = null)

    {

        $stringy = S::create($str, $encoding);

        $result = $stringy->pad($length, $padStr, $padType);

        $this->assertStringy($result);

        $this->assertEquals($expected, $result);

        $this->assertEquals($str, $stringy);

    }

    public function padProvider()

    {

    /**

     * @dataProvider padLeftProvider()

     */

    public function testPadLeft($expected, $str, $length, $padStr = ' ',

                                $encoding = null)

    {

        $stringy = S::create($str, $encoding);

        $result = $stringy->padLeft($length, $padStr);

        $this->assertStringy($result);

        $this->assertEquals($expected, $result);

        $this->assertEquals($str, $stringy);

    }

    public function padLeftProvider()

    {

    /**

     * @dataProvider padRightProvider()

     */

    public function testPadRight($expected, $str, $length, $padStr = ' ',

                                 $encoding = null)

    {

        $stringy = S::create($str, $encoding);

        $result = $stringy->padRight($length, $padStr);

        $this->assertStringy($result);

        $this->assertEquals($expected, $result);

        $this->assertEquals($str, $stringy);

    }

    public function padRightProvider()

    {

    /**

     * @dataProvider padBothProvider()

     */

    public function testPadBoth($expected, $str, $length, $padStr = ' ',

                                $encoding = null)

    {

        $stringy = S::create($str, $encoding);

        $result = $stringy->padBoth($length, $padStr);

        $this->assertStringy($result);

        $this->assertEquals($expected, $result);

        $this->assertEquals($str, $stringy);

    }

    public function padBothProvider()

    {

    /**

     * @dataProvider betweenProvider()

     */

    public function testBetween($expected, $str, $start, $end, $offset = null,

                                $encoding = null)

    {

        $stringy = S::create($str, $encoding);

        $result = $stringy->between($start, $end, $offset);

        $this->assertStringy($result);

        $this->assertEquals($expected, $result);

        $this->assertEquals($str, $stringy);

    }

    public function betweenProvider()

    {

    /**

     * @dataProvider insertProvider()

     */

    public function testInsert($expected, $str, $substring, $index,

                               $encoding = null)

    {

        $stringy = S::create($str, $encoding);

        $result = $stringy->insert($substring, $index);

        $this->assertStringy($result);

        $this->assertEquals($expected, $result);

        $this->assertEquals($str, $stringy);

    }

    public function insertProvider()

    {

    /**

     * @dataProvider truncateProvider()

     */

    public function testTruncate($expected, $str, $length, $substring = '',

                                 $encoding = null)

    {

        $stringy = S::create($str, $encoding);

        $result = $stringy->truncate($length, $substring);

        $this->assertStringy($result);

        $this->assertEquals($expected, $result);

        $this->assertEquals($str, $stringy);

    }

    public function truncateProvider()

    {

    /**

     * @dataProvider safeTruncateProvider()

     */

    public function testSafeTruncate($expected, $str, $length, $substring = '',

                                     $encoding = null)

    {

        $stringy = S::create($str, $encoding);

        $result = $stringy->safeTruncate($length, $substring);

        $this->assertStringy($result);

        $this->assertEquals($expected, $result);

        $this->assertEquals($str, $stringy);

    }

    public function safeTruncateProvider()

    {

    /**

     * @dataProvider repeatProvider()

     */

    public function testRepeat($expected, $str, $multiplier, $encoding = null)

    {

        $stringy = S::create($str, $encoding);

        $result = $stringy->repeat($multiplier);

        $this->assertStringy($result);

        $this->assertEquals($expected, $result);

        $this->assertEquals($str, $stringy);

    }

    public function repeatProvider()

    {

    /**

     * @dataProvider longestCommonPrefixProvider()

     */

    public function testLongestCommonPrefix($expected, $str, $otherStr,

                                            $encoding = null)

    {

        $stringy = S::create($str, $encoding);

        $result = $stringy->longestCommonPrefix($otherStr);

        $this->assertStringy($result);

        $this->assertEquals($expected, $result);

        $this->assertEquals($str, $stringy);

    }

    public function longestCommonPrefixProvider()

    {

    /**

     * @dataProvider longestCommonSuffixProvider()

     */

    public function testLongestCommonSuffix($expected, $str, $otherStr,

                                            $encoding = null)

    {

        $stringy = S::create($str, $encoding);

        $result = $stringy->longestCommonSuffix($otherStr);

        $this->assertStringy($result);

        $this->assertEquals($expected, $result);

        $this->assertEquals($str, $stringy);

    }

    public function longestCommonSuffixProvider()

    {

    /**

     * @dataProvider longestCommonSubstringProvider()

     */

    public function testLongestCommonSubstring($expected, $str, $otherStr,

                                               $encoding = null)

    {

        $stringy = S::create($str, $encoding);

        $result = $stringy->longestCommonSubstring($otherStr);

        $this->assertStringy($result);

        $this->assertEquals($expected, $result);

        $this->assertEquals($str, $stringy);

    }

    public function longestCommonSubstringProvider()

    {

    /**

     * @dataProvider sliceProvider()

     */

    public function testSlice($expected, $str, $start, $end = null,

                              $encoding = null)

    {

        $stringy = S::create($str, $encoding);

        $result = $stringy->slice($start, $end);

        $this->assertStringy($result);

        $this->assertEquals($expected, $result);

        $this->assertEquals($str, $stringy);

    }

    public function sliceProvider()

    {

    /**

     * @dataProvider substrProvider()

     */

    public function testSubstr($expected, $str, $start, $length = null,

                               $encoding = null)

    {

        $stringy = S::create($str, $encoding);

        $result = $stringy->substr($start, $length);

        $this->assertStringy($result);

        $this->assertEquals($expected, $result);

        $this->assertEquals($str, $stringy);

    }

    public function substrProvider()

    {

    /**

     * @dataProvider atProvider()

     */

    public function testAt($expected, $str, $index, $encoding = null)

    {

        $stringy = S::create($str, $encoding);

        $result = $stringy->at($index);

        $this->assertStringy($result);

        $this->assertEquals($expected, $result);

        $this->assertEquals($str, $stringy);

    }

    public function atProvider()

    {

    /**

     * @dataProvider firstProvider()

     */

    public function testFirst($expected, $str, $n, $encoding = null)

    {

        $stringy = S::create($str, $encoding);

        $result = $stringy->first($n);

        $this->assertStringy($result);

        $this->assertEquals($expected, $result);

        $this->assertEquals($str, $stringy);

    }

    public function firstProvider()

    {

    /**

     * @dataProvider lastProvider()

     */

    public function testLast($expected, $str, $n, $encoding = null)

    {

        $stringy = S::create($str, $encoding);

        $result = $stringy->last($n);

        $this->assertStringy($result);

        $this->assertEquals($expected, $result);

        $this->assertEquals($str, $stringy);

    }

    public function lastProvider()

    {

    /**

     * @dataProvider ensureLeftProvider()

     */

    public function testEnsureLeft($expected, $str, $substring, $encoding = null)

    {

        $stringy = S::create($str, $encoding);

        $result = $stringy->ensureLeft($substring);

        $this->assertStringy($result);

        $this->assertEquals($expected, $result);

        $this->assertEquals($str, $stringy);

    }

    public function ensureLeftProvider()

    {

    /**

     * @dataProvider ensureRightProvider()

     */

    public function testEnsureRight($expected, $str, $substring, $encoding = null)

    {

        $stringy = S::create($str, $encoding);

        $result = $stringy->ensureRight($substring);

        $this->assertStringy($result);

        $this->assertEquals($expected, $result);

        $this->assertEquals($str, $stringy);

    }

    public function ensureRightProvider()

    {

    /**

     * @dataProvider removeLeftProvider()

     */

    public function testRemoveLeft($expected, $str, $substring, $encoding = null)

    {

        $stringy = S::create($str, $encoding);

        $result = $stringy->removeLeft($substring);

        $this->assertStringy($result);

        $this->assertEquals($expected, $result);

        $this->assertEquals($str, $stringy);

    }

    public function removeLeftProvider()

    {

    /**

     * @dataProvider removeRightProvider()

     */

    public function testRemoveRight($expected, $str, $substring, $encoding = null)

    {

        $stringy = S::create($str, $encoding);

        $result = $stringy->removeRight($substring);

        $this->assertStringy($result);

        $this->assertEquals($expected, $result);

        $this->assertEquals($str, $stringy);

    }

    public function removeRightProvider()

    {

    /**

     * @dataProvider replaceProvider()

     */

    public function testReplace($expected, $str, $search, $replacement,

                                $encoding = null)

    {

        $stringy = S::create($str, $encoding);

        $result = $stringy->replace($search, $replacement);

        $this->assertStringy($result);

        $this->assertEquals($expected, $result);

        $this->assertEquals($str, $stringy);

    }

    public function replaceProvider()

    {

    /**

     * @dataProvider regexReplaceProvider()

     */

    public function testregexReplace($expected, $str, $pattern, $replacement,

                                     $options = 'msr', $encoding = null)

    {

        $stringy = S::create($str, $encoding);

        $result = $stringy->regexReplace($pattern, $replacement, $options);

        $this->assertStringy($result);

        $this->assertEquals($expected, $result);

        $this->assertEquals($str, $stringy);

    }

    public function regexReplaceProvider()

    {