diff options
Diffstat (limited to 'vendor/github.com/mgutz/str/str_test.go')
| -rw-r--r-- | vendor/github.com/mgutz/str/str_test.go | 696 |
1 files changed, 696 insertions, 0 deletions
diff --git a/vendor/github.com/mgutz/str/str_test.go b/vendor/github.com/mgutz/str/str_test.go new file mode 100644 index 000000000..3186a387d --- /dev/null +++ b/vendor/github.com/mgutz/str/str_test.go @@ -0,0 +1,696 @@ +package str + +//import "testing" +import "fmt" + +//import "strings" + +func ExampleBetween() { + eg(1, Between("<a>foo</a>", "<a>", "</a>")) + eg(2, Between("<a>foo</a></a>", "<a>", "</a>")) + eg(3, Between("<a><a>foo</a></a>", "<a>", "</a>")) + eg(4, Between("<a><a>foo</a></a>", "<a>", "</a>")) + eg(5, Between("<a>foo", "<a>", "</a>")) + eg(6, Between("Some strings } are very {weird}, dont you think?", "{", "}")) + eg(7, Between("This is ateststring", "", "test")) + eg(8, Between("This is ateststring", "test", "")) + // Output: + // 1: foo + // 2: foo + // 3: <a>foo + // 4: <a>foo + // 5: + // 6: weird + // 7: This is a + // 8: string +} + +func ExampleBetweenF() { + eg(1, Pipe("abc", BetweenF("a", "c"))) + // Output: + // 1: b +} + +func ExampleCamelize() { + eg(1, Camelize("data_rate")) + eg(2, Camelize("background-color")) + eg(3, Camelize("-moz-something")) + eg(4, Camelize("_car_speed_")) + eg(5, Camelize("yes_we_can")) + // Output: + // 1: dataRate + // 2: backgroundColor + // 3: MozSomething + // 4: CarSpeed + // 5: yesWeCan +} + +func ExampleCapitalize() { + eg(1, Capitalize("abc")) + eg(2, Capitalize("ABC")) + // Output: + // 1: Abc + // 2: Abc +} + +func ExampleCharAt() { + eg(1, CharAt("abc", 1)) + eg(2, CharAt("", -1)) + eg(3, CharAt("", 0)) + eg(4, CharAt("", 10)) + eg(5, CharAt("abc", -1)) + eg(6, CharAt("abc", 10)) + // Output: + // 1: b + // 2: + // 3: + // 4: + // 5: + // 6: +} + +func ExampleCharAtF() { + eg(1, Pipe("abc", CharAtF(1))) + // Output: + // 1: b +} + +func ExampleChompLeft() { + eg(1, ChompLeft("foobar", "foo")) + eg(2, ChompLeft("foobar", "bar")) + eg(3, ChompLeft("", "foo")) + eg(4, ChompLeft("", "")) + eg(5, ChompLeft("foo", "")) + // Output: + // 1: bar + // 2: foobar + // 3: + // 4: + // 5: foo +} + +func ExampleChompLeftF() { + eg(1, Pipe("abc", ChompLeftF("ab"))) + // Output: + // 1: c +} + +func ExampleChompRight() { + eg(1, ChompRight("foobar", "foo")) + eg(2, ChompRight("foobar", "bar")) + eg(3, ChompRight("", "foo")) + eg(4, ChompRight("", "")) + // Output: + // 1: foobar + // 2: foo + // 3: + // 4: +} + +func ExampleChompRightF() { + eg(1, Pipe("abc", ChompRightF("bc"))) + // Output: + // 1: a +} + +func ExampleClassify() { + eg(1, Classify("data_rate")) + eg(2, Classify("background-color")) + eg(3, Classify("-moz-something")) + eg(4, Classify("_car_speed_")) + eg(5, Classify("yes_we_can")) + // Output: + // 1: DataRate + // 2: BackgroundColor + // 3: MozSomething + // 4: CarSpeed + // 5: YesWeCan +} + +func ExampleClean() { + eg(1, Clean("clean")) + eg(2, Clean("")) + eg(3, Clean(" please\t clean \t \n me ")) + // Output: + // 1: clean + // 2: + // 3: please clean me +} + +func ExampleDasherize() { + eg(1, Dasherize("dataRate")) + eg(2, Dasherize("CarSpeed")) + eg(3, Dasherize("yesWeCan")) + eg(4, Dasherize("")) + eg(5, Dasherize("ABC")) + // Output: + // 1: data-rate + // 2: -car-speed + // 3: yes-we-can + // 4: + // 5: -a-b-c +} + +func ExampleDecodeHTMLEntities() { + eg(1, DecodeHTMLEntities("Ken Thompson & Dennis Ritchie")) + eg(2, DecodeHTMLEntities("3 < 4")) + eg(3, DecodeHTMLEntities("http://")) + // Output: + // 1: Ken Thompson & Dennis Ritchie + // 2: 3 < 4 + // 3: http:// +} + +func ExampleEnsurePrefix() { + eg(1, EnsurePrefix("foobar", "foo")) + eg(2, EnsurePrefix("bar", "foo")) + eg(3, EnsurePrefix("", "")) + eg(4, EnsurePrefix("foo", "")) + eg(5, EnsurePrefix("", "foo")) + // Output: + // 1: foobar + // 2: foobar + // 3: + // 4: foo + // 5: foo +} + +func ExampleEnsurePrefixF() { + eg(1, Pipe("dir", EnsurePrefixF("./"))) + // Output: + // 1: ./dir +} + +func ExampleEnsureSuffix() { + eg(1, EnsureSuffix("foobar", "bar")) + eg(2, EnsureSuffix("foo", "bar")) + eg(3, EnsureSuffix("", "")) + eg(4, EnsureSuffix("foo", "")) + eg(5, EnsureSuffix("", "bar")) + // Output: + // 1: foobar + // 2: foobar + // 3: + // 4: foo + // 5: bar +} + +func ExampleHumanize() { + eg(1, Humanize("the_humanize_string_method")) + eg(2, Humanize("ThehumanizeStringMethod")) + eg(3, Humanize("the humanize string method")) + // Output: + // 1: The humanize string method + // 2: Thehumanize string method + // 3: The humanize string method +} + +func ExampleIif() { + eg(1, Iif(true, "T", "F")) + eg(2, Iif(false, "T", "F")) + // Output: + // 1: T + // 2: F +} + +func ExampleIndexOf() { + eg(1, IndexOf("abcdef", "a", 0)) + eg(2, IndexOf("abcdef", "a", 3)) + eg(3, IndexOf("abcdef", "a", -2)) + eg(4, IndexOf("abcdef", "a", 10)) + eg(5, IndexOf("", "a", 0)) + eg(6, IndexOf("abcdef", "", 2)) + eg(7, IndexOf("abcdef", "", 1000)) + // Output: + // 1: 0 + // 2: -1 + // 3: -1 + // 4: -1 + // 5: -1 + // 6: 2 + // 7: 6 +} + +func ExampleIsAlpha() { + eg(1, IsAlpha("afaf")) + eg(2, IsAlpha("FJslfjkasfs")) + eg(3, IsAlpha("áéúóúÁÉÍÓÚãõÃÕàèìòùÀÈÌÒÙâêîôûÂÊÎÔÛäëïöüÄËÏÖÜçÇ")) + eg(4, IsAlpha("adflj43faljsdf")) + eg(5, IsAlpha("33")) + eg(6, IsAlpha("TT....TTTafafetstYY")) + eg(7, IsAlpha("-áéúóúÁÉÍÓÚãõÃÕàèìòùÀÈÌÒÙâêîôûÂÊÎÔÛäëïöüÄËÏÖÜçÇ")) + // Output: + // 1: true + // 2: true + // 3: true + // 4: false + // 5: false + // 6: false + // 7: false +} + +func eg(index int, example interface{}) { + output := fmt.Sprintf("%d: %v", index, example) + fmt.Printf("%s\n", Clean(output)) +} + +func ExampleIsAlphaNumeric() { + eg(1, IsAlphaNumeric("afaf35353afaf")) + eg(2, IsAlphaNumeric("FFFF99fff")) + eg(3, IsAlphaNumeric("99")) + eg(4, IsAlphaNumeric("afff")) + eg(5, IsAlphaNumeric("Infinity")) + eg(6, IsAlphaNumeric("áéúóúÁÉÍÓÚãõÃÕàèìòùÀÈÌÒÙâêîôûÂÊÎÔÛäëïöüÄËÏÖÜçÇ1234567890")) + eg(7, IsAlphaNumeric("-Infinity")) + eg(8, IsAlphaNumeric("-33")) + eg(9, IsAlphaNumeric("aaff..")) + eg(10, IsAlphaNumeric(".áéúóúÁÉÍÓÚãõÃÕàèìòùÀÈÌÒÙâêîôûÂÊÎÔÛäëïöüÄËÏÖÜçÇ1234567890")) + // Output: + // 1: true + // 2: true + // 3: true + // 4: true + // 5: true + // 6: true + // 7: false + // 8: false + // 9: false + // 10: false +} + +func ExampleIsEmpty() { + eg(1, IsEmpty(" ")) + eg(2, IsEmpty("\t\t\t ")) + eg(3, IsEmpty("\t\n ")) + eg(4, IsEmpty("hi")) + // Output: + // 1: true + // 2: true + // 3: true + // 4: false +} + +func ExampleIsLower() { + eg(1, IsLower("a")) + eg(2, IsLower("A")) + eg(3, IsLower("abc")) + eg(4, IsLower("aBc")) + eg(5, IsLower("áéúóúãõàèìòùâêîôûäëïöüç")) + eg(6, IsLower("hi jp")) + eg(7, IsLower("ÁÉÍÓÚÃÕÀÈÌÒÙÂÊÎÔÛÄËÏÖÜÇ")) + eg(8, IsLower("áéúóúãõàèìòùâêîôûäëïöüçÁ")) + eg(9, IsLower("áéúóúãõàèìòùâêîôû äëïöüç")) + // Output: + // 1: true + // 2: false + // 3: true + // 4: false + // 5: true + // 6: false + // 7: false + // 8: false + // 9: false +} + +func ExampleIsNumeric() { + eg(1, IsNumeric("3")) + eg(2, IsNumeric("34.22")) + eg(3, IsNumeric("-22.33")) + eg(4, IsNumeric("NaN")) + eg(5, IsNumeric("Infinity")) + eg(6, IsNumeric("-Infinity")) + eg(7, IsNumeric("JP")) + eg(8, IsNumeric("-5")) + eg(9, IsNumeric("00099242424")) + // Output: + // 1: true + // 2: false + // 3: false + // 4: false + // 5: false + // 6: false + // 7: false + // 8: false + // 9: true +} + +func ExampleIsUpper() { + eg(1, IsUpper("a")) + eg(2, IsUpper("A")) + eg(3, IsUpper("ABC")) + eg(4, IsUpper("aBc")) + eg(5, IsUpper("áéúóúãõàèìòùâêîôûäëïöüç")) + eg(6, IsUpper("HI JP")) + eg(7, IsUpper("ÁÉÍÓÚÃÕÀÈÌÒÙÂÊÎÔÛÄËÏÖÜÇ")) + eg(8, IsUpper("áéúóúãõàèìòùâêîôûäëïöüçÁ")) + eg(9, IsUpper("ÁÉÍÓÚÃÕÀÈÌÒÙÂÊÎ ÔÛÄËÏÖÜÇ")) + // Output: + // 1: false + // 2: true + // 3: true + // 4: false + // 5: false + // 6: false + // 7: true + // 8: false + // 9: false +} + +func ExampleLeft() { + eg(1, Left("abcdef", 0)) + eg(2, Left("abcdef", 1)) + eg(3, Left("abcdef", 4)) + eg(4, Left("abcdef", -2)) + // Output: + // 1: + // 2: a + // 3: abcd + // 4: ef +} + +func ExampleLeftOf() { + eg(1, LeftOf("abcdef", "def")) + eg(2, LeftOf("abcdef", "abc")) + eg(3, LeftOf("abcdef", "")) + eg(4, LeftOf("", "abc")) + eg(5, LeftOf("abcdef", "xyz")) + // Output: + // 1: abc + // 2: + // 3: abcdef + // 4: + // 5: +} + +func ExampleLines() { + eg(1, Lines("a\r\nb\nc\r\n")) + eg(2, Lines("a\r\nb\nc\r\nd")) + // Output: + // 1: [a b c ] + // 2: [a b c d] +} + +func ExampleMatch() { + eg(1, Match("foobar", `^fo.*r$`)) + eg(2, Match("foobar", `^fo.*x$`)) + eg(3, Match("", `^fo.*x$`)) + // Output: + // 1: true + // 2: false + // 3: false +} + +func ExamplePad() { + eg(1, Pad("hello", "x", 5)) + eg(2, Pad("hello", "x", 10)) + eg(3, Pad("hello", "x", 11)) + eg(4, Pad("hello", "x", 6)) + eg(5, Pad("hello", "x", 1)) + // Output: + // 1: hello + // 2: xxxhelloxx + // 3: xxxhelloxxx + // 4: xhello + // 5: hello +} + +func ExamplePadLeft() { + eg(1, PadLeft("hello", "x", 5)) + eg(2, PadLeft("hello", "x", 10)) + eg(3, PadLeft("hello", "x", 11)) + eg(4, PadLeft("hello", "x", 6)) + eg(5, PadLeft("hello", "x", 1)) + // Output: + // 1: hello + // 2: xxxxxhello + // 3: xxxxxxhello + // 4: xhello + // 5: hello +} + +func ExamplePadRight() { + eg(1, PadRight("hello", "x", 5)) + eg(2, PadRight("hello", "x", 10)) + eg(3, PadRight("hello", "x", 11)) + eg(4, PadRight("hello", "x", 6)) + eg(5, PadRight("hello", "x", 1)) + // Output: + // 1: hello + // 2: helloxxxxx + // 3: helloxxxxxx + // 4: hellox + // 5: hello +} + +func ExamplePipe() { + eg(1, Pipe("\nabcdef \n", Clean, BetweenF("a", "f"), ChompLeftF("bc"))) + // Output: + // 1: de +} + +func ExampleReplaceF() { + eg(1, Pipe("abcdefab", ReplaceF("ab", "x", -1))) + eg(2, Pipe("abcdefab", ReplaceF("ab", "x", 1))) + eg(3, Pipe("abcdefab", ReplaceF("ab", "x", 0))) + // Output: + // 1: xcdefx + // 2: xcdefab + // 3: abcdefab +} + +func ExampleReplacePattern() { + eg(1, ReplacePattern("aabbcc", `a`, "x")) + // Output: + // 1: xxbbcc +} + +func ExampleReplacePatternF() { + eg(1, Pipe("aabbcc", ReplacePatternF(`a`, "x"))) + // Output: + // 1: xxbbcc +} + +func ExampleReverse() { + eg(1, Reverse("abc")) + eg(2, Reverse("中文")) + // Output: + // 1: cba + // 2: 文中 +} + +func ExampleRight() { + eg(1, Right("abcdef", 0)) + eg(2, Right("abcdef", 1)) + eg(3, Right("abcdef", 4)) + eg(4, Right("abcdef", -2)) + // Output: + // 1: + // 2: f + // 3: cdef + // 4: ab +} + +func ExampleRightOf() { + eg(1, RightOf("abcdef", "abc")) + eg(2, RightOf("abcdef", "def")) + eg(3, RightOf("abcdef", "")) + eg(4, RightOf("", "abc")) + eg(5, RightOf("abcdef", "xyz")) + // Output: + // 1: def + // 2: + // 3: abcdef + // 4: + // 5: +} + +func ExampleRightF() { + eg(1, Pipe("abcdef", RightF(3))) + // Output: + // 1: def +} + +func ExampleSliceContains() { + eg(1, SliceContains([]string{"foo", "bar"}, "foo")) + eg(2, SliceContains(nil, "foo")) + eg(3, SliceContains([]string{"foo", "bar"}, "bah")) + eg(4, SliceContains([]string{"foo", "bar"}, "")) + // Output: + // 1: true + // 2: false + // 3: false + // 4: false +} + +func ExampleSliceIndexOf() { + eg(1, SliceIndexOf([]string{"foo", "bar"}, "foo")) + eg(2, SliceIndexOf(nil, "foo")) + eg(3, SliceIndexOf([]string{"foo", "bar"}, "bah")) + eg(4, SliceIndexOf([]string{"foo", "bar"}, "")) + eg(5, SliceIndexOf([]string{"foo", "bar"}, "bar")) + // Output: + // 1: 0 + // 2: -1 + // 3: -1 + // 4: -1 + // 5: 1 +} + +func ExampleSlugify() { + eg(1, Slugify("foo bar")) + eg(2, Slugify("foo/bar bah")) + eg(3, Slugify("foo-bar--bah")) + // Output: + // 1: foo-bar + // 2: foobar-bah + // 3: foo-bar-bah +} + +func ExampleStripPunctuation() { + eg(1, StripPunctuation("My, st[ring] *full* of %punct)")) + // Output: + // 1: My string full of punct +} + +func ExampleStripTags() { + eg(1, StripTags("<p>just <b>some</b> text</p>")) + eg(2, StripTags("<p>just <b>some</b> text</p>", "p")) + eg(3, StripTags("<a><p>just <b>some</b> text</p></a>", "a", "p")) + eg(4, StripTags("<a><p>just <b>some</b> text</p></a>", "b")) + // Output: + // 1: just some text + // 2: just <b>some</b> text + // 3: just <b>some</b> text + // 4: <a><p>just some text</p></a> +} + +func ExampleSubstr() { + eg(1, Substr("abcdef", 2, -1)) + eg(2, Substr("abcdef", 2, 0)) + eg(3, Substr("abcdef", 2, 1)) + eg(4, Substr("abcdef", 2, 3)) + eg(5, Substr("abcdef", 2, 4)) + eg(6, Substr("abcdef", 2, 100)) + eg(7, Substr("abcdef", 0, 1)) + // Output: + // 1: + // 2: + // 3: c + // 4: cde + // 5: cdef + // 6: cdef + // 7: a +} + +func ExampleTemplateWithDelimiters() { + eg(1, TemplateWithDelimiters("Hello {{name}} at {{date-year}}", map[string]interface{}{"name": "foo", "date-year": 2014}, "{{", "}}")) + eg(2, TemplateWithDelimiters("Hello #{name} at #{date-year}", map[string]interface{}{"name": "foo", "date-year": 2014}, "#{", "}")) + eg(3, TemplateWithDelimiters("Hello (name) at (date-year)", map[string]interface{}{"name": "foo", "date-year": 2014}, "(", ")")) + eg(4, TemplateWithDelimiters("Hello [name] at [date-year]", map[string]interface{}{"name": "foo", "date-year": 2014}, "[", "]")) + eg(5, TemplateWithDelimiters("Hello *name* at *date-year*", map[string]interface{}{"name": "foo", "date-year": 2014}, "*", "*")) + eg(6, TemplateWithDelimiters("Hello $name$ at $date-year$", map[string]interface{}{"name": "foo", "date-year": 2014}, "$", "$")) + // Output: + // 1: Hello foo at 2014 + // 2: Hello foo at 2014 + // 3: Hello foo at 2014 + // 4: Hello foo at 2014 + // 5: Hello foo at 2014 + // 6: Hello foo at 2014 +} + +func ExampleTemplate() { + eg(1, Template("Hello {{name}} at {{date-year}}", map[string]interface{}{"name": "foo", "date-year": 2014})) + eg(2, Template("Hello {{name}}", map[string]interface{}{"name": ""})) + SetTemplateDelimiters("{", "}") + eg(3, Template("Hello {name} at {date-year}", map[string]interface{}{"name": "foo", "date-year": 2014})) + // Output: + // 1: Hello foo at 2014 + // 2: Hello + // 3: Hello foo at 2014 +} + +func ExampleToArgv() { + eg(1, QuoteItems(ToArgv(`GO_ENV=test gosu --watch foo@release "some quoted string 'inside'"`))) + eg(2, QuoteItems(ToArgv(`gosu foo\ bar`))) + eg(3, QuoteItems(ToArgv(`gosu --test="some arg" -w -s a=123`))) + // Output: + // 1: ["GO_ENV=test" "gosu" "--watch" "foo@release" "some quoted string 'inside'"] + // 2: ["gosu" "foo bar"] + // 3: ["gosu" "--test=some arg" "-w" "-s" "a=123"] +} + +func ExampleToBool() { + eg(1, ToBool("true")) + eg(2, ToBool("yes")) + eg(3, ToBool("1")) + eg(4, ToBool("on")) + eg(5, ToBool("false")) + eg(6, ToBool("no")) + eg(7, ToBool("0")) + eg(8, ToBool("off")) + eg(9, ToBool("")) + eg(10, ToBool("?")) + // Output: + // 1: true + // 2: true + // 3: true + // 4: true + // 5: false + // 6: false + // 7: false + // 8: false + // 9: false + // 10: false +} + +func ExampleToBoolOr() { + eg(1, ToBoolOr("foo", true)) + eg(2, ToBoolOr("foo", false)) + eg(3, ToBoolOr("true", false)) + eg(4, ToBoolOr("", true)) + // Output: + // 1: true + // 2: false + // 3: true + // 4: true +} + +func ExampleToIntOr() { + eg(1, ToIntOr("foo", 0)) + eg(2, ToIntOr("", 1)) + eg(3, ToIntOr("100", 0)) + eg(4, ToIntOr("-1", 1)) + // Output: + // 1: 0 + // 2: 1 + // 3: 100 + // 4: -1 +} + +func ExampleUnderscore() { + eg(1, Underscore("fooBar")) + eg(2, Underscore("FooBar")) + eg(3, Underscore("")) + eg(4, Underscore("x")) + // Output: + // 1: foo_bar + // 2: _foo_bar + // 3: + // 4: x +} + +func ExampleWrapHTML() { + eg(1, WrapHTML("foo", "span", nil)) + eg(2, WrapHTML("foo", "", nil)) + eg(3, WrapHTML("foo", "", map[string]string{"class": "bar"})) + // Output: + // 1: <span>foo</span> + // 2: <div>foo</div> + // 3: <div class="bar">foo</div> +} + +func ExampleWrapHTMLF() { + eg(1, Pipe("foo", WrapHTMLF("div", nil))) + // Output: + // 1: <div>foo</div> +} |