346 lines
7.1 KiB
Elixir
346 lines
7.1 KiB
Elixir
Code.require_file "../test_helper", __FILE__
|
|
|
|
module ListTest
|
|
mixin ExUnit::Case
|
|
|
|
def length_size_test
|
|
3 = [1,2,3].length
|
|
0 = [].size
|
|
end
|
|
|
|
def multiplier_test
|
|
[] = [] * 3
|
|
[] = ['foo] * 0
|
|
"" = [] * ","
|
|
|
|
[1,1,1] = [1] * 3
|
|
[1,2,1,2] = [1,2] * 2
|
|
"1,2,3" = [1,2,3] * ","
|
|
end
|
|
|
|
def flatlength_test
|
|
3 = [1,2,3].flatlength
|
|
3 = [[1,2,3]].flatlength
|
|
3 = [1, [2,3]].flatlength
|
|
3 = [[1], [2], [3]].flatlength
|
|
end
|
|
|
|
def include_and_member_test
|
|
list = [1,2,3]
|
|
true = list.include?(1)
|
|
false = list.include?(4)
|
|
true = list.member?(1)
|
|
false = list.member?(4)
|
|
end
|
|
|
|
def double_brackets_test
|
|
2 = [1, [2], 3][1][0]
|
|
2 = (-> [1, [2], 3][1][0]).()
|
|
end
|
|
|
|
def inspect_test
|
|
"[]" = [].inspect
|
|
"[1,2,3]" = [1,2,3].inspect
|
|
"[1,2|3]" = [1,2|3].inspect
|
|
end
|
|
|
|
def add_two_lists_together_test
|
|
list_one = [1,2,3]
|
|
list_two = [4,5,6]
|
|
[1,2,3,4,5,6] = list_one + list_two
|
|
[1,2,3,1,2,3] = list_one + list_one
|
|
end
|
|
|
|
def fold_test
|
|
addfun = -> (e, acc) e + acc
|
|
"bazbarfoo" = ["foo", "bar", "baz"].foldl("", addfun)
|
|
"foobarbaz" = ["foo", "bar", "baz"].foldr("", addfun)
|
|
end
|
|
|
|
def flatten_test
|
|
[1,2,3] = [1,2,3].flatten
|
|
[1,2,3] = [[1,2,3]].flatten
|
|
[1,2,3] = [[[1,2,3]]].flatten
|
|
[1,2,3] = [[1],[2],[3]].flatten
|
|
end
|
|
|
|
def flatten_lists_test
|
|
[1,2,3] = [[1,2,3]].flatten_lists
|
|
[1,2,3] = [[1],[2],[3]].flatten_lists
|
|
assert_error 'badarg, -> [1,2,3].flatten_lists
|
|
end
|
|
|
|
def each_test
|
|
list = [1,2,4]
|
|
list.each do (x)
|
|
true = list.include?(x)
|
|
end
|
|
|
|
assert_error { 'badmatch, true }, do
|
|
list.each -> (x) false = list.include?(x)
|
|
end
|
|
end
|
|
|
|
def each_returns_self_test
|
|
list = [1,2,3]
|
|
each_returns = list.each -> (x) x
|
|
~list = each_returns
|
|
end
|
|
|
|
def map_and_collect_test
|
|
map_result = [1,2,3].map -> (x) x + 1
|
|
[2,3,4] = map_result
|
|
|
|
collect_result = [1,2,3].collect -> (x) x + 1
|
|
[2,3,4] = collect_result
|
|
end
|
|
|
|
def filter_and_select_test
|
|
filter_result = [1,2,3].filter -> (x) x / 2 == 1
|
|
[2] = filter_result
|
|
|
|
select_result = [1,2,3,4].select -> (x) [3,4].include?(x)
|
|
[3,4] = select_result
|
|
end
|
|
|
|
def proper_test
|
|
true = [1,2].proper?
|
|
true = [1|[2]].proper?
|
|
false = [1|2].proper?
|
|
end
|
|
|
|
def all_test
|
|
true = [].all? -> (_) false
|
|
false = [1,2,3].all? -> (i) i rem 2 == 0
|
|
true = [2,4,6].all? -> (i) i rem 2 == 0
|
|
end
|
|
|
|
def any_test
|
|
false = [].any? -> (_) false
|
|
false = [4,5,6].any? -> (i) i == 2
|
|
true = [1,2,3].any? -> (i) i == 2
|
|
end
|
|
|
|
def keyfind_test
|
|
{'foo, 1} = ['foo/1, 'bar/2].keyfind('foo, 0)
|
|
{'bar, 2} = ['foo/1, 'bar/2].keyfind('bar, 0)
|
|
false = ['foo/1, 'bar/2].keyfind('foo, 1)
|
|
false = ['foo/1, 'bar/2].keyfind('baz, 0)
|
|
end
|
|
|
|
def zip_test
|
|
[{'foo, 1}, {'bar, 2}] = ['foo, 'bar].zip([1, 2])
|
|
assert_error 'function_clause, -> ['foo].zip([1, 2])
|
|
end
|
|
|
|
def unzip_test
|
|
{['foo, 'bar], [1,2]} = [{'foo, 1}, {'bar, 2}].unzip
|
|
assert_error 'function_clause, -> [{'foo, 0}, 'bar].unzip
|
|
end
|
|
|
|
def zipwith_test
|
|
[5,7,9] = [1,2,3].zipwith([4,5,6], -> (x,y) x + y)
|
|
assert_error 'function_clause, -> [1,2,3].zipwith([1,2], -> (_,_) 0)
|
|
end
|
|
|
|
def sum_test
|
|
6 = [1,2,3].sum
|
|
0 = [].sum
|
|
end
|
|
|
|
def head_test
|
|
1 = [1,2,3].head
|
|
1 = [1].head
|
|
assert_error 'badarg, -> [].head
|
|
end
|
|
|
|
def tail_test
|
|
[2,3] = [1,2,3].tail
|
|
[2] = [1,2].tail
|
|
[] = [1].tail
|
|
assert_error 'badarg, -> [].tail
|
|
end
|
|
|
|
def min_max_test
|
|
1 = [1,2,3].min
|
|
"bar" = ["baz", "foo", "bar"].min
|
|
assert_error 'function_clause, -> [].min
|
|
end
|
|
|
|
def max_test
|
|
3 = [1,2,3].max
|
|
"foo" = ["baz", "foo", "bar"].max
|
|
assert_error 'function_clause, -> [].max
|
|
end
|
|
|
|
def uniq_test
|
|
[1,2,4] = [1,2,1,4,1,2].uniq
|
|
end
|
|
|
|
def delete_test
|
|
x = [6,8,4,9]
|
|
[6,8,4] = x.delete(9)
|
|
[6,8,9] = x.delete(4)
|
|
end
|
|
|
|
def arithmetic_syntax_test
|
|
[1,2,3] = [1,2,3].delete -1
|
|
2 = [1,2,3].length - 1
|
|
2 = [1,2,3].length-1
|
|
end
|
|
|
|
def delete_with_duplicates_test
|
|
x = [6,8,6,4,9]
|
|
[8,6,4,9] = x.delete(6)
|
|
end
|
|
|
|
def delete_all_test
|
|
x = [1,2,1,3]
|
|
[3,2] = x.delete_all(1)
|
|
end
|
|
|
|
def join_test
|
|
"1,2,3" = [1,2,3].join(",")
|
|
"foo" = ["foo"].join("_")
|
|
"foo_bar" = ['foo, 'bar].join("_")
|
|
end
|
|
|
|
def takewhile_test
|
|
[1,2] = [1,2,3,4,5].takewhile -> (x) x < 3
|
|
end
|
|
|
|
def dropwhile_test
|
|
[3,4,5] = [1,2,3,4,5].dropwhile -> (x) x < 3
|
|
end
|
|
|
|
def sort_test
|
|
[1,2,3,4,4] = [4,1,3,2,4].sort
|
|
["bar", "baz", "foo"] = ["foo", "bar", "baz"].sort
|
|
end
|
|
|
|
def split_test
|
|
{[1,2,3], [4,5]} = [1,2,3,4,5].split(3)
|
|
assert_error 'badarg, -> [1,2,3,4,5].split(10)
|
|
end
|
|
|
|
def insert_test
|
|
[1,2,0,3,4,5] = [1,2,3,4,5].insert(0, 2)
|
|
assert_error 'badarg, -> [1,2,3].insert(0, 10)
|
|
end
|
|
|
|
def partition_test
|
|
{[2,4,6], [1,3,5]} = [1,2,3,4,5,6].partition -> (x) x rem 2 == 0
|
|
{[], [1,3,5]} = [1,3,5].partition -> (x) x rem 2 == 0
|
|
{[2,4,6], []} = [2,4,6].partition -> (x) x rem 2 == 0
|
|
end
|
|
|
|
def splitwith_test
|
|
{[1], [2,3,4,5,6]} = [1,2,3,4,5,6].splitwith -> (x) x rem 2 == 1
|
|
end
|
|
|
|
def brackets_test
|
|
1 = [1,2,3][0]
|
|
2 = [1,2,3][1]
|
|
3 = [1,2,3][2]
|
|
nil = [1,2,3][3]
|
|
end
|
|
|
|
def brackets_negative_index_test
|
|
1 = [1,2,3][-3]
|
|
2 = [1,2,3][-2]
|
|
3 = [1,2,3][-1]
|
|
nil = [1,2,3][-4]
|
|
end
|
|
|
|
def brackets_syntax_test
|
|
2 = [1,2,3][1]
|
|
2 = [1,2,3] [1]
|
|
2 = ([1] + [2,3])[1]
|
|
|
|
% Test ambiguity in method calls
|
|
2 = a_list()[1]
|
|
2 = self.a_list()[1]
|
|
2 = a_list[1]
|
|
2 = self.a_list[1]
|
|
[1] = a_list [1]
|
|
[1] = self.a_list [1]
|
|
2 = 6 - 1 - self.a_list[1] - 1
|
|
|
|
% Test ambiguity in variables
|
|
a_list = [4,5,6]
|
|
5 = a_list[1]
|
|
[1] = a_list [1]
|
|
|
|
% Test ambiguity in method calls with punctuation
|
|
2 = a_list!()[1]
|
|
2 = self.a_list!()[1]
|
|
2 = a_list![1]
|
|
2 = self.a_list![1]
|
|
[1] = a_list! [1]
|
|
[1] = self.a_list! [1]
|
|
2 = 6 - 1 - self.a_list![1] - 1
|
|
end
|
|
|
|
def bracket_slice_test
|
|
[1,2,3] = [1,2,3,4,5][0,2]
|
|
[3,4,5] = [1,2,3,4,5][-3,3]
|
|
|
|
[] = [1,2,3,4,5][5, 1]
|
|
end
|
|
|
|
def list_comprehension_test
|
|
[2,4,6] = [x * 2 for x inlist [1,2,3]]
|
|
[2,4,6] = [x * 2 for x in [1,2,3], true]
|
|
[2,4,6] = [x * 2 for x in [1,2,3], x.abs > 0]
|
|
[2,6] = [x * 2 for x in [0,1,-2,3], x > 0]
|
|
[3,2,6,4,9,6] = [x * y for x in [1,2,3], y in [3,2]]
|
|
[] = [x * 2 for x in [1,2,3], falsy]
|
|
[] = [x * 2 for x in [1,2,3], nilly]
|
|
end
|
|
|
|
def list_comprehension_with_binary_generator_test
|
|
[2,4,6] = [x * 2 for <<x>> in <<1,2,3>>]
|
|
[2,4,6] = [x * 2 for <<x>> inlist [<<1>>,<<2>>,<<3>>]]
|
|
|
|
pixels = << 213,45,132,64,76,32,76,0,0,234,32,15 >>
|
|
result = [{213,45,132},{64,76,32},{76,0,0},{234,32,15}]
|
|
~result = [{r,g,b} for <<r:8,g:8,b:8>> in pixels]
|
|
end
|
|
|
|
def variables_in_list_comprehensions_do_not_leak_test
|
|
[2,4,6] = [falsy * 2 for falsy in [1,2,3]]
|
|
false = falsy
|
|
end
|
|
|
|
def empty_test
|
|
false = ["abc"].empty?
|
|
true = [].empty?
|
|
end
|
|
|
|
% Helper methods
|
|
|
|
def a_list
|
|
[1,2,3]
|
|
end
|
|
|
|
def a_list(list)
|
|
list
|
|
end
|
|
|
|
def falsy
|
|
false
|
|
end
|
|
|
|
def nilly
|
|
nil
|
|
end
|
|
|
|
def a_list!
|
|
[1,2,3]
|
|
end
|
|
|
|
def a_list!(list)
|
|
list
|
|
end
|
|
end
|