├── .editorconfig
├── .gitignore
├── .travis.yml
├── CONTRIBUTING.md
├── LICENSE
├── README.md
├── build.php
├── composer.json
├── dist
    └── zubr.php
├── phpunit.xml
├── src
    ├── abs.php.TODO
    ├── acos.php.TODO
    ├── acosh.php.TODO
    ├── addcslashes.php.TODO
    ├── addslashes.php.TODO
    ├── array_change_key_case.php
    ├── array_chunk.php
    ├── array_column.php
    ├── array_combine.php
    ├── array_count_values.php
    ├── array_diff.php.TODO
    ├── array_diff_assoc.php.TODO
    ├── array_diff_key.php.TODO
    ├── array_diff_uassoc.php.TODO
    ├── array_diff_ukey.php.TODO
    ├── array_fill.php
    ├── array_fill_keys.php
    ├── array_filter.php.TODO
    ├── array_flip.php
    ├── array_intersect.php.TODO
    ├── array_intersect_assoc.php.TODO
    ├── array_intersect_key.php.TODO
    ├── array_intersect_uassoc.php.TODO
    ├── array_intersect_ukey.php.TODO
    ├── array_key_exists.php
    ├── array_keys.php
    ├── array_map.php.TODO
    ├── array_merge.php.TODO
    ├── array_merge_recursive.php.TODO
    ├── array_multisort.php.TODO
    ├── array_pad.php.TODO
    ├── array_pop.php.TODO
    ├── array_product.php.TODO
    ├── array_push.php.TODO
    ├── array_rand.php.TODO
    ├── array_reduce.php.TODO
    ├── array_replace.php.TODO
    ├── array_replace_recursive.php.TODO
    ├── array_reverse.php.TODO
    ├── array_search.php.TODO
    ├── array_shift.php.TODO
    ├── array_slice.php.TODO
    ├── array_splice.php.TODO
    ├── array_sum.php.TODO
    ├── array_udiff.php.TODO
    ├── array_udiff_assoc.php.TODO
    ├── array_udiff_uassoc.php.TODO
    ├── array_uintersect.php.TODO
    ├── array_uintersect_uassoc.php.TODO
    ├── array_unique.php.TODO
    ├── array_unshift.php.TODO
    ├── array_values.php.TODO
    ├── array_walk.php.TODO
    ├── arsort.php.TODO
    ├── asin.php.TODO
    ├── asinh.php.TODO
    ├── asort.php.TODO
    ├── assert_options.php.TODO
    ├── atan.php.TODO
    ├── atan2.php.TODO
    ├── atanh.php.TODO
    ├── base64_decode.php.TODO
    ├── base64_encode.php.TODO
    ├── base_convert.php.TODO
    ├── basename.php.TODO
    ├── bin2hex.php.TODO
    ├── bindec.php.TODO
    ├── boolval.php.TODO
    ├── call_user_func.php.TODO
    ├── call_user_func_array.php.TODO
    ├── ceil.php.TODO
    ├── chop.php.TODO
    ├── chr.php.TODO
    ├── chunk_split.php.TODO
    ├── class_exists.php
    ├── convert_cyr_string.php.TODO
    ├── convert_uuencode.php.TODO
    ├── cos.php.TODO
    ├── cosh.php.TODO
    ├── count.php.TODO
    ├── count_chars.php.TODO
    ├── crc32.php.TODO
    ├── current.php.TODO
    ├── decbin.php.TODO
    ├── dechex.php.TODO
    ├── decoct.php.TODO
    ├── deg2rad.php.TODO
    ├── dirname.php.TODO
    ├── doubleval.php.TODO
    ├── end.php.TODO
    ├── escapeshellarg.php.TODO
    ├── exp.php.TODO
    ├── explode.php.TODO
    ├── expm1.php.TODO
    ├── file_get_contents.php.TODO
    ├── floatval.php.TODO
    ├── floor.php.TODO
    ├── fmod.php.TODO
    ├── get_html_translation_table.php.TODO
    ├── getenv.php.TODO
    ├── getrandmax.php.TODO
    ├── gettimeofday.php.TODO
    ├── gettype.php.TODO
    ├── hexdec.php.TODO
    ├── html_entities.php
    ├── html_entity_decode.php.TODO
    ├── htmlentities.php.TODO
    ├── htmlspecialchars.php.TODO
    ├── htmlspecialchars_decode.php.TODO
    ├── http_build_query.php.TODO
    ├── hypot.php.TODO
    ├── implode.php.TODO
    ├── in_array.php
    ├── inet_ntop.php.TODO
    ├── inet_pton.php.TODO
    ├── ini_get.php.TODO
    ├── ini_set.php.TODO
    ├── intval.php.TODO
    ├── ip2long.php.TODO
    ├── is_array.php.TODO
    ├── is_bool.php.TODO
    ├── is_callable.php.TODO
    ├── is_double.php.TODO
    ├── is_finite.php.TODO
    ├── is_float.php.TODO
    ├── is_infinite.php.TODO
    ├── is_int.php.TODO
    ├── is_integer.php.TODO
    ├── is_long.php.TODO
    ├── is_nan.php.TODO
    ├── is_null.php.TODO
    ├── is_numeric.php.TODO
    ├── is_object.php.TODO
    ├── is_real.php.TODO
    ├── is_scalar.php.TODO
    ├── is_string.php.TODO
    ├── join.php.TODO
    ├── key.php.TODO
    ├── krsort.php.TODO
    ├── ksort.php.TODO
    ├── lcfirst.php.TODO
    ├── lcg_value.php.TODO
    ├── levenshtein.php.TODO
    ├── localeconv.php.TODO
    ├── log.php.TODO
    ├── log10.php.TODO
    ├── log1p.php.TODO
    ├── long2ip.php.TODO
    ├── ltrim.php.TODO
    ├── max.php.TODO
    ├── md5.php.TODO
    ├── md5_file.php.TODO
    ├── metaphone.php.TODO
    ├── microtime.php.TODO
    ├── min.php.TODO
    ├── money_format.php.TODO
    ├── mt_getrandmax.php.TODO
    ├── mt_rand.php.TODO
    ├── natcasesort.php.TODO
    ├── natsort.php.TODO
    ├── next.php.TODO
    ├── nl2br.php.TODO
    ├── nl_langinfo.php.TODO
    ├── number_format.php.TODO
    ├── octdec.php.TODO
    ├── ord.php.TODO
    ├── pack.php.TODO
    ├── parse_str.php.TODO
    ├── parse_url.php
    ├── pathinfo.php.TODO
    ├── pi.php.TODO
    ├── pos.php.TODO
    ├── pow.php.TODO
    ├── prev.php.TODO
    ├── print_r.php.TODO
    ├── printf.php.TODO
    ├── quoted_printable_decode.php.TODO
    ├── quoted_printable_encode.php.TODO
    ├── quotemeta.php.TODO
    ├── rad2deg.php.TODO
    ├── rand.php.TODO
    ├── range.php.TODO
    ├── rawurldecode.php.TODO
    ├── rawurlencode.php.TODO
    ├── realpath.php.TODO
    ├── reset.php.TODO
    ├── round.php.TODO
    ├── rsort.php.TODO
    ├── rtrim.php.TODO
    ├── serialize.php.TODO
    ├── set_time_limit.php.TODO
    ├── setcookie.php.TODO
    ├── setlocale.php.TODO
    ├── setrawcookie.php.TODO
    ├── sha1.php.TODO
    ├── sha1_file.php.TODO
    ├── shuffle.php.TODO
    ├── similar_text.php.TODO
    ├── sin.php.TODO
    ├── sinh.php.TODO
    ├── sizeof.php.TODO
    ├── sort.php.TODO
    ├── soundex.php.TODO
    ├── sprintf.php.TODO
    ├── sqrt.php.TODO
    ├── sscanf.php.TODO
    ├── str_getcsv.php.TODO
    ├── str_ireplace.php.TODO
    ├── str_repeat.php.TODO
    ├── str_replace.php.TODO
    ├── str_rot13.php.TODO
    ├── str_shuffle.php.TODO
    ├── str_split.php.TODO
    ├── str_word_count.php.TODO
    ├── strchr.php.TODO
    ├── strcoll.php.TODO
    ├── strcspn.php.TODO
    ├── strip_tags.php.TODO
    ├── stripos.php.TODO
    ├── stripslashes.php.TODO
    ├── stristr.php.TODO
    ├── strnatcasecmp.php.TODO
    ├── strnatcmp.php.TODO
    ├── strpbrk.php.TODO
    ├── strpos.php.TODO
    ├── strptime.php.TODO
    ├── strrchr.php.TODO
    ├── strrev.php.TODO
    ├── strripos.php.TODO
    ├── strrpos.php.TODO
    ├── strspn.php.TODO
    ├── strstr.php.TODO
    ├── strtok.php.TODO
    ├── strtolower.php.TODO
    ├── strtoupper.php.TODO
    ├── strtr.php.TODO
    ├── strval.php.TODO
    ├── substr.php.TODO
    ├── substr_compare.php.TODO
    ├── substr_count.php.TODO
    ├── substr_replace.php.TODO
    ├── tan.php.TODO
    ├── tanh.php.TODO
    ├── trim.php.TODO
    ├── uasort.php.TODO
    ├── ucfirst.php.TODO
    ├── ucwords.php.TODO
    ├── uksort.php.TODO
    ├── uniqid.php.TODO
    ├── unserialize.php.TODO
    ├── urldecode.php.TODO
    ├── urlencode.php.TODO
    ├── usort.php.TODO
    ├── var_dump.php.TODO
    ├── var_export.php.TODO
    ├── version_compare.php.TODO
    ├── vprintf.php.TODO
    ├── vsprintf.php.TODO
    └── wordwrap.php.TODO
├── tests
    ├── AbsTest.php.TODO
    ├── AcosTest.php.TODO
    ├── AcoshTest.php.TODO
    ├── AddcslashesTest.php.TODO
    ├── AddslashesTest.php.TODO
    ├── ArrayChangeKeyCaseTest.php
    ├── ArrayChunkTest.php
    ├── ArrayColumnTest.php
    ├── ArrayCombineTest.php
    ├── ArrayCountValuesTest.php.TODO
    ├── ArrayDiffAssocTest.php.TODO
    ├── ArrayDiffKeyTest.php.TODO
    ├── ArrayDiffTest.php.TODO
    ├── ArrayDiffUassocTest.php.TODO
    ├── ArrayDiffUkeyTest.php.TODO
    ├── ArrayFillKeysTest.php.TODO
    ├── ArrayFillTest.php.TODO
    ├── ArrayFilterTest.php.TODO
    ├── ArrayFlipTest.php.TODO
    ├── ArrayIntersectAssocTest.php.TODO
    ├── ArrayIntersectKeyTest.php.TODO
    ├── ArrayIntersectTest.php.TODO
    ├── ArrayIntersectUassocTest.php.TODO
    ├── ArrayIntersectUkeyTest.php.TODO
    ├── ArrayKeyExistsTest.php.TODO
    ├── ArrayKeysTest.php.TODO
    ├── ArrayMapTest.php.TODO
    ├── ArrayMergeRecursiveTest.php.TODO
    ├── ArrayMergeTest.php.TODO
    ├── ArrayMultisortTest.php.TODO
    ├── ArrayPadTest.php.TODO
    ├── ArrayPopTest.php.TODO
    ├── ArrayProductTest.php.TODO
    ├── ArrayPushTest.php.TODO
    ├── ArrayRandTest.php.TODO
    ├── ArrayReduceTest.php.TODO
    ├── ArrayReplaceRecursiveTest.php.TODO
    ├── ArrayReplaceTest.php.TODO
    ├── ArrayReverseTest.php.TODO
    ├── ArraySearchTest.php.TODO
    ├── ArrayShiftTest.php.TODO
    ├── ArraySliceTest.php.TODO
    ├── ArraySpliceTest.php.TODO
    ├── ArraySumTest.php.TODO
    ├── ArrayUdiffAssocTest.php.TODO
    ├── ArrayUdiffTest.php.TODO
    ├── ArrayUdiffUassocTest.php.TODO
    ├── ArrayUintersectTest.php.TODO
    ├── ArrayUintersectUassocTest.php.TODO
    ├── ArrayUniqueTest.php.TODO
    ├── ArrayUnshiftTest.php.TODO
    ├── ArrayValuesTest.php.TODO
    ├── ArrayWalkTest.php.TODO
    ├── ArsortTest.php.TODO
    ├── AsinTest.php.TODO
    ├── AsinhTest.php.TODO
    ├── AsortTest.php.TODO
    ├── AssertOptionsTest.php.TODO
    ├── Atan2Test.php.TODO
    ├── AtanTest.php.TODO
    ├── AtanhTest.php.TODO
    ├── Base64DecodeTest.php.TODO
    ├── Base64EncodeTest.php.TODO
    ├── BaseConvertTest.php.TODO
    ├── BasenameTest.php.TODO
    ├── Bin2hexTest.php.TODO
    ├── BindecTest.php.TODO
    ├── BoolvalTest.php.TODO
    ├── CallUserFuncArrayTest.php.TODO
    ├── CallUserFuncTest.php.TODO
    ├── CeilTest.php.TODO
    ├── ChopTest.php.TODO
    ├── ChrTest.php.TODO
    ├── ChunkSplitTest.php.TODO
    ├── ClassExistsTest.php
    ├── ConvertCyrStringTest.php.TODO
    ├── ConvertUuencodeTest.php.TODO
    ├── CosTest.php.TODO
    ├── CoshTest.php.TODO
    ├── CountCharsTest.php.TODO
    ├── CountTest.php.TODO
    ├── Crc32Test.php.TODO
    ├── CurrentTest.php.TODO
    ├── DecbinTest.php.TODO
    ├── DechexTest.php.TODO
    ├── DecoctTest.php.TODO
    ├── Deg2radTest.php.TODO
    ├── DirnameTest.php.TODO
    ├── DoublevalTest.php.TODO
    ├── EndTest.php.TODO
    ├── EscapeshellargTest.php.TODO
    ├── ExpTest.php.TODO
    ├── ExplodeTest.php.TODO
    ├── Expm1Test.php.TODO
    ├── FileGetContentsTest.php.TODO
    ├── FloatvalTest.php.TODO
    ├── FloorTest.php.TODO
    ├── FmodTest.php.TODO
    ├── GetHtmlTranslationTableTest.php.TODO
    ├── GetenvTest.php.TODO
    ├── GetrandmaxTest.php.TODO
    ├── GettimeofdayTest.php.TODO
    ├── GettypeTest.php.TODO
    ├── HexdecTest.php.TODO
    ├── HtmlEntitiesTest.php
    ├── HtmlEntityDecodeTest.php.TODO
    ├── HtmlspecialcharsDecodeTest.php.TODO
    ├── HtmlspecialcharsTest.php.TODO
    ├── HttpBuildQueryTest.php.TODO
    ├── HypotTest.php.TODO
    ├── ImplodeTest.php.TODO
    ├── InArrayTest.php
    ├── InetNtopTest.php.TODO
    ├── InetPtonTest.php.TODO
    ├── IniGetTest.php.TODO
    ├── IniSetTest.php.TODO
    ├── IntvalTest.php.TODO
    ├── Ip2longTest.php.TODO
    ├── IsArrayTest.php.TODO
    ├── IsBoolTest.php.TODO
    ├── IsCallableTest.php.TODO
    ├── IsDoubleTest.php.TODO
    ├── IsFiniteTest.php.TODO
    ├── IsFloatTest.php.TODO
    ├── IsInfiniteTest.php.TODO
    ├── IsIntTest.php.TODO
    ├── IsIntegerTest.php.TODO
    ├── IsLongTest.php.TODO
    ├── IsNanTest.php.TODO
    ├── IsNullTest.php.TODO
    ├── IsNumericTest.php.TODO
    ├── IsObjectTest.php.TODO
    ├── IsRealTest.php.TODO
    ├── IsScalarTest.php.TODO
    ├── IsStringTest.php.TODO
    ├── JoinTest.php.TODO
    ├── KeyTest.php.TODO
    ├── KrsortTest.php.TODO
    ├── KsortTest.php.TODO
    ├── LcfirstTest.php.TODO
    ├── LcgValueTest.php.TODO
    ├── LevenshteinTest.php.TODO
    ├── LocaleconvTest.php.TODO
    ├── Log10Test.php.TODO
    ├── Log1pTest.php.TODO
    ├── LogTest.php.TODO
    ├── Long2ipTest.php.TODO
    ├── LtrimTest.php.TODO
    ├── MaxTest.php.TODO
    ├── Md5FileTest.php.TODO
    ├── Md5Test.php.TODO
    ├── MetaphoneTest.php.TODO
    ├── MicrotimeTest.php.TODO
    ├── MinTest.php.TODO
    ├── MoneyFormatTest.php.TODO
    ├── MtGetrandmaxTest.php.TODO
    ├── MtRandTest.php.TODO
    ├── NatcasesortTest.php.TODO
    ├── NatsortTest.php.TODO
    ├── NextTest.php.TODO
    ├── Nl2brTest.php.TODO
    ├── NlLanginfoTest.php.TODO
    ├── NumberFormatTest.php.TODO
    ├── OctdecTest.php.TODO
    ├── OrdTest.php.TODO
    ├── PackTest.php.TODO
    ├── ParseStrTest.php.TODO
    ├── ParseUrlTest.php
    ├── PathinfoTest.php.TODO
    ├── PiTest.php.TODO
    ├── PosTest.php.TODO
    ├── PowTest.php.TODO
    ├── PrevTest.php.TODO
    ├── PrintRTest.php.TODO
    ├── PrintfTest.php.TODO
    ├── QuotedPrintableDecodeTest.php.TODO
    ├── QuotedPrintableEncodeTest.php.TODO
    ├── QuotemetaTest.php.TODO
    ├── Rad2degTest.php.TODO
    ├── RandTest.php.TODO
    ├── RangeTest.php.TODO
    ├── RawurldecodeTest.php.TODO
    ├── RawurlencodeTest.php.TODO
    ├── RealpathTest.php.TODO
    ├── ResetTest.php.TODO
    ├── RoundTest.php.TODO
    ├── RsortTest.php.TODO
    ├── RtrimTest.php.TODO
    ├── SerializeTest.php.TODO
    ├── SetTimeLimitTest.php.TODO
    ├── SetcookieTest.php.TODO
    ├── SetlocaleTest.php.TODO
    ├── SetrawcookieTest.php.TODO
    ├── Sha1FileTest.php.TODO
    ├── Sha1Test.php.TODO
    ├── ShuffleTest.php.TODO
    ├── SimilarTextTest.php.TODO
    ├── SinTest.php.TODO
    ├── SinhTest.php.TODO
    ├── SizeofTest.php.TODO
    ├── SortTest.php.TODO
    ├── SoundexTest.php.TODO
    ├── SprintfTest.php.TODO
    ├── SqrtTest.php.TODO
    ├── SscanfTest.php.TODO
    ├── StrGetcsvTest.php.TODO
    ├── StrIreplaceTest.php.TODO
    ├── StrRepeatTest.php.TODO
    ├── StrReplaceTest.php.TODO
    ├── StrRot13Test.php.TODO
    ├── StrShuffleTest.php.TODO
    ├── StrSplitTest.php.TODO
    ├── StrWordCountTest.php.TODO
    ├── StrchrTest.php.TODO
    ├── StrcollTest.php.TODO
    ├── StrcspnTest.php.TODO
    ├── StripTagsTest.php.TODO
    ├── StriposTest.php.TODO
    ├── StripslashesTest.php.TODO
    ├── StristrTest.php.TODO
    ├── StrnatcasecmpTest.php.TODO
    ├── StrnatcmpTest.php.TODO
    ├── StrpbrkTest.php.TODO
    ├── StrposTest.php.TODO
    ├── StrptimeTest.php.TODO
    ├── StrrchrTest.php.TODO
    ├── StrrevTest.php.TODO
    ├── StrriposTest.php.TODO
    ├── StrrposTest.php.TODO
    ├── StrspnTest.php.TODO
    ├── StrstrTest.php.TODO
    ├── StrtokTest.php.TODO
    ├── StrtolowerTest.php.TODO
    ├── StrtoupperTest.php.TODO
    ├── StrtrTest.php.TODO
    ├── StrvalTest.php.TODO
    ├── SubstrCompareTest.php.TODO
    ├── SubstrCountTest.php.TODO
    ├── SubstrReplaceTest.php.TODO
    ├── SubstrTest.php.TODO
    ├── TanTest.php.TODO
    ├── TanhTest.php.TODO
    ├── TrimTest.php.TODO
    ├── UasortTest.php.TODO
    ├── UcfirstTest.php.TODO
    ├── UcwordsTest.php.TODO
    ├── UksortTest.php.TODO
    ├── UniqidTest.php.TODO
    ├── UnserializeTest.php.TODO
    ├── UrldecodeTest.php.TODO
    ├── UrlencodeTest.php.TODO
    ├── UsortTest.php.TODO
    ├── VarDumpTest.php.TODO
    ├── VarExportTest.php.TODO
    ├── VersionCompareTest.php.TODO
    ├── VprintfTest.php.TODO
    ├── VsprintfTest.php.TODO
    └── WordwrapTest.php.TODO
