import re
from urllib.parse import parse_qsl, urlsplit

import pytest

import pydash as _


parametrize = pytest.mark.parametrize


@parametrize(
    "case,expected",
    [
        ("foo bar baz", "fooBarBaz"),
        ("foo  bar baz", "fooBarBaz"),
        ("foo__bar_baz", "fooBarBaz"),
        ("foo-_bar-_-baz", "fooBarBaz"),
        ("foo!bar,baz", "fooBarBaz"),
        ("--foo.bar;baz", "fooBarBaz"),
        ("Foo!#Bar's", "fooBars"),
        ("你好,世界", "你好世界"),
        ("你好 世界", "你好世界"),
        ("你好(世界)", "你好世界"),
        ("你好（世界）", "你好（世界）"),
        ("你好，世界", "你好，世界"),
        ("Σὲ γνωρίζω ἀπὸ τὴν κόψη", "σὲΓνωρίζωἈπὸΤὴνΚόψη"),
        ("แผ่นดินฮั่นเสื่อมโทรมแสนสังเวช", "แผ่นดินฮั่นเสื่อมโทรมแสนสังเวช"),
        ("いろはにほへど　ちりぬるを", "いろはにほへどちりぬるを"),
        (
            "나는 유리를 먹을 수 있어요. 그래도 아프지 않아요",
            "나는유리를먹을수있어요그래도아프지않아요",
        ),
        ("J'peux manger d'la vitre, ça m'fa pas mal.", "jpeuxMangerDlaVitreCaMfaPasMal"),
        ("e peux manger du verre, ça ne me fait pas mal.", "ePeuxMangerDuVerreCaNeMeFaitPasMal"),
        (8, "8"),
        ("", ""),
        (None, ""),
    ],
)
def test_camel_case(case, expected):
    assert _.camel_case(case) == expected


@parametrize(
    "case,expected",
    [
        (("foo",), "Foo"),
        (("foo bar",), "Foo bar"),
        (("fOO bar",), "Foo bar"),
        (("foo Bar",), "Foo bar"),
        (("foo", False), "Foo"),
        (("foo bar", False), "Foo bar"),
        (("fOO bar", False), "FOO bar"),
        (("foo Bar", False), "Foo Bar"),
        ((8,), "8"),
        ((" ",), " "),
        (("",), ""),
        ((None,), ""),
    ],
)
def test_capitalize(case, expected):
    assert _.capitalize(*case) == expected


@parametrize(
    "case,expected",
    [
        (("foobarbaz", 3), ["foo", "bar", "baz"]),
        (("foobarbazaa", 3), ["foo", "bar", "baz", "aa"]),
        (("foo", 4), ["foo"]),
        (("foo", 0), ["foo"]),
        (("", 3), []),
        (("foo", -2), ["foo"]),
        ((None, 0), []),
        ((None, 1), []),
        ((None, -1), []),
    ],
)
def test_chop(case, expected):
    assert _.chop(*case) == expected


@parametrize(
    "case,expected",
    [
        (("foobarbaz", 3), ["foo", "bar", "baz"]),
        (("foobarbazaa", 3), ["fo", "oba", "rba", "zaa"]),
        (("foo", 4), ["foo"]),
        (("foo", 0), ["foo"]),
        (("", 3), []),
        (("foo", -2), ["foo"]),
        ((None, 0), []),
        ((None, 1), []),
        ((None, -1), []),
    ],
)
def test_chop_right(case, expected):
    assert _.chop_right(*case) == expected


@parametrize(
    "case,expected",
    [
        ("  foo bar", "foo bar"),
        ("  foo  bar", "foo bar"),
        ("  foo  bar  ", "foo bar"),
        ("", ""),
        (None, ""),
    ],
)
def test_clean(case, expected):
    assert _.clean(case) == expected


@parametrize(
    "case,expected",
    [
        ("foobar", ["f", "o", "o", "b", "a", "r"]),
        ("", []),
        (5, ["5"]),
        (-5.6, ["-", "5", ".", "6"]),
        (None, []),
    ],
)
def test_chars(case, expected):
    assert _.chars(case) == expected


@parametrize(
    "case,expected",
    [
        (("foobar", "o"), 2),
        (("foobar", "oo"), 1),
        (("foobar", "ooo"), 0),
        (("", "ooo"), 0),
        (("", None), 0),
        ((None, "ooo"), 0),
        ((None, None), 0),
        ((5, None), 0),
        ((5, 5), 1),
        ((5.5, 5), 2),
        ((5.5, "5."), 1),
        ((65.5, "5."), 1),
        ((654.5, "5."), 0),
        (("", ""), 1),
        (("1", ""), 2),
        ((1.4, ""), 4),
    ],
)
def test_count_substr(case, expected):
    assert _.count_substr(*case) == expected


