2.4.0

Before this, calling safeTruncate with a string without spaces and a truncate length less than the string length would return an empty string.

.editorconfig

@@ -0,0 +1,16 @@
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+insert_final_newline = true
+indent_style = space
+indent_size = 4
+trim_trailing_whitespace = true
+
+[*.md]
+trim_trailing_whitespace = false
+
+[*.yml]
+indent_style = space
+indent_size = 2

.gitattributes

@@ -0,0 +1,8 @@
+* text=auto
+
+.editorconfig export-ignore
+.gitattributes export-ignore
+.gitignore export-ignore
+.travis.yml export-ignore
+phpunit.xml.dist export-ignore
+tests export-ignore

.travis.yml

@@ -1,7 +1,43 @@
 language: php
+
 php:
-  - 5.6
-  - 5.5
-  - 5.4
-  - 5.3
   - hhvm
+
+# This triggers builds to run on the new TravisCI infrastructure.
+# See: http://docs.travis-ci.com/user/workers/container-based-infrastructure/
+sudo: false
+
+matrix:
+  fast_finish: true
+  include:
+    - php: 5.3
+      env: polyfill='true'
+    - php: 5.3
+      env: polyfill='false'
+    - php: 5.4
+      env: polyfill='true'
+    - php: 5.4
+      env: polyfill='false'
+    - php: 5.5
+      env: polyfill='true'
+    - php: 5.5
+      env: polyfill='false'
+    - php: 5.6
+      env: polyfill='true'
+    - php: 5.6
+      env: polyfill='false'
+    - php: 7.0
+      env: polyfill='true'
+    - php: 7.0
+      env: polyfill='false'
+
+install: travis_retry composer install --no-interaction --prefer-source
+
+before_script:
+  - travis_retry composer self-update
+  - travis_retry composer install --no-interaction --prefer-source
+  - if [[ $polyfill = 'false' ]]; then travis_retry composer remove symfony/polyfill-mbstring; fi
+
+script:
+  - vendor/bin/phpunit
+

CHANGELOG.md

@@ -1,3 +1,47 @@
+### 2.4.0 (2017-03-02)
+
+* Add startsWithAny
+* Add endsWithAny
+* Add stripWhitespace
+* Fix error handling for unsupported encodings
+* Change private methods to protected for extending class
+* Fix safeTruncate for strings without spaces
+* Additional char support in toAscii, e.g. full width chars and wide
+  non-breaking space
+
+### 2.3.2 (2016-05-02)
+
+* Improve support without mbstring
+
+### 2.3.1 (2016-03-21)
+
+* Always use root namespace for mbstring functions
+
+### 2.3.0 (2016-03-19)
+
+* Add Persian characters in Stringy::charsArray()
+* Use symfony/polyfill-mbstring to avoid dependency on ext-mbstring
+
+### 2.2.0 (2015-12-20)
+
+* isJSON now returns false for empty strings
+* Update for German umlaut transformation
+* Use reflection to generate method list for StaticStringy
+* Added isBase64 method
+* Improved toAscii char coverage
+
+### 2.1.0 (2015-09-02)
+
+* Added simplified StaticStringy class
+* str in Stringy::create and constructor is now optional
+
+### 2.0.0 (2015-07-29)
+
+ * Removed StaticStringy class
+ * Added append, prepend, toBoolean, repeat, between, slice, split, and lines
+ * camelize/upperCamelize now strip leading dashes and underscores
+ * titleize converts to lowercase, thus no longer preserving acronyms
+
 ### 1.10.0 (2015-07-22)
 
  * Added trimLeft, trimRight

composer.json

