include :assert
add_results setup name: "array tests" {
test "array" {
assert_equal 1 { x = array.new; x[0] = 1; x[0] }
assert_equal 11 { x = array.new; x[10] = :jello; x.length }
assert_equal 3 { x = [1,2,3]; x.length }
assert_equal "a" { y = { 3}; x = [1, "a", y]; x[1] }
assert_equal "b" { ["a", "b", "c"][1] }
assert_equal 2 { [1,2,3,4][2,3].length }
}
test "large_array" {
assert_equal "a" { x = [:a, :b, :c, :d, :e, :f, :g, :h, :i, :j, :k, :l, :m, :n, :o, :p, :q, :r, :s, :t, :u, :v, :w, :x, :y, :z, :aa, :ab, :ac, :ad, :ae, :af, :ag, :ah, :ai, :aj, :ak, :al, :am, :an, :ao, :ap, :aq, :ar, :as, :at, :au, :av, :aw, :ax, :ay, :az, :ba, :bb, :bc, :bd, :be, :bf, :bg, :bh, :bi, :bj, :bk, :bl, :bm, :bn, :bo, :bp, :bq, :br, :bs, :bt, :bu, :bv, :bw, :bx, :by, :bz, :ca, :cb, :cc, :cd, :ce, :cf, :cg, :ch, :ci, :cj, :ck, :cl, :cm, :cn, :co, :cp, :cq, :cr, :cs, :ct, :cu, :cv, :cw, :cx, :cy, :cz]; x[0] }
assert_equal "cz" { x = [:a, :b, :c, :d, :e, :f, :g, :h, :i, :j, :k, :l, :m, :n, :o, :p, :q, :r, :s, :t, :u, :v, :w, :x, :y, :z, :aa, :ab, :ac, :ad, :ae, :af, :ag, :ah, :ai, :aj, :ak, :al, :am, :an, :ao, :ap, :aq, :ar, :as, :at, :au, :av, :aw, :ax, :ay, :az, :ba, :bb, :bc, :bd, :be, :bf, :bg, :bh, :bi, :bj, :bk, :bl, :bm, :bn, :bo, :bp, :bq, :br, :bs, :bt, :bu, :bv, :bw, :bx, :by, :bz, :ca, :cb, :cc, :cd, :ce, :cf, :cg, :ch, :ci, :cj, :ck, :cl, :cm, :cn, :co, :cp, :cq, :cr, :cs, :ct, :cu, :cv, :cw, :cx, :cy, :cz]; x[-1] }
}
test "array_compact" {
assert_equal [:a, 2, :c] { [:a 2 :c null].compact }
assert_equal [:a, 2, :c, null] { a = [:a 2 :c null];a.compact;a }
assert_equal [:a, 2, :c] { a = [:a null, 2 :c ];a.compact!;a }
assert_equal [:a, 2, :c, 10] { a = [:a null, 2 :c ];a[10] = 10;a.compact!;a }
}
test "array_copy" {
assert_equal "a" { a = [:a]; b = a.copy; b[0] }
assert_equal "a" { a = [:a]; b = a.copy; a[0] = 1; b[0] }
assert_equal "a" { a = [:a]; b = a.copy; b[0] = 1; a[0] }
assert_equal 11 { a = []; a[10] = 2; b = a.copy; b.length }
}
test "array_indexing" {
assert_equal "b" { b = ["a", "b", "c"]; b[1] }
assert_equal [:a, :b, :c] { ["z", "a", "b", "c", "d", "e", "f"][1,3] }
assert_equal [:a, :b, :c] { ["z", "a", "b", "c", "d", "e", "f"][-6,-4] }
assert_equal [] { ["z", "a", "b", "c", "d", "e", "f"][10,15] }
assert_null { [][1] }
assert_equal [:e, :f] { ["z", "a", "b", "c", "d", "e", "f"][10,5] }
assert_equal [null, null, null, :a] { a = []; a[5] = :a; a[-1, -4] }
}
test "array_index_of" {
assert_equal 1 { [1 2 3 4 5].index_of 2 }
assert_equal 3 { [1 :2 3 :4 5].index_of :4 }
assert_equal 3 { [1 2 3 2 4 5 5].index_of 2 2 }
assert_null { [:1 :2 :3 :4 :5].index_of :hello }
}
test "array_rindex_of" {
assert_equal 1 { [1,2,3,4,5].rindex_of 2 }
assert_equal 3 { [1,:2,3,:4,5].rindex_of :4 }
assert_equal 3 { [1,2,3,2,5].rindex_of 2 }
assert_equal 4 { [1 :4 :2 3 :4 5].rindex_of :4 }
assert_equal 1 { [1 5 3 2 4 5 5].rindex_of 5 4 }
assert_null { [:1,:2,:3,:4,:5].rindex_of :hello }
}
test "array_set" {
assert_equal "b" { a = [1, 2, 3]; a[1] = "b"; a[1] }
assert_null { a = [1,2,3]; a[7] = 5; a[5] }
assert_equal "b" { a = [1,2,3]; a[-1] = "b"; a[2] }
assert_equal [1 2 3] { a = [1 2]; a[2] = 3; a }
}
test "array_nested_set" {
assert_equal "b" { a = []; a[0] = []; a[0][1] = "b"; a[0][1] }
assert_equal "b" { a = []; a[0] = []; a[0][1] = []; a[0][1][2] = "b"; a[0][1][2] }
}
test "array.insert" {
assert_equal [1 2 3] { [1 2].insert 2 3 }
assert_equal [1 3 2] { [1 2].insert -1 3 }
assert_equal [3 1 2] { [1 2].insert -2 3 }
assert_equal [1 2 null, 3] { [1 2].insert 3 3 }
assert_fail { [1 2].insert -10 "hello" }
}
test "array_method" {
assert_equal 2 { z = object.new; z.test = { [1,2,3] }; z.test[1] }
}
test "array invoke" {
assert_equal 1 { y = {x| x}; z = [->y]; z[0](1) }
}
test "array_reverse" {
assert_equal [1, 2, 3] { [3,2,1].reverse }
assert_equal [1, 2, 3] { a = [1,2,3];a.reverse;a }
assert_equal [3, 2, 1] { a = [1,2,3];a.reverse!;a }
}
test "array_concat" {
assert_equal [:a, :b, :c, :d] { ["a"] + ["b"] + ["c"] + ["d"] }
}
test "array_push" {
assert_equal [:a, :b, :c, :d] { ["a"] << "b" << "c" << "d" }
assert_equal [:a, :b, :c, :d] { ["a"].push("b").push("c").push("d") }
assert_equal [:a, :b, :c, :d] { a = ["a"]; a.push("b").push("c").push("d"); a }
}
test "array_pop" {
assert_equal 3 { [1,2,3].pop }
assert_equal 2 { a = [1,2,3]; a.pop; a.length }
assert_equal [1, 2] { a = [1,2,3]; a.pop; a }
assert_null { a = []; a.pop }
assert_equal [3, 2] { a = [1,2,3]; a.pop(2) }
assert_equal [1] { a = [1,2,3]; a.pop(2); a }
assert_equal [1] { a = [1]; a.pop(2) }
assert_equal [] { a = []; a.pop(2); a }
}
test "array_map" {
assert_equal [2, 3, 4] { a = [1,2,3]; a.map {i| i + 1 } }
assert_equal [] { a = []; a.map {i| i + 1 } }
}
test "array_map!" {
assert_equal [2, 3, 4] { a = [1,2,3]; a.map! {i| i + 1 }; a }
assert_equal [] { a = []; a.map! {i| i + 1 }; a }
}
test "array_map_string" {
assert_equal [2, 3, 4] { a = ['1','2','3']; a.map(:to_i).map {i| i + 1 } }
assert_equal [:dcba, :zyxw] { [:abcd, :wxyz].map(:reverse) }
}
test "array_map!_string" {
assert_equal [:dcba, :zyxw] { a = [:abcd, :wxyz]; a.map! :reverse; a }
}
test "array_map_with_index" {
assert_equal [[0, :a], [1, :b], [2, :c]] { b = [:a, :b, :c]; b.map_with_index { obj, index | [index, obj] } }
assert_equal [] { a = []; a.map_with_index {i, in | i + 1 } }
}
test "array_reduce" {
assert_equal 45 { 5.to(10).reduce { sum, n | sum + n } }
assert_equal 151200 { (5).to(10).reduce 1 { product, n | product * n } }
assert_equal 1 { [1].reduce { sum, n | sum + n } }
assert_equal 1 { [1].reduce 0 { sum, n | sum + n } }
assert_equal 0 { [1].reduce 0 { product, n | product * n } }
assert_equal 0 { [].reduce 0 { product, n | product * n } }
assert_null { [].reduce { product, n | product * n } }
assert_equal "sheep" { [:cat :sheep :dog :bear].reduce { longest, word | true? longest.length > word.length, { longest } { word } } }
}
test "array_reduce_with_string" {
assert_equal 45 { 5.to(10).reduce :+ }
assert_equal 151200 { 5.to(10).reduce :* }
assert_equal 1 { [1].reduce :+ }
assert_equal 1 { [1].reduce 0 :+ }
assert_equal 0 { [1].reduce 0 :* }
assert_equal 0 { [].reduce 0 :* }
assert_null { [].reduce :* }
assert_equal "manbearpig" { [:man :bear :pig].reduce :+ }
}
test "array_first" {
assert_equal 1 { a = [1,2,3]; a.first }
assert_equal 1 { [1,2,3].first }
}
test "array_last" {
assert_equal 3 { a = [1,2,3]; a.last }
assert_equal 3 { [1,2,3].last }
}
test "array_rest" {
assert_equal 2 { a = [1,2,3]; a.rest.length }
assert_equal 3 { [1,2,3].rest.rest.first }
assert_equal [] { [1].rest }
assert_equal [] { [].rest }
}
test "array_each" {
assert_equal [1, 2, 3] { b = []; [1,2,3].each { i | b << i }; b }
assert_equal [] { b = []; [].each { i | b << i }; b }
}
test "array_each_with_index" {
assert_equal [0, :a, 1, :b, 2, :c] { a = [];b = [:a, :b, :c]; b.each_with_index { obj, index | a << index << obj }; a }
assert_equal [] { b = []; [].each_with_index { i, in | b << i }; b }
}
test "array_reverse_each" {
assert_equal [3, 2, 1] { b = []; [1,2,3].reverse_each { i | b << i }; b }
assert_equal [] { b = []; [].reverse_each { i | b << i }; b }
}
test "array.each_slice" {
assert_equal [[1, 2], [3, 4]], { res = []; [1 2 3 4].each_slice 2, { a, b | res << [a, b] }; res }
}
test "array_empty" {
assert { [].empty? }
assert_false { [1,2].empty? }
assert_false { a = [1,2]; a.empty? }
}
test "array.reject!" {
assert_equal [] { [].reject! { n | n > 4 } }
assert_equal [1 2 3 4] { a = 1.to 10; a.reject! { n | n > 4 }; a }
}
test "array.reject! with method name" {
assert_equal [:a :b :c] { a = [:a 1 2 :b 100 :c]; a.reject! :number?; a }
}
test "array_select" {
assert_equal [1, 2] { [1,2,3].select { i | i < 3 } }
assert_equal [] { [].select { i | i < 3 } }
}
test "array_select!" {
assert_equal [1 2 3 4] { a = 1.to 10; a.select! { i | i < 5 }; a }
assert_equal [] { a = []; a.select! { i | i < 3 }; a }
}
test "array.select! with method name" {
assert_equal [1 2 3] { a = [1 :a 2 [] :b :c [ a: 1] 3]; a.select! :number?; a }
}
test "array_clear" {
assert_equal [] { [1,2,3,4].clear }
}
test "array_delete_first" {
assert_equal [1, 2, 3] { [1,2,3,4].delete_first 4; }
assert_equal [2, 3, 4] { [1,2,3,4].delete_first 1 }
assert_equal [1, 2, 3] { [1,2,3].delete_first 4 }
assert_equal [1, 2, 3, 4] { [1,1,2,3,4].delete_first 1 }
assert_equal [1, 3] { [1,2,3].delete_first 2 }
}
test "array_include?" {
assert { [1,2,3].include? 3 }
assert { a = object.new; b = [a]; b.include? a }
assert_false { a = 1; b = [a]; b.include? 2 }
assert_false { b = []; b.include? 2 }
assert { b = []; b[10] = 2; b.include? 2 }
assert_false { a = ['a', 'b', 'c']; a.include? 'd' }
}
test "array_any?" {
assert { [1,2,3].any? { x | x > 2 } }
assert { [3,2,1].any? { x | x > 2 } }
assert_false { [1,2,3].any? { x | x > 4 } }
assert_false { [].any? { x | x > 4 } }
}
test "array.concat" {
assert_equal [1 2] { [1].concat [2] }
assert_equal [1] { [1].concat [] }
assert_equal [1] { [].concat [1] }
assert_equal [1 2] { x = [1]; x.concat [2]; x }
}
test "array_each_while" {
assert_equal 2 { x = 0; [1, 2, 3].each_while { e | x = e; e < 2 }; x }
assert_equal null, { [1, 2, null, 3].each_while { e | e }}
}
test "array.each_until" {
assert_equal 3 { x = 0; [1 2 3 4].each_until { e | x = e; e > 2 }; x }
assert_equal 3 { [null, null, 3].each_until { e | e }}
}
test "array_find" {
assert_equal 3 { [1,2,3].find { x | x > 2 } }
assert_null { [1,2,3].find { x | x > 4 } }
assert_null { [].find { x | x > 4 } }
}
test "array.flatten" {
assert_equal [1 2 3] { [1 [[[[2]]]] [3]].flatten }
assert_equal [] { [].flatten }
assert_equal [1] { [1].flatten }
}
test "array_compare" {
assert { [] == [] }
assert_false { [1,2] == [3,4] }
assert_false { [1,2,3] == [1,2] }
assert_false { ["a", "b"] == ["b", "a"] }
}
test "array_sort" {
assert_equal [1, 2, 3] { [3,2,1].sort }
assert_equal [3, 2, 1] { a = [3,2,1]; a.sort; a }
assert_equal [:a, :b, :c] { a = ["b", "c", "a"]; a.sort }
assert_equal [:b, :c, :a] { a = ["b", "c", "a"]; a.sort; a }
}
test "array.sort_by" {
assert_equal ["aaa", "aa", "a"] { ["a", "aaa", "aa"].sort_by { a, b | a.length > b.length } }
}
test "array_sort!" {
assert_equal [1, 2, 3] { [3,2,1].sort! }
assert_equal [1, 2, 3] { a = [3,2,1]; a.sort!; a }
assert_equal [:a, :b, :c] { a = ["b", "c", "a"]; a.sort! }
assert_equal [:a, :b, :c] { a = ["b", "c", "a"]; a.sort!; a }
}
test "array.sum" {
assert_equal 0 { [].sum }
assert_equal 1 { [1].sum }
assert_equal 3 { [1 2].sum }
}
test "array_compare" {
assert { [1,2,3] == [1,2,3] }
assert_false { [1,3,2] == [1,2,3] }
assert { a = ["a"]; b = ["a"]; a == b }
assert_false { a = ["a"]; b = ["b"]; a == b }
assert_false { a = ["a"]; b = ["b", "c"]; a == b }
assert { a = object.new; b = object.new; c = [a,b]; d = [a,b]; c == d }
}
test "array_unique" {
assert_equal [1, 2, 3] { a = [1 2 3]; a.unique.sort }
assert_equal [1, 2, 3] { a = [3 1 2 1 2 3]; a.unique.sort }
assert_equal [1, 2, 3] { a = [3 1 2 1 2 3]; a.unique.sort }
assert_false { a = [3 1 2 1 2 3]; a.unique; a.sort == [1 2 3] }
assert_equal 4 { b = object.new; a = [b, :sup 1 :sup :hello b, 1]; a.unique.length }
assert_equal 3 { a = []; a[10] = 11; a[4] = :hello; a[2] = :hello; a.unique.length }
}
test "array_unique!" {
assert { a = [1 2 3]; a.unique!; a == [1 2 3] }
assert { a = [3 1 2 1 2 3]; a.unique!; a == [1 2 3] }
assert { a = [3 1 2 1 2 3]; a.unique!; a == [1 2 3] }
assert { a = [3 1 2 1 2 3]; a.unique!; a == [1 2 3] }
assert_equal 4 { b = object.new; a = [b, :sup 1 :sup :hello b, 1]; a.unique!; a.length }
assert_equal 3 { a = []; a[10] = 11; a[4] = :hello; a[2] = :hello; a.unique!; a.length }
}
test "array_join" {
assert_equal "a, b, c" { ["a", "b", "c"].join ", " }
assert_equal "1, 2, 3" { [1, 2, 3].join ", " }
}
test "array.join with final" {
assert_equal "1" { [1].join ", " " and " }
assert_equal "1 and 2" { [1 2].join ", " " and " }
assert_equal "1, 2 and 3" { [1 2 3].join ", " " and " }
}
}