└── utils
    └── stubs
        ├── README.md
        ├── composer.json
        ├── install.sh
        └── make.php


/.editorconfig:
--------------------------------------------------------------------------------
 1 | # This file is for unifying the coding style for different editors and IDEs
 2 | # editorconfig.org
 3 | 
 4 | # PHP PSR-2 Coding Standards
 5 | # http://www.php-fig.org/psr/psr-2/
 6 | 
 7 | root = true
 8 | 
 9 | [*.php]
10 | charset = utf-8
11 | end_of_line = lf
12 | insert_final_newline = true
13 | trim_trailing_whitespace = true
14 | indent_style = space
15 | indent_size = 4
16 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
 1 | language: php
 2 | 
 3 | php:
 4 |   - 7.0
 5 |   - 7.1
 6 |   - 7.2
 7 | 
 8 | matrix:
 9 |   allow_failures:
10 |     - php: 7.2
11 |   fast_finish: true
12 | 
13 | sudo: false
14 | 
15 | cache:
16 |   directories:
17 |     - $HOME/.composer/cache
18 | 
19 | before_install:
20 |   - if [[ $TRAVIS_PHP_VERSION != 7.2 ]] ; then phpenv config-rm xdebug.ini; fi
21 |   - travis_retry composer self-update
22 | 
23 | install:
24 |   - travis_retry composer install --no-interaction --prefer-dist --no-suggest
25 | 
26 | script:
27 |   - composer run-script phpunit
28 |   - composer run-script phpcs
29 |   - composer run-script build
30 | 