@@ -16,7 +16,7 @@
     ],
     "require": {
         "php": ">=5.3.0",
-        "ext-mbstring": "*"
+        "symfony/polyfill-mbstring": "~1.1"
     },
     "require-dev": {
         "phpunit/phpunit": "~4.0"

phpunit.xml.dist

@@ -1,11 +1,11 @@
 <?xml version="1.0" encoding="UTF-8"?>
 
-<phpunit processIsolation="false"
+<phpunit bootstrap="vendor/autoload.php"
+         processIsolation="false"
          stopOnFailure="false"
          syntaxCheck="false">
     <testsuites>
         <testsuite name="Stringy">
-            <file>tests/CommonTest.php</file>
             <file>tests/StringyTest.php</file>
             <file>tests/StaticStringyTest.php</file>
             <file phpVersion="5.6.0">tests/CreateTest.php</file>

tests/CreateTest.php

@@ -1,7 +1,5 @@
 <?php
 
-require __DIR__ . '/../src/Create.php';
-
 use function Stringy\create as s;
 
 class CreateTestCase extends PHPUnit_Framework_TestCase

tests/StaticStringyTest.php

@@ -1,710 +1,60 @@
 <?php
 
-require __DIR__ . '/../src/StaticStringy.php';
-
 use Stringy\StaticStringy as S;
 
-class StaticStringyTestCase extends CommonTest
+class StaticStringyTestCase extends PHPUnit_Framework_TestCase
 {
-	/**
-     * @dataProvider indexOfProvider()
+    /**
+     * @expectedException BadMethodCallException
      */
-    public function testIndexOf($expected, $str, $subStr, $offset = 0, $encoding = null)
+    public function testBadMethodCall()
     {
-        $result = S::indexOf($str, $subStr, $offset, $encoding);
-        $this->assertEquals($expected, $result);
+        $result = S::invalidMethod('foo');
+    }
+
+    public function testEmptyArgsInvocation()
+    {
+        $result = S::toLowerCase();
+        $this->assertEquals('', (string) $result);
+    }
+
+    public function testInvocation()
+    {
+        $result = S::toLowerCase('FOOBAR');
+        $this->assertEquals('foobar', (string) $result);
+    }
+
+    public function testPartialArgsInvocation()
+    {
+        $result = S::slice('foobar', 0, 3);
+        $this->assertEquals('foo', (string) $result);
+    }
+
+    public function testFullArgsInvocation()
+    {
+        $result = S::slice('fòôbàř', 0, 3, 'UTF-8');
+        $this->assertEquals('fòô', (string) $result);
     }
 
     /**
-     * @dataProvider indexOfLastProvider()
+     * Use reflection to ensure that all argument numbers are correct. Each
+     * static method should accept 2 more arguments than their Stringy
+     * equivalent.
      */
-    public function testIndexOfLast($expected, $str, $subStr, $offset = 0, $encoding = null)
+    public function testArgumentNumbers()
     {
-        $result = S::indexOfLast($str, $subStr, $offset, $encoding);
-        $this->assertEquals($expected, $result);
-    }
+        $staticStringyClass = new ReflectionClass('Stringy\StaticStringy');
+        $stringyClass = new ReflectionClass('Stringy\Stringy');
 
-    /**
-     * @dataProvider charsProvider()
-     */
-    public function testChars($expected, $str, $encoding = null)
-    {
-        $result = S::chars($str, $encoding);
-        $this->assertInternalType('array', $result);
-        foreach ($result as $char) {
-            $this->assertInternalType('string', $char);
+        // getStaticPropertyValue can't access protected properties
+        $properties = $staticStringyClass->getStaticProperties();
+
+        foreach ($properties['methodArgs'] as $method => $expected) {
+            $num = $stringyClass->getMethod($method)
+                ->getNumberOfParameters() + 2;
+
+            $this->assertEquals($expected, $num,
+                'Invalid num args for ' . $method);
         }
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider upperCaseFirstProvider()
-     */
-    public function testUpperCaseFirst($expected, $str, $encoding = null)
-    {
-        $result = S::upperCaseFirst($str, $encoding);
-        $this->assertInternalType('string', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider lowerCaseFirstProvider()
-     */
-    public function testLowerCaseFirst($expected, $str, $encoding = null)
-    {
-        $result = S::lowerCaseFirst($str, $encoding);
-        $this->assertInternalType('string', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider camelizeProvider()
-     */
-    public function testCamelize($expected, $str, $encoding = null)
-    {
-        $result = S::camelize($str, $encoding);
-        $this->assertInternalType('string', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider upperCamelizeProvider()
-     */
-    public function testUpperCamelize($expected, $str, $encoding = null)
-    {
-        $result = S::upperCamelize($str, $encoding);
-        $this->assertInternalType('string', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider dasherizeProvider()
-     */
-    public function testDasherize($expected, $str, $encoding = null)
-    {
-        $result = S::dasherize($str, $encoding);
-        $this->assertInternalType('string', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider underscoredProvider()
-     */
-    public function testUnderscored($expected, $str, $encoding = null)
-    {
-        $result = S::underscored($str, $encoding);
-        $this->assertInternalType('string', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider swapCaseProvider()
-     */
-    public function testSwapCase($expected, $str, $encoding = null)
-    {
-        $result = S::swapCase($str, $encoding);
-        $this->assertInternalType('string', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider titleizeProvider()
-     */
-    public function testTitleize($expected, $str, $ignore = null,
-                                 $encoding = null)
-    {
-        $result = S::titleize($str, $ignore, $encoding);
-        $this->assertInternalType('string', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider humanizeProvider()
-     */
-    public function testHumanize($expected, $str, $encoding = null)
-    {
-        $result = S::humanize($str, $encoding);
-        $this->assertInternalType('string', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider tidyProvider()
-     */
-    public function testTidy($expected, $str)
-    {
-        $result = S::tidy($str);
-        $this->assertInternalType('string', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider collapseWhitespaceProvider()
-     */
-    public function testCollapseWhitespace($expected, $str, $encoding = null)
-    {
-        $result = S::collapseWhitespace($str, $encoding);
-        $this->assertInternalType('string', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider toAsciiProvider()
-     */
-    public function testToAscii($expected, $str, $removeUnsupported = true)
-    {
-        $result = S::toAscii($str, $removeUnsupported);
-        $this->assertInternalType('string', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider padProvider()
-     */
-    public function testPad($expected, $str, $length, $padStr = ' ',
-                            $padType = 'right', $encoding = null)
-    {
-        $result = S::pad($str, $length, $padStr, $padType, $encoding);
-        $this->assertInternalType('string', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @expectedException \InvalidArgumentException
-     */
-    public function testPadException()
-    {
-        $result = S::pad('string', 5, 'foo', 'bar');
-    }
-
-    /**
-     * @dataProvider padLeftProvider()
-     */
-    public function testPadLeft($expected, $str, $length, $padStr = ' ',
-                                $encoding = null)
-    {
-        $result = S::padLeft($str, $length, $padStr, $encoding);
-        $this->assertInternalType('string', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider padRightProvider()
-     */
-    public function testPadRight($expected, $str, $length, $padStr = ' ',
-                                 $encoding = null)
-    {
-        $result = S::padRight($str, $length, $padStr, $encoding);
-        $this->assertInternalType('string', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider padBothProvider()
-     */
-    public function testPadBoth($expected, $str, $length, $padStr = ' ',
-                                $encoding = null)
-    {
-        $result = S::padBoth($str, $length, $padStr, $encoding);
-        $this->assertInternalType('string', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider startsWithProvider()
-     */
-    public function testStartsWith($expected, $str, $substring,
-                                   $caseSensitive = true, $encoding = null)
-    {
-        $result = S::startsWith($str, $substring, $caseSensitive, $encoding);
-        $this->assertInternalType('boolean', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider endsWithProvider()
-     */
-    public function testEndsWith($expected, $str, $substring,
-                                 $caseSensitive = true, $encoding = null)
-    {
-        $result = S::endsWith($str, $substring, $caseSensitive, $encoding);
-        $this->assertInternalType('boolean', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider toSpacesProvider()
-     */
-    public function testToSpaces($expected, $str, $tabLength = 4)
-    {
-        $result = S::toSpaces($str, $tabLength);
-        $this->assertInternalType('string', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider toTabsProvider()
-     */
-    public function testToTabs($expected, $str, $tabLength = 4)
-    {
-        $result = S::toTabs($str, $tabLength);
-        $this->assertInternalType('string', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider toLowerCaseProvider()
-     */
-    public function testToLowerCase($expected, $str, $encoding = null)
-    {
-        $result = S::toLowerCase($str, $encoding);
-        $this->assertInternalType('string', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider toTitleCaseProvider()
-     */
-    public function testToTitleCase($expected, $str, $encoding = null)
-    {
-        $result = S::toTitleCase($str, $encoding);
-        $this->assertInternalType('string', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider toUpperCaseProvider()
-     */
-    public function testToUpperCase($expected, $str, $encoding = null)
-    {
-        $result = S::toUpperCase($str, $encoding);
-        $this->assertInternalType('string', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider slugifyProvider()
-     */
-    public function testSlugify($expected, $str, $replacement = '-')
-    {
-        $result = S::slugify($str, $replacement);
-        $this->assertInternalType('string', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider containsProvider()
-     */
-    public function testContains($expected, $haystack, $needle,
-                                 $caseSensitive = true, $encoding = null)
-    {
-        $result = S::contains($haystack, $needle, $caseSensitive, $encoding);
-        $this->assertInternalType('boolean', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider containsAnyProvider()
-     */
-    public function testcontainsAny($expected, $haystack, $needles,
-                                    $caseSensitive = true, $encoding = null)
-    {
-        $result = S::containsAny($haystack, $needles, $caseSensitive, $encoding);
-        $this->assertInternalType('boolean', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider containsAllProvider()
-     */
-    public function testContainsAll($expected, $haystack, $needles,
-                                    $caseSensitive = true, $encoding = null)
-    {
-        $result = S::containsAll($haystack, $needles, $caseSensitive, $encoding);
-        $this->assertInternalType('boolean', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider surroundProvider()
-     */
-    public function testSurround($expected, $str, $substring)
-    {
-        $result = S::surround($str, $substring);
-        $this->assertInternalType('string', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider insertProvider()
-     */
-    public function testInsert($expected, $str, $substring, $index,
-                               $encoding = null)
-    {
-        $result = S::insert($str, $substring, $index, $encoding);
-        $this->assertInternalType('string', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider truncateProvider()
-     */
-    public function testTruncate($expected, $str, $length, $substring = '',
-                                 $encoding = null)
-    {
-        $result = S::truncate($str, $length, $substring, $encoding);
-        $this->assertInternalType('string', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider safeTruncateProvider()
-     */
-    public function testSafeTruncate($expected, $str, $length, $substring = '',
-                                     $encoding = null)
-    {
-        $result = S::safeTruncate($str, $length, $substring, $encoding);
-        $this->assertInternalType('string', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider reverseProvider()
-     */
-    public function testReverse($expected, $str, $encoding = null)
-    {
-        $result = S::reverse($str, $encoding);
-        $this->assertInternalType('string', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider shuffleProvider()
-     */
-    public function testShuffle($str, $encoding = null)
-    {
-        $result = S::shuffle($str, $encoding);
-        $encoding = $encoding ?: mb_internal_encoding();
-
-        $this->assertInternalType('string', $result);
-        $this->assertEquals(mb_strlen($str, $encoding),
-            mb_strlen($result, $encoding));
-
-        // We'll make sure that the chars are present after shuffle
-        for ($i = 0; $i < mb_strlen($str, $encoding); $i++) {
-            $char = mb_substr($str, $i, 1, $encoding);
-            $countBefore = mb_substr_count($str, $char, $encoding);
-            $countAfter = mb_substr_count($result, $char, $encoding);
-            $this->assertEquals($countBefore, $countAfter);
-        }
-    }
-
-    /**
-     * @dataProvider trimProvider()
-     */
-    public function testTrim($expected, $str, $chars = null, $encoding = null)
-    {
-        $result = S::trim($str, $chars, $encoding);
-        $this->assertInternalType('string', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider trimLeftProvider()
-     */
-    public function testTrimLeft($expected, $str, $chars = null,
-                                 $encoding = null)
-    {
-        $result = S::trimLeft($str, $chars, $encoding);
-        $this->assertInternalType('string', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider trimRightProvider()
-     */
-    public function testTrimRight($expected, $str, $chars = null,
-                                  $encoding = null)
-    {
-        $result = S::trimRight($str, $chars, $encoding);
-        $this->assertInternalType('string', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider longestCommonPrefixProvider()
-     */
-    public function testLongestCommonPrefix($expected, $str, $otherStr,
-                                            $encoding = null)
-    {
-        $result = S::longestCommonPrefix($str, $otherStr, $encoding);
-        $this->assertInternalType('string', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider longestCommonSuffixProvider()
-     */
-    public function testLongestCommonSuffix($expected, $str, $otherStr,
-                                            $encoding = null)
-    {
-        $result = S::longestCommonSuffix($str, $otherStr, $encoding);
-        $this->assertInternalType('string', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider longestCommonSubstringProvider()
-     */
-    public function testLongestCommonSubstring($expected, $str, $otherStr,
-                                               $encoding = null)
-    {
-        $result = S::longestCommonSubstring($str, $otherStr, $encoding);
-        $this->assertInternalType('string', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider lengthProvider()
-     */
-    public function testLength($expected, $str, $encoding = null)
-    {
-        $result = S::length($str, $encoding);
-        $this->assertEquals($expected, $result);
-        $this->assertInternalType('int', $result);
-    }
-
-    /**
-     * @dataProvider substrProvider()
-     */
-    public function testSubstr($expected, $str, $start, $length = null,
-                               $encoding = null)
-    {
-        $result = S::substr($str, $start, $length, $encoding);
-        $this->assertInternalType('string', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider atProvider()
-     */
-    public function testAt($expected, $str, $index, $encoding = null)
-    {
-        $result = S::at($str, $index, $encoding);
-        $this->assertInternalType('string', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider firstProvider()
-     */
-    public function testFirst($expected, $str, $n, $encoding = null)
-    {
-        $result = S::first($str, $n, $encoding);
-        $this->assertInternalType('string', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider lastProvider()
-     */
-    public function testLast($expected, $str, $n, $encoding = null)
-    {
-        $result = S::last($str, $n, $encoding);
-        $this->assertInternalType('string', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider ensureLeftProvider()
-     */
-    public function testEnsureLeft($expected, $str, $substring, $encoding = null)
-    {
-        $result = S::ensureLeft($str, $substring, $encoding);
-        $this->assertInternalType('string', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider ensureRightProvider()
-     */
-    public function testEnsureRight($expected, $str, $substring, $encoding = null)
-    {
-        $result = S::ensureRight($str, $substring, $encoding);
-        $this->assertInternalType('string', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider removeLeftProvider()
-     */
-    public function testRemoveLeft($expected, $str, $substring, $encoding = null)
-    {
-        $result = S::removeLeft($str, $substring, $encoding);
-        $this->assertInternalType('string', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider removeRightProvider()
-     */
-    public function testRemoveRight($expected, $str, $substring, $encoding = null)
-    {
-        $result = S::removeRight($str, $substring, $encoding);
-        $this->assertInternalType('string', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider isAlphaProvider()
-     */
-    public function testIsAlpha($expected, $str, $encoding = null)
-    {
-        $result = S::isAlpha($str, $encoding);
-        $this->assertInternalType('boolean', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider isAlphanumericProvider()
-     */
-    public function testIsAlphanumeric($expected, $str, $encoding = null)
-    {
-        $result = S::isAlphanumeric($str, $encoding);
-        $this->assertInternalType('boolean', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider isBlankProvider()
-     */
-    public function testIsBlank($expected, $str, $encoding = null)
-    {
-        $result = S::isBlank($str, $encoding);
-        $this->assertInternalType('boolean', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider isJsonProvider()
-     */
-    public function testIsJson($expected, $str, $encoding = null)
-    {
-        $result = S::isJson($str, $encoding);
-        $this->assertInternalType('boolean', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider isLowerCaseProvider()
-     */
-    public function testIsLowerCase($expected, $str, $encoding = null)
-    {
-        $result = S::isLowerCase($str, $encoding);
-        $this->assertInternalType('boolean', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider hasLowerCaseProvider()
-     */
-    public function testHasLowerCase($expected, $str, $encoding = null)
-    {
-        $result = S::hasLowerCase($str, $encoding);
-        $this->assertInternalType('boolean', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider isSerializedProvider()
-     */
-    public function testIsSerialized($expected, $str, $encoding = null)
-    {
-        $result = S::isSerialized($str, $encoding);
-        $this->assertInternalType('boolean', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider isUpperCaseProvider()
-     */
-    public function testIsUpperCase($expected, $str, $encoding = null)
-    {
-        $result = S::isUpperCase($str, $encoding);
-        $this->assertInternalType('boolean', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider hasUpperCaseProvider()
-     */
-    public function testHasUpperCase($expected, $str, $encoding = null)
-    {
-        $result = S::hasUpperCase($str, $encoding);
-        $this->assertInternalType('boolean', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider isHexadecimalProvider()
-     */
-    public function testIsHexadecimal($expected, $str, $encoding = null)
-    {
-        $result = S::isHexadecimal($str, $encoding);
-        $this->assertInternalType('boolean', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider countSubstrProvider()
-     */
-    public function testCountSubstr($expected, $str, $substring,
-                                    $caseSensitive = true, $encoding = null)
-    {
-        $result = S::countSubstr($str, $substring, $caseSensitive, $encoding);
-        $this->assertInternalType('int', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider replaceProvider()
-     */
-    public function testReplace($expected, $str, $search, $replacement,
-                                $encoding = null)
-    {
-        $result = S::replace($str, $search, $replacement, $encoding);
-        $this->assertInternalType('string', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider regexReplaceProvider()
-     */
-    public function testRegexReplace($expected, $str, $pattern, $replacement,
-                                     $options = 'msr', $encoding = null)
-    {
-        $result = S::regexReplace($str, $pattern, $replacement, $options, $encoding);
-        $this->assertInternalType('string', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider htmlEncodeProvider()
-     */
-    public function testHtmlEncode($expected, $str, $flags = ENT_COMPAT, $encoding = null)
-    {
-        $result = S::htmlEncode($str, $flags, $encoding);
-        $this->assertInternalType('string', $result);
-        $this->assertEquals($expected, $result);
-    }
-
-    /**
-     * @dataProvider htmlDecodeProvider()
-     */
-    public function testHtmlDecode($expected, $str, $flags = ENT_COMPAT, $encoding = null)
-    {
-        $result = S::htmlDecode($str, $flags, $encoding);
-        $this->assertInternalType('string', $result);
-        $this->assertEquals($expected, $result);
     }
 }