@parametrize(
    "case,expected",
    [
        (
            "\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf"
            "\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf"
            "\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef"
            "\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff",
            "AAAAAAAeCEEEEIIIIDNOOOOO OUUUUYThssaaaaaaaeceeeeiiiidnooooo ouuuuythy",
        ),
        ("abcABC", "abcABC"),
        ("", ""),
        (None, ""),
    ],
)
def test_deburr(case, expected):
    assert _.deburr(case) == expected


@parametrize(
    "case,expected",
    [
        ("Foo", "foo"),
        ("Foo bar", "foo bar"),
        ("Foo Bar", "foo Bar"),
        ("FOO BAR", "fOO BAR"),
        (None, ""),
    ],
)
def test_decapitalize(case, expected):
    assert _.decapitalize(case) == expected


@parametrize(
    "case,expected",
    [
        (("abc", "c"), True),
        (("abc", "b"), False),
        (("abc", None), True),
        (("", "b"), False),
        (("", None), True),
        ((None, "b"), False),
        ((None, None), True),
        ((6.34, 4), True),
        ((6.34, 3), False),
        (("abc", "c", 3), True),
        (("abc", "c", 2), False),
        (("abc", "b", 2), True),
        (("abc", "b", 1), False),
        ((6.34, "b", 1), False),
    ],
)
def test_ends_with(case, expected):
    assert _.ends_with(*case) == expected


@parametrize(
    "case,expected",
    [
        ("abc<> &\"'`efg", "abc&lt;&gt; &amp;&quot;&#39;&#96;efg"),
        ("abc", "abc"),
        ("", ""),
        (None, ""),
    ],
)
def test_escape(case, expected):
    assert _.escape(case) == expected


@parametrize(
    "case,expected",
    [
        ("abc", "abc"),
        ("", ""),
        (None, ""),
        (
            "[pydash](http://pydash.readthedocs.org/)",
            "\\[pydash\\]\\(http://pydash\\.readthedocs\\.org/\\)",
        ),
    ],
)
def test_escape_reg_exp(case, expected):
    assert _.escape_reg_exp(case) == expected


@parametrize(
    "text,prefix,expected",
    [
        ("Hello world!", "Hello", "Hello world!"),
        (" world!", "Hello", "Hello world!"),
        ("", "Hello", "Hello"),
        ("", "", ""),
        ("1", "", "1"),
        ("1", "1", "1"),
        (5, 6, "65"),
        (None, 6, "6"),
        (None, None, ""),
    ],
)
def test_ensure_starts_with(text, prefix, expected):
    assert _.ensure_starts_with(text, prefix) == expected


@parametrize(
    "text,suffix,expected",
    [
        ("Hello world!", "world!", "Hello world!"),
        ("Hello ", "world!", "Hello world!"),
        ("", "Hello", "Hello"),
        ("", "", ""),
        ("1", "", "1"),
        ("1", "1", "1"),
        (5, 6, "56"),
        (None, 6, "6"),
        (None, None, ""),
    ],
)
def test_ensure_ends_with(text, suffix, expected):
    assert _.ensure_ends_with(text, suffix) == expected


@parametrize(
    "case,expected",
    [
        (("foobar", "oo"), True),
        (("foobar", "x"), False),
        (("foobar", "f"), True),
        (("foobar", "r"), True),
        (("foobar", ""), True),
        (("foobar", None), True),
        (("", ""), True),
        (("", None), True),
        ((None, None), True),
        ((56, 6), True),
        ((56, 7), False),
        ((5.6, "."), True),
    ],
)
def test_has_substr(case, expected):
    assert _.has_substr(*case) == expected


@parametrize(
    "case,expected",
    [
        (
            "  capitalize dash-CamelCase_underscore trim_id  ",
            "Capitalize dash camel case underscore trim",
        ),
        ("foo_bar_id", "Foo bar"),
        ("FooBar", "Foo bar"),
        (5, "5"),
        ("", ""),
        (None, ""),
    ],
)
def test_human_case(case, expected):
    assert _.human_case(case) == expected


@parametrize(
    "case,expected",
    [
        (("foobar", 0, "xx"), "xxfoobar"),
        (("foobar", 1, "xx"), "fxxoobar"),
        (("foobar", 4, "xx"), "foobxxar"),
        (("foobar", 6, "xx"), "foobarxx"),
        (("foobar", 7, "xx"), "foobarxx"),
        (("f", 7, "xx"), "fxx"),
        (("", 7, "xx"), "xx"),
        (("", 7, ""), ""),
        (("", 7, None), ""),
        ((None, 7, None), ""),
        ((None, 0, None), ""),
    ],
)
def test_insert_substr(case, expected):
    assert _.insert_substr(*case) == expected