--------------------------------------------------------------------------------
/CONTRIBUTING.md:
--------------------------------------------------------------------------------
1 | Pull requests that add functions must contain no more than a single function, and must include a reference to the related issue. 
2 | 
3 | For instance:
4 | 
5 |     Add `html_entities`, fixes #33
6 |     
7 | See our [milestones](https://github.com/nkkollaw/php/milestones) and [issues](https://github.com/nkkollaw/php/issues) to get started.   
8 | 


--------------------------------------------------------------------------------
/phpunit.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <phpunit backupGlobals="false"
 3 |          backupStaticAttributes="false"
 4 |          bootstrap="vendor/autoload.php"
 5 |          colors="true"
 6 |          convertErrorsToExceptions="true"
 7 |          convertNoticesToExceptions="true"
 8 |          convertWarningsToExceptions="true"
 9 |          processIsolation="false"
10 |          stopOnFailure="false">
11 |     <testsuites>
12 |         <testsuite name="Unit">
13 |             <directory suffix="Test.php">./tests/</directory>
14 |         </testsuite>
15 |     </testsuites>
16 | </phpunit>
17 | 


--------------------------------------------------------------------------------
/src/abs.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\abs()
 8 |  *
 9 |  * @link https://secure.php.net/abs
10 |  *
11 |  * NOTES: same as \abs() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function abs($number)
14 | {
15 |     return \abs($number);
16 | }


--------------------------------------------------------------------------------
/src/acos.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\acos()
 8 |  *
 9 |  * @link https://secure.php.net/acos
10 |  *
11 |  * NOTES: same as \acos() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function acos($arg)
14 | {
15 |     return \acos($arg);
16 | }


--------------------------------------------------------------------------------
/src/acosh.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\acosh()
 8 |  *
 9 |  * @link https://secure.php.net/acosh
10 |  *
11 |  * NOTES: same as \acosh() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function acosh($arg)
14 | {
15 |     return \acosh($arg);
16 | }


--------------------------------------------------------------------------------
/src/addcslashes.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\addcslashes()
 8 |  *
 9 |  * @link https://secure.php.net/addcslashes
10 |  *
11 |  * NOTES: same as \addcslashes() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function addcslashes($str, $charlist)
14 | {
15 |     return \addcslashes($str, $charlist);
16 | }


--------------------------------------------------------------------------------
/src/addslashes.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\addslashes()
 8 |  *
 9 |  * @link https://secure.php.net/addslashes
10 |  *
11 |  * NOTES: same as \addslashes() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function addslashes($str)
14 | {
15 |     return \addslashes($str);
16 | }


--------------------------------------------------------------------------------
/src/array_change_key_case.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\array_change_key_case()
 8 |  *
 9 |  * @link https://secure.php.net/array_change_key_case
10 |  *
11 |  * NOTES: same as \array_change_key_case()
12 | */
13 | function array_change_key_case(array $input, $case = CASE_LOWER)
14 | {
15 |     return \array_change_key_case($input, $case);
16 | }
17 | 


--------------------------------------------------------------------------------
/src/array_chunk.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\array_chunk()
 8 |  *
 9 |  * @link https://secure.php.net/array_chunk
10 |  *
11 |  * NOTES: same as \array_chunk()
12 | */
13 | function array_chunk(array $input, int $size, bool $preserve_keys = false)
14 | {
15 |     return \array_chunk($input, $size, $preserve_keys);
16 | }
17 | 


--------------------------------------------------------------------------------
/src/array_combine.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\array_combine()
 8 |  *
 9 |  * @link https://secure.php.net/array_combine
10 |  *
11 |  * NOTES: same as \array_combine()
12 | */
13 | function array_combine(array $keys, array $values)
14 | {
15 |     return \array_combine($keys, $values);
16 | }
17 | 


--------------------------------------------------------------------------------
/src/array_count_values.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\array_count_values()
 8 |  *
 9 |  * @link https://secure.php.net/array_count_values
10 |  *
11 |  * NOTES: same as \array_count_values()
12 | */
13 | function array_count_values($input)
14 | {
15 |     return \array_count_values($input);
16 | }
17 | 


--------------------------------------------------------------------------------
/src/array_diff.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\array_diff()
 8 |  *
 9 |  * @link https://secure.php.net/array_diff
10 |  *
11 |  * NOTES: same as \array_diff() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function array_diff(array $array1, array $array2, array $_ = null)
14 | {
15 |     return \array_diff();
16 | }


--------------------------------------------------------------------------------
/src/array_diff_assoc.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\array_diff_assoc()
 8 |  *
 9 |  * @link https://secure.php.net/array_diff_assoc
10 |  *
11 |  * NOTES: same as \array_diff_assoc() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function array_diff_assoc(array $array1, array $array2, array $_ = null)
14 | {
15 |     return \array_diff_assoc();
16 | }


--------------------------------------------------------------------------------
/src/array_diff_key.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\array_diff_key()
 8 |  *
 9 |  * @link https://secure.php.net/array_diff_key
10 |  *
11 |  * NOTES: same as \array_diff_key() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function array_diff_key(array $array1, array $array2, array $_ = null)
14 | {
15 |     return \array_diff_key();
16 | }


--------------------------------------------------------------------------------
/src/array_diff_uassoc.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\array_diff_uassoc()
 8 |  *
 9 |  * @link https://secure.php.net/array_diff_uassoc
10 |  *
11 |  * NOTES: same as \array_diff_uassoc() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function array_diff_uassoc(array $array1, array $array2, array $_ = null, $key_compare_func)
14 | {
15 |     return \array_diff_uassoc();
16 | }


--------------------------------------------------------------------------------
/src/array_diff_ukey.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\array_diff_ukey()
 8 |  *
 9 |  * @link https://secure.php.net/array_diff_ukey
10 |  *
11 |  * NOTES: same as \array_diff_ukey() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function array_diff_ukey(array $array1, array $array2, array $_ = null, $key_compare_func)
14 | {
15 |     return \array_diff_ukey();
16 | }


--------------------------------------------------------------------------------
/src/array_fill.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\array_fill()
 8 |  *
 9 |  * @link https://secure.php.net/array_fill
10 |  *
11 |  * NOTES: same as \array_fill()
12 | */
13 | function array_fill($start_index, $num, $value)
14 | {
15 |     return \array_fill($start_index, $num, $value);
16 | }
17 | 


--------------------------------------------------------------------------------
/src/array_fill_keys.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\array_fill_keys()
 8 |  *
 9 |  * @link https://secure.php.net/array_fill_keys
10 |  *
11 |  * NOTES: same as \array_fill_keys()
12 | */
13 | function array_fill_keys($keys, $value)
14 | {
15 |     return \array_fill_keys($keys, $value);
16 | }
17 | 


--------------------------------------------------------------------------------
/src/array_filter.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\array_filter()
 8 |  *
 9 |  * @link https://secure.php.net/array_filter
10 |  *
11 |  * NOTES: same as \array_filter() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function array_filter(array $input, $callback = null, $flag = 0)
14 | {
15 |     return \array_filter();
16 | }


--------------------------------------------------------------------------------
/src/array_flip.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\array_flip()
 8 |  *
 9 |  * @link https://secure.php.net/array_flip
10 |  *
11 |  * NOTES: same as \array_flip()
12 | */
13 | function array_flip($array)
14 | {
15 |     return \array_flip($array);
16 | }
17 | 


--------------------------------------------------------------------------------
/src/array_intersect.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\array_intersect()
 8 |  *
 9 |  * @link https://secure.php.net/array_intersect
10 |  *
11 |  * NOTES: same as \array_intersect() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function array_intersect(array $array1, array $array2, array $_ = null)
14 | {
15 |     return \array_intersect();
16 | }


--------------------------------------------------------------------------------
/src/array_intersect_assoc.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\array_intersect_assoc()
 8 |  *
 9 |  * @link https://secure.php.net/array_intersect_assoc
10 |  *
11 |  * NOTES: same as \array_intersect_assoc() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function array_intersect_assoc(array $array1, array $array2, array $_ = null)
14 | {
15 |     return \array_intersect_assoc();
16 | }


--------------------------------------------------------------------------------
/src/array_intersect_key.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\array_intersect_key()
 8 |  *
 9 |  * @link https://secure.php.net/array_intersect_key
10 |  *
11 |  * NOTES: same as \array_intersect_key() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function array_intersect_key(array $array1, array $array2, array $_ = null)
14 | {
15 |     return \array_intersect_key();
16 | }


--------------------------------------------------------------------------------
/src/array_intersect_uassoc.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\array_intersect_uassoc()
 8 |  *
 9 |  * @link https://secure.php.net/array_intersect_uassoc
10 |  *
11 |  * NOTES: same as \array_intersect_uassoc() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function array_intersect_uassoc(array $array1, array $array2, array $_ = null, $key_compare_func)
14 | {
15 |     return \array_intersect_uassoc();
16 | }


--------------------------------------------------------------------------------
/src/array_intersect_ukey.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\array_intersect_ukey()
 8 |  *
 9 |  * @link https://secure.php.net/array_intersect_ukey
10 |  *
11 |  * NOTES: same as \array_intersect_ukey() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function array_intersect_ukey(array $array1, array $array2, array $_ = null, $key_compare_func)
14 | {
15 |     return \array_intersect_ukey();
16 | }


--------------------------------------------------------------------------------
/src/array_key_exists.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\array_key_exists()
 8 |  *
 9 |  * @link https://secure.php.net/array_key_exists
10 |  *
11 |  * NOTES: in Zubr, the $array parameter comes before $key
12 | */
13 | function array_key_exists($array, $key)
14 | {
15 |     return \array_key_exists($key, $array);
16 | }
17 | 


--------------------------------------------------------------------------------
/src/array_keys.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\array_keys()
 8 |  *
 9 |  * @link https://secure.php.net/array_keys
10 |  *
11 |  * NOTES: same as \array_keys()
12 | */
13 | function array_keys(array $input, $search_value = null, $strict = false)
14 | {
15 |     return \array_keys($input, $search_value, $strict);
16 | }
17 | 


--------------------------------------------------------------------------------
/src/array_map.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\array_map()
 8 |  *
 9 |  * @link https://secure.php.net/array_map
10 |  *
11 |  * NOTES: same as \array_map() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function array_map($callback, array $arr1, array $_ = null)
14 | {
15 |     return \array_map();
16 | }


--------------------------------------------------------------------------------
/src/array_merge.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\array_merge()
 8 |  *
 9 |  * @link https://secure.php.net/array_merge
10 |  *
11 |  * NOTES: same as \array_merge() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function array_merge(array $array1, array $array2 = null, array $_ = null)
14 | {
15 |     return \array_merge(array $array1, array $array2 = null, array $_ = null);
16 | }


--------------------------------------------------------------------------------
/src/array_merge_recursive.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\array_merge_recursive()
 8 |  *
 9 |  * @link https://secure.php.net/array_merge_recursive
10 |  *
11 |  * NOTES: same as \array_merge_recursive() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function array_merge_recursive(array $array1, array $_ = null)
14 | {
15 |     return \array_merge_recursive();
16 | }


--------------------------------------------------------------------------------
/src/array_multisort.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\array_multisort()
 8 |  *
 9 |  * @link https://secure.php.net/array_multisort
10 |  *
11 |  * NOTES: same as \array_multisort() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function array_multisort(array &$arr, $arg = null, $arg = null, $_ = null)
14 | {
15 |     return \array_multisort(array &$arr, $arg = null, $arg = null, $_ = null);
16 | }


--------------------------------------------------------------------------------
/src/array_pad.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\array_pad()
 8 |  *
 9 |  * @link https://secure.php.net/array_pad
10 |  *
11 |  * NOTES: same as \array_pad() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function array_pad(array $input, $pad_size, $pad_value)
14 | {
15 |     return \array_pad();
16 | }


--------------------------------------------------------------------------------
/src/array_pop.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\array_pop()
 8 |  *
 9 |  * @link https://secure.php.net/array_pop
10 |  *
11 |  * NOTES: same as \array_pop() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function array_pop(array &$array)
14 | {
15 |     return \array_pop(array &$array);
16 | }


--------------------------------------------------------------------------------
/src/array_product.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\array_product()
 8 |  *
 9 |  * @link https://secure.php.net/array_product
10 |  *
11 |  * NOTES: same as \array_product() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function array_product(array $array)
14 | {
15 |     return \array_product();
16 | }


--------------------------------------------------------------------------------
/src/array_push.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\array_push()
 8 |  *
 9 |  * @link https://secure.php.net/array_push
10 |  *
11 |  * NOTES: same as \array_push() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function array_push(array &$array, $var, $_ = null)
14 | {
15 |     return \array_push(array &$array, $var, $_ = null);
16 | }


--------------------------------------------------------------------------------
/src/array_rand.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\array_rand()
 8 |  *
 9 |  * @link https://secure.php.net/array_rand
10 |  *
11 |  * NOTES: same as \array_rand() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function array_rand(array $input, $num_req = null)
14 | {
15 |     return \array_rand();
16 | }


--------------------------------------------------------------------------------
/src/array_reduce.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\array_reduce()
 8 |  *
 9 |  * @link https://secure.php.net/array_reduce
10 |  *
11 |  * NOTES: same as \array_reduce() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function array_reduce(array $input, $function, $initial = null)
14 | {
15 |     return \array_reduce();
16 | }


--------------------------------------------------------------------------------
/src/array_replace.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\array_replace()
 8 |  *
 9 |  * @link https://secure.php.net/array_replace
10 |  *
11 |  * NOTES: same as \array_replace() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function array_replace(array $array, array $array1, array $array2 = null, array $_ = null)
14 | {
15 |     return \array_replace();
16 | }


--------------------------------------------------------------------------------
/src/array_replace_recursive.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\array_replace_recursive()
 8 |  *
 9 |  * @link https://secure.php.net/array_replace_recursive
10 |  *
11 |  * NOTES: same as \array_replace_recursive() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function array_replace_recursive(array $array, array $array1, array $array2 = null, array $_ = null)
14 | {
15 |     return \array_replace_recursive();
16 | }


--------------------------------------------------------------------------------
/src/array_reverse.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\array_reverse()
 8 |  *
 9 |  * @link https://secure.php.net/array_reverse
10 |  *
11 |  * NOTES: same as \array_reverse() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function array_reverse(array $array, $preserve_keys = null)
14 | {
15 |     return \array_reverse();
16 | }


--------------------------------------------------------------------------------
/src/array_search.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\array_search()
 8 |  *
 9 |  * @link https://secure.php.net/array_search
10 |  *
11 |  * NOTES: same as \array_search() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function array_search($needle, array $haystack, $strict = null)
14 | {
15 |     return \array_search($needle, array $haystack, $strict = null);
16 | }


--------------------------------------------------------------------------------
/src/array_shift.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\array_shift()
 8 |  *
 9 |  * @link https://secure.php.net/array_shift
10 |  *
11 |  * NOTES: same as \array_shift() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function array_shift(array &$array)
14 | {
15 |     return \array_shift(array &$array);
16 | }


--------------------------------------------------------------------------------
/src/array_slice.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\array_slice()
 8 |  *
 9 |  * @link https://secure.php.net/array_slice
10 |  *
11 |  * NOTES: same as \array_slice() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function array_slice(array $array, $offset, $length = null, $preserve_keys = false)
14 | {
15 |     return \array_slice(array $array, $offset, $length = null, $preserve_keys = false);
16 | }


--------------------------------------------------------------------------------
/src/array_splice.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\array_splice()
 8 |  *
 9 |  * @link https://secure.php.net/array_splice
10 |  *
11 |  * NOTES: same as \array_splice() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function array_splice(array &$input, $offset, $length = null, $replacement = null)
14 | {
15 |     return \array_splice(array &$input, $offset, $length = null, $replacement = null);
16 | }


--------------------------------------------------------------------------------
/src/array_sum.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\array_sum()
 8 |  *
 9 |  * @link https://secure.php.net/array_sum
10 |  *
11 |  * NOTES: same as \array_sum() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function array_sum(array $array)
14 | {
15 |     return \array_sum();
16 | }


--------------------------------------------------------------------------------
/src/array_udiff.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\array_udiff()
 8 |  *
 9 |  * @link https://secure.php.net/array_udiff
10 |  *
11 |  * NOTES: same as \array_udiff() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function array_udiff(array $array1, array $array2, array $_ = null, $data_compare_func)
14 | {
15 |     return \array_udiff();
16 | }


--------------------------------------------------------------------------------
/src/array_udiff_assoc.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\array_udiff_assoc()
 8 |  *
 9 |  * @link https://secure.php.net/array_udiff_assoc
10 |  *
11 |  * NOTES: same as \array_udiff_assoc() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function array_udiff_assoc(array $array1, array $array2, array $_ = null, $data_compare_func)
14 | {
15 |     return \array_udiff_assoc();
16 | }


--------------------------------------------------------------------------------
/src/array_udiff_uassoc.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\array_udiff_uassoc()
 8 |  *
 9 |  * @link https://secure.php.net/array_udiff_uassoc
10 |  *
11 |  * NOTES: same as \array_udiff_uassoc() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function array_udiff_uassoc(array $array1, array $array2, array $_ = null, $data_compare_func, $key_compare_func)
14 | {
15 |     return \array_udiff_uassoc();
16 | }


--------------------------------------------------------------------------------
/src/array_uintersect.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\array_uintersect()
 8 |  *
 9 |  * @link https://secure.php.net/array_uintersect
10 |  *
11 |  * NOTES: same as \array_uintersect() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function array_uintersect(array $array1, array $array2, array $_ = null, $data_compare_func)
14 | {
15 |     return \array_uintersect();
16 | }


--------------------------------------------------------------------------------
/src/array_uintersect_uassoc.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\array_uintersect_uassoc()
 8 |  *
 9 |  * @link https://secure.php.net/array_uintersect_uassoc
10 |  *
11 |  * NOTES: same as \array_uintersect_uassoc() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function array_uintersect_uassoc(array $array1, array $array2, array $_ = null, $data_compare_func, $key_compare_func)
14 | {
15 |     return \array_uintersect_uassoc();
16 | }


--------------------------------------------------------------------------------
/src/array_unique.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\array_unique()
 8 |  *
 9 |  * @link https://secure.php.net/array_unique
10 |  *
11 |  * NOTES: same as \array_unique() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function array_unique(array $array, $sort_flags = null)
14 | {
15 |     return \array_unique();
16 | }


--------------------------------------------------------------------------------
/src/array_unshift.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\array_unshift()
 8 |  *
 9 |  * @link https://secure.php.net/array_unshift
10 |  *
11 |  * NOTES: same as \array_unshift() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function array_unshift(array &$array, $var, $_ = null)
14 | {
15 |     return \array_unshift(array &$array, $var, $_ = null);
16 | }


--------------------------------------------------------------------------------
/src/array_values.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\array_values()
 8 |  *
 9 |  * @link https://secure.php.net/array_values
10 |  *
11 |  * NOTES: same as \array_values() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function array_values(array $input)
14 | {
15 |     return \array_values();
16 | }


--------------------------------------------------------------------------------
/src/array_walk.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\array_walk()
 8 |  *
 9 |  * @link https://secure.php.net/array_walk
10 |  *
11 |  * NOTES: same as \array_walk() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function array_walk(array &$array, $funcname, $userdata = null)
14 | {
15 |     return \array_walk(array &$array, $funcname, $userdata = null);
16 | }


--------------------------------------------------------------------------------
/src/arsort.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\arsort()
 8 |  *
 9 |  * @link https://secure.php.net/arsort
10 |  *
11 |  * NOTES: same as \arsort() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function arsort(array &$array, $sort_flags = null)
14 | {
15 |     return \arsort(array &$array, $sort_flags = null);
16 | }


--------------------------------------------------------------------------------
/src/asin.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\asin()
 8 |  *
 9 |  * @link https://secure.php.net/asin
10 |  *
11 |  * NOTES: same as \asin() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function asin($arg)
14 | {
15 |     return \asin($arg);
16 | }


--------------------------------------------------------------------------------
/src/asinh.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\asinh()
 8 |  *
 9 |  * @link https://secure.php.net/asinh
10 |  *
11 |  * NOTES: same as \asinh() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function asinh($arg)
14 | {
15 |     return \asinh($arg);
16 | }


--------------------------------------------------------------------------------
/src/asort.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\asort()
 8 |  *
 9 |  * @link https://secure.php.net/asort
10 |  *
11 |  * NOTES: same as \asort() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function asort(array &$array, $sort_flags = null)
14 | {
15 |     return \asort(array &$array, $sort_flags = null);
16 | }


--------------------------------------------------------------------------------
/src/assert_options.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\assert_options()
 8 |  *
 9 |  * @link https://secure.php.net/assert_options
10 |  *
11 |  * NOTES: same as \assert_options() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function assert_options($what, $value = null)
14 | {
15 |     return \assert_options();
16 | }


--------------------------------------------------------------------------------
/src/atan.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\atan()
 8 |  *
 9 |  * @link https://secure.php.net/atan
10 |  *
11 |  * NOTES: same as \atan() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function atan($arg)
14 | {
15 |     return \atan($arg);
16 | }


--------------------------------------------------------------------------------
/src/atan2.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\atan2()
 8 |  *
 9 |  * @link https://secure.php.net/atan2
10 |  *
11 |  * NOTES: same as \atan2() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function atan2($y, $x)
14 | {
15 |     return \atan2($y, $x);
16 | }


--------------------------------------------------------------------------------
/src/atanh.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\atanh()
 8 |  *
 9 |  * @link https://secure.php.net/atanh
10 |  *
11 |  * NOTES: same as \atanh() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function atanh($arg)
14 | {
15 |     return \atanh($arg);
16 | }


--------------------------------------------------------------------------------
/src/base64_decode.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\base64_decode()
 8 |  *
 9 |  * @link https://secure.php.net/base64_decode
10 |  *
11 |  * NOTES: same as \base64_decode() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function base64_decode($data, $strict = null)
14 | {
15 |     return \base64_decode($data, $strict = null);
16 | }


--------------------------------------------------------------------------------
/src/base64_encode.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\base64_encode()
 8 |  *
 9 |  * @link https://secure.php.net/base64_encode
10 |  *
11 |  * NOTES: same as \base64_encode() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function base64_encode($data)
14 | {
15 |     return \base64_encode($data);
16 | }


--------------------------------------------------------------------------------
/src/base_convert.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\base_convert()
 8 |  *
 9 |  * @link https://secure.php.net/base_convert
10 |  *
11 |  * NOTES: same as \base_convert() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function base_convert($number, $frombase, $tobase)
14 | {
15 |     return \base_convert($number, $frombase, $tobase);
16 | }


--------------------------------------------------------------------------------
/src/basename.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\basename()
 8 |  *
 9 |  * @link https://secure.php.net/basename
10 |  *
11 |  * NOTES: same as \basename() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function basename($path, $suffix = null)
14 | {
15 |     return \basename($path, $suffix = null);
16 | }


--------------------------------------------------------------------------------
/src/bin2hex.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\bin2hex()
 8 |  *
 9 |  * @link https://secure.php.net/bin2hex
10 |  *
11 |  * NOTES: same as \bin2hex() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function bin2hex($str)
14 | {
15 |     return \bin2hex($str);
16 | }


--------------------------------------------------------------------------------
/src/bindec.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\bindec()
 8 |  *
 9 |  * @link https://secure.php.net/bindec
10 |  *
11 |  * NOTES: same as \bindec() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function bindec($binary_string)
14 | {
15 |     return \bindec($binary_string);
16 | }


--------------------------------------------------------------------------------
/src/boolval.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\boolval()
 8 |  *
 9 |  * @link https://secure.php.net/boolval
10 |  *
11 |  * NOTES: same as \boolval() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function boolval($var)
14 | {
15 |     return \boolval();
16 | }


--------------------------------------------------------------------------------
/src/call_user_func.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\call_user_func()
 8 |  *
 9 |  * @link https://secure.php.net/call_user_func
10 |  *
11 |  * NOTES: same as \call_user_func() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function call_user_func($function, $parameter = null, $_ = null)
14 | {
15 |     return \call_user_func($function, $parameter = null, $_ = null);
16 | }


--------------------------------------------------------------------------------
/src/call_user_func_array.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\call_user_func_array()
 8 |  *
 9 |  * @link https://secure.php.net/call_user_func_array
10 |  *
11 |  * NOTES: same as \call_user_func_array() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function call_user_func_array($function, array $param_arr)
14 | {
15 |     return \call_user_func_array($function, array $param_arr);
16 | }


--------------------------------------------------------------------------------
/src/ceil.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\ceil()
 8 |  *
 9 |  * @link https://secure.php.net/ceil
10 |  *
11 |  * NOTES: same as \ceil() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function ceil($value)
14 | {
15 |     return \ceil($value);
16 | }


--------------------------------------------------------------------------------
/src/chop.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\chop()
 8 |  *
 9 |  * @link https://secure.php.net/chop
10 |  *
11 |  * NOTES: same as \chop() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function chop($str, $character_mask)
14 | {
15 |     return \chop($str, $character_mask);
16 | }


--------------------------------------------------------------------------------
/src/chr.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\chr()
 8 |  *
 9 |  * @link https://secure.php.net/chr
10 |  *
11 |  * NOTES: same as \chr() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function chr($ascii)
14 | {
15 |     return \chr($ascii);
16 | }


--------------------------------------------------------------------------------
/src/chunk_split.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\chunk_split()
 8 |  *
 9 |  * @link https://secure.php.net/chunk_split
10 |  *
11 |  * NOTES: same as \chunk_split() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function chunk_split($body, $chunklen = null, $end = null)
14 | {
15 |     return \chunk_split($body, $chunklen = null, $end = null);
16 | }


--------------------------------------------------------------------------------
/src/class_exists.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Zubr;
 4 | 
 5 | /**
 6 |  * Checks if the class has been defined
 7 |  *
 8 |  * @param string $className
 9 |  * @param bool $autoload
10 |  * @return bool
11 |  * @see \class_exists
12 |  */
13 | function class_exists(string $className, bool $autoload = true): bool
14 | {
15 |     return \class_exists($className, $autoload);
16 | }
17 | 


--------------------------------------------------------------------------------
/src/convert_cyr_string.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\convert_cyr_string()
 8 |  *
 9 |  * @link https://secure.php.net/convert_cyr_string
10 |  *
11 |  * NOTES: same as \convert_cyr_string() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function convert_cyr_string($str, $from, $to)
14 | {
15 |     return \convert_cyr_string($str, $from, $to);
16 | }


--------------------------------------------------------------------------------
/src/convert_uuencode.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\convert_uuencode()
 8 |  *
 9 |  * @link https://secure.php.net/convert_uuencode
10 |  *
11 |  * NOTES: same as \convert_uuencode() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function convert_uuencode($data)
14 | {
15 |     return \convert_uuencode($data);
16 | }


--------------------------------------------------------------------------------
/src/cos.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\cos()
 8 |  *
 9 |  * @link https://secure.php.net/cos
10 |  *
11 |  * NOTES: same as \cos() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function cos($arg)
14 | {
15 |     return \cos($arg);
16 | }


--------------------------------------------------------------------------------
/src/cosh.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\cosh()
 8 |  *
 9 |  * @link https://secure.php.net/cosh
10 |  *
11 |  * NOTES: same as \cosh() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function cosh($arg)
14 | {
15 |     return \cosh($arg);
16 | }


--------------------------------------------------------------------------------
/src/count.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\count()
 8 |  *
 9 |  * @link https://secure.php.net/count
10 |  *
11 |  * NOTES: same as \count() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function count($var, $mode = COUNT_NORMAL)
14 | {
15 |     return \count($var, $mode = COUNT_NORMAL);
16 | }


--------------------------------------------------------------------------------
/src/count_chars.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\count_chars()
 8 |  *
 9 |  * @link https://secure.php.net/count_chars
10 |  *
11 |  * NOTES: same as \count_chars() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function count_chars($string, $mode = null)
14 | {
15 |     return \count_chars($string, $mode = null);
16 | }


--------------------------------------------------------------------------------
/src/crc32.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\crc32()
 8 |  *
 9 |  * @link https://secure.php.net/crc32
10 |  *
11 |  * NOTES: same as \crc32() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function crc32($str)
14 | {
15 |     return \crc32($str);
16 | }


--------------------------------------------------------------------------------
/src/current.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\current()
 8 |  *
 9 |  * @link https://secure.php.net/current
10 |  *
11 |  * NOTES: same as \current() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function current(array $array)
14 | {
15 |     return \current(array $array);
16 | }


--------------------------------------------------------------------------------
/src/decbin.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\decbin()
 8 |  *
 9 |  * @link https://secure.php.net/decbin
10 |  *
11 |  * NOTES: same as \decbin() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function decbin($number)
14 | {
15 |     return \decbin($number);
16 | }


--------------------------------------------------------------------------------
/src/dechex.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\dechex()
 8 |  *
 9 |  * @link https://secure.php.net/dechex
10 |  *
11 |  * NOTES: same as \dechex() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function dechex($number)
14 | {
15 |     return \dechex($number);
16 | }


--------------------------------------------------------------------------------
/src/decoct.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\decoct()
 8 |  *
 9 |  * @link https://secure.php.net/decoct
10 |  *
11 |  * NOTES: same as \decoct() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function decoct($number)
14 | {
15 |     return \decoct($number);
16 | }


--------------------------------------------------------------------------------
/src/deg2rad.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\deg2rad()
 8 |  *
 9 |  * @link https://secure.php.net/deg2rad
10 |  *
11 |  * NOTES: same as \deg2rad() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function deg2rad($number)
14 | {
15 |     return \deg2rad($number);
16 | }


--------------------------------------------------------------------------------
/src/dirname.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\dirname()
 8 |  *
 9 |  * @link https://secure.php.net/dirname
10 |  *
11 |  * NOTES: same as \dirname() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function dirname($path, $levels = 1)
14 | {
15 |     return \dirname($path, $levels = 1);
16 | }


--------------------------------------------------------------------------------
/src/doubleval.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\doubleval()
 8 |  *
 9 |  * @link https://secure.php.net/doubleval
10 |  *
11 |  * NOTES: same as \doubleval() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function doubleval($var)
14 | {
15 |     return \doubleval($var);
16 | }


--------------------------------------------------------------------------------
/src/end.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\end()
 8 |  *
 9 |  * @link https://secure.php.net/end
10 |  *
11 |  * NOTES: same as \end() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function end(array &$array)
14 | {
15 |     return \end(array &$array);
16 | }


--------------------------------------------------------------------------------
/src/escapeshellarg.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\escapeshellarg()
 8 |  *
 9 |  * @link https://secure.php.net/escapeshellarg
10 |  *
11 |  * NOTES: same as \escapeshellarg() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function escapeshellarg($arg)
14 | {
15 |     return \escapeshellarg($arg);
16 | }


--------------------------------------------------------------------------------
/src/exp.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\exp()
 8 |  *
 9 |  * @link https://secure.php.net/exp
10 |  *
11 |  * NOTES: same as \exp() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function exp($arg)
14 | {
15 |     return \exp($arg);
16 | }


--------------------------------------------------------------------------------
/src/explode.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\explode()
 8 |  *
 9 |  * @link https://secure.php.net/explode
10 |  *
11 |  * NOTES: same as \explode() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function explode($delimiter, $string, $limit = null)
14 | {
15 |     return \explode($delimiter, $string, $limit = null);
16 | }


--------------------------------------------------------------------------------
/src/expm1.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\expm1()
 8 |  *
 9 |  * @link https://secure.php.net/expm1
10 |  *
11 |  * NOTES: same as \expm1() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function expm1($arg)
14 | {
15 |     return \expm1($arg);
16 | }


--------------------------------------------------------------------------------
/src/file_get_contents.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\file_get_contents()
 8 |  *
 9 |  * @link https://secure.php.net/file_get_contents
10 |  *
11 |  * NOTES: same as \file_get_contents() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function file_get_contents($filename, $use_include_path = false, $context = null, $offset = 0, $maxlen = null)
14 | {
15 |     return \file_get_contents($filename, $use_include_path = false, $context = null, $offset = 0, $maxlen = null);
16 | }


--------------------------------------------------------------------------------
/src/floatval.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\floatval()
 8 |  *
 9 |  * @link https://secure.php.net/floatval
10 |  *
11 |  * NOTES: same as \floatval() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function floatval($var)
14 | {
15 |     return \floatval($var);
16 | }


--------------------------------------------------------------------------------
/src/floor.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\floor()
 8 |  *
 9 |  * @link https://secure.php.net/floor
10 |  *
11 |  * NOTES: same as \floor() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function floor($value)
14 | {
15 |     return \floor($value);
16 | }


--------------------------------------------------------------------------------
/src/fmod.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\fmod()
 8 |  *
 9 |  * @link https://secure.php.net/fmod
10 |  *
11 |  * NOTES: same as \fmod() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function fmod($x, $y)
14 | {
15 |     return \fmod($x, $y);
16 | }


--------------------------------------------------------------------------------
/src/get_html_translation_table.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\get_html_translation_table()
 8 |  *
 9 |  * @link https://secure.php.net/get_html_translation_table
10 |  *
11 |  * NOTES: same as \get_html_translation_table() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function get_html_translation_table($table = null, $quote_style = null)
14 | {
15 |     return \get_html_translation_table($table = null, $quote_style = null);
16 | }


--------------------------------------------------------------------------------
/src/getenv.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\getenv()
 8 |  *
 9 |  * @link https://secure.php.net/getenv
10 |  *
11 |  * NOTES: same as \getenv() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function getenv($varname = null, $local_only = false)
14 | {
15 |     return \getenv($varname = null, $local_only = false);
16 | }


--------------------------------------------------------------------------------
/src/getrandmax.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\getrandmax()
 8 |  *
 9 |  * @link https://secure.php.net/getrandmax
10 |  *
11 |  * NOTES: same as \getrandmax() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function getrandmax()
14 | {
15 |     return \getrandmax();
16 | }


--------------------------------------------------------------------------------
/src/gettimeofday.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\gettimeofday()
 8 |  *
 9 |  * @link https://secure.php.net/gettimeofday
10 |  *
11 |  * NOTES: same as \gettimeofday() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function gettimeofday($return_float = null)
14 | {
15 |     return \gettimeofday($return_float = null);
16 | }


--------------------------------------------------------------------------------
/src/gettype.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\gettype()
 8 |  *
 9 |  * @link https://secure.php.net/gettype
10 |  *
11 |  * NOTES: same as \gettype() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function gettype($var)
14 | {
15 |     return \gettype($var);
16 | }


--------------------------------------------------------------------------------
/src/hexdec.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\hexdec()
 8 |  *
 9 |  * @link https://secure.php.net/hexdec
10 |  *
11 |  * NOTES: same as \hexdec() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function hexdec($hex_string)
14 | {
15 |     return \hexdec($hex_string);
16 | }


--------------------------------------------------------------------------------
/src/html_entities.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Zubr;
 4 | 
 5 | /**
 6 |  * Convert all applicable characters to HTML entities
 7 |  *
 8 |  * @see \htmlentities
 9 |  * @param string $string
10 |  * @param int $flags
11 |  * @param string $encoding
12 |  * @param bool $doubleEncode
13 |  * @return string
14 |  */
15 | function html_entities(
16 |     string $string,
17 |     int $flags = ENT_COMPAT | ENT_HTML401,
18 |     string $encoding = null,
19 |     bool $doubleEncode = true
20 | ): string {
21 |     $encoding = $encoding ?? ini_get('default_charset');
22 |     return \htmlentities($string, $flags, $encoding, $doubleEncode);
23 | }
24 | 


--------------------------------------------------------------------------------
/src/html_entity_decode.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\html_entity_decode()
 8 |  *
 9 |  * @link https://secure.php.net/html_entity_decode
10 |  *
11 |  * NOTES: same as \html_entity_decode() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function html_entity_decode($string, $quote_style = null, $charset = null)
14 | {
15 |     return \html_entity_decode($string, $quote_style = null, $charset = null);
16 | }


--------------------------------------------------------------------------------
/src/htmlentities.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\htmlentities()
 8 |  *
 9 |  * @link https://secure.php.net/htmlentities
10 |  *
11 |  * NOTES: same as \htmlentities() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function htmlentities($string, $quote_style = null, $charset = null, $double_encode = true)
14 | {
15 |     return \htmlentities($string, $quote_style = null, $charset = null, $double_encode = true);
16 | }


--------------------------------------------------------------------------------
/src/htmlspecialchars.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\htmlspecialchars()
 8 |  *
 9 |  * @link https://secure.php.net/htmlspecialchars
10 |  *
11 |  * NOTES: same as \htmlspecialchars() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function htmlspecialchars($string, $flags = ENT_COMPAT, $encoding = 'UTF-8', $double_encode = true)
14 | {
15 |     return \htmlspecialchars($string, $flags = ENT_COMPAT, $encoding = 'UTF-8', $double_encode = true);
16 | }


--------------------------------------------------------------------------------
/src/htmlspecialchars_decode.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\htmlspecialchars_decode()
 8 |  *
 9 |  * @link https://secure.php.net/htmlspecialchars_decode
10 |  *
11 |  * NOTES: same as \htmlspecialchars_decode() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function htmlspecialchars_decode($string, $quote_style = null)
14 | {
15 |     return \htmlspecialchars_decode($string, $quote_style = null);
16 | }


--------------------------------------------------------------------------------
/src/http_build_query.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\http_build_query()
 8 |  *
 9 |  * @link https://secure.php.net/http_build_query
10 |  *
11 |  * NOTES: same as \http_build_query() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function http_build_query($query_data, $numeric_prefix = null, $arg_separator = null, $enc_type = PHP_QUERY_RFC1738){}


--------------------------------------------------------------------------------
/src/hypot.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\hypot()
 8 |  *
 9 |  * @link https://secure.php.net/hypot
10 |  *
11 |  * NOTES: same as \hypot() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function hypot($x, $y)
14 | {
15 |     return \hypot($x, $y);
16 | }


--------------------------------------------------------------------------------
/src/implode.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\implode()
 8 |  *
 9 |  * @link https://secure.php.net/implode
10 |  *
11 |  * NOTES: same as \implode() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function implode($glue = "", array $pieces)
14 | {
15 |     return \implode($glue = "", array $pieces);
16 | }


--------------------------------------------------------------------------------
/src/in_array.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Zubr;
 4 | 
 5 | /**
 6 |  * Checks if a value exists in an array
 7 |  *
 8 |  * @param array $haystack
 9 |  * @param mixed $needle
10 |  * @param bool $strict
11 |  * @return bool
12 |  * @see \in_array
13 |  */
14 | function in_array(array $haystack, $needle, bool $strict = false): bool
15 | {
16 |     return \in_array($needle, $haystack, $strict);
17 | }
18 | 


--------------------------------------------------------------------------------
/src/inet_ntop.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\inet_ntop()
 8 |  *
 9 |  * @link https://secure.php.net/inet_ntop
10 |  *
11 |  * NOTES: same as \inet_ntop() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function inet_ntop($in_addr)
14 | {
15 |     return \inet_ntop($in_addr);
16 | }


--------------------------------------------------------------------------------
/src/inet_pton.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\inet_pton()
 8 |  *
 9 |  * @link https://secure.php.net/inet_pton
10 |  *
11 |  * NOTES: same as \inet_pton() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function inet_pton($address)
14 | {
15 |     return \inet_pton($address);
16 | }


--------------------------------------------------------------------------------
/src/ini_get.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\ini_get()
 8 |  *
 9 |  * @link https://secure.php.net/ini_get
10 |  *
11 |  * NOTES: same as \ini_get() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function ini_get($varname)
14 | {
15 |     return \ini_get($varname);
16 | }


--------------------------------------------------------------------------------
/src/ini_set.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\ini_set()
 8 |  *
 9 |  * @link https://secure.php.net/ini_set
10 |  *
11 |  * NOTES: same as \ini_set() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function ini_set($varname, $newvalue)
14 | {
15 |     return \ini_set($varname, $newvalue);
16 | }


--------------------------------------------------------------------------------
/src/intval.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\intval()
 8 |  *
 9 |  * @link https://secure.php.net/intval
10 |  *
11 |  * NOTES: same as \intval() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function intval($var, $base = null)
14 | {
15 |     return \intval($var, $base = null);
16 | }


--------------------------------------------------------------------------------
/src/ip2long.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\ip2long()
 8 |  *
 9 |  * @link https://secure.php.net/ip2long
10 |  *
11 |  * NOTES: same as \ip2long() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function ip2long($ip_address)
14 | {
15 |     return \ip2long($ip_address);
16 | }


--------------------------------------------------------------------------------
/src/is_array.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\is_array()
 8 |  *
 9 |  * @link https://secure.php.net/is_array
10 |  *
11 |  * NOTES: same as \is_array() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function is_array($var)
14 | {
15 |     return \is_array($var);
16 | }


--------------------------------------------------------------------------------
/src/is_bool.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\is_bool()
 8 |  *
 9 |  * @link https://secure.php.net/is_bool
10 |  *
11 |  * NOTES: same as \is_bool() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function is_bool($var)
14 | {
15 |     return \is_bool($var);
16 | }


--------------------------------------------------------------------------------
/src/is_callable.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\is_callable()
 8 |  *
 9 |  * @link https://secure.php.net/is_callable
10 |  *
11 |  * NOTES: same as \is_callable() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function is_callable($var, $syntax_only = null, &$callable_name = null)
14 | {
15 |     return \is_callable($var, $syntax_only = null, &$callable_name = null);
16 | }


--------------------------------------------------------------------------------
/src/is_double.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\is_double()
 8 |  *
 9 |  * @link https://secure.php.net/is_double
10 |  *
11 |  * NOTES: same as \is_double() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function is_double($var)
14 | {
15 |     return \is_double($var);
16 | }


--------------------------------------------------------------------------------
/src/is_finite.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\is_finite()
 8 |  *
 9 |  * @link https://secure.php.net/is_finite
10 |  *
11 |  * NOTES: same as \is_finite() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function is_finite($val)
14 | {
15 |     return \is_finite($val);
16 | }


--------------------------------------------------------------------------------
/src/is_float.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\is_float()
 8 |  *
 9 |  * @link https://secure.php.net/is_float
10 |  *
11 |  * NOTES: same as \is_float() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function is_float($var)
14 | {
15 |     return \is_float($var);
16 | }


--------------------------------------------------------------------------------
/src/is_infinite.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\is_infinite()
 8 |  *
 9 |  * @link https://secure.php.net/is_infinite
10 |  *
11 |  * NOTES: same as \is_infinite() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function is_infinite($val)
14 | {
15 |     return \is_infinite($val);
16 | }


--------------------------------------------------------------------------------
/src/is_int.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\is_int()
 8 |  *
 9 |  * @link https://secure.php.net/is_int
10 |  *
11 |  * NOTES: same as \is_int() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function is_int($var)
14 | {
15 |     return \is_int($var);
16 | }


--------------------------------------------------------------------------------
/src/is_integer.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\is_integer()
 8 |  *
 9 |  * @link https://secure.php.net/is_integer
10 |  *
11 |  * NOTES: same as \is_integer() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function is_integer($var)
14 | {
15 |     return \is_integer($var);
16 | }


--------------------------------------------------------------------------------
/src/is_long.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\is_long()
 8 |  *
 9 |  * @link https://secure.php.net/is_long
10 |  *
11 |  * NOTES: same as \is_long() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function is_long($var)
14 | {
15 |     return \is_long($var);
16 | }


--------------------------------------------------------------------------------
/src/is_nan.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\is_nan()
 8 |  *
 9 |  * @link https://secure.php.net/is_nan
10 |  *
11 |  * NOTES: same as \is_nan() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function is_nan($val)
14 | {
15 |     return \is_nan($val);
16 | }


--------------------------------------------------------------------------------
/src/is_null.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\is_null()
 8 |  *
 9 |  * @link https://secure.php.net/is_null
10 |  *
11 |  * NOTES: same as \is_null() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function is_null($var)
14 | {
15 |     return \is_null($var);
16 | }


--------------------------------------------------------------------------------
/src/is_numeric.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\is_numeric()
 8 |  *
 9 |  * @link https://secure.php.net/is_numeric
10 |  *
11 |  * NOTES: same as \is_numeric() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function is_numeric($var)
14 | {
15 |     return \is_numeric($var);
16 | }


--------------------------------------------------------------------------------
/src/is_object.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\is_object()
 8 |  *
 9 |  * @link https://secure.php.net/is_object
10 |  *
11 |  * NOTES: same as \is_object() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function is_object($var)
14 | {
15 |     return \is_object($var);
16 | }


--------------------------------------------------------------------------------
/src/is_real.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\is_real()
 8 |  *
 9 |  * @link https://secure.php.net/is_real
10 |  *
11 |  * NOTES: same as \is_real() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function is_real($var)
14 | {
15 |     return \is_real($var);
16 | }


--------------------------------------------------------------------------------
/src/is_scalar.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\is_scalar()
 8 |  *
 9 |  * @link https://secure.php.net/is_scalar
10 |  *
11 |  * NOTES: same as \is_scalar() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function is_scalar($var)
14 | {
15 |     return \is_scalar($var);
16 | }


--------------------------------------------------------------------------------
/src/is_string.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\is_string()
 8 |  *
 9 |  * @link https://secure.php.net/is_string
10 |  *
11 |  * NOTES: same as \is_string() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function is_string($var)
14 | {
15 |     return \is_string($var);
16 | }


--------------------------------------------------------------------------------
/src/join.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\join()
 8 |  *
 9 |  * @link https://secure.php.net/join
10 |  *
11 |  * NOTES: same as \join() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function join($glue = "", $pieces)
14 | {
15 |     return \join($glue = "", $pieces);
16 | }


--------------------------------------------------------------------------------
/src/key.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\key()
 8 |  *
 9 |  * @link https://secure.php.net/key
10 |  *
11 |  * NOTES: same as \key() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function key(array $array)
14 | {
15 |     return \key(array $array);
16 | }


--------------------------------------------------------------------------------
/src/krsort.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\krsort()
 8 |  *
 9 |  * @link https://secure.php.net/krsort
10 |  *
11 |  * NOTES: same as \krsort() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function krsort(array &$array, $sort_flags = null)
14 | {
15 |     return \krsort(array &$array, $sort_flags = null);
16 | }


--------------------------------------------------------------------------------
/src/ksort.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\ksort()
 8 |  *
 9 |  * @link https://secure.php.net/ksort
10 |  *
11 |  * NOTES: same as \ksort() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function ksort(array &$array, $sort_flags = null)
14 | {
15 |     return \ksort(array &$array, $sort_flags = null);
16 | }


--------------------------------------------------------------------------------
/src/lcfirst.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\lcfirst()
 8 |  *
 9 |  * @link https://secure.php.net/lcfirst
10 |  *
11 |  * NOTES: same as \lcfirst() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function lcfirst($str)
14 | {
15 |     return \lcfirst($str);
16 | }


--------------------------------------------------------------------------------
/src/lcg_value.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\lcg_value()
 8 |  *
 9 |  * @link https://secure.php.net/lcg_value
10 |  *
11 |  * NOTES: same as \lcg_value() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function lcg_value()
14 | {
15 |     return \lcg_value();
16 | }


--------------------------------------------------------------------------------
/src/levenshtein.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\levenshtein()
 8 |  *
 9 |  * @link https://secure.php.net/levenshtein
10 |  *
11 |  * NOTES: same as \levenshtein() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function levenshtein($str1, $str2, $cost_ins = null, $cost_rep = null, $cost_del = null)
14 | {
15 |     return \levenshtein($str1, $str2, $cost_ins = null, $cost_rep = null, $cost_del = null);
16 | }


--------------------------------------------------------------------------------
/src/localeconv.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\localeconv()
 8 |  *
 9 |  * @link https://secure.php.net/localeconv
10 |  *
11 |  * NOTES: same as \localeconv() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function localeconv()
14 | {
15 |     return \localeconv();
16 | }


--------------------------------------------------------------------------------
/src/log.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\log()
 8 |  *
 9 |  * @link https://secure.php.net/log
10 |  *
11 |  * NOTES: same as \log() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function log($arg, $base = null)
14 | {
15 |     return \log($arg, $base = null);
16 | }


--------------------------------------------------------------------------------
/src/log10.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\log10()
 8 |  *
 9 |  * @link https://secure.php.net/log10
10 |  *
11 |  * NOTES: same as \log10() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function log10($arg)
14 | {
15 |     return \log10($arg);
16 | }


--------------------------------------------------------------------------------
/src/log1p.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\log1p()
 8 |  *
 9 |  * @link https://secure.php.net/log1p
10 |  *
11 |  * NOTES: same as \log1p() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function log1p($number)
14 | {
15 |     return \log1p($number);
16 | }


--------------------------------------------------------------------------------
/src/long2ip.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\long2ip()
 8 |  *
 9 |  * @link https://secure.php.net/long2ip
10 |  *
11 |  * NOTES: same as \long2ip() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function long2ip($proper_address)
14 | {
15 |     return \long2ip($proper_address);
16 | }


--------------------------------------------------------------------------------
/src/ltrim.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\ltrim()
 8 |  *
 9 |  * @link https://secure.php.net/ltrim
10 |  *
11 |  * NOTES: same as \ltrim() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function ltrim($str, $charlist = " \t\n\r\0\x0B")
14 | {
15 |     return \ltrim($str, $charlist = " \t\n\r\0\x0B");
16 | }


--------------------------------------------------------------------------------
/src/max.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\max()
 8 |  *
 9 |  * @link https://secure.php.net/max
10 |  *
11 |  * NOTES: same as \max() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function max(array $value1, $value2 = null, ...$values)
14 | {
15 |     return \max(array $value1, $value2 = null, ...$values);
16 | }


--------------------------------------------------------------------------------
/src/md5.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\md5()
 8 |  *
 9 |  * @link https://secure.php.net/md5
10 |  *
11 |  * NOTES: same as \md5() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function md5($str, $raw_output = null)
14 | {
15 |     return \md5($str, $raw_output = null);
16 | }


--------------------------------------------------------------------------------
/src/md5_file.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\md5_file()
 8 |  *
 9 |  * @link https://secure.php.net/md5_file
10 |  *
11 |  * NOTES: same as \md5_file() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function md5_file($filename, $raw_output = null)
14 | {
15 |     return \md5_file($filename, $raw_output = null);
16 | }


--------------------------------------------------------------------------------
/src/metaphone.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\metaphone()
 8 |  *
 9 |  * @link https://secure.php.net/metaphone
10 |  *
11 |  * NOTES: same as \metaphone() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function metaphone($str, $phonemes = 0)
14 | {
15 |     return \metaphone($str, $phonemes = 0);
16 | }


--------------------------------------------------------------------------------
/src/microtime.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\microtime()
 8 |  *
 9 |  * @link https://secure.php.net/microtime
10 |  *
11 |  * NOTES: same as \microtime() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function microtime($get_as_float = null)
14 | {
15 |     return \microtime($get_as_float = null);
16 | }


--------------------------------------------------------------------------------
/src/min.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\min()
 8 |  *
 9 |  * @link https://secure.php.net/min
10 |  *
11 |  * NOTES: same as \min() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function min(array $value1, $value2 = null, ...$values)
14 | {
15 |     return \min(array $value1, $value2 = null, ...$values);
16 | }


--------------------------------------------------------------------------------
/src/money_format.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\money_format()
 8 |  *
 9 |  * @link https://secure.php.net/money_format
10 |  *
11 |  * NOTES: same as \money_format() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function money_format($format, $number)
14 | {
15 |     return \money_format($format, $number);
16 | }


--------------------------------------------------------------------------------
/src/mt_getrandmax.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\mt_getrandmax()
 8 |  *
 9 |  * @link https://secure.php.net/mt_getrandmax
10 |  *
11 |  * NOTES: same as \mt_getrandmax() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function mt_getrandmax()
14 | {
15 |     return \mt_getrandmax();
16 | }


--------------------------------------------------------------------------------
/src/mt_rand.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\mt_rand()
 8 |  *
 9 |  * @link https://secure.php.net/mt_rand
10 |  *
11 |  * NOTES: same as \mt_rand() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function mt_rand($min, $max)
14 | {
15 |     return \mt_rand($min, $max);
16 | }


--------------------------------------------------------------------------------
/src/natcasesort.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\natcasesort()
 8 |  *
 9 |  * @link https://secure.php.net/natcasesort
10 |  *
11 |  * NOTES: same as \natcasesort() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function natcasesort(array &$array)
14 | {
15 |     return \natcasesort(array &$array);
16 | }


--------------------------------------------------------------------------------
/src/natsort.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\natsort()
 8 |  *
 9 |  * @link https://secure.php.net/natsort
10 |  *
11 |  * NOTES: same as \natsort() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function natsort(array &$array)
14 | {
15 |     return \natsort(array &$array);
16 | }


--------------------------------------------------------------------------------
/src/next.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\next()
 8 |  *
 9 |  * @link https://secure.php.net/next
10 |  *
11 |  * NOTES: same as \next() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function next(array &$array)
14 | {
15 |     return \next(array &$array);
16 | }


--------------------------------------------------------------------------------
/src/nl2br.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\nl2br()
 8 |  *
 9 |  * @link https://secure.php.net/nl2br
10 |  *
11 |  * NOTES: same as \nl2br() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function nl2br($string, $is_xhtml = null)
14 | {
15 |     return \nl2br($string, $is_xhtml = null);
16 | }


--------------------------------------------------------------------------------
/src/nl_langinfo.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\nl_langinfo()
 8 |  *
 9 |  * @link https://secure.php.net/nl_langinfo
10 |  *
11 |  * NOTES: same as \nl_langinfo() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function nl_langinfo($item)
14 | {
15 |     return \nl_langinfo($item);
16 | }


--------------------------------------------------------------------------------
/src/number_format.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\number_format()
 8 |  *
 9 |  * @link https://secure.php.net/number_format
10 |  *
11 |  * NOTES: same as \number_format() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function number_format($number , $decimals = 0 , $dec_point = '.' , $thousands_sep = ',' )
14 | {
15 |     return \number_format($number , $decimals = 0 , $dec_point = '.' , $thousands_sep = ',');
16 | }


--------------------------------------------------------------------------------
/src/octdec.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\octdec()
 8 |  *
 9 |  * @link https://secure.php.net/octdec
10 |  *
11 |  * NOTES: same as \octdec() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function octdec($octal_string)
14 | {
15 |     return \octdec($octal_string);
16 | }


--------------------------------------------------------------------------------
/src/ord.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\ord()
 8 |  *
 9 |  * @link https://secure.php.net/ord
10 |  *
11 |  * NOTES: same as \ord() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function ord($string)
14 | {
15 |     return \ord($string);
16 | }


--------------------------------------------------------------------------------
/src/pack.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\pack()
 8 |  *
 9 |  * @link https://secure.php.net/pack
10 |  *
11 |  * NOTES: same as \pack() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function pack($format, $args = null, $_ = null)
14 | {
15 |     return \pack($format, $args = null, $_ = null);
16 | }


--------------------------------------------------------------------------------
/src/parse_str.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\parse_str()
 8 |  *
 9 |  * @link https://secure.php.net/parse_str
10 |  *
11 |  * NOTES: same as \parse_str() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function parse_str($str, array &$arr = null)
14 | {
15 |     return \parse_str($str, array &$arr = null);
16 | }


--------------------------------------------------------------------------------
/src/parse_url.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | namespace Zubr;
 4 | 
 5 | /**
 6 |  * Parse a URL and return its components
 7 |  *
 8 |  * @param string $url
 9 |  * @param int $component
10 |  * @return mixed
11 |  * @see \parse_url
12 |  */
13 | function parse_url(string $url, int $component = -1)
14 | {
15 |     return \parse_url($url, $component);
16 | }
17 | 


--------------------------------------------------------------------------------
/src/pathinfo.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\pathinfo()
 8 |  *
 9 |  * @link https://secure.php.net/pathinfo
10 |  *
11 |  * NOTES: same as \pathinfo() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function pathinfo($path, $options = null)
14 | {
15 |     return \pathinfo($path, $options = null);
16 | }


--------------------------------------------------------------------------------
/src/pi.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\pi()
 8 |  *
 9 |  * @link https://secure.php.net/pi
10 |  *
11 |  * NOTES: same as \pi() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function pi()
14 | {
15 |     return \pi();
16 | }


--------------------------------------------------------------------------------
/src/pos.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\pos()
 8 |  *
 9 |  * @link https://secure.php.net/pos
10 |  *
11 |  * NOTES: same as \pos() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function pos(&$arg)
14 | {
15 |     return \pos();
16 | }


--------------------------------------------------------------------------------
/src/pow.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\pow()
 8 |  *
 9 |  * @link https://secure.php.net/pow
10 |  *
11 |  * NOTES: same as \pow() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function pow($base, $exp)
14 | {
15 |     return \pow($base, $exp);
16 | }


--------------------------------------------------------------------------------
/src/prev.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\prev()
 8 |  *
 9 |  * @link https://secure.php.net/prev
10 |  *
11 |  * NOTES: same as \prev() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function prev(array &$array)
14 | {
15 |     return \prev(array &$array);
16 | }


--------------------------------------------------------------------------------
/src/print_r.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\print_r()
 8 |  *
 9 |  * @link https://secure.php.net/print_r
10 |  *
11 |  * NOTES: same as \print_r() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function print_r($expression, $return = null)
14 | {
15 |     return \print_r($expression, $return = null);
16 | }


--------------------------------------------------------------------------------
/src/printf.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\printf()
 8 |  *
 9 |  * @link https://secure.php.net/printf
10 |  *
11 |  * NOTES: same as \printf() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function printf($format, $args = null, $_ = null)
14 | {
15 |     return \printf($format, $args = null, $_ = null);
16 | }


--------------------------------------------------------------------------------
/src/quoted_printable_decode.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\quoted_printable_decode()
 8 |  *
 9 |  * @link https://secure.php.net/quoted_printable_decode
10 |  *
11 |  * NOTES: same as \quoted_printable_decode() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function quoted_printable_decode($str)
14 | {
15 |     return \quoted_printable_decode($str);
16 | }


--------------------------------------------------------------------------------
/src/quoted_printable_encode.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\quoted_printable_encode()
 8 |  *
 9 |  * @link https://secure.php.net/quoted_printable_encode
10 |  *
11 |  * NOTES: same as \quoted_printable_encode() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function quoted_printable_encode($str)
14 | {
15 |     return \quoted_printable_encode($str);
16 | }


--------------------------------------------------------------------------------
/src/quotemeta.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\quotemeta()
 8 |  *
 9 |  * @link https://secure.php.net/quotemeta
10 |  *
11 |  * NOTES: same as \quotemeta() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function quotemeta($str)
14 | {
15 |     return \quotemeta($str);
16 | }


--------------------------------------------------------------------------------
/src/rad2deg.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\rad2deg()
 8 |  *
 9 |  * @link https://secure.php.net/rad2deg
10 |  *
11 |  * NOTES: same as \rad2deg() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function rad2deg($number)
14 | {
15 |     return \rad2deg($number);
16 | }


--------------------------------------------------------------------------------
/src/rand.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\rand()
 8 |  *
 9 |  * @link https://secure.php.net/rand
10 |  *
11 |  * NOTES: same as \rand() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function rand($min, $max)
14 | {
15 |     return \rand($min, $max);
16 | }


--------------------------------------------------------------------------------
/src/range.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\range()
 8 |  *
 9 |  * @link https://secure.php.net/range
10 |  *
11 |  * NOTES: same as \range() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function range($low, $high, $step = null)
14 | {
15 |     return \range($low, $high, $step = null);
16 | }


--------------------------------------------------------------------------------
/src/rawurldecode.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\rawurldecode()
 8 |  *
 9 |  * @link https://secure.php.net/rawurldecode
10 |  *
11 |  * NOTES: same as \rawurldecode() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function rawurldecode($str)
14 | {
15 |     return \rawurldecode($str);
16 | }


--------------------------------------------------------------------------------
/src/rawurlencode.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\rawurlencode()
 8 |  *
 9 |  * @link https://secure.php.net/rawurlencode
10 |  *
11 |  * NOTES: same as \rawurlencode() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function rawurlencode($str)
14 | {
15 |     return \rawurlencode($str);
16 | }


--------------------------------------------------------------------------------
/src/realpath.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\realpath()
 8 |  *
 9 |  * @link https://secure.php.net/realpath
10 |  *
11 |  * NOTES: same as \realpath() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function realpath($path)
14 | {
15 |     return \realpath($path);
16 | }


--------------------------------------------------------------------------------
/src/reset.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\reset()
 8 |  *
 9 |  * @link https://secure.php.net/reset
10 |  *
11 |  * NOTES: same as \reset() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function reset(array &$array)
14 | {
15 |     return \reset(array &$array);
16 | }


--------------------------------------------------------------------------------
/src/round.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\round()
 8 |  *
 9 |  * @link https://secure.php.net/round
10 |  *
11 |  * NOTES: same as \round() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function round($val, $precision = 0, $mode = PHP_ROUND_HALF_UP)
14 | {
15 |     return \round($val, $precision = 0, $mode = PHP_ROUND_HALF_UP);
16 | }


--------------------------------------------------------------------------------
/src/rsort.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\rsort()
 8 |  *
 9 |  * @link https://secure.php.net/rsort
10 |  *
11 |  * NOTES: same as \rsort() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function rsort(array &$array, $sort_flags = null)
14 | {
15 |     return \rsort(array &$array, $sort_flags = null);
16 | }


--------------------------------------------------------------------------------
/src/rtrim.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\rtrim()
 8 |  *
 9 |  * @link https://secure.php.net/rtrim
10 |  *
11 |  * NOTES: same as \rtrim() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function rtrim($str, $charlist = " \t\n\r\0\x0B")
14 | {
15 |     return \rtrim($str, $charlist = " \t\n\r\0\x0B");
16 | }


--------------------------------------------------------------------------------
/src/serialize.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\serialize()
 8 |  *
 9 |  * @link https://secure.php.net/serialize
10 |  *
11 |  * NOTES: same as \serialize() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function serialize($value)
14 | {
15 |     return \serialize($value);
16 | }


--------------------------------------------------------------------------------
/src/set_time_limit.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\set_time_limit()
 8 |  *
 9 |  * @link https://secure.php.net/set_time_limit
10 |  *
11 |  * NOTES: same as \set_time_limit() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function set_time_limit($seconds)
14 | {
15 |     return \set_time_limit($seconds);
16 | }


--------------------------------------------------------------------------------
/src/setcookie.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\setcookie()
 8 |  *
 9 |  * @link https://secure.php.net/setcookie
10 |  *
11 |  * NOTES: same as \setcookie() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function setcookie($name, $value = "", $expire = 0, $path = "", $domain = "", $secure = false, $httponly = false)
14 | {
15 |     return \setcookie($name, $value = "", $expire = 0, $path = "", $domain = "", $secure = false, $httponly = false);
16 | }


--------------------------------------------------------------------------------
/src/setlocale.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\setlocale()
 8 |  *
 9 |  * @link https://secure.php.net/setlocale
10 |  *
11 |  * NOTES: same as \setlocale() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function setlocale($category, $locale, $_ = null)
14 | {
15 |     return \setlocale($category, $locale, $_ = null);
16 | }


--------------------------------------------------------------------------------
/src/setrawcookie.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\setrawcookie()
 8 |  *
 9 |  * @link https://secure.php.net/setrawcookie
10 |  *
11 |  * NOTES: same as \setrawcookie() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function setrawcookie($name, $value = null, $expire = 0, $path = "", $domain = "", $secure = false, $httponly = false)
14 | {
15 |     return \setrawcookie($name, $value = null, $expire = 0, $path = "", $domain = "", $secure = false, $httponly = false);
16 | }


--------------------------------------------------------------------------------
/src/sha1.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\sha1()
 8 |  *
 9 |  * @link https://secure.php.net/sha1
10 |  *
11 |  * NOTES: same as \sha1() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function sha1($str, $raw_output = null)
14 | {
15 |     return \sha1($str, $raw_output = null);
16 | }


--------------------------------------------------------------------------------
/src/sha1_file.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\sha1_file()
 8 |  *
 9 |  * @link https://secure.php.net/sha1_file
10 |  *
11 |  * NOTES: same as \sha1_file() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function sha1_file($filename, $raw_output = null)
14 | {
15 |     return \sha1_file($filename, $raw_output = null);
16 | }


--------------------------------------------------------------------------------
/src/shuffle.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\shuffle()
 8 |  *
 9 |  * @link https://secure.php.net/shuffle
10 |  *
11 |  * NOTES: same as \shuffle() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function shuffle(array &$array)
14 | {
15 |     return \shuffle(array &$array);
16 | }


--------------------------------------------------------------------------------
/src/similar_text.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\similar_text()
 8 |  *
 9 |  * @link https://secure.php.net/similar_text
10 |  *
11 |  * NOTES: same as \similar_text() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function similar_text($first, $second, &$percent = null)
14 | {
15 |     return \similar_text($first, $second, &$percent = null);
16 | }


--------------------------------------------------------------------------------
/src/sin.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\sin()
 8 |  *
 9 |  * @link https://secure.php.net/sin
10 |  *
11 |  * NOTES: same as \sin() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function sin($arg)
14 | {
15 |     return \sin($arg);
16 | }


--------------------------------------------------------------------------------
/src/sinh.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\sinh()
 8 |  *
 9 |  * @link https://secure.php.net/sinh
10 |  *
11 |  * NOTES: same as \sinh() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function sinh($arg)
14 | {
15 |     return \sinh($arg);
16 | }


--------------------------------------------------------------------------------
/src/sizeof.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\sizeof()
 8 |  *
 9 |  * @link https://secure.php.net/sizeof
10 |  *
11 |  * NOTES: same as \sizeof() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function sizeof($var, $mode)
14 | {
15 |     return \sizeof();
16 | }


--------------------------------------------------------------------------------
/src/sort.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\sort()
 8 |  *
 9 |  * @link https://secure.php.net/sort
10 |  *
11 |  * NOTES: same as \sort() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function sort(array &$array, $sort_flags = null)
14 | {
15 |     return \sort(array &$array, $sort_flags = null);
16 | }


--------------------------------------------------------------------------------
/src/soundex.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\soundex()
 8 |  *
 9 |  * @link https://secure.php.net/soundex
10 |  *
11 |  * NOTES: same as \soundex() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function soundex($str)
14 | {
15 |     return \soundex($str);
16 | }


--------------------------------------------------------------------------------
/src/sprintf.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\sprintf()
 8 |  *
 9 |  * @link https://secure.php.net/sprintf
10 |  *
11 |  * NOTES: same as \sprintf() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function sprintf($format, $args = null, $_ = null)
14 | {
15 |     return \sprintf($format, $args = null, $_ = null);
16 | }


--------------------------------------------------------------------------------
/src/sqrt.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\sqrt()
 8 |  *
 9 |  * @link https://secure.php.net/sqrt
10 |  *
11 |  * NOTES: same as \sqrt() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function sqrt($arg)
14 | {
15 |     return \sqrt($arg);
16 | }


--------------------------------------------------------------------------------
/src/sscanf.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\sscanf()
 8 |  *
 9 |  * @link https://secure.php.net/sscanf
10 |  *
11 |  * NOTES: same as \sscanf() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function sscanf($str, $format, &$_ = null)
14 | {
15 |     return \sscanf($str, $format, &$_ = null);
16 | }


--------------------------------------------------------------------------------
/src/str_getcsv.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\str_getcsv()
 8 |  *
 9 |  * @link https://secure.php.net/str_getcsv
10 |  *
11 |  * NOTES: same as \str_getcsv() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function str_getcsv($input, $delimiter = ",", $enclosure = '"', $escape = "\\")
14 | {
15 |     return \str_getcsv($input, $delimiter = ",", $enclosure = '"', $escape = "\\");
16 | }


--------------------------------------------------------------------------------
/src/str_ireplace.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\str_ireplace()
 8 |  *
 9 |  * @link https://secure.php.net/str_ireplace
10 |  *
11 |  * NOTES: same as \str_ireplace() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function str_ireplace($search, $replace, $subject, &$count = null)
14 | {
15 |     return \str_ireplace($search, $replace, $subject, &$count = null);
16 | }


--------------------------------------------------------------------------------
/src/str_repeat.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\str_repeat()
 8 |  *
 9 |  * @link https://secure.php.net/str_repeat
10 |  *
11 |  * NOTES: same as \str_repeat() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function str_repeat($input, $multiplier)
14 | {
15 |     return \str_repeat($input, $multiplier);
16 | }


--------------------------------------------------------------------------------
/src/str_replace.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\str_replace()
 8 |  *
 9 |  * @link https://secure.php.net/str_replace
10 |  *
11 |  * NOTES: same as \str_replace() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function str_replace($search, $replace, $subject, &$count = null)
14 | {
15 |     return \str_replace($search, $replace, $subject, &$count = null);
16 | }


--------------------------------------------------------------------------------
/src/str_rot13.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\str_rot13()
 8 |  *
 9 |  * @link https://secure.php.net/str_rot13
10 |  *
11 |  * NOTES: same as \str_rot13() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function str_rot13($str)
14 | {
15 |     return \str_rot13();
16 | }


--------------------------------------------------------------------------------
/src/str_shuffle.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\str_shuffle()
 8 |  *
 9 |  * @link https://secure.php.net/str_shuffle
10 |  *
11 |  * NOTES: same as \str_shuffle() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function str_shuffle($str)
14 | {
15 |     return \str_shuffle($str);
16 | }


--------------------------------------------------------------------------------
/src/str_split.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\str_split()
 8 |  *
 9 |  * @link https://secure.php.net/str_split
10 |  *
11 |  * NOTES: same as \str_split() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function str_split($string, $split_length = 1)
14 | {
15 |     return \str_split($string, $split_length = 1);
16 | }


--------------------------------------------------------------------------------
/src/str_word_count.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\str_word_count()
 8 |  *
 9 |  * @link https://secure.php.net/str_word_count
10 |  *
11 |  * NOTES: same as \str_word_count() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function str_word_count($string, $format = null, $charlist = null)
14 | {
15 |     return \str_word_count($string, $format = null, $charlist = null);
16 | }


--------------------------------------------------------------------------------
/src/strchr.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\strchr()
 8 |  *
 9 |  * @link https://secure.php.net/strchr
10 |  *
11 |  * NOTES: same as \strchr() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function strchr($haystack, $needle, $part)
14 | {
15 |     return \strchr($haystack, $needle, $part);
16 | }


--------------------------------------------------------------------------------
/src/strcoll.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\strcoll()
 8 |  *
 9 |  * @link https://secure.php.net/strcoll
10 |  *
11 |  * NOTES: same as \strcoll() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function strcoll($str1, $str2)
14 | {
15 |     return \strcoll($str1, $str2);
16 | }


--------------------------------------------------------------------------------
/src/strcspn.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\strcspn()
 8 |  *
 9 |  * @link https://secure.php.net/strcspn
10 |  *
11 |  * NOTES: same as \strcspn() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function strcspn($str1, $str2, $start = null, $length = null)
14 | {
15 |     return \strcspn($str1, $str2, $start = null, $length = null);
16 | }


--------------------------------------------------------------------------------
/src/strip_tags.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\strip_tags()
 8 |  *
 9 |  * @link https://secure.php.net/strip_tags
10 |  *
11 |  * NOTES: same as \strip_tags() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function strip_tags($str, $allowable_tags = null)
14 | {
15 |     return \strip_tags($str, $allowable_tags = null);
16 | }


--------------------------------------------------------------------------------
/src/stripos.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\stripos()
 8 |  *
 9 |  * @link https://secure.php.net/stripos
10 |  *
11 |  * NOTES: same as \stripos() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function stripos($haystack, $needle, $offset = null)
14 | {
15 |     return \stripos($haystack, $needle, $offset = null);
16 | }


--------------------------------------------------------------------------------
/src/stripslashes.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\stripslashes()
 8 |  *
 9 |  * @link https://secure.php.net/stripslashes
10 |  *
11 |  * NOTES: same as \stripslashes() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function stripslashes($str)
14 | {
15 |     return \stripslashes($str);
16 | }


--------------------------------------------------------------------------------
/src/stristr.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\stristr()
 8 |  *
 9 |  * @link https://secure.php.net/stristr
10 |  *
11 |  * NOTES: same as \stristr() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function stristr($haystack, $needle, $before_needle = null)
14 | {
15 |     return \stristr($haystack, $needle, $before_needle = null);
16 | }


--------------------------------------------------------------------------------
/src/strnatcasecmp.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\strnatcasecmp()
 8 |  *
 9 |  * @link https://secure.php.net/strnatcasecmp
10 |  *
11 |  * NOTES: same as \strnatcasecmp() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function strnatcasecmp($str1, $str2)
14 | {
15 |     return \strnatcasecmp($str1, $str2);
16 | }


--------------------------------------------------------------------------------
/src/strnatcmp.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\strnatcmp()
 8 |  *
 9 |  * @link https://secure.php.net/strnatcmp
10 |  *
11 |  * NOTES: same as \strnatcmp() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function strnatcmp($str1, $str2)
14 | {
15 |     return \strnatcmp($str1, $str2);
16 | }


--------------------------------------------------------------------------------
/src/strpbrk.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\strpbrk()
 8 |  *
 9 |  * @link https://secure.php.net/strpbrk
10 |  *
11 |  * NOTES: same as \strpbrk() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function strpbrk($haystack, $char_list)
14 | {
15 |     return \strpbrk($haystack, $char_list);
16 | }


--------------------------------------------------------------------------------
/src/strpos.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\strpos()
 8 |  *
 9 |  * @link https://secure.php.net/strpos
10 |  *
11 |  * NOTES: same as \strpos() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function strpos($haystack, $needle, $offset = 0)
14 | {
15 |     return \strpos($haystack, $needle, $offset = 0);
16 | }


--------------------------------------------------------------------------------
/src/strptime.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\strptime()
 8 |  *
 9 |  * @link https://secure.php.net/strptime
10 |  *
11 |  * NOTES: same as \strptime() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function strptime($date, $format)
14 | {
15 |     return \strptime($date, $format);
16 | }


--------------------------------------------------------------------------------
/src/strrchr.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\strrchr()
 8 |  *
 9 |  * @link https://secure.php.net/strrchr
10 |  *
11 |  * NOTES: same as \strrchr() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function strrchr($haystack, $needle)
14 | {
15 |     return \strrchr($haystack, $needle);
16 | }


--------------------------------------------------------------------------------
/src/strrev.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\strrev()
 8 |  *
 9 |  * @link https://secure.php.net/strrev
10 |  *
11 |  * NOTES: same as \strrev() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function strrev($string)
14 | {
15 |     return \strrev($string);
16 | }


--------------------------------------------------------------------------------
/src/strripos.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\strripos()
 8 |  *
 9 |  * @link https://secure.php.net/strripos
10 |  *
11 |  * NOTES: same as \strripos() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function strripos($haystack, $needle, $offset = null)
14 | {
15 |     return \strripos($haystack, $needle, $offset = null);
16 | }


--------------------------------------------------------------------------------
/src/strrpos.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\strrpos()
 8 |  *
 9 |  * @link https://secure.php.net/strrpos
10 |  *
11 |  * NOTES: same as \strrpos() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function strrpos($haystack, $needle, $offset = 0)
14 | {
15 |     return \strrpos($haystack, $needle, $offset = 0);
16 | }


--------------------------------------------------------------------------------
/src/strspn.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\strspn()
 8 |  *
 9 |  * @link https://secure.php.net/strspn
10 |  *
11 |  * NOTES: same as \strspn() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function strspn($subject, $mask, $start = null, $length = null)
14 | {
15 |     return \strspn($subject, $mask, $start = null, $length = null);
16 | }


--------------------------------------------------------------------------------
/src/strstr.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\strstr()
 8 |  *
 9 |  * @link https://secure.php.net/strstr
10 |  *
11 |  * NOTES: same as \strstr() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function strstr($haystack, $needle, $before_needle = null)
14 | {
15 |     return \strstr($haystack, $needle, $before_needle = null);
16 | }


--------------------------------------------------------------------------------
/src/strtok.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\strtok()
 8 |  *
 9 |  * @link https://secure.php.net/strtok
10 |  *
11 |  * NOTES: same as \strtok() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function strtok($str = null, $token)
14 | {
15 |     return \strtok($str = null, $token);
16 | }


--------------------------------------------------------------------------------
/src/strtolower.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\strtolower()
 8 |  *
 9 |  * @link https://secure.php.net/strtolower
10 |  *
11 |  * NOTES: same as \strtolower() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function strtolower($str)
14 | {
15 |     return \strtolower($str);
16 | }


--------------------------------------------------------------------------------
/src/strtoupper.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\strtoupper()
 8 |  *
 9 |  * @link https://secure.php.net/strtoupper
10 |  *
11 |  * NOTES: same as \strtoupper() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function strtoupper($string)
14 | {
15 |     return \strtoupper($string);
16 | }


--------------------------------------------------------------------------------
/src/strtr.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\strtr()
 8 |  *
 9 |  * @link https://secure.php.net/strtr
10 |  *
11 |  * NOTES: same as \strtr() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function strtr($str, $from, $to)
14 | {
15 |     return \strtr($str, $from, $to);
16 | }


--------------------------------------------------------------------------------
/src/strval.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\strval()
 8 |  *
 9 |  * @link https://secure.php.net/strval
10 |  *
11 |  * NOTES: same as \strval() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function strval($var)
14 | {
15 |     return \strval($var);
16 | }


--------------------------------------------------------------------------------
/src/substr.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\substr()
 8 |  *
 9 |  * @link https://secure.php.net/substr
10 |  *
11 |  * NOTES: same as \substr() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function substr($string, $start, $length = null)
14 | {
15 |     return \substr($string, $start, $length = null);
16 | }


--------------------------------------------------------------------------------
/src/substr_compare.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\substr_compare()
 8 |  *
 9 |  * @link https://secure.php.net/substr_compare
10 |  *
11 |  * NOTES: same as \substr_compare() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function substr_compare($main_str, $str, $offset, $length = null, $case_insensitivity = null)
14 | {
15 |     return \substr_compare($main_str, $str, $offset, $length = null, $case_insensitivity = null);
16 | }


--------------------------------------------------------------------------------
/src/substr_count.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\substr_count()
 8 |  *
 9 |  * @link https://secure.php.net/substr_count
10 |  *
11 |  * NOTES: same as \substr_count() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function substr_count($haystack, $needle, $offset = null, $length = null)
14 | {
15 |     return \substr_count($haystack, $needle, $offset = null, $length = null);
16 | }


--------------------------------------------------------------------------------
/src/substr_replace.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\substr_replace()
 8 |  *
 9 |  * @link https://secure.php.net/substr_replace
10 |  *
11 |  * NOTES: same as \substr_replace() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function substr_replace($string, $replacement, $start, $length = null)
14 | {
15 |     return \substr_replace($string, $replacement, $start, $length = null);
16 | }


--------------------------------------------------------------------------------
/src/tan.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\tan()
 8 |  *
 9 |  * @link https://secure.php.net/tan
10 |  *
11 |  * NOTES: same as \tan() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function tan($arg)
14 | {
15 |     return \tan($arg);
16 | }


--------------------------------------------------------------------------------
/src/tanh.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\tanh()
 8 |  *
 9 |  * @link https://secure.php.net/tanh
10 |  *
11 |  * NOTES: same as \tanh() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function tanh($arg)
14 | {
15 |     return \tanh($arg);
16 | }


--------------------------------------------------------------------------------
/src/trim.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\trim()
 8 |  *
 9 |  * @link https://secure.php.net/trim
10 |  *
11 |  * NOTES: same as \trim() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function trim($str, $charlist = " \t\n\r\0\x0B")
14 | {
15 |     return \trim($str, $charlist = " \t\n\r\0\x0B");
16 | }


--------------------------------------------------------------------------------
/src/uasort.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\uasort()
 8 |  *
 9 |  * @link https://secure.php.net/uasort
10 |  *
11 |  * NOTES: same as \uasort() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function uasort(array &$array, $cmp_function)
14 | {
15 |     return \uasort(array &$array, $cmp_function);
16 | }


--------------------------------------------------------------------------------
/src/ucfirst.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\ucfirst()
 8 |  *
 9 |  * @link https://secure.php.net/ucfirst
10 |  *
11 |  * NOTES: same as \ucfirst() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function ucfirst($str)
14 | {
15 |     return \ucfirst($str);
16 | }


--------------------------------------------------------------------------------
/src/ucwords.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\ucwords()
 8 |  *
 9 |  * @link https://secure.php.net/ucwords
10 |  *
11 |  * NOTES: same as \ucwords() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function ucwords($str, $delimiters = " \t\r\n\f\v")
14 | {
15 |     return \ucwords($str, $delimiters = " \t\r\n\f\v");
16 | }


--------------------------------------------------------------------------------
/src/uksort.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\uksort()
 8 |  *
 9 |  * @link https://secure.php.net/uksort
10 |  *
11 |  * NOTES: same as \uksort() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function uksort(array &$array, $cmp_function)
14 | {
15 |     return \uksort(array &$array, $cmp_function);
16 | }


--------------------------------------------------------------------------------
/src/uniqid.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\uniqid()
 8 |  *
 9 |  * @link https://secure.php.net/uniqid
10 |  *
11 |  * NOTES: same as \uniqid() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function uniqid($prefix = "", $more_entropy = false)
14 | {
15 |     return \uniqid($prefix = "", $more_entropy = false);
16 | }


--------------------------------------------------------------------------------
/src/unserialize.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\unserialize()
 8 |  *
 9 |  * @link https://secure.php.net/unserialize
10 |  *
11 |  * NOTES: same as \unserialize() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function unserialize($str, array $options = null)
14 | {
15 |     return \unserialize($str, array $options = null);
16 | }


--------------------------------------------------------------------------------
/src/urldecode.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\urldecode()
 8 |  *
 9 |  * @link https://secure.php.net/urldecode
10 |  *
11 |  * NOTES: same as \urldecode() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function urldecode($str)
14 | {
15 |     return \urldecode($str);
16 | }


--------------------------------------------------------------------------------
/src/urlencode.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\urlencode()
 8 |  *
 9 |  * @link https://secure.php.net/urlencode
10 |  *
11 |  * NOTES: same as \urlencode() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function urlencode($str)
14 | {
15 |     return \urlencode($str);
16 | }


--------------------------------------------------------------------------------
/src/usort.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\usort()
 8 |  *
 9 |  * @link https://secure.php.net/usort
10 |  *
11 |  * NOTES: same as \usort() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function usort(array &$array, $cmp_function)
14 | {
15 |     return \usort(array &$array, $cmp_function);
16 | }


--------------------------------------------------------------------------------
/src/var_dump.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\var_dump()
 8 |  *
 9 |  * @link https://secure.php.net/var_dump
10 |  *
11 |  * NOTES: same as \var_dump() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function var_dump($expression, $_ = null)
14 | {
15 |     return \var_dump($expression, $_ = null);
16 | }


--------------------------------------------------------------------------------
/src/var_export.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\var_export()
 8 |  *
 9 |  * @link https://secure.php.net/var_export
10 |  *
11 |  * NOTES: same as \var_export() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function var_export($expression, $return = null)
14 | {
15 |     return \var_export($expression, $return = null);
16 | }


--------------------------------------------------------------------------------
/src/version_compare.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\version_compare()
 8 |  *
 9 |  * @link https://secure.php.net/version_compare
10 |  *
11 |  * NOTES: same as \version_compare() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function version_compare($version1, $version2, $operator = null)
14 | {
15 |     return \version_compare();
16 | }


--------------------------------------------------------------------------------
/src/vprintf.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\vprintf()
 8 |  *
 9 |  * @link https://secure.php.net/vprintf
10 |  *
11 |  * NOTES: same as \vprintf() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function vprintf($format, array $args)
14 | {
15 |     return \vprintf($format, array $args);
16 | }


--------------------------------------------------------------------------------
/src/vsprintf.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\vsprintf()
 8 |  *
 9 |  * @link https://secure.php.net/vsprintf
10 |  *
11 |  * NOTES: same as \vsprintf() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function vsprintf($format, array $args)
14 | {
15 |     return \vsprintf($format, array $args);
16 | }


--------------------------------------------------------------------------------
/src/wordwrap.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Zubr;
 5 | 
 6 | /**
 7 |  * \Zubr\wordwrap()
 8 |  *
 9 |  * @link https://secure.php.net/wordwrap
10 |  *
11 |  * NOTES: same as \wordwrap() || in Zubr, $param_1 goes before $param_2, and we return an array instead of void
12 | */
13 | function wordwrap($str, $width = 75, $break = "\n", $cut = false)
14 | {
15 |     return \wordwrap($str, $width = 75, $break = "\n", $cut = false);
16 | }


--------------------------------------------------------------------------------
/tests/AcosTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => (acos(0.3) + '').substr(0, 17)
10 |     [returns] => "1.266103672779499"
11 | )
12 | */
13 | class Acos extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\acos(/* put stuff here */);
19 |         $expected = \acos(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/AcoshTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => acosh(8723321.4)
10 |     [returns] => 16.674657798418625
11 | )
12 | */
13 | class Acosh extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\acosh(/* put stuff here */);
19 |         $expected = \acosh(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/AddslashesTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => addslashes("kevin's birthday")
10 |     [returns] => "kevin\\'s birthday"
11 | )
12 | */
13 | class Addslashes extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\addslashes(/* put stuff here */);
19 |         $expected = \addslashes(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/ArrayCombineTest.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | 
 3 | class ArrayCombineTest extends \PHPUnit\Framework\TestCase
 4 | {
 5 |     /**
 6 |      * @dataProvider wrapperDataProvider
 7 |      */
 8 |     public function testWrapper(array $keys, array $values)
 9 |     {
10 |         $expected = array_combine($keys, $values);
11 |         $actual = \Zubr\array_combine($keys, $values);
12 |         
13 |         $this->assertEquals($expected, $actual);
14 |     }
15 | 
16 |     public function wrapperDataProvider()
17 |     {
18 |         return [
19 |             [[1,2,3], ['a', 'b', 'c']],
20 |             [['a', 'b', 'c'], [1,2,3]],
21 |         ];
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/tests/ArrayDiffTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => array_diff(['Kevin', 'van', 'Zonneveld'], ['van', 'Zonneveld'])
10 |     [returns] => {0:'Kevin'}
11 | )
12 | */
13 | class ArrayDiff extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\array_diff(/* put stuff here */);
19 |         $expected = \array_diff(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/ArrayFlipTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => array_flip( {a: 1, b: 1, c: 2} )
10 |     [returns] => {1: 'b', 2: 'c'}
11 | )
12 | */
13 | class ArrayFlip extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\array_flip(/* put stuff here */);
19 |         $expected = \array_flip(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/ArrayKeyExistsTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => array_key_exists('kevin', {'kevin': 'van Zonneveld'})
10 |     [returns] => true
11 | )
12 | */
13 | class ArrayKeyExists extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\array_key_exists(/* put stuff here */);
19 |         $expected = \array_key_exists(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/ArrayKeysTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => array_keys( {firstname: 'Kevin', surname: 'van Zonneveld'} )
10 |     [returns] => [ 'firstname', 'surname' ]
11 | )
12 | */
13 | class ArrayKeys extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\array_keys(/* put stuff here */);
19 |         $expected = \array_keys(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/ArrayMapTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => array_map( function (a){return (a * a * a)}, [1, 2, 3, 4, 5] )
10 |     [returns] => [ 1, 8, 27, 64, 125 ]
11 | )
12 | */
13 | class ArrayMap extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\array_map(/* put stuff here */);
19 |         $expected = \array_map(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/ArrayProductTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => array_product([ 2, 4, 6, 8 ])
10 |     [returns] => 384
11 | )
12 | */
13 | class ArrayProduct extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\array_product(/* put stuff here */);
19 |         $expected = \array_product(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/ArrayPushTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => array_push(['kevin','van'], 'zonneveld')
10 |     [returns] => 3
11 | )
12 | */
13 | class ArrayPush extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\array_push(/* put stuff here */);
19 |         $expected = \array_push(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/ArrayRandTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => array_rand( ['Kevin'], 1 )
10 |     [returns] => '0'
11 | )
12 | */
13 | class ArrayRand extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\array_rand(/* put stuff here */);
19 |         $expected = \array_rand(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/ArrayReduceTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => array_reduce([1, 2, 3, 4, 5], function (v, w){v += w;return v;})
10 |     [returns] => 15
11 | )
12 | */
13 | class ArrayReduce extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\array_reduce(/* put stuff here */);
19 |         $expected = \array_reduce(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/ArrayShiftTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => array_shift(['Kevin', 'van', 'Zonneveld'])
10 |     [returns] => 'Kevin'
11 | )
12 | */
13 | class ArrayShift extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\array_shift(/* put stuff here */);
19 |         $expected = \array_shift(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/ArrayUnshiftTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => array_unshift(['van', 'Zonneveld'], 'Kevin')
10 |     [returns] => 3
11 | )
12 | */
13 | class ArrayUnshift extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\array_unshift(/* put stuff here */);
19 |         $expected = \array_unshift(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/ArrayValuesTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => array_values( {firstname: 'Kevin', surname: 'van Zonneveld'} )
10 |     [returns] => [ 'Kevin', 'van Zonneveld' ]
11 | )
12 | */
13 | class ArrayValues extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\array_values(/* put stuff here */);
19 |         $expected = \array_values(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/ArrayWalkTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => array_walk ([3, 4], function () {}, 'userdata')
10 |     [returns] => true
11 | )
12 | */
13 | class ArrayWalk extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\array_walk(/* put stuff here */);
19 |         $expected = \array_walk(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/AsinTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => (asin(0.3) + '').substr(0, 17)
10 |     [returns] => "0.304692654015397"
11 | )
12 | */
13 | class Asin extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\asin(/* put stuff here */);
19 |         $expected = \asin(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/AsinhTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => asinh(8723321.4)
10 |     [returns] => 16.67465779841863
11 | )
12 | */
13 | class Asinh extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\asinh(/* put stuff here */);
19 |         $expected = \asinh(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/AssertOptionsTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => assert_options('ASSERT_CALLBACK')
10 |     [returns] => null
11 | )
12 | */
13 | class AssertOptions extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\assert_options(/* put stuff here */);
19 |         $expected = \assert_options(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/Atan2Test.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => atan2(1, 1)
10 |     [returns] => 0.7853981633974483
11 | )
12 | */
13 | class Atan2 extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\atan2(/* put stuff here */);
19 |         $expected = \atan2(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/AtanTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => atan(8723321.4)
10 |     [returns] => 1.5707962121596615
11 | )
12 | */
13 | class Atan extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\atan(/* put stuff here */);
19 |         $expected = \atan(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/AtanhTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => atanh(0.3)
10 |     [returns] => 0.3095196042031118
11 | )
12 | */
13 | class Atanh extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\atanh(/* put stuff here */);
19 |         $expected = \atanh(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/BaseConvertTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => base_convert('A37334', 16, 2)
10 |     [returns] => '101000110111001100110100'
11 | )
12 | */
13 | class BaseConvert extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\base_convert(/* put stuff here */);
19 |         $expected = \base_convert(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/CallUserFuncTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => call_user_func('isNaN', 'a')
10 |     [returns] => true
11 | )
12 | */
13 | class CallUserFunc extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\call_user_func(/* put stuff here */);
19 |         $expected = \call_user_func(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/CeilTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => ceil(8723321.4)
10 |     [returns] => 8723322
11 | )
12 | */
13 | class Ceil extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\ceil(/* put stuff here */);
19 |         $expected = \ceil(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/ChopTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => chop('    Kevin van Zonneveld    ')
10 |     [returns] => '    Kevin van Zonneveld'
11 | )
12 | */
13 | class Chop extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\chop(/* put stuff here */);
19 |         $expected = \chop(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/ChrTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => chr(75) === 'K'
10 | chr(65536) === '\uD800\uDC00'
11 |     [returns] => true
12 | true
13 | )
14 | */
15 | class Chr extends PHPUnit\Framework\TestCase
16 | {
17 |     public function test()
18 |     {
19 |         $input = ['test1', 'tEsT2', 'TEST3'];
20 |         $actual = \Zubr\chr(/* put stuff here */);
21 |         $expected = \chr(/* put stuff here */);
22 | 
23 |         $this->assertEquals($expected, $actual);
24 |     }
25 | }


--------------------------------------------------------------------------------
/tests/ConvertUuencodeTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => convert_uuencode("test\ntext text\r\n")
10 |     [returns] => "0=&5S=`IT97AT('1E>'0-\"@\n`\n"
11 | )
12 | */
13 | class ConvertUuencode extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\convert_uuencode(/* put stuff here */);
19 |         $expected = \convert_uuencode(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/CosTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => Math.ceil(cos(8723321.4) * 10000000)
10 |     [returns] => -1812718
11 | )
12 | */
13 | class Cos extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\cos(/* put stuff here */);
19 |         $expected = \cos(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/CoshTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => cosh(-0.18127180117607017)
10 |     [returns] => 1.0164747716114113
11 | )
12 | */
13 | class Cosh extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\cosh(/* put stuff here */);
19 |         $expected = \cosh(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/Crc32Test.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => crc32('Kevin van Zonneveld')
10 |     [returns] => 1249991249
11 | )
12 | */
13 | class Crc32 extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\crc32(/* put stuff here */);
19 |         $expected = \crc32(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/CurrentTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => var $transport = ['foot', 'bike', 'car', 'plane']
10 | current($transport)
11 |     [returns] => 'foot'
12 | )
13 | */
14 | class Current extends PHPUnit\Framework\TestCase
15 | {
16 |     public function test()
17 |     {
18 |         $input = ['test1', 'tEsT2', 'TEST3'];
19 |         $actual = \Zubr\current(/* put stuff here */);
20 |         $expected = \current(/* put stuff here */);
21 | 
22 |         $this->assertEquals($expected, $actual);
23 |     }
24 | }


--------------------------------------------------------------------------------
/tests/DecoctTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => decoct(15)
10 |     [returns] => '17'
11 | )
12 | Array
13 | (
14 |     [code] => decoct(264)
15 |     [returns] => '410'
16 | )
17 | */
18 | class Decoct extends PHPUnit\Framework\TestCase
19 | {
20 |     public function test()
21 |     {
22 |         $input = ['test1', 'tEsT2', 'TEST3'];
23 |         $actual = \Zubr\decoct(/* put stuff here */);
24 |         $expected = \decoct(/* put stuff here */);
25 | 
26 |         $this->assertEquals($expected, $actual);
27 |     }
28 | }


