Mercurial > lasercutter

     1 (ns clojure.contrib.test-string

     2   (:require [clojure.contrib.string :as s])

     3   (:use clojure.test))

     4 

     5 (deftest t-codepoints

     6   (is (= (list 102 111 111 65536 98 97 114)

     7          (s/codepoints "foo\uD800\uDC00bar"))

     8       "Handles Unicode supplementary characters"))

     9 

    10 (deftest t-escape

    11   (is (= "&lt;foo&amp;bar&gt;"

    12          (s/escape {\& "&amp;" \< "&lt;" \> "&gt;"} "<foo&bar>")))

    13   (is (= " \\\"foo\\\" "

    14          (s/escape {\" "\\\""} " \"foo\" " )))

    15   (is (= "faabor" (s/escape {\a \o, \o \a} "foobar"))))

    16 

    17 (deftest t-blank

    18   (is (s/blank? nil))

    19   (is (s/blank? ""))

    20   (is (s/blank? " "))

    21   (is (s/blank? " \t \n  \r "))

    22   (is (not (s/blank? "  foo  "))))

    23 

    24 (deftest t-take

    25   (is (= "foo" (s/take 3 "foobar")))

    26   (is (= "foobar" (s/take 7 "foobar")))

    27   (is (= "" (s/take 0 "foo"))))

    28 

    29 (deftest t-drop

    30   (is (= "bar" (s/drop 3 "foobar")))

    31   (is (= "" (s/drop 9 "foobar")))

    32   (is (= "foobar" (s/drop 0 "foobar"))))

    33 

    34 (deftest t-butlast

    35   (is (= "foob" (s/butlast 2 "foobar")))

    36   (is (= "" (s/butlast 9 "foobar")))

    37   (is (= "foobar" (s/butlast 0 "foobar"))))

    38 

    39 (deftest t-tail

    40   (is (= "ar" (s/tail 2 "foobar")))

    41   (is (= "foobar" (s/tail 9 "foobar")))

    42   (is (= "" (s/tail 0 "foobar"))))

    43 

    44 (deftest t-repeat

    45   (is (= "foofoofoo" (s/repeat 3 "foo"))))

    46 

    47 (deftest t-reverse

    48   (is (= "tab" (s/reverse "bat"))))

    49 

    50 (deftest t-replace

    51   (is (= "faabar" (s/replace-char \o \a "foobar")))

    52   (is (= "barbarbar" (s/replace-str "foo" "bar" "foobarfoo")))

    53   (is (= "FOObarFOO" (s/replace-by #"foo" s/upper-case  "foobarfoo"))))

    54 

    55 (deftest t-replace-first

    56   (is (= "barbarfoo" (s/replace-first-re #"foo" "bar" "foobarfoo")))

    57   (is (= "FOObarfoo" (s/replace-first-by #"foo" s/upper-case "foobarfoo"))))

    58 

    59 (deftest t-partition

    60   (is (= (list "" "abc" "123" "def")

    61          (s/partition #"[a-z]+" "abc123def"))))

    62 

    63 (deftest t-join

    64   (is (= "1,2,3" (s/join \, [1 2 3])))

    65   (is (= "" (s/join \, [])))

    66   (is (= "1 and-a 2 and-a 3" (s/join " and-a " [1 2 3]))))

    67 

    68 (deftest t-chop

    69   (is (= "fo" (s/chop "foo")))

    70   (is (= "") (s/chop "f"))

    71   (is (= "") (s/chop "")))

    72 

    73 (deftest t-chomp

    74   (is (= "foo" (s/chomp "foo\n")))

    75   (is (= "foo" (s/chomp "foo\r\n")))

    76   (is (= "foo" (s/chomp "foo")))

    77   (is (= "" (s/chomp ""))))

    78 

    79 (deftest t-swap-case

    80   (is (= "fOO!bAR" (s/swap-case "Foo!Bar")))

    81   (is (= "" (s/swap-case ""))))

    82 

    83 (deftest t-capitalize

    84   (is (= "Foobar" (s/capitalize "foobar")))

    85   (is (= "Foobar" (s/capitalize "FOOBAR"))))

    86 

    87 (deftest t-ltrim

    88   (is (= "foo " (s/ltrim " foo ")))

    89   (is (= "" (s/ltrim "   "))))

    90 

    91 (deftest t-rtrim

    92   (is (= " foo" (s/rtrim " foo ")))

    93   (is (= "" (s/rtrim "   "))))

    94 

    95 (deftest t-split-lines

    96   (is (= (list "one" "two" "three")

    97          (s/split-lines "one\ntwo\r\nthree")))

    98   (is (= (list "foo") (s/split-lines "foo"))))

    99 

   100 (deftest t-upper-case

   101   (is (= "FOOBAR" (s/upper-case "Foobar"))))

   102 

   103 (deftest t-lower-case

   104   (is (= "foobar" (s/lower-case "FooBar"))))

   105 

   106 (deftest t-trim

   107   (is (= "foo" (s/trim "  foo  \r\n"))))

   108 

   109 (deftest t-substring

   110   (is (s/substring? "foo" "foobar"))

   111   (is (not (s/substring? "baz" "foobar"))))

   112 

   113 (deftest t-get

   114   (is (= \o (s/get "foo" 1))))

   115 

   116 (deftest t-as-str

   117   (testing "keyword to string"

   118     (is (= "foo") (s/as-str :foo)))

   119   (testing "symbol to string"

   120     (is (= "foo") (s/as-str 'foo)))

   121   (testing "string to string"

   122     (is (= "foo") (s/as-str "foo")))

   123   (testing "stringifying non-namish things"

   124     (is (= "42") (s/as-str 42))))
author	Robert McIntyre <rlm@mit.edu>
date	Sat, 21 Aug 2010 06:25:44 -0400
parents
children