@parametrize(
    "case,expected",
    [
        (((1, 2, 3), "."), "1.2.3"),
        ((("one", "two", "three"), "-.-"), "one-.-two-.-three"),
        ((("s", "t", "r", "i", "n", "g"), ""), "string"),
        ((("s", "t", "r", "i", "n", "g"),), "string"),
        ((("s", "t", "r", "i", "n", "g"), None), "string"),
        ((("string1", "string2"), ","), "string1,string2"),
        ((("string1", "string2"), 5.6), "string15.6string2"),
        (((None, "string2"), 5.6), "5.6string2"),
        (((7,), 5.6), "7"),
        (((None,), 5.6), ""),
        (((None, None), 5.6), "5.6"),
        (((None, None, None), 5.6), "5.65.6"),
        (((None, None, None), None), ""),
        ((None, None), ""),
    ],
)
def test_join(case, expected):
    assert _.join(*case) == expected


@parametrize(
    "case,expected",
    [
        ("foo  bar baz", "foo-bar-baz"),
        ("foo__bar_baz", "foo-bar-baz"),
        ("foo-_bar-_-baz", "foo-bar-baz"),
        ("foo!bar,baz", "foo-bar-baz"),
        ("--foo.bar;baz", "foo-bar-baz"),
        ("Foo Bar", "foo-bar"),
        ("fooBar", "foo-bar"),
        ("你好,世界", "你好-世界"),
        ("你好(世界)", "你好-世界"),
        ("你好（世界）", "你好（世界）"),
        ("Σὲ γνωρίζω ἀπὸ τὴν κόψη", "σὲ-γνωρίζω-ἀπὸ-τὴν-κόψη"),
        ("แผ่นดินฮั่นเสื่อมโทรมแสนสังเวช", "แผ่นดินฮั่นเสื่อมโทรมแสนสังเวช"),
        ("いろはにほへど　ちりぬるを", "いろはにほへど-ちりぬるを"),
        (
            "나는 유리를 먹을 수 있어요. 그래도 아프지 않아요",
            "나는-유리를-먹을-수-있어요-그래도-아프지-않아요",
        ),
        ("J'peux manger d'la vitre, ça m'fa pas mal.", "jpeux-manger-dla-vitre-ca-mfa-pas-mal"),
        (
            "e peux manger du verre, ça ne me fait pas mal.",
            "e-peux-manger-du-verre-ca-ne-me-fait-pas-mal",
        ),
        (None, ""),
        (5, "5"),
        (5.6, "5-6"),
        (-5.6, "5-6"),
    ],
)
def test_kebab_case(case, expected):
    assert _.kebab_case(case) == expected


@parametrize(
    "case,expected",
    [
        ("foo\nbar", ["foo", "bar"]),
        ("foo\rbar", ["foo", "bar"]),
        ("foo\r\nbar", ["foo", "bar"]),
        ("foo\n", ["foo"]),
        ("\nfoo", ["", "foo"]),
        ("", []),
        (None, []),
    ],
)
def test_lines(case, expected):
    assert _.lines(case) == expected


@parametrize(
    "case,expected",
    [  # noqa
        ("fooBar", "foo bar"),
        ("--foo-Bar--", "foo bar"),
        ("*Foo*B_a*R", "foo b a r"),
        ("*Foo10_B*Ar", "foo 10 b ar"),
        ('/?*Foo10/;"B*Ar', "foo 10 b ar"),
        ('/?F@O__o10456?>.B?>";Ar', "f o o 10456 b ar"),
        ("FoO Bar", "fo o bar"),
        ("F\n\\soO Bar", "f so o bar"),
        ("Foo1054665Bar", "foo 1054665 bar"),
    ],
)
def test_lower_case(case, expected):
    assert _.lower_case(case) == expected


@parametrize(
    "case,expected",
    [("Foobar", "foobar"), ("Foo Bar", "foo Bar"), ("1foobar", "1foobar"), (";foobar", ";foobar")],
)
def test_lower_first(case, expected):
    assert _.lower_first(case) == expected


@parametrize(
    "case,expected",
    [
        ((1234,), "1,234"),
        ((1234567890,), "1,234,567,890"),
        ((1234, 2), "1,234.00"),
        ((1234, 1), "1,234.0"),
        ((1234, 2, ",", "."), "1.234,00"),
        (("1234",), ""),
    ],
)
def test_number_format(case, expected):
    assert _.number_format(*case) == expected


@parametrize(
    "case,expected",
    [
        (("abc", 5, "12"), "1abc1"),
        (("abc", 8), "  abc   "),
        (("abc", 8, "_-"), "_-abc_-_"),
        (("abc", 3), "abc"),
        (("", 3), "   "),
        ((" ", 3), "   "),
        ((None, 3), "   "),
    ],
)
def test_pad(case, expected):
    assert _.pad(*case) == expected


@parametrize(
    "case,expected",
    [
        (("aaaaa", 3), "aaaaa"),
        (("aaaaa", 6), " aaaaa"),
        (("aaaaa", 10), "     aaaaa"),
        (("aaaaa", 6, "b"), "baaaaa"),
        (("aaaaa", 6, "bc"), "caaaaa"),
        (("aaaaa", 9, "bc"), "bcbcaaaaa"),
        (("a", 9, "12"), "12121212a"),
        (("a", 8, "12"), "2121212a"),
        (("", 8, "12"), "12121212"),
        ((None, 8, "12"), "12121212"),
    ],
)
def test_pad_start(case, expected):
    assert _.pad_start(*case) == expected