--------------------------------------------------------------------------------
/tests/Deg2radTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => deg2rad(45)
10 |     [returns] => 0.7853981633974483
11 | )
12 | */
13 | class Deg2rad extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\deg2rad(/* put stuff here */);
19 |         $expected = \deg2rad(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/DoublevalTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => doubleval(186)
10 |     [returns] => 186.00
11 | )
12 | */
13 | class Doubleval extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\doubleval(/* put stuff here */);
19 |         $expected = \doubleval(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/EscapeshellargTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => escapeshellarg("kevin's birthday")
10 |     [returns] => "'kevin\\'s birthday'"
11 | )
12 | */
13 | class Escapeshellarg extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\escapeshellarg(/* put stuff here */);
19 |         $expected = \escapeshellarg(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/ExpTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => exp(0.3)
10 |     [returns] => 1.3498588075760032
11 | )
12 | */
13 | class Exp extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\exp(/* put stuff here */);
19 |         $expected = \exp(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/ExplodeTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => explode(' ', 'Kevin van Zonneveld')
10 |     [returns] => [ 'Kevin', 'van', 'Zonneveld' ]
11 | )
12 | */
13 | class Explode extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\explode(/* put stuff here */);
19 |         $expected = \explode(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/Expm1Test.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => expm1(1e-15)
10 |     [returns] => 1.0000000000000007e-15
11 | )
12 | */
13 | class Expm1 extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\expm1(/* put stuff here */);
19 |         $expected = \expm1(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/FloorTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => floor(8723321.4)
10 |     [returns] => 8723321
11 | )
12 | */
13 | class Floor extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\floor(/* put stuff here */);
19 |         $expected = \floor(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/FmodTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => fmod(5.7, 1.3)
10 |     [returns] => 0.5
11 | )
12 | */
13 | class Fmod extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\fmod(/* put stuff here */);
19 |         $expected = \fmod(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/GetenvTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => getenv('LC_ALL')
10 |     [returns] => false
11 | )
12 | */
13 | class Getenv extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\getenv(/* put stuff here */);
19 |         $expected = \getenv(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/GetrandmaxTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => getrandmax()
10 |     [returns] => 2147483647
11 | )
12 | */
13 | class Getrandmax extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\getrandmax(/* put stuff here */);
19 |         $expected = \getrandmax(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/HexdecTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => hexdec('that')
10 |     [returns] => 10
11 | )
12 | Array
13 | (
14 |     [code] => hexdec('a0')
15 |     [returns] => 160
16 | )
17 | */
18 | class Hexdec extends PHPUnit\Framework\TestCase
19 | {
20 |     public function test()
21 |     {
22 |         $input = ['test1', 'tEsT2', 'TEST3'];
23 |         $actual = \Zubr\hexdec(/* put stuff here */);
24 |         $expected = \hexdec(/* put stuff here */);
25 | 
26 |         $this->assertEquals($expected, $actual);
27 |     }
28 | }


