core/sequences/sequences-tests.factor

   1 USING: arrays assocs byte-arrays generic.single kernel make math
   2 math.functions math.order math.parser math.vectors sbufs
   3 sequences sequences.private strings tools.test vectors ;
   4 IN: sequences.tests
   5
   6 { "empty" } [ { } [ "empty" ] [ "not empty" ] if-empty ] unit-test
   7 { { 1 } "not empty" } [ { 1 } [ "empty" ] [ "not empty" ] if-empty ] unit-test
   8
   9 { V{ 1 2 3 4 } } [ 1 5 dup iota <slice> >vector ] unit-test
  10 { 3 } [ 1 4 dup iota <slice> length ] unit-test
  11 { 2 } [ 1 3 { 1 2 3 4 } <slice> length ] unit-test
  12 { V{ 2 3 } } [ 1 3 { 1 2 3 4 } <slice> >vector ] unit-test
  13 { V{ 4 5 } } [ { 1 2 3 4 5 } 2 tail-slice* >vector ] unit-test
  14 { V{ 3 4 } } [ 2 4 1 10 dup iota <slice> subseq >vector ] unit-test
  15 { V{ 3 4 } } [ 0 2 2 4 1 10 dup iota <slice> <slice> subseq >vector ] unit-test
  16 [ 0 10 "hello" <slice> ] must-fail
  17 [ -10 3 "hello" <slice> ] must-fail
  18 [ 2 1 "hello" <slice> ] must-fail
  19
  20 { "cba" } [ "abcdef" 3 head-slice reverse ] unit-test
  21
  22 { 5040 } [ [ 1 2 3 4 5 6 7 ] 1 [ * ] reduce ] unit-test
  23
  24 { 5040 { 1 1 2 6 24 120 720 } }
  25 [ { 1 2 3 4 5 6 7 } 1 [ * ] accumulate ] unit-test
  26
  27 { 64 B{ 1 2 4 16 } }
  28 [ B{ 2 2 4 4 } 1 [ * ] accumulate ] unit-test
  29
  30 { 5040 { 1 1 2 6 24 120 720 } }
  31 [ { 1 2 3 4 5 6 7 } 1 [ * ] accumulate! ] unit-test
  32
  33 { t }
  34 [ { 1 2 3 4 5 6 7 } dup 1 [ * ] accumulate! nip eq? ] unit-test
  35
  36 { { 1 2 6 24 120 720 5040 } }
  37 [ { 1 2 3 4 5 6 7 } 1 [ * ] accumulate* ] unit-test
  38
  39 { B{ 2 4 16 64 } }
  40 [ B{ 2 2 4 4 } 1 [ * ] accumulate* ] unit-test
  41
  42 { { 1 2 6 24 120 720 5040 } }
  43 [ { 1 2 3 4 5 6 7 } 1 [ * ] accumulate*! ] unit-test
  44
  45 { t }
  46 [ { 1 2 3 4 5 6 7 } dup 1 [ * ] accumulate*! eq? ] unit-test
  47
  48 { f f } [ [ ] [ ] find ] unit-test
  49 { 0 1 } [ [ 1 ] [ ] find ] unit-test
  50 { 1 "world" } [ [ "hello" "world" ] [ "world" = ] find ] unit-test
  51 { 2 3 } [ [ 1 2 3 ] [ 2 > ] find ] unit-test
  52 { f f } [ [ 1 2 3 ] [ 10 > ] find ] unit-test
  53
  54 { 1 CHAR: e }
  55 [ "hello world" "aeiou" [ member? ] curry find ] unit-test
  56
  57 { 4 CHAR: o }
  58 [ 3 "hello world" "aeiou" [ member? ] curry find-from ] unit-test
  59
  60 { f f } [ "abcd" [ 10 > nip ] find-index ] unit-test
  61 { f f } [ "abcd" [ drop CHAR: e = ] find-index ] unit-test
  62 { 3 CHAR: d } [ "abcdefg" [ 3 = nip ] find-index ] unit-test
  63 { 3 CHAR: d } [ "abcdefg" [ drop CHAR: d = ] find-index ] unit-test
  64
  65 { 0 CHAR: a } [ 0 "abcdef" [ drop CHAR: a >= ] find-index-from ] unit-test
  66 { 1 CHAR: b } [ 0 "abcdef" [ drop CHAR: a > ] find-index-from ] unit-test
  67 { 2 CHAR: c } [ 1 "abcdef" [ drop CHAR: b > ] find-index-from ] unit-test
  68
  69 { f } [ 3 [ ]     member? ] unit-test
  70 { f } [ 3 [ 1 2 ] member? ] unit-test
  71 { t } [ 1 [ 1 2 ] member? ] unit-test
  72 { t } [ 2 [ 1 2 ] member? ] unit-test
  73
  74 { t }
  75 [ [ "hello" "world" ] [ second ] keep member-eq? ] unit-test
  76
  77 { 4 } [ CHAR: x "tuvwxyz" >vector index ] unit-test
  78
  79 { f } [ CHAR: x 5 "tuvwxyz" >vector index-from ] unit-test
  80
  81 { f } [ CHAR: a 0 "tuvwxyz" >vector index-from ] unit-test
  82
  83 { f } [ [ "Hello" { } 0.75 ] [ string? ] all? ] unit-test
  84 { t } [ [ ] [ ] all? ] unit-test
  85 { t } [ [ "hi" t 0.5 ] [ ] all? ] unit-test
  86
  87 { [ 1 2 3 ] } [ [ 1 4 2 5 3 6 ] [ 4 < ] filter ] unit-test
  88 { { 4 2 6 } } [ { 1 4 2 5 3 6 } [ 2 mod 0 = ] filter ] unit-test
  89
  90 { [ 3 ] } [ [ 1 2 3 ] 2 [ swap < ] curry filter ] unit-test
  91
  92 { V{ 1 2 3 } } [ V{ 1 4 2 5 3 6 } clone [ 4 < ] filter! ] unit-test
  93 { V{ 4 2 6 } } [ V{ 1 4 2 5 3 6 } clone [ 2 mod 0 = ] filter! ] unit-test
  94
  95 { V{ 3 } } [ V{ 1 2 3 } clone 2 [ swap < ] curry filter! ] unit-test
  96
  97 { "hello world how are you" }
  98 [ { "hello" "world" "how" "are" "you" } " " join ] unit-test
  99
 100 { "hello world how are you" }
 101 [ { "hello" "world" "how" "are" "you" } " " "" join-as ] unit-test
 102
 103 { "" } [ { } "" join ] unit-test
 104
 105 { "" } [ { } "" "" join-as ] unit-test
 106
 107 { { } } [ { } flip ] unit-test
 108
 109 { { "b" "e" } } [ 1 { { "a" "b" "c" } { "d" "e" "f" } } flip nth ] unit-test
 110
 111 { { { 1 4 } { 2 5 } { 3 6 } } }
 112 [ { { 1 2 3 } { 4 5 6 } } flip ] unit-test
 113
 114 { [ 2 3 4 ] } [ [ 1 2 3 ] 1 [ + ] curry map ] unit-test
 115
 116 { 1 } [ 0 [ 1 2 ] nth ] unit-test
 117 { 2 } [ 1 [ 1 2 ] nth ] unit-test
 118
 119 { [ ]           } [ [ ]   [ ]       append ] unit-test
 120 { [ 1 ]         } [ [ 1 ] [ ]       append ] unit-test
 121 { [ 2 ]         } [ [ ] [ 2 ]       append ] unit-test
 122 { [ 1 2 3 4 ]   } [ [ 1 2 3 ] [ 4 ] append ] unit-test
 123 { [ 1 2 3 4 ]   } [ [ 1 2 3 ] { 4 } append ] unit-test
 124
 125 [ "a" -1 append ] must-fail
 126 [ -1 "a" append ] must-fail
 127
 128 { t } [ B{ 0 } { 1 } append byte-array? ] unit-test
 129 { t } [ B{ 0 } { 1 } prepend byte-array? ] unit-test
 130
 131 { "0123456789" } [ 58 iota [ 48 < ] "" reject-as ] unit-test
 132
 133 { [ ]       } [ 1 [ ]           remove ] unit-test
 134 { [ ]       } [ 1 [ 1 ]         remove ] unit-test
 135 { [ 3 1 1 ] } [ 2 [ 3 2 1 2 1 ] remove ] unit-test
 136
 137 { [ ]       } [ [ ]       reverse ] unit-test
 138 { [ 1 ]     } [ [ 1 ]     reverse ] unit-test
 139 { [ 3 2 1 ] } [ [ 1 2 3 ] reverse ] unit-test
 140
 141 { f } [ f 0 head ] unit-test
 142 { [ ] } [ [ 1 ] 0 head ] unit-test
 143 { [ 1 2 3 ] } [ [ 1 2 3 4 ] 3 head ] unit-test
 144 { [ ] } [ [ 1 2 3 ] 3 tail ] unit-test
 145 { [ 3 ] } [ [ 1 2 3 ] 2 tail ] unit-test
 146
 147 { "blah" } [ "blahxx" 2 head* ] unit-test
 148
 149 { "xx" } [ "blahxx" 2 tail* ] unit-test
 150
 151 { t } [ "xxfoo" 2 head-slice "xxbar" 2 head-slice = ] unit-test
 152 { t } [ "xxfoo" 2 head-slice "xxbar" 2 head-slice [ hashcode ] same? ] unit-test
 153
 154 { t } [ "xxfoo" 2 head-slice SBUF" barxx" 2 tail-slice* = ] unit-test
 155 { t } [ "xxfoo" 2 head-slice SBUF" barxx" 2 tail-slice* [ hashcode ] same? ] unit-test
 156
 157 { t } [ [ 1 2 3 ] [ 1 2 3 ] sequence= ] unit-test
 158 { t } [ [ 1 2 3 ] { 1 2 3 } sequence= ] unit-test
 159 { t } [ { 1 2 3 } [ 1 2 3 ] sequence= ] unit-test
 160 { f } [ [ ] [ 1 2 3 ] sequence= ] unit-test
 161
 162 { { 1 3 2 4 } } [ { 1 2 3 4 } clone 1 2 pick exchange ] unit-test
 163
 164 { { "" "a" "aa" "aaa" } }
 165 [ 4 [ CHAR: a <string> ] { } map-integers ]
 166 unit-test
 167
 168 { V{ 1 3 5 7 9 } } [ 10 iota >vector [ even? ] reject! ] unit-test
 169
 170 { V{ } } [ "f" V{ } clone remove! ] unit-test
 171 { V{ } } [ "f" V{ "f" } clone remove! ] unit-test
 172 { V{ } } [ "f" V{ "f" "f" } clone remove! ] unit-test
 173 { V{ "x" } } [ "f" V{ "f" "x" "f" } clone remove! ] unit-test
 174 { V{ "y" "x" } } [ "f" V{ "y" "f" "x" "f" } clone remove! ] unit-test
 175
 176 { V{ 0 1 4 5 } } [ 6 iota >vector 2 4 pick delete-slice ] unit-test
 177
 178 [ 6 >vector 2 8 pick delete-slice ] must-fail
 179
 180 { V{ } } [ 6 iota >vector 0 6 pick delete-slice ] unit-test
 181
 182 { { 1 2 "a" "b" 5 6 7 } } [
 183     { "a" "b" } 2 4 { 1 2 3 4 5 6 7 }
 184     replace-slice
 185 ] unit-test
 186
 187 { { 1 2 "a" "b" 6 7 } } [
 188     { "a" "b" } 2 5 { 1 2 3 4 5 6 7 }
 189     replace-slice
 190 ] unit-test
 191
 192 { { 1 2 "a" "b" 4 5 6 7 } } [
 193     { "a" "b" } 2 3 { 1 2 3 4 5 6 7 }
 194     replace-slice
 195 ] unit-test
 196
 197 { { 1 2 3 4 5 6 7 "a" "b" } } [
 198     { "a" "b" } 7 7 { 1 2 3 4 5 6 7 }
 199     replace-slice
 200 ] unit-test
 201
 202 { { "a" 3 } } [
 203     { "a" } 0 2 { 1 2 3 } replace-slice
 204 ] unit-test
 205
 206 { { 1 4 9 } } [ { 1 2 3 } clone [ sq ] map! ] unit-test
 207
 208 { 5 } [ 1 >bignum { 1 5 7 } nth-unsafe ] unit-test
 209 { 5 } [ 1 >bignum { 1 5 7 } nth-unsafe ] unit-test
 210 { 5 } [ 1 >bignum "\u000001\u000005\u000007" nth-unsafe ] unit-test
 211
 212 { SBUF" before&after" } [
 213     "&" 6 11 SBUF" before and after" replace-slice
 214 ] unit-test
 215
 216 { 3 "a" } [ { "a" "b" "c" "a" "d" } [ "a" = ] find-last ] unit-test
 217
 218 { f f } [ 100 { 1 2 3 } [ 1 = ] find-from ] unit-test
 219 { f f } [ 100 { 1 2 3 } [ 1 = ] find-last-from ] unit-test
 220 { f f } [ -1 { 1 2 3 } [ 1 = ] find-from ] unit-test
 221
 222 { 0 } [ { "a" "b" "c" } { "A" "B" "C" } mismatch ] unit-test
 223
 224 { 1 } [ { "a" "b" "c" } { "a" "B" "C" } mismatch ] unit-test
 225
 226 { f } [ { "a" "b" "c" } { "a" "b" "c" } mismatch ] unit-test
 227
 228 { V{ } V{ } } [ { "a" "b" } { "a" "b" } drop-prefix [ >vector ] bi@ ] unit-test
 229
 230 { V{ "C" } V{ "c" } } [ { "a" "b" "C" } { "a" "b" "c" } drop-prefix [ >vector ] bi@ ] unit-test
 231
 232 [ -1 1 "abc" <slice> ] must-fail
 233
 234 { V{ "a" "b" } V{ } } [ { "X" "a" "b" } { "X" } drop-prefix [ >vector ] bi@ ] unit-test
 235
 236 [ 0.5 { 1 2 3 } nth ] [ no-method? ] must-fail-with
 237 [ 0.5 "asdfasdf" nth ] [ no-method? ] must-fail-with
 238
 239 ! Pathological case
 240 { "ihbye" } [ "hi" <reversed> "bye" append ] unit-test
 241
 242 { t } [ "hi" <reversed> SBUF" hi" <reversed> = ] unit-test
 243
 244 { t } [ "hi" <reversed> SBUF" hi" <reversed> = ] unit-test
 245
 246 { t } [ "hi" <reversed> SBUF" hi" <reversed> [ hashcode ] same? ] unit-test
 247
 248 [ -10 "hi" "bye" copy ] must-fail
 249 [ 10 "hi" "bye" copy ] must-fail
 250
 251 { V{ 1 2 3 5 6 } } [
 252     3 V{ 1 2 3 4 5 6 } clone remove-nth!
 253 ] unit-test
 254
 255 ! erg's random tester found this one
 256 { SBUF" 12341234" } [
 257     9 <sbuf> dup "1234" swap push-all dup dup swap push-all
 258 ] unit-test
 259
 260 { f } [ f V{ } like f V{ } like eq? ] unit-test
 261
 262 { V{ f f f } } [ 3 V{ } new-sequence ] unit-test
 263 { SBUF" \0\0\0" } [ 3 SBUF" " new-sequence ] unit-test
 264
 265 { 0 } [ f length ] unit-test
 266 [ f first ] must-fail
 267 { 3 } [ 3 10 iota nth ] unit-test
 268 { 3 } [ 3 10 iota nth-unsafe ] unit-test
 269 [ -3 10 iota nth ] must-fail
 270 [ 11 10 iota nth ] must-fail
 271
 272 { f } [ f ?first ] unit-test
 273 { f } [ { } ?first ] unit-test
 274 { 0 } [ 10 iota ?first ] unit-test
 275
 276 { f } [ f ?last ] unit-test
 277 { f } [ { } ?last ] unit-test
 278 { 9 } [ 10 iota ?last ] unit-test
 279
 280 [ -1/0. 0 remove-nth! ] must-fail
 281 { "" } [ "" [ CHAR: \s = ] trim ] unit-test
 282 { "" } [ "" [ CHAR: \s = ] trim-head ] unit-test
 283 { "" } [ "" [ CHAR: \s = ] trim-tail ] unit-test
 284 { "" } [ "  " [ CHAR: \s = ] trim-head ] unit-test
 285 { "" } [ "  " [ CHAR: \s = ] trim-tail ] unit-test
 286 { "asdf" } [ " asdf " [ CHAR: \s = ] trim ] unit-test
 287 { "asdf " } [ " asdf " [ CHAR: \s = ] trim-head ] unit-test
 288 { " asdf" } [ " asdf " [ CHAR: \s = ] trim-tail ] unit-test
 289
 290 { 328350 } [ 100 iota [ sq ] map-sum ] unit-test
 291
 292 { 50 } [ 100 iota [ even? ] count ] unit-test
 293 { 50 } [ 100 iota [ odd?  ] count ] unit-test
 294
 295 { { "b" "d" } } [ { 1 3 } { "a" "b" "c" "d" } nths ] unit-test
 296 { { "a" "b" "c" "d" } } [ { 0 1 2 3 } { "a" "b" "c" "d" } nths ] unit-test
 297 { { "d" "c" "b" "a" } } [ { 3 2 1 0 } { "a" "b" "c" "d" } nths ] unit-test
 298 { { "d" "a" "b" "c" } } [ { 3 0 1 2 } { "a" "b" "c" "d" } nths ] unit-test
 299
 300 { "dac" } [ { 3 0 2 } "abcd" nths ] unit-test
 301
 302 TUPLE: bogus-hashcode ;
 303
 304 M: bogus-hashcode hashcode* 2drop 0 >bignum ;
 305
 306 { 0 } [ { T{ bogus-hashcode } } hashcode ] unit-test
 307
 308 { { 2 4 6 } { 1 3 5 7 } } [ { 1 2 3 4 5 6 7 } [ even? ] partition ] unit-test
 309
 310 { { 1 3 7 } } [ 2 { 1 3 5 7 } remove-nth ] unit-test
 311
 312 { { 1 3 "X" 5 7 } } [ "X" 2 { 1 3 5 7 } insert-nth ] unit-test
 313
 314 { V{ 0 2 } } [ "a" { "a" "b" "a" } indices ] unit-test
 315
 316 { "a,b" } [ "a" "b" "," glue ] unit-test
 317 { "(abc)" } [ "abc" "(" ")" surround ] unit-test
 318
 319 { "HELLO" } [
 320     "HELLO" { -1 -1 -1 -1 -1 } { 2 2 2 2 2 2 }
 321     [ * 2 + + ] 3map
 322 ] unit-test
 323
 324 { 3 1 } [ [ 3array ] 3map ] must-infer-as
 325
 326 { 3 0 } [ [ 3drop ] 3each ] must-infer-as
 327
 328 { V{ 0 3 } } [ "A" { "A" "B" "C" "A" "D" } indices ] unit-test
 329
 330 [ "asdf" iota ] must-fail
 331 [ -1 iota ] must-fail
 332 { T{ iota-tuple { n 10 } } } [ 10 iota ] unit-test
 333 { 0 } [ 10 iota first ] unit-test
 334 { 0 } [ 0 iota sum ] unit-test
 335 { 0 } [ 1 iota sum ] unit-test
 336 { 10 } [ 5 iota sum ] unit-test
 337 { 15 } [ 6 iota sum ] unit-test
 338
 339 { "hi" 3 } [
 340     { 1 2 3 4 5 6 7 8 } [ H{ { 3 "hi" } } at ] map-find
 341 ] unit-test
 342
 343 { f f } [
 344     { 1 2 3 4 5 6 7 8 } [ H{ { 11 "hi" } } at ] map-find
 345 ] unit-test
 346
 347 { { "a" 1 "b" 1 "c" } }
 348 [ 1 { "a" "b" "c" } [ [ dup , ] [ , ] interleave drop ] { } make ] unit-test
 349
 350 { t } [ 0 array-capacity? ] unit-test
 351 { f } [ -1 array-capacity? ] unit-test
 352
 353 { +lt+ } [ { 0 0 0 } { 1 1 1 } <=> ] unit-test
 354 { +lt+ } [ { 0 0 0 } { 0 1 1 } <=> ] unit-test
 355 { +lt+ } [ { 0 0 0 } { 0 0 0 0 } <=> ] unit-test
 356 { +gt+ } [ { 1 1 1 } { 0 0 0 } <=> ] unit-test
 357 { +gt+ } [ { 0 1 1 } { 0 0 0 } <=> ] unit-test
 358 { +gt+ } [ { 0 0 0 0 } { 0 0 0 } <=> ] unit-test
 359 { +eq+ } [ { } { } <=> ] unit-test
 360 { +eq+ } [ { 1 2 3 } { 1 2 3 } <=> ] unit-test
 361
 362 { { { { 1 "a" } { 1 "b" } } { { 2 "a" } { 2 "b" } } } }
 363 [ { 1 2 } { "a" "b" } cartesian-product ] unit-test
 364
 365 [ { } [ string>digits sum ] [ + ] map-reduce ] must-infer
 366 [ { } [ ] [ + ] map-reduce ] must-fail
 367 { 4 } [ { 1 1 } [ 1 + ] [ + ] map-reduce ] unit-test
 368
 369 [ { } { } [ [ string>digits product ] bi@ + ] [ + ] 2map-reduce ] must-infer
 370 [ { } { } [ + ] [ + ] 2map-reduce ] must-fail
 371 { 24 } [ { 1 2 } { 3 4 } [ + ] [ * ] 2map-reduce ] unit-test
 372
 373 { 4 } [ 5 iota [ ] supremum-by ] unit-test
 374 { 0 } [ 5 iota [ ] infimum-by ] unit-test
 375 { "bar" } [ { "bar" "baz" "qux" } [ length ] supremum-by ] unit-test
 376 { "bar" } [ { "bar" "baz" "qux" } [ length ] infimum-by ] unit-test
 377 { { "foo" } } [ { { "foo" } { "bar" } } [ first ] supremum-by ] unit-test
 378 { { "bar" } } [ { { "foo" } { "bar" } } [ first ] infimum-by ] unit-test
 379 { -2 1 } [ -2 { 1 2 3 } [ over ^ ] supremum-by ] unit-test
 380 { -2 3 } [ -2 { 1 2 3 } [ over ^ ] infimum-by ] unit-test
 381
 382 { { 0 0 255 } } [
 383     {
 384         { 0 0 0 }
 385         { 95 255 95 }
 386         { 215 95 95 }
 387         { 95 135 255 }
 388         { 135 95 135 }
 389         { 135 255 255 }
 390         { 0 0 255 }
 391         { 0 95 95 }
 392         { 0 255 215 }
 393         { 135 0 95 }
 394         { 255 0 175 }
 395     } [ { 0 0 255 } distance ] infimum-by
 396 ] unit-test
 397
 398 [ -1 0 <repetition> ] must-fail
 399 { { } } [ 0 0 <repetition> >array ] unit-test
 400 { { 0 } } [ 1 0 <repetition> >array ] unit-test
 401 { { 0 0 0 } } [ 3 0 <repetition> >array ] unit-test
 402
 403 {
 404     { 11 23 35 }
 405 } [ { 11 22 33 } [ + ] map-index ] unit-test
 406
 407 {
 408     V{ 11 23 35 }
 409 } [ { 11 22 33 } [ + ] V{ } map-index-as ] unit-test
 410
 411 {
 412     B{ 11 23 35 }
 413 } [ { 11 22 33 } [ + ] B{ } map-index-as ] unit-test
 414
 415 {
 416     BV{ 11 23 35 }
 417 } [ { 11 22 33 } [ + ] BV{ } map-index-as ] unit-test
 418
 419 { t } [ { } { 99 88 } [ <= ] 2all? ] unit-test