Skip to content

Commit c1ff8c5

Browse files
michaelficarramichaelficarra
committed
finished the tests
1 parent a26afdf commit c1ff8c5

File tree

3 files changed

+126
-75
lines changed

3 files changed

+126
-75
lines changed

‎src/Data/String/CodePoints.js‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -69,7 +69,7 @@ exports._take = function (fallback) {
6969
return function (n) {
7070
if (hasArrayFrom) {
7171
return function (str) {
72-
return Array.from(str).slice(0, n).join('');
72+
return Array.from(str).slice(0, Math.max(0, n)).join('');
7373
};
7474
} else if (hasStringIterator) {
7575
return function (str) {

‎src/Data/String/CodePoints.purs‎

Lines changed: 7 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -104,15 +104,19 @@ indexOf p s = (\i -> length (String.take i s)) <$> String.indexOf p s
104104

105105

106106
indexOf' :: String.Pattern -> Int -> String -> Maybe Int
107-
indexOf' p i s = (\k -> length (String.take k s)) <$> String.indexOf' p i s
107+
indexOf' p i s =
108+
let s' = drop i s in
109+
(\k -> i + length (String.take k s')) <$> String.indexOf p s'
108110

109111

110112
lastIndexOf :: String.Pattern -> String -> Maybe Int
111113
lastIndexOf p s = (\i -> length (String.take i s)) <$> String.lastIndexOf p s
112114

113115

114116
lastIndexOf' :: String.Pattern -> Int -> String -> Maybe Int
115-
lastIndexOf' p i s = (\k -> length (String.take k s)) <$> String.lastIndexOf' p i s
117+
lastIndexOf' p i s =
118+
let s' = drop i s in
119+
(\k -> i + length (String.take k s')) <$> String.lastIndexOf p s'
116120

117121

118122
length :: String -> Int
@@ -125,7 +129,7 @@ foreign import singleton :: CodePoint -> String
125129
splitAt :: Int -> String -> Maybe { before :: String, after :: String }
126130
splitAt i s =
127131
let cps = toCodePointArray s in
128-
if i < 0 || Array.length cps <= i
132+
if i < 0 || Array.length cps < i
129133
then Nothing
130134
else Just {
131135
before: fromCodePointArray (Array.take i cps),

‎test/Test/Data/String/CodePoints.purs‎

Lines changed: 118 additions & 71 deletions
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,6 @@
11
module Test.Data.String.CodePoints (testStringCodePoints) where
22

3-
import Prelude (Unit, Ordering(..), (==), ($), discard, negate, not, (/=), (&&), (<))
3+
import Prelude (Unit, discard, negate, (==), ($), (&&), (<), (<$>))
44

55
import Control.Monad.Eff (Eff)
66
import Control.Monad.Eff.Console (CONSOLE, log)
@@ -54,6 +54,7 @@ testStringCodePoints = do
5454
log "indexOf"
5555
assert $ indexOf (Pattern "") "" == Just 0
5656
assert $ indexOf (Pattern "") str == Just 0
57+
assert $ indexOf (Pattern str) str == Just 0
5758
assert $ indexOf (Pattern "a") str == Just 0
5859
assert $ indexOf (Pattern "\xDC00\xD800\xD800") str == Just 1
5960
assert $ indexOf (Pattern "\xD800") str == Just 2
@@ -71,73 +72,119 @@ testStringCodePoints = do
7172
-- I vote we just delete the test. Passing surrogate halves to the CodePoints functions should not be supported.
7273
assert $ indexOf (Pattern "\xDC05") str == Just 5
7374

74-
-- log "singleton"
75-
-- assert $ singleton 'a' == "a"
76-
--
77-
-- log "takeWhile"
78-
-- assert $ takeWhile (\c -> true) "abc" == "abc"
79-
-- assert $ takeWhile (\c -> false) "abc" == ""
80-
-- assert $ takeWhile (\c -> c /= 'b') "aabbcc" == "aa"
81-
--
82-
-- log "indexOf'"
83-
-- assert $ indexOf' (Pattern "") 0 "" == Just 0
84-
-- assert $ indexOf' (Pattern "") (-1) "ab" == Nothing
85-
-- assert $ indexOf' (Pattern "") 0 "ab" == Just 0
86-
-- assert $ indexOf' (Pattern "") 1 "ab" == Just 1
87-
-- assert $ indexOf' (Pattern "") 2 "ab" == Just 2
88-
-- assert $ indexOf' (Pattern "") 3 "ab" == Nothing
89-
-- assert $ indexOf' (Pattern "bc") 0 "abcd" == Just 1
90-
-- assert $ indexOf' (Pattern "bc") 1 "abcd" == Just 1
91-
-- assert $ indexOf' (Pattern "bc") 2 "abcd" == Nothing
92-
-- assert $ indexOf' (Pattern "cb") 0 "abcd" == Nothing
93-
--
94-
-- log "lastIndexOf"
95-
-- assert $ lastIndexOf (Pattern "") "" == Just 0
96-
-- assert $ lastIndexOf (Pattern "") "abcd" == Just 4
97-
-- assert $ lastIndexOf (Pattern "bc") "abcd" == Just 1
98-
-- assert $ lastIndexOf (Pattern "cb") "abcd" == Nothing
99-
--
100-
-- log "lastIndexOf'"
101-
-- assert $ lastIndexOf' (Pattern "") 0 "" == Just 0
102-
-- assert $ lastIndexOf' (Pattern "") (-1) "ab" == Nothing
103-
-- assert $ lastIndexOf' (Pattern "") 0 "ab" == Just 0
104-
-- assert $ lastIndexOf' (Pattern "") 1 "ab" == Just 1
105-
-- assert $ lastIndexOf' (Pattern "") 2 "ab" == Just 2
106-
-- assert $ lastIndexOf' (Pattern "") 3 "ab" == Nothing
107-
-- assert $ lastIndexOf' (Pattern "bc") 0 "abcd" == Nothing
108-
-- assert $ lastIndexOf' (Pattern "bc") 1 "abcd" == Just 1
109-
-- assert $ lastIndexOf' (Pattern "bc") 2 "abcd" == Just 1
110-
-- assert $ lastIndexOf' (Pattern "cb") 0 "abcd" == Nothing
111-
--
112-
-- log "length"
113-
-- assert $ length "" == 0
114-
-- assert $ length "a" == 1
115-
-- assert $ length "ab" == 2
116-
--
117-
-- log "take"
118-
-- assert $ take 0 "ab" == ""
119-
-- assert $ take 1 "ab" == "a"
120-
-- assert $ take 2 "ab" == "ab"
121-
-- assert $ take 3 "ab" == "ab"
122-
-- assert $ take (-1) "ab" == ""
123-
--
124-
-- log "count"
125-
-- assert $ count (_ == 'a') "" == 0
126-
-- assert $ count (_ == 'a') "ab" == 1
127-
-- assert $ count (_ == 'a') "aaab" == 3
128-
-- assert $ count (_ == 'a') "abaa" == 1
129-
--
130-
-- log "splitAt"
131-
-- let testSplitAt i str res =
132-
-- assert $ case splitAt i str of
133-
-- Nothing ->
134-
-- isNothing res
135-
-- Just { before, after } ->
136-
-- maybe false (\r ->
137-
-- r.before == before && r.after == after) res
138-
--
139-
-- testSplitAt 1 "" Nothing
140-
-- testSplitAt 0 "a" $ Just {before: "", after: "a"}
141-
-- testSplitAt 1 "ab" $ Just {before: "a", after: "b"}
142-
-- testSplitAt 3 "aabcc" $ Just {before: "aab", after: "cc"}
143-
-- testSplitAt (-1) "abc" $ Nothing
75+
log "indexOf'"
76+
assert $ indexOf' (Pattern "") 0 "" == Just 0
77+
assert $ indexOf' (Pattern str) 0 str == Just 0
78+
assert $ indexOf' (Pattern str) 1 str == Nothing
79+
assert $ indexOf' (Pattern "a") 0 str == Just 0
80+
assert $ indexOf' (Pattern "a") 1 str == Nothing
81+
assert $ indexOf' (Pattern "z") 0 str == Just 6
82+
assert $ indexOf' (Pattern "z") 1 str == Just 6
83+
assert $ indexOf' (Pattern "z") 2 str == Just 6
84+
assert $ indexOf' (Pattern "z") 3 str == Just 6
85+
assert $ indexOf' (Pattern "z") 4 str == Just 6
86+
assert $ indexOf' (Pattern "z") 5 str == Just 6
87+
assert $ indexOf' (Pattern "z") 6 str == Just 6
88+
assert $ indexOf' (Pattern "z") 7 str == Nothing
89+
90+
log "lastIndexOf"
91+
assert $ lastIndexOf (Pattern "") "" == Just 0
92+
assert $ lastIndexOf (Pattern "") str == Just 7
93+
assert $ lastIndexOf (Pattern str) str == Just 0
94+
assert $ lastIndexOf (Pattern "a") str == Just 0
95+
assert $ lastIndexOf (Pattern "\xDC00\xD800\xD800") str == Just 1
96+
assert $ lastIndexOf (Pattern "\xD800") str == Just 3
97+
assert $ lastIndexOf (Pattern "\xD800\xD800") str == Just 2
98+
assert $ lastIndexOf (Pattern "\xD800\xD81A") str == Just 3
99+
assert $ lastIndexOf (Pattern "\xD800\x16805") str == Just 3
100+
assert $ lastIndexOf (Pattern "\x16805") str == Just 4
101+
assert $ lastIndexOf (Pattern "\x16A06") str == Just 5
102+
assert $ lastIndexOf (Pattern "z") str == Just 6
103+
assert $ lastIndexOf (Pattern "\0") str == Nothing
104+
assert $ lastIndexOf (Pattern "\xD81A") str == Just 5
105+
106+
log "lastIndexOf'"
107+
assert $ lastIndexOf' (Pattern "") 0 "" == Just 0
108+
assert $ lastIndexOf' (Pattern str) 0 str == Just 0
109+
assert $ lastIndexOf' (Pattern str) 1 str == Nothing
110+
assert $ lastIndexOf' (Pattern "a") 0 str == Just 0
111+
assert $ lastIndexOf' (Pattern "a") 1 str == Nothing
112+
assert $ lastIndexOf' (Pattern "z") 0 str == Just 6
113+
assert $ lastIndexOf' (Pattern "z") 1 str == Just 6
114+
assert $ lastIndexOf' (Pattern "z") 2 str == Just 6
115+
assert $ lastIndexOf' (Pattern "z") 3 str == Just 6
116+
assert $ lastIndexOf' (Pattern "z") 4 str == Just 6
117+
assert $ lastIndexOf' (Pattern "z") 5 str == Just 6
118+
assert $ lastIndexOf' (Pattern "z") 6 str == Just 6
119+
assert $ lastIndexOf' (Pattern "z") 7 str == Nothing
120+
121+
log "length"
122+
assert $ length "" == 0
123+
assert $ length "a" == 1
124+
assert $ length "ab" == 2
125+
assert $ length str == 7
126+
127+
log "singleton"
128+
assert $ (singleton <$> codePointFromInt 0x30) == Just "0"
129+
assert $ (singleton <$> codePointFromInt 0x16805) == Just "\x16805"
130+
131+
log "splitAt"
132+
let testSplitAt i s res =
133+
assert $ case splitAt i s of
134+
Nothing ->
135+
isNothing res
136+
Just { before, after } ->
137+
maybe false (\r ->
138+
r.before == before && r.after == after) res
139+
140+
testSplitAt 0 "" $ Just {before: "", after: ""}
141+
testSplitAt 1 "" Nothing
142+
testSplitAt 0 "a" $ Just {before: "", after: "a"}
143+
testSplitAt 1 "ab" $ Just {before: "a", after: "b"}
144+
testSplitAt 3 "aabcc" $ Just {before: "aab", after: "cc"}
145+
testSplitAt (-1) "abc" $ Nothing
146+
testSplitAt 0 str $ Just {before: "", after: str}
147+
testSplitAt 1 str $ Just {before: "a", after: "\xDC00\xD800\xD800\x16805\x16A06\&z"}
148+
testSplitAt 2 str $ Just {before: "a\xDC00", after: "\xD800\xD800\x16805\x16A06\&z"}
149+
testSplitAt 3 str $ Just {before: "a\xDC00\xD800", after: "\xD800\x16805\x16A06\&z"}
150+
testSplitAt 4 str $ Just {before: "a\xDC00\xD800\xD800", after: "\x16805\x16A06\&z"}
151+
testSplitAt 5 str $ Just {before: "a\xDC00\xD800\xD800\x16805", after: "\x16A06\&z"}
152+
testSplitAt 6 str $ Just {before: "a\xDC00\xD800\xD800\x16805\x16A06", after: "z"}
153+
testSplitAt 7 str $ Just {before: str, after: ""}
154+
testSplitAt 8 str $ Nothing
155+
156+
log "take"
157+
assert $ take (-1) str == ""
158+
assert $ take 0 str == ""
159+
assert $ take 1 str == "a"
160+
assert $ take 2 str == "a\xDC00"
161+
assert $ take 3 str == "a\xDC00\xD800"
162+
assert $ take 4 str == "a\xDC00\xD800\xD800"
163+
assert $ take 5 str == "a\xDC00\xD800\xD800\x16805"
164+
assert $ take 6 str == "a\xDC00\xD800\xD800\x16805\x16A06"
165+
assert $ take 7 str == str
166+
assert $ take 8 str == str
167+
168+
log "takeWhile"
169+
assert $ takeWhile (\c -> true) str == str
170+
assert $ takeWhile (\c -> false) str == ""
171+
assert $ takeWhile (\c -> codePointToInt c < 0xFFFF) str == "a\xDC00\xD800\xD800"
172+
assert $ takeWhile (\c -> codePointToInt c < 0xDC00) str == "a"
173+
174+
log "uncons"
175+
let testUncons s res =
176+
assert $ case uncons s of
177+
Nothing ->
178+
isNothing res
179+
Just { head, tail } ->
180+
maybe false (\r ->
181+
r.head == codePointToInt head && r.tail == tail) res
182+
183+
testUncons str $ Just {head: 0x61, tail: "\xDC00\xD800\xD800\x16805\x16A06\&z"}
184+
testUncons (drop 1 str) $ Just {head: 0xDC00, tail: "\xD800\xD800\x16805\x16A06\&z"}
185+
testUncons (drop 2 str) $ Just {head: 0xD800, tail: "\xD800\x16805\x16A06\&z"}
186+
testUncons (drop 3 str) $ Just {head: 0xD800, tail: "\x16805\x16A06\&z"}
187+
testUncons (drop 4 str) $ Just {head: 0x16805, tail: "\x16A06\&z"}
188+
testUncons (drop 5 str) $ Just {head: 0x16A06, tail: "z"}
189+
testUncons (drop 6 str) $ Just {head: 0x7A, tail: ""}
190+
testUncons "" Nothing

0 commit comments

Comments
 (0)