--------------------------------------------------------------------------------
/tests/HypotTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => hypot(3, 4)
10 |     [returns] => 5
11 | )
12 | Array
13 | (
14 |     [code] => hypot([], 'a')
15 |     [returns] => null
16 | )
17 | */
18 | class Hypot extends PHPUnit\Framework\TestCase
19 | {
20 |     public function test()
21 |     {
22 |         $input = ['test1', 'tEsT2', 'TEST3'];
23 |         $actual = \Zubr\hypot(/* put stuff here */);
24 |         $expected = \hypot(/* put stuff here */);
25 | 
26 |         $this->assertEquals($expected, $actual);
27 |     }
28 | }


--------------------------------------------------------------------------------
/tests/InetNtopTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => inet_ntop('\x7F\x00\x00\x01')
10 |     [returns] => '127.0.0.1'
11 | )
12 | */
13 | class InetNtop extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\inet_ntop(/* put stuff here */);
19 |         $expected = \inet_ntop(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/IniGetTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => ini_set('date.timezone', 'Asia/Hong_Kong')
10 | ini_get('date.timezone')
11 |     [returns] => 'Asia/Hong_Kong'
12 | )
13 | */
14 | class IniGet extends PHPUnit\Framework\TestCase
15 | {
16 |     public function test()
17 |     {
18 |         $input = ['test1', 'tEsT2', 'TEST3'];
19 |         $actual = \Zubr\ini_get(/* put stuff here */);
20 |         $expected = \ini_get(/* put stuff here */);
21 | 
22 |         $this->assertEquals($expected, $actual);
23 |     }
24 | }