@parametrize(
    "case,expected",
    [
        (("aaaaa", 3), "aaaaa"),
        (("aaaaa", 6), "aaaaa "),
        (("aaaaa", 10), "aaaaa     "),
        (("aaaaa", 6, "b"), "aaaaab"),
        (("aaaaa", 6, "bc"), "aaaaab"),
        (("aaaaa", 9, "bc"), "aaaaabcbc"),
        (("a", 9, "12"), "a12121212"),
        (("a", 8, "12"), "a1212121"),
        (("", 8, "12"), "12121212"),
        ((None, 8, "12"), "12121212"),
    ],
)
def test_pad_end(case, expected):
    assert _.pad_end(*case) == expected


@parametrize(
    "case,expected",
    [
        ("foo bar baz", "FooBarBaz"),
        ("foo  bar baz", "FooBarBaz"),
        ("foo__bar_baz", "FooBarBaz"),
        ("foo-_bar-_-baz", "FooBarBaz"),
        ("foo!bar,baz", "FooBarBaz"),
        ("--foo.bar;baz", "FooBarBaz"),
        ("", ""),
        (None, ""),
    ],
)
def test_pascal_case(case, expected):
    assert _.pascal_case(case) == expected


@parametrize(
    "case,expected",
    [
        ("b", "a"),
        ("B", "A"),
    ],
)
def test_predecessor(case, expected):
    assert _.predecessor(case) == expected


@parametrize(
    "case,expected",
    [
        (("Hello, world",), "..."),
        (("Hello, world", 5), "Hello..."),
        (("Hello, world", 8), "Hello..."),
        (("Hello, world", 5, " (read a lot more)"), "Hello, world"),
        (("Hello, cruel world", 15), "Hello, cruel..."),
        (("Hello", 10), "Hello"),
        (("", 10), ""),
        (("",), ""),
        ((None,), ""),
    ],
)
def test_prune(case, expected):
    assert _.prune(*case) == expected


@parametrize(
    "case,expected",
    [
        (("hello world!",), '"hello world!"'),
        (("",), '""'),
        (("", None), ""),
        ((None,), '""'),
        ((None, None), ""),
        ((5,), '"5"'),
        ((5, None), "5"),
        ((-89,), '"-89"'),
        (("hello world!", "*"), "*hello world!*"),
        (("hello world!", "**"), "**hello world!**"),
        (("", "**"), "****"),
        (("hello world!", ""), "hello world!"),
        ((28, "**"), "**28**"),
        ((28, ""), "28"),
        ((2, 8), "828"),
        ((-2, 8), "8-28"),
        ((-2, -8), "-8-2-8"),
        ((-8.5, 0), "0-8.50"),
    ],
)
def test_quote(case, expected):
    assert _.quote(*case) == expected


@parametrize(
    "case,expected",
    [
        (("Hello World", "/[A-Z]/"), ["H"]),
        (("Hello World", "/[A-Z]/g"), ["H", "W"]),
        (("hello world", "/[A-Z]/i"), ["h"]),
        (("hello world", "/[A-Z]/gi"), ["h", "e", "l", "l", "o", "w", "o", "r", "l", "d"]),
        (("12345", "/[A-Z]/"), []),
    ],
)
def test_reg_exp_js_match(case, expected):
    assert _.reg_exp_js_match(*case) == expected


@parametrize(
    "case,expected",
    [
        (("Hello World", "/[A-Z]/", "!"), "!ello World"),
        (("Hello World", "/[A-Z]/g", "!"), "!ello !orld"),
        (("hello world", "/[A-Z]/i", "!"), "!ello world"),
        (("hello world", "/[A-Z]/gi", "!"), "!!!!! !!!!!"),
        (("hello world", "/[A-Z]/gi", ""), " "),
        (("hello world", "/[A-Z]/gi", None), " "),
    ],
)
def test_reg_exp_js_replace(case, expected):
    assert _.reg_exp_js_replace(*case) == expected


@parametrize(
    "case,expected",
    [
        (("foo", "o", "a"), "faa"),
        (("foo", "o", "a", False, 1), "fao"),
        (("fOO", "o", "a"), "fOO"),
        (("fOO", "o", "a", True), "faa"),
        (("", "", ""), ""),
        (("foo", "o", ""), "f"),
        (("foo", "x", "y"), "foo"),
        (("foo", "^o", "a"), "foo"),
        (("ooo", "^o", "f"), "foo"),
        (("foo", "o$", "a"), "foa"),
        (("foo", "", "a"), "afaoaoa"),
        (("foo", "", ""), "foo"),
        (("foo", "", None), "foo"),
        (("foo", None, None), "foo"),
        (("foo", None, ""), "foo"),
        (("foo", None, "a"), "foo"),
        ((54.7, 5, 6), "64.7"),
    ],
)
def test_reg_exp_replace(case, expected):
    assert _.reg_exp_replace(*case) == expected


