core/sequences/sequences-tests.factor

   1 USING: arrays kernel math namespaces sequences kernel.private
   2 sequences.private strings sbufs tools.test vectors
   3 generic vocabs.loader ;
   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 <slice> >vector ] unit-test
  10 [ 3 ] [ 1 4 dup <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 <slice> subseq >vector ] unit-test
  15 [ V{ 3 4 } ] [ 0 2 2 4 1 10 dup <slice> <slice> subseq >vector ] unit-test
  16 [ "cba" ] [ "abcdef" 3 head-slice reverse ] unit-test
  17
  18 [ 5040 ] [ [ 1 2 3 4 5 6 7 ] 1 [ * ] reduce ] unit-test
  19
  20 [ 5040 [ 1 1 2 6 24 120 720 ] ]
  21 [ [ 1 2 3 4 5 6 7 ] 1 [ * ] accumulate ] unit-test
  22
  23 [ f f ] [ [ ] [ ] find ] unit-test
  24 [ 0 1 ] [ [ 1 ] [ ] find ] unit-test
  25 [ 1 "world" ] [ [ "hello" "world" ] [ "world" = ] find ] unit-test
  26 [ 2 3 ] [ [ 1 2 3 ] [ 2 > ] find ] unit-test
  27 [ f f ] [ [ 1 2 3 ] [ 10 > ] find ] unit-test
  28
  29 [ 1 CHAR: e ]
  30 [ "hello world" "aeiou" [ member? ] curry find ] unit-test
  31
  32 [ 4 CHAR: o ]
  33 [ 3 "hello world" "aeiou" [ member? ] curry find-from ] unit-test
  34
  35 [ f ] [ 3 [ ]     member? ] unit-test
  36 [ f ] [ 3 [ 1 2 ] member? ] unit-test
  37 [ t ] [ 1 [ 1 2 ] member? ] unit-test
  38 [ t ] [ 2 [ 1 2 ] member? ] unit-test
  39
  40 [ t ]
  41 [ [ "hello" "world" ] [ second ] keep memq? ] unit-test
  42
  43 [ 4 ] [ CHAR: x "tuvwxyz" >vector index ] unit-test
  44
  45 [ f ] [ CHAR: x 5 "tuvwxyz" >vector index-from ] unit-test
  46
  47 [ f ] [ CHAR: a 0 "tuvwxyz" >vector index-from ] unit-test
  48
  49 [ f ] [ [ "Hello" { } 0.75 ] [ string? ] all? ] unit-test
  50 [ t ] [ [ ] [ ] all? ] unit-test
  51 [ t ] [ [ "hi" t 0.5 ] [ ] all? ] unit-test
  52
  53 [ [ 1 2 3 ] ] [ [ 1 4 2 5 3 6 ] [ 4 < ] filter ] unit-test
  54 [ { 4 2 6 } ] [ { 1 4 2 5 3 6 } [ 2 mod 0 = ] filter ] unit-test
  55
  56 [ [ 3 ] ] [ [ 1 2 3 ] 2 [ swap < ] curry filter ] unit-test
  57
  58 [ V{ 1 2 3 } ] [ V{ 1 4 2 5 3 6 } clone [ [ 4 < ] filter-here ] keep ] unit-test
  59 [ V{ 4 2 6 } ] [ V{ 1 4 2 5 3 6 } clone [ [ 2 mod 0 = ] filter-here ] keep ] unit-test
  60
  61 [ V{ 3 } ] [ V{ 1 2 3 } clone [ 2 [ swap < ] curry filter-here ] keep ] unit-test
  62
  63 [ "hello world how are you" ]
  64 [ { "hello" "world" "how" "are" "you" } " " join ]
  65 unit-test
  66
  67 [ "" ] [ { } "" join ] unit-test
  68
  69 [ { } ] [ { } flip ] unit-test
  70
  71 [ { "b" "e" } ] [ 1 { { "a" "b" "c" } { "d" "e" "f" } } flip nth ] unit-test
  72
  73 [ { { 1 4 } { 2 5 } { 3 6 } } ]
  74 [ { { 1 2 3 } { 4 5 6 } } flip ] unit-test
  75
  76 [ f ] [ [ { } { } "Hello" ] all-equal? ] unit-test
  77 [ f ] [ [ { 2 } { } { } ] all-equal? ] unit-test
  78 [ t ] [ [ ] all-equal? ] unit-test
  79 [ t ] [ [ 1234 ] all-equal? ] unit-test
  80 [ f ] [ [ 1.0 1 1 ] all-equal? ] unit-test
  81 [ t ] [ { 1 2 3 4 } [ < ] monotonic? ] unit-test
  82 [ f ] [ { 1 2 3 4 } [ > ] monotonic? ] unit-test
  83 [ [ 2 3 4 ] ] [ [ 1 2 3 ] 1 [ + ] curry map ] unit-test
  84
  85 [ 1 ] [ 0 [ 1 2 ] nth ] unit-test
  86 [ 2 ] [ 1 [ 1 2 ] nth ] unit-test
  87
  88 [ [ ]           ] [ [ ]   [ ]       append ] unit-test
  89 [ [ 1 ]         ] [ [ 1 ] [ ]       append ] unit-test
  90 [ [ 2 ]         ] [ [ ] [ 2 ]       append ] unit-test
  91 [ [ 1 2 3 4 ]   ] [ [ 1 2 3 ] [ 4 ] append ] unit-test
  92 [ [ 1 2 3 4 ]   ] [ [ 1 2 3 ] { 4 } append ] unit-test
  93
  94 [ "a" -1 append ] must-fail
  95 [ -1 "a" append ] must-fail
  96
  97 [ [ ]       ] [ 1 [ ]           remove ] unit-test
  98 [ [ ]       ] [ 1 [ 1 ]         remove ] unit-test
  99 [ [ 3 1 1 ] ] [ 2 [ 3 2 1 2 1 ] remove ] unit-test
 100
 101 [ [ ]       ] [ [ ]       reverse ] unit-test
 102 [ [ 1 ]     ] [ [ 1 ]     reverse ] unit-test
 103 [ [ 3 2 1 ] ] [ [ 1 2 3 ] reverse ] unit-test
 104
 105 [ f ] [ f 0 head ] unit-test
 106 [ [ ] ] [ [ 1 ] 0 head ] unit-test
 107 [ [ 1 2 3 ] ] [ [ 1 2 3 4 ] 3 head ] unit-test
 108 [ [ ] ] [ [ 1 2 3 ] 3 tail ] unit-test
 109 [ [ 3 ] ] [ [ 1 2 3 ] 2 tail ] unit-test
 110
 111 [ "blah" ] [ "blahxx" 2 head* ] unit-test
 112
 113 [ "xx" ] [ "blahxx" 2 tail* ] unit-test
 114
 115 [ t ] [ "xxfoo" 2 head-slice "xxbar" 2 head-slice = ] unit-test
 116 [ t ] [ "xxfoo" 2 head-slice "xxbar" 2 head-slice [ hashcode ] bi@ = ] unit-test
 117
 118 [ t ] [ "xxfoo" 2 head-slice SBUF" barxx" 2 tail-slice* = ] unit-test
 119 [ t ] [ "xxfoo" 2 head-slice SBUF" barxx" 2 tail-slice* [ hashcode ] bi@ = ] unit-test
 120
 121 [ t ] [ [ 1 2 3 ] [ 1 2 3 ] sequence= ] unit-test
 122 [ t ] [ [ 1 2 3 ] { 1 2 3 } sequence= ] unit-test
 123 [ t ] [ { 1 2 3 } [ 1 2 3 ] sequence= ] unit-test
 124 [ f ] [ [ ] [ 1 2 3 ] sequence= ] unit-test
 125
 126 [ { 1 3 2 4 } ] [ { 1 2 3 4 } clone 1 2 pick exchange ] unit-test
 127
 128 [ { "" "a" "aa" "aaa" } ]
 129 [ 4 [ CHAR: a <string> ] map ]
 130 unit-test
 131
 132 [ V{ } ] [ "f" V{ } clone [ delete ] keep ] unit-test
 133 [ V{ } ] [ "f" V{ "f" } clone [ delete ] keep ] unit-test
 134 [ V{ } ] [ "f" V{ "f" "f" } clone [ delete ] keep ] unit-test
 135 [ V{ "x" } ] [ "f" V{ "f" "x" "f" } clone [ delete ] keep ] unit-test
 136 [ V{ "y" "x" } ] [ "f" V{ "y" "f" "x" "f" } clone [ delete ] keep ] unit-test
 137
 138 [ V{ 0 1 4 5 } ] [ 6 >vector 2 4 pick delete-slice ] unit-test
 139
 140 [ 6 >vector 2 8 pick delete-slice ] must-fail
 141
 142 [ V{ } ] [ 6 >vector 0 6 pick delete-slice ] unit-test
 143
 144 [ V{ 1 2 "a" "b" 5 6 7 } ] [
 145     { "a" "b" } 2 4 V{ 1 2 3 4 5 6 7 } clone
 146     [ replace-slice ] keep
 147 ] unit-test
 148
 149 [ V{ 1 2 "a" "b" 6 7 } ] [
 150     { "a" "b" } 2 5 V{ 1 2 3 4 5 6 7 } clone
 151     [ replace-slice ] keep
 152 ] unit-test
 153
 154 [ V{ 1 2 "a" "b" 4 5 6 7 } ] [
 155     { "a" "b" } 2 3 V{ 1 2 3 4 5 6 7 } clone
 156     [ replace-slice ] keep
 157 ] unit-test
 158
 159 [ V{ 1 2 3 4 5 6 7 "a" "b" } ] [
 160     { "a" "b" } 7 7 V{ 1 2 3 4 5 6 7 } clone
 161     [ replace-slice ] keep
 162 ] unit-test
 163
 164 [ V{ "a" 3 } ] [
 165     { "a" } 0 2 V{ 1 2 3 } clone [ replace-slice ] keep
 166 ] unit-test
 167
 168 [ { 1 4 9 } ] [ { 1 2 3 } clone dup [ sq ] change-each ] unit-test
 169
 170 [ 5 ] [ 1 >bignum { 1 5 7 } nth-unsafe ] unit-test
 171 [ 5 ] [ 1 >bignum { 1 5 7 } nth-unsafe ] unit-test
 172 [ 5 ] [ 1 >bignum "\u000001\u000005\u000007" nth-unsafe ] unit-test
 173
 174 [ SBUF" before&after" ] [
 175     "&" 6 11 SBUF" before and after" [ replace-slice ] keep
 176 ] unit-test
 177
 178 [ 3 "a" ] [ { "a" "b" "c" "a" "d" } [ "a" = ] find-last ] unit-test
 179
 180 [ f f ] [ 100 { 1 2 3 } [ 1 = ] find-from ] unit-test
 181 [ f f ] [ 100 { 1 2 3 } [ 1 = ] find-last-from ] unit-test
 182 [ f f ] [ -1 { 1 2 3 } [ 1 = ] find-from ] unit-test
 183
 184 [ 0 ] [ { "a" "b" "c" } { "A" "B" "C" } mismatch ] unit-test
 185
 186 [ 1 ] [ { "a" "b" "c" } { "a" "B" "C" } mismatch ] unit-test
 187
 188 [ f ] [ { "a" "b" "c" } { "a" "b" "c" } mismatch ] unit-test
 189
 190 [ V{ } V{ } ] [ { "a" "b" } { "a" "b" } drop-prefix [ >vector ] bi@ ] unit-test
 191
 192 [ V{ "C" } V{ "c" } ] [ { "a" "b" "C" } { "a" "b" "c" } drop-prefix [ >vector ] bi@ ] unit-test
 193
 194 [ -1 1 "abc" <slice> ] must-fail
 195
 196 [ V{ "a" "b" } V{ } ] [ { "X" "a" "b" } { "X" } drop-prefix [ >vector ] bi@ ] unit-test
 197
 198 [ 1 ] [ 0.5 { 1 2 3 } nth ] unit-test
 199
 200 ! Pathological case
 201 [ "ihbye" ] [ "hi" <reversed> "bye" append ] unit-test
 202
 203 [ t ] [ "hi" <reversed> SBUF" hi" <reversed> = ] unit-test
 204
 205 [ t ] [ "hi" <reversed> SBUF" hi" <reversed> = ] unit-test
 206
 207 [ t ] [ "hi" <reversed> SBUF" hi" <reversed> [ hashcode ] bi@ = ] unit-test
 208
 209 [ -10 "hi" "bye" copy ] must-fail
 210 [ 10 "hi" "bye" copy ] must-fail
 211
 212 [ V{ 1 2 3 5 6 } ] [
 213     3 V{ 1 2 3 4 5 6 } clone [ delete-nth ] keep
 214 ] unit-test
 215
 216 ! erg's random tester found this one
 217 [ SBUF" 12341234" ] [
 218     9 <sbuf> dup "1234" swap push-all dup dup swap push-all
 219 ] unit-test
 220
 221 [ f ] [ f V{ } like f V{ } like eq? ] unit-test
 222
 223 [ V{ f f f } ] [ 3 V{ } new-sequence ] unit-test
 224 [ SBUF" \0\0\0" ] [ 3 SBUF" " new-sequence ] unit-test
 225
 226 [ 0 ] [ f length ] unit-test
 227 [ f first ] must-fail
 228 [ 3 ] [ 3 10 nth ] unit-test
 229 [ 3 ] [ 3 10 nth-unsafe ] unit-test
 230 [ -3 10 nth ] must-fail
 231 [ 11 10 nth ] must-fail
 232
 233 [ -1./0. 0 delete-nth ] must-fail
 234 [ "" ] [ "" [ CHAR: \s = ] trim ] unit-test
 235 [ "" ] [ "" [ CHAR: \s = ] trim-left ] unit-test
 236 [ "" ] [ "" [ CHAR: \s = ] trim-right ] unit-test
 237 [ "" ] [ "  " [ CHAR: \s = ] trim-left ] unit-test
 238 [ "" ] [ "  " [ CHAR: \s = ] trim-right ] unit-test
 239 [ "asdf" ] [ " asdf " [ CHAR: \s = ] trim ] unit-test
 240 [ "asdf " ] [ " asdf " [ CHAR: \s = ] trim-left ] unit-test
 241 [ " asdf" ] [ " asdf " [ CHAR: \s = ] trim-right ] unit-test
 242
 243 [ 328350 ] [ 100 [ sq ] sigma ] unit-test
 244
 245 [ 50 ] [ 100 [ even? ] count ] unit-test
 246 [ 50 ] [ 100 [ odd?  ] count ] unit-test
 247
 248 [ { "b" "d" } ] [ { 1 3 } { "a" "b" "c" "d" } nths ] unit-test
 249 [ { "a" "b" "c" "d" } ] [ { 0 1 2 3 } { "a" "b" "c" "d" } nths ] unit-test
 250 [ { "d" "c" "b" "a" } ] [ { 3 2 1 0 } { "a" "b" "c" "d" } nths ] unit-test
 251 [ { "d" "a" "b" "c" } ] [ { 3 0 1 2 } { "a" "b" "c" "d" } nths ] unit-test
 252
 253 TUPLE: bogus-hashcode ;
 254
 255 M: bogus-hashcode hashcode* 2drop 0 >bignum ;
 256
 257 [ 0 ] [ { T{ bogus-hashcode } } hashcode ] unit-test
 258
 259 [ { 2 4 6 } { 1 3 5 7 } ] [ { 1 2 3 4 5 6 7 } [ even? ] partition ] unit-test
 260
 261 [ { 1 3 7 } ] [ 2 { 1 3 5 7 } remove-nth ] unit-test
 262
 263 [ { 1 3 "X" 5 7 } ] [ "X" 2 { 1 3 5 7 } insert-nth ] unit-test
 264
 265 [ V{ 0 2 } ] [ "a" { "a" "b" "a" } indices ] unit-test
 266
 267 [ "a,b" ] [ "a" "b" "," glue ] unit-test
 268 [ "(abc)" ] [ "abc" "(" ")" surround ] unit-test
 269
 270 [ "HELLO" ] [
 271     "HELLO" { -1 -1 -1 -1 -1 } { 2 2 2 2 2 2 }
 272     [ * 2 + + ] 3map
 273 ] unit-test
 274
 275 { 3 1 } [ [ 3array ] 3map ] must-infer-as
 276
 277 { 3 0 } [ [ 3drop ] 3each ] must-infer-as
 278
 279 [ V{ 0 3 } ] [ "A" { "A" "B" "C" "A" "D" } indices ] unit-test
 280
 281 [ "asdf" iota ] must-fail
 282 [ T{ iota { n 10 } } ] [ 10 iota ] unit-test
 283 [ 0 ] [ 10 iota first ] unit-test