--------------------------------------------------------------------------------
/tests/IsBoolTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => is_bool(false)
10 |     [returns] => true
11 | )
12 | Array
13 | (
14 |     [code] => is_bool(0)
15 |     [returns] => false
16 | )
17 | */
18 | class IsBool extends PHPUnit\Framework\TestCase
19 | {
20 |     public function test()
21 |     {
22 |         $input = ['test1', 'tEsT2', 'TEST3'];
23 |         $actual = \Zubr\is_bool(/* put stuff here */);
24 |         $expected = \is_bool(/* put stuff here */);
25 | 
26 |         $this->assertEquals($expected, $actual);
27 |     }
28 | }


--------------------------------------------------------------------------------
/tests/IsDoubleTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => is_double(186.31)
10 |     [returns] => true
11 | )
12 | */
13 | class IsDouble extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\is_double(/* put stuff here */);
19 |         $expected = \is_double(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/IsFloatTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => is_float(186.31)
10 |     [returns] => true
11 | )
12 | */
13 | class IsFloat extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\is_float(/* put stuff here */);
19 |         $expected = \is_float(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/IsLongTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => is_long(186.31)
10 |     [returns] => true
11 | )
12 | */
13 | class IsLong extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\is_long(/* put stuff here */);
19 |         $expected = \is_long(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/IsNanTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => is_nan(NaN)
10 |     [returns] => true
11 | )
12 | Array
13 | (
14 |     [code] => is_nan(0)
15 |     [returns] => false
16 | )
17 | */
18 | class IsNan extends PHPUnit\Framework\TestCase
19 | {
20 |     public function test()
21 |     {
22 |         $input = ['test1', 'tEsT2', 'TEST3'];
23 |         $actual = \Zubr\is_nan(/* put stuff here */);
24 |         $expected = \is_nan(/* put stuff here */);
25 | 
26 |         $this->assertEquals($expected, $actual);
27 |     }
28 | }