@parametrize(
    "case,expected",
    [
        (("foo",), ""),
        (("foo", 0), ""),
        (("foo", 1), "foo"),
        (("foo", 3), "foofoofoo"),
        (("", 3), ""),
        (("", 0), ""),
        ((None, 0), ""),
        ((None, 1), ""),
    ],
)
def test_repeat(case, expected):
    assert _.repeat(*case) == expected


@parametrize(
    "case,expected",
    [
        (("foo", "o", "a"), "faa"),
        (("foo", re.compile("o"), "a"), "faa"),
        (("foo", "o", "a", False, 1), "fao"),
        (("fOO", "o", "a"), "fOO"),
        (("fOO", "o", "a", True), "faa"),
        (("", "", ""), ""),
        (("foo", "o", ""), "f"),
        (("foo", "x", "y"), "foo"),
        (("foo", "", ""), "foo"),
        (("foo", "", None), "foo"),
        (("foo", None, None), "foo"),
        (("foo", None, ""), "foo"),
        (("foo", None, "a"), "foo"),
        ((54.7, 5, 6), "64.7"),
    ],
)
def test_replace(case, expected):
    assert _.replace(*case) == expected


@parametrize(
    "case,expected",
    [
        (("foo", "o", "a"), "foa"),
        (("foo", "f", "a"), "foo"),
    ],
)
def test_replace_end(case, expected):
    assert _.replace_end(*case) == expected


@parametrize(
    "case,expected",
    [
        (("foo", "o", "a"), "foo"),
        (("foo", "f", "a"), "aoo"),
    ],
)
def test_replace_start(case, expected):
    assert _.replace_start(*case) == expected


@parametrize(
    "case,expected",
    [
        (("foo  bar baz", "-"), "foo-bar-baz"),
        (("foo__bar_baz", "-"), "foo-bar-baz"),
        (("foo-_bar-_-baz", "-"), "foo-bar-baz"),
        (("foo!bar,baz", "-"), "foo-bar-baz"),
        (("--foo.bar;baz", "-"), "foo-bar-baz"),
        (("Foo Bar", "-"), "foo-bar"),
        (("foo  bar baz", "_"), "foo_bar_baz"),
        (("foo__bar_baz", "_"), "foo_bar_baz"),
        (("foo-_bar-_-baz", "_"), "foo_bar_baz"),
        (("foo!bar,baz", "_"), "foo_bar_baz"),
        (("--foo.bar;baz", "_"), "foo_bar_baz"),
        (("Foo Bar", "_"), "foo_bar"),
        (("", "_"), ""),
        ((None, "_"), ""),
    ],
)
def test_separator_case(case, expected):
    assert _.separator_case(*case) == expected


@parametrize(
    "case,expected",
    [
        (([],), ""),
        ((tuple(),), ""),
        (((None,),), ""),
        (((None, None),), ""),
        ((("", None),), ""),
        (((None, ""),), ""),
        (((None, 5),), "5"),
        (((7.88, None),), "7.88"),
        ((["", ""],), ""),
        ((["foo"],), "foo"),
        ((["foo", "bar"],), "foo and bar"),
        ((["foo", "bar", "baz"],), "foo, bar and baz"),
        ((["foo", "bar", "baz", "qux"], ", ", " or "), "foo, bar, baz or qux"),
        ((["foo", "bar", "baz", "qux"], ";", " or "), "foo;bar;baz or qux"),
        ((["foo", "bar", "baz", "qux"], 0.6, " or "), "foo0.6bar0.6baz or qux"),
        ((["foo", "bar", "baz", "qux"], 0.6, 1), "foo0.6bar0.6baz1qux"),
        ((["foo", "bar", "baz", "qux"], 0.6, None), "foo0.6bar0.6bazqux"),
        ((["foo", 23, "baz", "qux"], None, None), "foo23bazqux"),
    ],
)
def test_series_phrase(case, expected):
    assert _.series_phrase(*case) == expected


@parametrize(
    "case,expected",
    [
        (([],), ""),
        ((tuple(),), ""),
        (((None,),), ""),
        (((None, None),), ""),
        ((("", None),), ""),
        (((None, ""),), ""),
        (((None, 5),), "5"),
        (((7.88, None),), "7.88"),
        ((["", ""],), ""),
        ((["foo"],), "foo"),
        ((["foo", "bar"],), "foo and bar"),
        ((["foo", "bar", "baz"],), "foo, bar, and baz"),
        ((["foo", "bar", "baz", "qux"], ", ", " or "), "foo, bar, baz, or qux"),
        ((["foo", "bar", "baz", "qux"], ";", " or "), "foo;bar;baz; or qux"),
    ],
)
def test_series_phrase_serial(case, expected):
    assert _.series_phrase_serial(*case) == expected