--------------------------------------------------------------------------------
/tests/IsNullTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => is_null('23')
10 |     [returns] => false
11 | )
12 | Array
13 | (
14 |     [code] => is_null(null)
15 |     [returns] => true
16 | )
17 | */
18 | class IsNull extends PHPUnit\Framework\TestCase
19 | {
20 |     public function test()
21 |     {
22 |         $input = ['test1', 'tEsT2', 'TEST3'];
23 |         $actual = \Zubr\is_null(/* put stuff here */);
24 |         $expected = \is_null(/* put stuff here */);
25 | 
26 |         $this->assertEquals($expected, $actual);
27 |     }
28 | }


--------------------------------------------------------------------------------
/tests/IsRealTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => is_real(186.31)
10 |     [returns] => true
11 | )
12 | */
13 | class IsReal extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\is_real(/* put stuff here */);
19 |         $expected = \is_real(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/JoinTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => join(' ', ['Kevin', 'van', 'Zonneveld'])
10 |     [returns] => 'Kevin van Zonneveld'
11 | )
12 | */
13 | class Join extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\join(/* put stuff here */);
19 |         $expected = \join(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/KeyTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => var $array = {fruit1: 'apple', 'fruit2': 'orange'}
10 | key($array)
11 |     [returns] => 'fruit1'
12 | )
13 | */
14 | class Key extends PHPUnit\Framework\TestCase
15 | {
16 |     public function test()
17 |     {
18 |         $input = ['test1', 'tEsT2', 'TEST3'];
19 |         $actual = \Zubr\key(/* put stuff here */);
20 |         $expected = \key(/* put stuff here */);
21 | 
22 |         $this->assertEquals($expected, $actual);
23 |     }
24 | }