@parametrize(
    "case,expected",
    [
        ("Foo Bar", "foo-bar"),
        (" foo bar ", "foo-bar"),
        ("Un éléphant à l'orée du bois", "un-elephant-a-loree-du-bois"),
        ("shouldn't couldn't wouldn't", "shouldnt-couldnt-wouldnt"),
        ("", ""),
        (5, "5"),
        (None, ""),
    ],
)
def test_slugify(case, expected):
    assert _.slugify(case) == expected


@parametrize(
    "case,expected",
    [
        ("foo  bar baz", "foo_bar_baz"),
        ("foo__bar_baz", "foo_bar_baz"),
        ("foo-_bar-_-baz", "foo_bar_baz"),
        ("foo!bar,baz", "foo_bar_baz"),
        ("--foo.bar;baz", "foo_bar_baz"),
        ("FooBar", "foo_bar"),
        ("fooBar", "foo_bar"),
        ("你好,世界", "你好_世界"),
        ("你好(世界)", "你好_世界"),
        ("你好（世界）", "你好（世界）"),
        ("你好，世界", "你好，世界"),
        ("Σὲ γνωρίζω ἀπὸ τὴν κόψη", "σὲ_γνωρίζω_ἀπὸ_τὴν_κόψη"),
        ("แผ่นดินฮั่นเสื่อมโทรมแสนสังเวช", "แผ่นดินฮั่นเสื่อมโทรมแสนสังเวช"),
        ("いろはにほへど　ちりぬるを", "いろはにほへど_ちりぬるを"),
        (
            "나는 유리를 먹을 수 있어요. 그래도 아프지 않아요",
            "나는_유리를_먹을_수_있어요_그래도_아프지_않아요",
        ),
        ("J'peux manger d'la vitre, ça m'fa pas mal.", "jpeux_manger_dla_vitre_ca_mfa_pas_mal"),
        (
            "e peux manger du verre, ça ne me fait pas mal.",
            "e_peux_manger_du_verre_ca_ne_me_fait_pas_mal",
        ),
        ("", ""),
        (None, ""),
        (5, "5"),
    ],
)
def test_snake_case(case, expected):
    assert _.snake_case(case) == expected


@parametrize(
    "case,expected",
    [
        (("string1 string2",), ["string1", "string2"]),
        (("string", ""), ["s", "t", "r", "i", "n", "g"]),
        (("string", None), ["s", "t", "r", "i", "n", "g"]),
        (("", ""), []),
        (("", None), []),
        ((None, None), []),
        (("string1,string2", ","), ["string1", "string2"]),
    ],
)
def test_split(case, expected):
    assert _.split(*case) == expected


@parametrize(
    "case,expected",
    [
        ("foo bar baz", "Foo Bar Baz"),
        ("foo-bar-baz", "Foo Bar Baz"),
        ("Foo!#Bar's", "Foo Bars"),
        ("fooBar", "Foo Bar"),
        ("___FOO-BAR___", "FOO BAR"),
        ("XMLHttp", "XML Http"),
        ("", ""),
        (None, ""),
        (5, "5"),
    ],
)
def test_start_case(case, expected):
    assert _.start_case(case) == expected


@parametrize(
    "case,expected",
    [
        (("abc", "a"), True),
        (("abc", "b"), False),
        (("abc", "a", 0), True),
        (("abc", "a", 1), False),
        (("abc", "b", 1), True),
        (("abc", "b", 2), False),
        ((5.78, 5), True),
        (("5.78", 5), True),
        ((5.78, "5"), True),
        ((5.78, ""), True),
        ((5.78, None), True),
        ((None, None), True),
        (("", None), True),
        ((" ", None), True),
    ],
)
def test_starts_with(case, expected):
    assert _.starts_with(*case) == expected


@parametrize(
    "case,expected",
    [
        ('a <a href="#">link</a>', "a link"),
        (
            'a <a href="#">link</a><script>alert("hello world!")</script>',
            'a linkalert("hello world!")',
        ),
        ("", ""),
        (None, ""),
    ],
)
def test_strip_tags(case, expected):
    assert _.strip_tags(case) == expected


@parametrize(
    "case,expected",
    [
        (("This_is_a_test_string", "_"), "This"),
        (("This_is_a_test_string", ""), "This_is_a_test_string"),
        (("This_is_a_test_string", " "), "This_is_a_test_string"),
        (("This_is_a_test_string", None), "This_is_a_test_string"),
        ((None, None), ""),
        ((None, "4"), ""),
        ((None, ""), ""),
    ],
)
def test_substr_left(case, expected):
    assert _.substr_left(*case) == expected


@parametrize(
    "case,expected",
    [
        (("This_is_a_test_string", "_"), "This_is_a_test"),
        (("This_is_a_test_string", ""), "This_is_a_test_string"),
        (("This_is_a_test_string", " "), "This_is_a_test_string"),
        (("This_is_a_test_string", None), "This_is_a_test_string"),
        ((None, None), ""),
        ((None, "4"), ""),
        ((None, ""), ""),
    ],
)
def test_substr_left_end(case, expected):
    assert _.substr_left_end(*case) == expected


@parametrize(
    "case,expected",
    [
        (("This_is_a_test_string", "_"), "is_a_test_string"),
        (("This_is_a_test_string", ""), "This_is_a_test_string"),
        (("This_is_a_test_string", " "), "This_is_a_test_string"),
        (("This_is_a_test_string", None), "This_is_a_test_string"),
        ((None, None), ""),
        ((None, "4"), ""),
        ((None, ""), ""),
    ],
)
def test_substr_right(case, expected):
    assert _.substr_right(*case) == expected


@parametrize(
    "case,expected",
    [
        (("This_is_a_test_string", "_"), "string"),
        (("This_is_a_test_string", ""), "This_is_a_test_string"),
        (("This_is_a_test_string", " "), "This_is_a_test_string"),
        (("This_is_a_test_string", None), "This_is_a_test_string"),
        ((None, None), ""),
        ((None, "4"), ""),
        ((None, ""), ""),
    ],
)
def test_substr_right_end(case, expected):
    assert _.substr_right_end(*case) == expected


@parametrize(
    "case,expected",
    [
        ("a", "b"),
        ("A", "B"),
    ],
)
def test_successor(case, expected):
    assert _.successor(case) == expected


@parametrize(
    "source,wrapper,expected",
    [
        ("hello world!", "*", "*hello world!*"),
        ("hello world!", "**", "**hello world!**"),
        ("", "**", "****"),
        ("hello world!", "", "hello world!"),
        (5, "1", "151"),
        (5, 1, "151"),
        ("5", 1, "151"),
        ("5", 12, "12512"),
        (5, "", "5"),
        ("", 5, "55"),
        ("", None, ""),
        (None, None, ""),
        (5, None, "5"),
    ],
)
def test_surround(source, wrapper, expected):
    assert _.surround(source, wrapper) == expected


@parametrize(
    "case,expected",
    [
        ("fOoBaR", "FoObAr"),
        ("", ""),
        (None, ""),
    ],
)
def test_swap_case(case, expected):
    assert _.swap_case(case) == expected


@parametrize(
    "case,expected",
    [
        ("foo bar baz", "Foo Bar Baz"),
        ("they're bill's friends from the UK", "They're Bill's Friends From The Uk"),
        ("", ""),
        (None, ""),
        (5, "5"),
    ],
)
def test_title_case(case, expected):
    assert _.title_case(case) == expected


@parametrize(
    "case,expected",
    [("--Foo-Bar--", "--foo-bar--"), ("fooBar", "foobar"), ("__FOO_BAR__", "__foo_bar__")],
)
def test_to_lower(case, expected):
    assert _.to_lower(case) == expected


@parametrize(
    "case,expected",
    [("--Foo-Bar--", "--FOO-BAR--"), ("fooBar", "FOOBAR"), ("__FOO_BAR__", "__FOO_BAR__")],
)
def test_to_upper(case, expected):
    assert _.to_upper(case) == expected


@parametrize(
    "case,expected",
    [
        (("  fred  ",), "fred"),
        (("-_-fred-_-", "_-"), "fred"),
        (("-_-fred-_-", None), "-_-fred-_-"),
        ((None,), ""),
        ((None, None), ""),
    ],
)
def test_trim(case, expected):
    assert _.trim(*case) == expected


@parametrize(
    "case,expected",
    [
        (("  fred  ",), "fred  "),
        (("-_-fred-_-", "_-"), "fred-_-"),
        (("-_-fred-_-", None), "-_-fred-_-"),
        ((None,), ""),
        ((None, None), ""),
    ],
)
def test_trim_start(case, expected):
    assert _.trim_start(*case) == expected


@parametrize(
    "case,expected",
    [
        (("  fred  ",), "  fred"),
        (("-_-fred-_-", "_-"), "-_-fred"),
        (("-_-fred-_-", None), "-_-fred-_-"),
        ((None,), ""),
        ((None, None), ""),
    ],
)
def test_trim_end(case, expected):
    assert _.trim_end(*case) == expected


@parametrize(
    "case,expected",
    [
        (("hi-diddly-ho there, neighborino",), "hi-diddly-ho there, neighbo..."),
        (("hi-diddly-ho there, neighborino", 24), "hi-diddly-ho there, n..."),
        (("hi-diddly-ho there, neighborino", 24, "...", " "), "hi-diddly-ho there,..."),
        (
            ("hi-diddly-ho there, neighborino", 24, "...", re.compile(",? +")),
            "hi-diddly-ho there...",
        ),
        (("hi-diddly-ho there, neighborino", 30, " [...]"), "hi-diddly-ho there, neig [...]"),
        (("123456789", 9), "123456789"),
        (("123456789", 8), "12345..."),
        (("x",), "x"),
        ((" ",), " "),
        (("",), ""),
        ((None,), ""),
    ],
)
def test_truncate(case, expected):
    assert _.truncate(*case) == expected