--------------------------------------------------------------------------------
/tests/LcfirstTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => lcfirst('Kevin Van Zonneveld')
10 |     [returns] => 'kevin Van Zonneveld'
11 | )
12 | */
13 | class Lcfirst extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\lcfirst(/* put stuff here */);
19 |         $expected = \lcfirst(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/LcgValueTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => var $rnd = lcg_value()
10 | var $result = $rnd >= 0 && $rnd <= 1
11 |     [returns] => true
12 | )
13 | */
14 | class LcgValue extends PHPUnit\Framework\TestCase
15 | {
16 |     public function test()
17 |     {
18 |         $input = ['test1', 'tEsT2', 'TEST3'];
19 |         $actual = \Zubr\lcg_value(/* put stuff here */);
20 |         $expected = \lcg_value(/* put stuff here */);
21 | 
22 |         $this->assertEquals($expected, $actual);
23 |     }
24 | }


--------------------------------------------------------------------------------
/tests/Log10Test.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => log10(10)
10 |     [returns] => 1
11 | )
12 | Array
13 | (
14 |     [code] => log10(1)
15 |     [returns] => 0
16 | )
17 | */
18 | class Log10 extends PHPUnit\Framework\TestCase
19 | {
20 |     public function test()
21 |     {
22 |         $input = ['test1', 'tEsT2', 'TEST3'];
23 |         $actual = \Zubr\log10(/* put stuff here */);
24 |         $expected = \log10(/* put stuff here */);
25 | 
26 |         $this->assertEquals($expected, $actual);
27 |     }
28 | }


--------------------------------------------------------------------------------
/tests/Log1pTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => log1p(1e-15)
10 |     [returns] => 9.999999999999995e-16
11 | )
12 | */
13 | class Log1p extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\log1p(/* put stuff here */);
19 |         $expected = \log1p(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/LogTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => log(8723321.4, 7)
10 |     [returns] => 8.212871815082147
11 | )
12 | */
13 | class Log extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\log(/* put stuff here */);
19 |         $expected = \log(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/Long2ipTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => long2ip( 3221234342 )
10 |     [returns] => '192.0.34.166'
11 | )
12 | */
13 | class Long2ip extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\long2ip(/* put stuff here */);
19 |         $expected = \long2ip(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/LtrimTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => ltrim('    Kevin van Zonneveld    ')
10 |     [returns] => 'Kevin van Zonneveld    '
11 | )
12 | */
13 | class Ltrim extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\ltrim(/* put stuff here */);
19 |         $expected = \ltrim(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/Md5FileTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => md5_file('test/never-change.txt')
10 |     [returns] => 'bc3aa724b0ec7dce4c26e7f4d0d9b064'
11 | )
12 | */
13 | class Md5File extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\md5_file(/* put stuff here */);
19 |         $expected = \md5_file(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/Md5Test.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => md5('Kevin van Zonneveld')
10 |     [returns] => '6e658d4bfcb59cc13f96c14450ac40b9'
11 | )
12 | */
13 | class Md5 extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\md5(/* put stuff here */);
19 |         $expected = \md5(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/MtGetrandmaxTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => mt_getrandmax()
10 |     [returns] => 2147483647
11 | )
12 | */
13 | class MtGetrandmax extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\mt_getrandmax(/* put stuff here */);
19 |         $expected = \mt_getrandmax(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/MtRandTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => mt_rand(1, 1)
10 |     [returns] => 1
11 | )
12 | */
13 | class MtRand extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\mt_rand(/* put stuff here */);
19 |         $expected = \mt_rand(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/NextTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => var $transport = ['foot', 'bike', 'car', 'plane']
10 | next($transport)
11 | next($transport)
12 |     [returns] => 'car'
13 | )
14 | */
15 | class Next extends PHPUnit\Framework\TestCase
16 | {
17 |     public function test()
18 |     {
19 |         $input = ['test1', 'tEsT2', 'TEST3'];
20 |         $actual = \Zubr\next(/* put stuff here */);
21 |         $expected = \next(/* put stuff here */);
22 | 
23 |         $this->assertEquals($expected, $actual);
24 |     }
25 | }


--------------------------------------------------------------------------------
/tests/NlLanginfoTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => nl_langinfo('DAY_1')
10 |     [returns] => 'Sunday'
11 | )
12 | */
13 | class NlLanginfo extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\nl_langinfo(/* put stuff here */);
19 |         $expected = \nl_langinfo(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/OctdecTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => octdec('77')
10 |     [returns] => 63
11 | )
12 | */
13 | class Octdec extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\octdec(/* put stuff here */);
19 |         $expected = \octdec(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/PiTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => pi(8723321.4)
10 |     [returns] => 3.141592653589793
11 | )
12 | */
13 | class Pi extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\pi(/* put stuff here */);
19 |         $expected = \pi(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/PosTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => var $transport = ['foot', 'bike', 'car', 'plane']
10 | pos($transport)
11 |     [returns] => 'foot'
12 | )
13 | */
14 | class Pos extends PHPUnit\Framework\TestCase
15 | {
16 |     public function test()
17 |     {
18 |         $input = ['test1', 'tEsT2', 'TEST3'];
19 |         $actual = \Zubr\pos(/* put stuff here */);
20 |         $expected = \pos(/* put stuff here */);
21 | 
22 |         $this->assertEquals($expected, $actual);
23 |     }
24 | }


--------------------------------------------------------------------------------
/tests/PowTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => pow(8723321.4, 7)
10 |     [returns] => 3.8439091680778995e+48
11 | )
12 | */
13 | class Pow extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\pow(/* put stuff here */);
19 |         $expected = \pow(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/PrevTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => var $transport = ['foot', 'bike', 'car', 'plane']
10 | prev($transport)
11 |     [returns] => false
12 | )
13 | */
14 | class Prev extends PHPUnit\Framework\TestCase
15 | {
16 |     public function test()
17 |     {
18 |         $input = ['test1', 'tEsT2', 'TEST3'];
19 |         $actual = \Zubr\prev(/* put stuff here */);
20 |         $expected = \prev(/* put stuff here */);
21 | 
22 |         $this->assertEquals($expected, $actual);
23 |     }
24 | }


--------------------------------------------------------------------------------
/tests/PrintRTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => print_r(1, true)
10 |     [returns] => '1'
11 | )
12 | */
13 | class PrintR extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\print_r(/* put stuff here */);
19 |         $expected = \print_r(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/PrintfTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => printf("%01.2f", 123.1)
10 |     [returns] => 6
11 | )
12 | */
13 | class Printf extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\printf(/* put stuff here */);
19 |         $expected = \printf(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/QuotemetaTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => quotemeta(". + * ? ^ ( $ )")
10 |     [returns] => '\\. \\+ \\* \\? \\^ \\( \\$ \\)'
11 | )
12 | */
13 | class Quotemeta extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\quotemeta(/* put stuff here */);
19 |         $expected = \quotemeta(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/Rad2degTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => rad2deg(3.141592653589793)
10 |     [returns] => 180
11 | )
12 | */
13 | class Rad2deg extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\rad2deg(/* put stuff here */);
19 |         $expected = \rad2deg(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/RandTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => rand(1, 1)
10 |     [returns] => 1
11 | )
12 | */
13 | class Rand extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\rand(/* put stuff here */);
19 |         $expected = \rand(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/ResetTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => reset({0: 'Kevin', 1: 'van', 2: 'Zonneveld'})
10 |     [returns] => 'Kevin'
11 | )
12 | */
13 | class Reset extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\reset(/* put stuff here */);
19 |         $expected = \reset(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/RtrimTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => rtrim('    Kevin van Zonneveld    ')
10 |     [returns] => '    Kevin van Zonneveld'
11 | )
12 | */
13 | class Rtrim extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\rtrim(/* put stuff here */);
19 |         $expected = \rtrim(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/SetTimeLimitTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => set_time_limit(4)
10 |     [returns] => undefined
11 | )
12 | */
13 | class SetTimeLimit extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\set_time_limit(/* put stuff here */);
19 |         $expected = \set_time_limit(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/SetcookieTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => setcookie('author_name', 'Kevin van Zonneveld')
10 |     [returns] => true
11 | )
12 | */
13 | class Setcookie extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\setcookie(/* put stuff here */);
19 |         $expected = \setcookie(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/SetlocaleTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => setlocale('LC_ALL', 'en_US')
10 |     [returns] => 'en_US'
11 | )
12 | */
13 | class Setlocale extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\setlocale(/* put stuff here */);
19 |         $expected = \setlocale(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/SetrawcookieTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => setrawcookie('author_name', 'Kevin van Zonneveld')
10 |     [returns] => true
11 | )
12 | */
13 | class Setrawcookie extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\setrawcookie(/* put stuff here */);
19 |         $expected = \setrawcookie(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/Sha1FileTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => sha1_file('test/never-change.txt')
10 |     [returns] => '0ea65a1f4b4d69712affc58240932f3eb8a2af66'
11 | )
12 | */
13 | class Sha1File extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\sha1_file(/* put stuff here */);
19 |         $expected = \sha1_file(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/Sha1Test.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => sha1('Kevin van Zonneveld')
10 |     [returns] => '54916d2e62f65b3afa6e192e6a601cdbe5cb5897'
11 | )
12 | */
13 | class Sha1 extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\sha1(/* put stuff here */);
19 |         $expected = \sha1(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/SinTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => Math.ceil(sin(8723321.4) * 10000000)
10 |     [returns] => -9834330
11 | )
12 | */
13 | class Sin extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\sin(/* put stuff here */);
19 |         $expected = \sin(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/SinhTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => sinh(-0.9834330348825909)
10 |     [returns] => -1.1497971402636502
11 | )
12 | */
13 | class Sinh extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\sinh(/* put stuff here */);
19 |         $expected = \sinh(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/SqrtTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => sqrt(8723321.4)
10 |     [returns] => 2953.5269424875746
11 | )
12 | */
13 | class Sqrt extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\sqrt(/* put stuff here */);
19 |         $expected = \sqrt(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/StrRepeatTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => str_repeat('-=', 10)
10 |     [returns] => '-=-=-=-=-=-=-=-=-=-='
11 | )
12 | */
13 | class StrRepeat extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\str_repeat(/* put stuff here */);
19 |         $expected = \str_repeat(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/StrShuffleTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => var $shuffled = str_shuffle("abcdef")
10 | var $result = $shuffled.length
11 |     [returns] => 6
12 | )
13 | */
14 | class StrShuffle extends PHPUnit\Framework\TestCase
15 | {
16 |     public function test()
17 |     {
18 |         $input = ['test1', 'tEsT2', 'TEST3'];
19 |         $actual = \Zubr\str_shuffle(/* put stuff here */);
20 |         $expected = \str_shuffle(/* put stuff here */);
21 | 
22 |         $this->assertEquals($expected, $actual);
23 |     }
24 | }


--------------------------------------------------------------------------------
/tests/StrSplitTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => str_split('Hello Friend', 3)
10 |     [returns] => ['Hel', 'lo ', 'Fri', 'end']
11 | )
12 | */
13 | class StrSplit extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\str_split(/* put stuff here */);
19 |         $expected = \str_split(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/StrcollTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => strcoll('a', 'b')
10 |     [returns] => -1
11 | )
12 | */
13 | class Strcoll extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\strcoll(/* put stuff here */);
19 |         $expected = \strcoll(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/StriposTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => stripos('ABC', 'a')
10 |     [returns] => 0
11 | )
12 | */
13 | class Stripos extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\stripos(/* put stuff here */);
19 |         $expected = \stripos(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/StrpbrkTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => strpbrk('This is a Simple text.', 'is')
10 |     [returns] => 'is is a Simple text.'
11 | )
12 | */
13 | class Strpbrk extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\strpbrk(/* put stuff here */);
19 |         $expected = \strpbrk(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/StrposTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => strpos('Kevin van Zonneveld', 'e', 5)
10 |     [returns] => 14
11 | )
12 | */
13 | class Strpos extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\strpos(/* put stuff here */);
19 |         $expected = \strpos(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/StrrchrTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => strrchr("Line 1\nLine 2\nLine 3", 10).substr(1)
10 |     [returns] => 'Line 3'
11 | )
12 | */
13 | class Strrchr extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\strrchr(/* put stuff here */);
19 |         $expected = \strrchr(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/StrriposTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => strripos('Kevin van Zonneveld', 'E')
10 |     [returns] => 16
11 | )
12 | */
13 | class Strripos extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\strripos(/* put stuff here */);
19 |         $expected = \strripos(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/StrtolowerTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => strtolower('Kevin van Zonneveld')
10 |     [returns] => 'kevin van zonneveld'
11 | )
12 | */
13 | class Strtolower extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\strtolower(/* put stuff here */);
19 |         $expected = \strtolower(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/StrtoupperTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => strtoupper('Kevin van Zonneveld')
10 |     [returns] => 'KEVIN VAN ZONNEVELD'
11 | )
12 | */
13 | class Strtoupper extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\strtoupper(/* put stuff here */);
19 |         $expected = \strtoupper(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/StrvalTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => strval({red: 1, green: 2, blue: 3, white: 4})
10 |     [returns] => 'Object'
11 | )
12 | */
13 | class Strval extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\strval(/* put stuff here */);
19 |         $expected = \strval(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/SubstrCompareTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => substr_compare("abcde", "bc", 1, 2)
10 |     [returns] => 0
11 | )
12 | */
13 | class SubstrCompare extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\substr_compare(/* put stuff here */);
19 |         $expected = \substr_compare(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/TanTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => Math.ceil(tan(8723321.4) * 10000000)
10 |     [returns] => 54251849
11 | )
12 | */
13 | class Tan extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\tan(/* put stuff here */);
19 |         $expected = \tan(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/TanhTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => tanh(5.4251848798444815)
10 |     [returns] => 0.9999612058841574
11 | )
12 | */
13 | class Tanh extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\tanh(/* put stuff here */);
19 |         $expected = \tanh(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/UcfirstTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => ucfirst('kevin van zonneveld')
10 |     [returns] => 'Kevin van zonneveld'
11 | )
12 | */
13 | class Ucfirst extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\ucfirst(/* put stuff here */);
19 |         $expected = \ucfirst(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/VarDumpTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => var_dump(1)
10 |     [returns] => 'int(1)'
11 | )
12 | */
13 | class VarDump extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\var_dump(/* put stuff here */);
19 |         $expected = \var_dump(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/VprintfTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => vprintf("%01.2f", 123.1)
10 |     [returns] => 6
11 | )
12 | */
13 | class Vprintf extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\vprintf(/* put stuff here */);
19 |         $expected = \vprintf(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/VsprintfTest.php.TODO:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | /* These are tests from Locutus for porting
 5 | TODO: implement adding automatically (if it's possible)
 6 | 
 7 | Array
 8 | (
 9 |     [code] => vsprintf('%04d-%02d-%02d', [1988, 8, 1])
10 |     [returns] => '1988-08-01'
11 | )
12 | */
13 | class Vsprintf extends PHPUnit\Framework\TestCase
14 | {
15 |     public function test()
16 |     {
17 |         $input = ['test1', 'tEsT2', 'TEST3'];
18 |         $actual = \Zubr\vsprintf(/* put stuff here */);
19 |         $expected = \vsprintf(/* put stuff here */);
20 | 
21 |         $this->assertEquals($expected, $actual);
22 |     }
23 | }


--------------------------------------------------------------------------------
/utils/stubs/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "nkkollaw/stubs-util",
 3 |     "authors": [
 4 |         {
 5 |             "name": "Niccolò Brogi",
 6 |             "email": "me@nbrogi.com"
 7 |         }
 8 |     ],
 9 |     "require": {
10 |         "symfony/yaml": "^3.3",
11 |         "ijortengab/parse-html": "^0.0.7",
12 |         "nkkollaw/str-utils": "^1.0"
13 |     }
14 | }
15 | 


--------------------------------------------------------------------------------
/utils/stubs/install.sh:
--------------------------------------------------------------------------------
 1 | # clean up
 2 | rm -v -r -f phpstorm-stubs locutus
 3 | 
 4 | # clone repos
 5 | git clone https://github.com/JetBrains/phpstorm-stubs.git
 6 | git clone https://github.com/kvz/locutus.git
 7 | 
 8 | # build Locutus
 9 | npm install --prefix locutus
10 | npm run --prefix locutus build
11 | composer install
12 | echo "Done :-)"


--------------------------------------------------------------------------------