@parametrize(
    "case,expected",
    [
        ("abc&lt;&gt; &amp;&quot;&#39;&#96;efg", "abc<> &\"'`efg"),
        ("", ""),
        (" ", " "),
        (None, ""),
    ],
)
def test_unescape(case, expected):
    assert _.unescape(case) == expected


@parametrize(
    "case,expected",
    [
        (('"foo"',), "foo"),
        (("'foo'", "'"), "foo"),
        (('"foo',), '"foo'),
        (('foo"',), 'foo"'),
        ((" ",), " "),
        (("",), ""),
        ((None,), ""),
    ],
)
def test_unquote(case, expected):
    assert _.unquote(*case) == expected


@parametrize(
    "case,expected",
    [  # noqa
        ("fooBar", "FOO BAR"),
        ("--foo-Bar--", "FOO BAR"),
        ("*Foo*B_a*R", "FOO B A R"),
        ("*Foo10_B*Ar", "FOO 10 B AR"),
        ('/?*Foo10/;"B*Ar', "FOO 10 B AR"),
        ('/?F@O__o10456?>.B?>";Ar', "F O O 10456 B AR"),
        ("FoO Bar", "FO O BAR"),
        ("F\n\\soO Bar", "F SO O BAR"),
        ("Foo1054665Bar", "FOO 1054665 BAR"),
    ],
)
def test_upper_case(case, expected):
    assert _.upper_case(case) == expected


@parametrize(
    "case,expected",
    [("foobar", "Foobar"), ("Foobar", "Foobar"), ("1foobar", "1foobar"), (";foobar", ";foobar")],
)
def test_upper_first(case, expected):
    assert _.upper_first(case) == expected


@parametrize(
    "case,expected",
    [
        ({"args": [""], "kwargs": {}}, ""),
        ({"args": ["/"], "kwargs": {}}, "/"),
        ({"args": ["http://github.com"], "kwargs": {}}, "http://github.com"),
        ({"args": ["http://github.com:80"], "kwargs": {}}, "http://github.com:80"),
        (
            {"args": ["http://github.com:80", "pydash", "issues/"], "kwargs": {}},
            "http://github.com:80/pydash/issues/",
        ),
        ({"args": ["/foo", "bar", "/baz", "/qux/"], "kwargs": {}}, "/foo/bar/baz/qux/"),
        ({"args": ["/foo/bar"], "kwargs": {"a": 1, "b": "two"}}, "/foo/bar?a=1&b=two"),
        ({"args": ["/foo/bar?x=5"], "kwargs": {"a": 1, "b": "two"}}, "/foo/bar?x=5&a=1&b=two"),
        (
            {"args": ["/foo/bar?x=5", "baz?z=3"], "kwargs": {"a": 1, "b": "two"}},
            "/foo/bar/baz?x=5&a=1&b=two&z=3",
        ),
        (
            {"args": ["/foo/bar?x=5", "baz?z=3"], "kwargs": {"a": [1, 2], "b": "two"}},
            "/foo/bar/baz?x=5&a=1&a=2&b=two&z=3",
        ),
        (
            {"args": ["/foo#bar", "baz"], "kwargs": {"a": [1, 2], "b": "two"}},
            "/foo?a=1&a=2&b=two#bar/baz",
        ),
        (
            {"args": ["/foo", "baz#bar"], "kwargs": {"a": [1, 2], "b": "two"}},
            "/foo/baz?a=1&a=2&b=two#bar",
        ),
    ],
)
def test_url(case, expected):
    result = _.url(*case["args"], **case["kwargs"])

    r_scheme, r_netloc, r_path, r_query, r_fragment = urlsplit(result)
    e_scheme, e_netloc, e_path, e_query, e_fragment = urlsplit(expected)

    assert r_scheme == e_scheme
    assert r_netloc == e_netloc
    assert r_path == e_path
    assert set(parse_qsl(r_query)) == set(parse_qsl(e_query))
    assert r_fragment == e_fragment


@parametrize(
    "case,expected",
    [  # noqa
        ("hello world!", ["hello", "world"]),  # noqa
        ("hello_world", ["hello", "world"]),
        ("hello!@#$%^&*()_+{}|:\"<>?-=[]\\;\\,.'/world", ["hello", "world"]),
        ("hello 12345 world", ["hello", "12345", "world"]),
        ("enable 24h format", ["enable", "24", "h", "format"]),
        ("tooLegit2Quit", ["too", "Legit", "2", "Quit"]),
        ("xhr2Request", ["xhr", "2", "Request"]),
        (" ", []),
        ("", []),
        (None, []),
    ],
)
def test_words(case, expected):
    assert _.words(case) == expected


@parametrize(
    "case,expected",
    [
        ("enable 24h format", "enable24HFormat"),
    ],
)
def test_word_cycle(case, expected):
    actual = _.chain(case).camel_case().kebab_case().snake_case().start_case().camel_case().value()

    assert actual == expected