diff options
Diffstat (limited to 'test')
| -rw-r--r-- | test/gleam/base_test.gleam | 44 | ||||
| -rw-r--r-- | test/gleam/function_test.gleam | 183 | ||||
| -rw-r--r-- | test/gleam/iterator_test.gleam | 730 | ||||
| -rw-r--r-- | test/gleam/string_test.gleam | 20 |
4 files changed, 493 insertions, 484 deletions
diff --git a/test/gleam/base_test.gleam b/test/gleam/base_test.gleam index 80f0024..dd59196 100644 --- a/test/gleam/base_test.gleam +++ b/test/gleam/base_test.gleam @@ -1,31 +1,23 @@ if erlang { import gleam/base - import gleam/bit_string.{BitString} import gleam/io import gleam/list import gleam/should - external fn list_to_binary(List(Int)) -> BitString = - "erlang" "list_to_binary" - pub fn encode64_test() { - [255, 127, 254, 252] - |> list_to_binary() + <<255, 127, 254, 252>> |> base.encode64(True) |> should.equal("/3/+/A==") - [255, 127, 254, 252] - |> list_to_binary() + <<255, 127, 254, 252>> |> base.encode64(False) |> should.equal("/3/+/A") - [0, 0, 0] - |> list_to_binary() + <<0, 0, 0>> |> base.encode64(True) |> should.equal("AAAA") - [] - |> list_to_binary() + <<>> |> base.encode64(True) |> should.equal("") } @@ -33,19 +25,19 @@ if erlang { pub fn decode64_test() { "/3/+/A==" |> base.decode64() - |> should.equal(Ok(list_to_binary([255, 127, 254, 252]))) + |> should.equal(Ok(<<255, 127, 254, 252>>)) "/3/+/A" |> base.decode64() - |> should.equal(Ok(list_to_binary([255, 127, 254, 252]))) + |> should.equal(Ok(<<255, 127, 254, 252>>)) "AAAA" |> base.decode64() - |> should.equal(Ok(list_to_binary([0, 0, 0]))) + |> should.equal(Ok(<<0, 0, 0>>)) "" |> base.decode64() - |> should.equal(Ok(list_to_binary([]))) + |> should.equal(Ok(<<>>)) ")!" |> base.decode64() @@ -53,23 +45,19 @@ if erlang { } pub fn url_encode64_test() { - [255, 127, 254, 252] - |> list_to_binary() + <<255, 127, 254, 252>> |> base.url_encode64(True) |> should.equal("_3_-_A==") - [255, 127, 254, 252] - |> list_to_binary() + <<255, 127, 254, 252>> |> base.url_encode64(False) |> should.equal("_3_-_A") - [0, 0, 0] - |> list_to_binary() + <<0, 0, 0>> |> base.url_encode64(True) |> should.equal("AAAA") - [] - |> list_to_binary() + <<>> |> base.url_encode64(True) |> should.equal("") } @@ -77,19 +65,19 @@ if erlang { pub fn url_decode64_test() { "_3_-_A==" |> base.url_decode64() - |> should.equal(Ok(list_to_binary([255, 127, 254, 252]))) + |> should.equal(Ok(<<255, 127, 254, 252>>)) "_3_-_A" |> base.url_decode64() - |> should.equal(Ok(list_to_binary([255, 127, 254, 252]))) + |> should.equal(Ok(<<255, 127, 254, 252>>)) "AAAA" |> base.url_decode64() - |> should.equal(Ok(list_to_binary([0, 0, 0]))) + |> should.equal(Ok(<<0, 0, 0>>)) "" |> base.url_decode64() - |> should.equal(Ok(list_to_binary([]))) + |> should.equal(Ok(<<>>)) ")!" |> base.url_decode64() diff --git a/test/gleam/function_test.gleam b/test/gleam/function_test.gleam index e4a368c..0b3bd8c 100644 --- a/test/gleam/function_test.gleam +++ b/test/gleam/function_test.gleam @@ -1,112 +1,109 @@ -if erlang { - // TODO: JavaScript - import gleam/should - import gleam/dynamic - import gleam/function - import gleam/int - import gleam/list - import gleam/result - import gleam/string - - pub fn compose_test() { - let add_two = fn(int: Int) { int + 2 } - let add_three = fn(int: Int) { int + 3 } - - let add_five = function.compose(add_two, add_three) - - 1 - |> add_five - |> should.equal(6) - - // Takes a list of ints and returns the head as a string (if there is one, or - // else "0" if there is not) - let head_to_string = - list.head - |> function.compose(result.unwrap(_, 0)) - |> function.compose(int.to_string) - - [1] - |> head_to_string - |> should.equal("1") - - [] - |> head_to_string - |> should.equal("0") - } +import gleam/should +import gleam/dynamic +import gleam/function +import gleam/int +import gleam/list +import gleam/result +import gleam/string + +pub fn compose_test() { + let add_two = fn(int: Int) { int + 2 } + let add_three = fn(int: Int) { int + 3 } + + let add_five = function.compose(add_two, add_three) + + 1 + |> add_five + |> should.equal(6) + + // Takes a list of ints and returns the head as a string (if there is one, or + // else "0" if there is not) + let head_to_string = + list.head + |> function.compose(result.unwrap(_, 0)) + |> function.compose(int.to_string) + + [1] + |> head_to_string + |> should.equal("1") + + [] + |> head_to_string + |> should.equal("0") +} - pub fn curry2_test() { - let fun = fn(a, b) { a + b } - let curried = function.curry2(fun) +pub fn curry2_test() { + let fun = fn(a, b) { a + b } + let curried = function.curry2(fun) - curried(1)(2) - |> should.equal(3) - } + curried(1)(2) + |> should.equal(3) +} - pub fn curry3_test() { - let fun = fn(a, b, c) { a + b + c } - let curried = function.curry3(fun) +pub fn curry3_test() { + let fun = fn(a, b, c) { a + b + c } + let curried = function.curry3(fun) - curried(1)(2)(4) - |> should.equal(7) - } + curried(1)(2)(4) + |> should.equal(7) +} - pub fn curry4_test() { - let fun = fn(a, b, c, d) { a + b + c + d } - let curried = function.curry4(fun) +pub fn curry4_test() { + let fun = fn(a, b, c, d) { a + b + c + d } + let curried = function.curry4(fun) - curried(1)(2)(4)(8) - |> should.equal(15) - } + curried(1)(2)(4)(8) + |> should.equal(15) +} - pub fn curry5_test() { - let fun = fn(a, b, c, d, e) { a + b + c + d + e } - let curried = function.curry5(fun) +pub fn curry5_test() { + let fun = fn(a, b, c, d, e) { a + b + c + d + e } + let curried = function.curry5(fun) - curried(1)(2)(4)(8)(16) - |> should.equal(31) - } + curried(1)(2)(4)(8)(16) + |> should.equal(31) +} - pub fn curry6_test() { - let fun = fn(a, b, c, d, e, f) { a + b + c + d + e + f } - let curried = function.curry6(fun) +pub fn curry6_test() { + let fun = fn(a, b, c, d, e, f) { a + b + c + d + e + f } + let curried = function.curry6(fun) - curried(1)(2)(4)(8)(16)(32) - |> should.equal(63) - } + curried(1)(2)(4)(8)(16)(32) + |> should.equal(63) +} - pub fn flip_test() { - let fun = fn(s: String, i: Int) { - s - |> string.append("String: '", _) - |> string.append("', Int: '") - |> string.append(int.to_string(i)) - |> string.append("'") - } +pub fn flip_test() { + let fun = fn(s: String, i: Int) { + s + |> string.append("String: '", _) + |> string.append("', Int: '") + |> string.append(int.to_string(i)) + |> string.append("'") + } - let flipped_fun = function.flip(fun) + let flipped_fun = function.flip(fun) - fun("Bob", 1) - |> should.equal("String: 'Bob', Int: '1'") + fun("Bob", 1) + |> should.equal("String: 'Bob', Int: '1'") - flipped_fun(2, "Alice") - |> should.equal("String: 'Alice', Int: '2'") - } + flipped_fun(2, "Alice") + |> should.equal("String: 'Alice', Int: '2'") +} - pub fn identity_test() { - 1 - |> function.identity - |> should.equal(1) +pub fn identity_test() { + 1 + |> function.identity + |> should.equal(1) - "" - |> function.identity - |> should.equal("") + "" + |> function.identity + |> should.equal("") - [] - |> function.identity - |> should.equal([]) + [] + |> function.identity + |> should.equal([]) - #(1, 2.0) - |> function.identity - |> should.equal(#(1, 2.0)) - } + #(1, 2.0) + |> function.identity + |> should.equal(#(1, 2.0)) } diff --git a/test/gleam/iterator_test.gleam b/test/gleam/iterator_test.gleam index 50d1c99..8de4251 100644 --- a/test/gleam/iterator_test.gleam +++ b/test/gleam/iterator_test.gleam @@ -1,370 +1,378 @@ +import gleam/should +import gleam/iterator.{Done, Next} +import gleam/list + if erlang { - import gleam/should - import gleam/iterator.{Done, Next} - import gleam/list import gleam/map +} - // a |> from_list |> to_list == a - pub fn to_from_list_test() { - let test = fn(subject) { - subject - |> iterator.from_list - |> iterator.to_list - |> should.equal(subject) - } - - test([]) - test([1]) - test([1, 2]) - test([1, 2, 4, 8]) +// a |> from_list |> to_list == a +pub fn to_from_list_test() { + let test = fn(subject) { + subject + |> iterator.from_list + |> iterator.to_list + |> should.equal(subject) } - pub fn step_test() { - let test = fn(subject) { - let step = - subject - |> iterator.from_list - |> iterator.step - - case subject { - [] -> - step - |> should.equal(Done) - - [h, ..t] -> - step - |> should.equal(Next(h, iterator.from_list(t))) - } - } - - test([]) - test([1]) - test([1, 2]) - test([1, 2, 3]) - } + test([]) + test([1]) + test([1, 2]) + test([1, 2, 4, 8]) +} - // a |> from_list |> take(n) == a |> list.take(_, n) - pub fn take_test() { - let test = fn(n, subject) { +pub fn step_test() { + let test = fn(subject) { + let step = subject |> iterator.from_list - |> iterator.take(n) - |> iterator.to_list - |> should.equal(list.take(subject, n)) + |> iterator.step + + case subject { + [] -> + step + |> should.equal(Done) + + [h, ..t] -> { + assert Next(h2, t2) = step + h + |> should.equal(h2) + t2 + |> iterator.to_list + |> should.equal(t) + } } - - test(0, []) - test(1, []) - test(-1, []) - test(0, [0]) - test(1, [0]) - test(-1, [0]) - test(0, [0, 1, 2, 3, 4]) - test(1, [0, 1, 2, 3, 4]) - test(2, [0, 1, 2, 3, 4]) - test(22, [0, 1, 2, 3, 4]) } - // a |> from_list |> fold(a, f) == a |> list.fold(_, a, f) - pub fn fold_test() { - let test = fn(subject, acc, f) { - subject - |> iterator.from_list - |> iterator.fold(acc, f) - |> should.equal(list.fold(subject, acc, f)) - } - - let f = fn(e, acc) { [e, ..acc] } - test([], [], f) - test([1], [], f) - test([1, 2, 3], [], f) - test([1, 2, 3, 4, 5, 6, 7, 8], [], f) - } + test([]) + test([1]) + test([1, 2]) + test([1, 2, 3]) +} - // a |> from_list |> map(f) |> to_list == a |> list.map(_, f) - pub fn map_test() { - let test = fn(subject, f) { - subject - |> iterator.from_list - |> iterator.map(f) - |> iterator.to_list - |> should.equal(list.map(subject, f)) - } +// a |> from_list |> take(n) == a |> list.take(_, n) +pub fn take_test() { + let test = fn(n, subject) { + subject + |> iterator.from_list + |> iterator.take(n) + |> iterator.to_list + |> should.equal(list.take(subject, n)) + } + + test(0, []) + test(1, []) + test(-1, []) + test(0, [0]) + test(1, [0]) + test(-1, [0]) + test(0, [0, 1, 2, 3, 4]) + test(1, [0, 1, 2, 3, 4]) + test(2, [0, 1, 2, 3, 4]) + test(22, [0, 1, 2, 3, 4]) +} - let f = fn(e) { e * 2 } - test([], f) - test([1], f) - test([1, 2, 3], f) - test([1, 2, 3, 4, 5, 6, 7, 8], f) +// a |> from_list |> fold(a, f) == a |> list.fold(_, a, f) +pub fn fold_test() { + let test = fn(subject, acc, f) { + subject + |> iterator.from_list + |> iterator.fold(acc, f) + |> should.equal(list.fold(subject, acc, f)) } - // a |> from_list |> flat_map(f) |> to_list == - // a |> list.map(f) |> list.map(to_list) |> list.flatten - pub fn flat_map_test() { - let test = fn(subject, f) { - subject - |> iterator.from_list - |> iterator.flat_map(f) - |> iterator.to_list - |> should.equal( - subject - |> list.map(f) - |> list.map(iterator.to_list) - |> list.flatten, - ) - } - - let f = fn(i) { iterator.range(i, i + 2) } + let f = fn(e, acc) { [e, ..acc] } + test([], [], f) + test([1], [], f) + test([1, 2, 3], [], f) + test([1, 2, 3, 4, 5, 6, 7, 8], [], f) +} - test([], f) - test([1], f) - test([1, 2], f) +// a |> from_list |> map(f) |> to_list == a |> list.map(_, f) +pub fn map_test() { + let test = fn(subject, f) { + subject + |> iterator.from_list + |> iterator.map(f) + |> iterator.to_list + |> should.equal(list.map(subject, f)) } - // a |> from_list |> append(from_list(b)) |> to_list == list.flatten([a, b]) - pub fn append_test() { - let test = fn(left, right) { - left - |> iterator.from_list - |> iterator.append(iterator.from_list(right)) - |> iterator.to_list - |> should.equal(list.flatten([left, right])) - } + let f = fn(e) { e * 2 } + test([], f) + test([1], f) + test([1, 2, 3], f) + test([1, 2, 3, 4, 5, 6, 7, 8], f) +} - test([], []) - test([1], [2]) - test([1, 2], [3, 4]) +// a |> from_list |> flat_map(f) |> to_list == +// a |> list.map(f) |> list.map(to_list) |> list.flatten +pub fn flat_map_test() { + let test = fn(subject, f) { + subject + |> iterator.from_list + |> iterator.flat_map(f) + |> iterator.to_list + |> should.equal( + subject + |> list.map(f) + |> list.map(iterator.to_list) + |> list.flatten, + ) } - // a |> list.map(from_list) |> flatten |> to_list == list.flatten(a) - pub fn flatten_test() { - let test = fn(lists) { - lists - |> list.map(iterator.from_list) - |> iterator.from_list - |> iterator.flatten - |> iterator.to_list - |> should.equal(list.flatten(lists)) - } - - test([[], []]) - test([[1], [2]]) - test([[1, 2], [3, 4]]) - } + let f = fn(i) { iterator.range(i, i + 2) } - // a |> from_list |> filter(f) |> to_list == a |> list.filter(_, f) - pub fn filter_test() { - let test = fn(subject, f) { - subject - |> iterator.from_list - |> iterator.filter(f) - |> iterator.to_list - |> should.equal(list.filter(subject, f)) - } + test([], f) + test([1], f) + test([1, 2], f) +} - let even = fn(x) { x % 2 == 0 } - test([], even) - test([1], even) - test([1, 2], even) - test([1, 2, 3], even) - test([1, 2, 3, 4], even) - test([1, 2, 3, 4, 5], even) - test([1, 2, 3, 4, 5, 6], even) +// a |> from_list |> append(from_list(b)) |> to_list == list.flatten([a, b]) +pub fn append_test() { + let test = fn(left, right) { + left + |> iterator.from_list + |> iterator.append(iterator.from_list(right)) + |> iterator.to_list + |> should.equal(list.flatten([left, right])) } - pub fn repeat_test() { - 1 - |> iterator.repeat - |> iterator.take(5) + test([], []) + test([1], [2]) + test([1, 2], [3, 4]) +} + +// a |> list.map(from_list) |> flatten |> to_list == list.flatten(a) +pub fn flatten_test() { + let test = fn(lists) { + lists + |> list.map(iterator.from_list) + |> iterator.from_list + |> iterator.flatten |> iterator.to_list - |> should.equal([1, 1, 1, 1, 1]) + |> should.equal(list.flatten(lists)) } - pub fn cycle_test() { - [1, 2, 3] + test([[], []]) + test([[1], [2]]) + test([[1, 2], [3, 4]]) +} + +// a |> from_list |> filter(f) |> to_list == a |> list.filter(_, f) +pub fn filter_test() { + let test = fn(subject, f) { + subject |> iterator.from_list - |> iterator.cycle - |> iterator.take(9) + |> iterator.filter(f) |> iterator.to_list - |> should.equal([1, 2, 3, 1, 2, 3, 1, 2, 3]) + |> should.equal(list.filter(subject, f)) } - pub fn unfold_test() { - iterator.unfold(2, fn(acc) { iterator.Next(acc, acc * 2) }) - |> iterator.take(5) - |> iterator.to_list - |> should.equal([2, 4, 8, 16, 32]) + let even = fn(x) { x % 2 == 0 } + test([], even) + test([1], even) + test([1, 2], even) + test([1, 2, 3], even) + test([1, 2, 3, 4], even) + test([1, 2, 3, 4, 5], even) + test([1, 2, 3, 4, 5, 6], even) +} - iterator.unfold(2, fn(_) { iterator.Done }) - |> iterator.take(5) - |> iterator.to_list - |> should.equal([]) +pub fn repeat_test() { + 1 + |> iterator.repeat + |> iterator.take(5) + |> iterator.to_list + |> should.equal([1, 1, 1, 1, 1]) +} - fn(n) { - case n { - 0 -> iterator.Done - n -> iterator.Next(element: n, accumulator: n - 1) - } - } - |> iterator.unfold(from: 5) - |> iterator.to_list - |> should.equal([5, 4, 3, 2, 1]) - } +pub fn cycle_test() { + [1, 2, 3] + |> iterator.from_list + |> iterator.cycle + |> iterator.take(9) + |> iterator.to_list + |> should.equal([1, 2, 3, 1, 2, 3, 1, 2, 3]) +} - pub fn range_test() { - let test = fn(a, b, expected) { - iterator.range(a, b) - |> iterator.to_list - |> should.equal(expected) +pub fn unfold_test() { + iterator.unfold(2, fn(acc) { iterator.Next(acc, acc * 2) }) + |> iterator.take(5) + |> iterator.to_list + |> should.equal([2, 4, 8, 16, 32]) + + iterator.unfold(2, fn(_) { iterator.Done }) + |> iterator.take(5) + |> iterator.to_list + |> should.equal([]) + + fn(n) { + case n { + 0 -> iterator.Done + n -> iterator.Next(element: n, accumulator: n - 1) } - - test(0, 0, []) - test(1, 1, []) - test(-1, -1, []) - test(0, 1, [0]) - test(0, 5, [0, 1, 2, 3, 4]) - test(1, -5, [1, 0, -1, -2, -3, -4]) } + |> iterator.unfold(from: 5) + |> iterator.to_list + |> should.equal([5, 4, 3, 2, 1]) +} - pub fn drop_test() { - iterator.range(0, 10) - |> iterator.drop(5) +pub fn range_test() { + let test = fn(a, b, expected) { + iterator.range(a, b) |> iterator.to_list - |> should.equal([5, 6, 7, 8, 9]) + |> should.equal(expected) } - type Cat { - Cat(id: Int) - } - - pub fn find_test() { - iterator.range(0, 10) - |> iterator.find(fn(e) { e == 5 }) - |> should.equal(Ok(5)) - - iterator.range(0, 10) - |> iterator.find(fn(e) { e > 10 }) - |> should.equal(Error(Nil)) - - iterator.empty() - |> iterator.find(fn(_x) { True }) - |> should.equal(Error(Nil)) + test(0, 0, []) + test(1, 1, []) + test(-1, -1, []) + test(0, 1, [0]) + test(0, 5, [0, 1, 2, 3, 4]) + test(1, -5, [1, 0, -1, -2, -3, -4]) +} - iterator.unfold( - Cat(id: 1), - fn(cat: Cat) { iterator.Next(cat, Cat(id: cat.id + 1)) }, - ) - |> iterator.find(fn(cat: Cat) { cat.id == 10 }) - |> should.equal(Ok(Cat(id: 10))) - } +pub fn drop_test() { + iterator.range(0, 10) + |> iterator.drop(5) + |> iterator.to_list + |> should.equal([5, 6, 7, 8, 9]) +} - pub fn index_test() { - iterator.from_list(["a", "b", "c"]) - |> iterator.index - |> iterator.to_list - |> should.equal([#(0, "a"), #(1, "b"), #(2, "c")]) - } +type Cat { + Cat(id: Int) +} - pub fn iterate_test() { - fn(x) { x * 3 } - |> iterator.iterate(from: 1) - |> iterator.take(5) - |> iterator.to_list - |> should.equal([1, 3, 9, 27, 81]) - } +pub fn find_test() { + iterator.range(0, 10) + |> iterator.find(fn(e) { e == 5 }) + |> should.equal(Ok(5)) + + iterator.range(0, 10) + |> iterator.find(fn(e) { e > 10 }) + |> should.equal(Error(Nil)) + + iterator.empty() + |> iterator.find(fn(_x) { True }) + |> should.equal(Error(Nil)) + + iterator.unfold( + Cat(id: 1), + fn(cat: Cat) { iterator.Next(cat, Cat(id: cat.id + 1)) }, + ) + |> iterator.find(fn(cat: Cat) { cat.id == 10 }) + |> should.equal(Ok(Cat(id: 10))) +} - pub fn take_while_test() { - iterator.from_list([1, 2, 3, 2, 4]) - |> iterator.take_while(satisfying: fn(x) { x < 3 }) - |> iterator.to_list - |> should.equal([1, 2]) - } +pub fn index_test() { + iterator.from_list(["a", "b", "c"]) + |> iterator.index + |> iterator.to_list + |> should.equal([#(0, "a"), #(1, "b"), #(2, "c")]) +} - pub fn drop_while_test() { - iterator.from_list([1, 2, 3, 4, 2, 5]) - |> iterator.drop_while(satisfying: fn(x) { x < 4 }) - |> iterator.to_list - |> should.equal([4, 2, 5]) - } +pub fn iterate_test() { + fn(x) { x * 3 } + |> iterator.iterate(from: 1) + |> iterator.take(5) + |> iterator.to_list + |> should.equal([1, 3, 9, 27, 81]) +} - pub fn scan_test() { - iterator.from_list([1, 2, 3, 4, 5]) - |> iterator.scan(from: 0, with: fn(el, acc) { acc + el }) - |> iterator.to_list - |> should.equal([1, 3, 6, 10, 15]) - } +pub fn take_while_test() { + iterator.from_list([1, 2, 3, 2, 4]) + |> iterator.take_while(satisfying: fn(x) { x < 3 }) + |> iterator.to_list + |> should.equal([1, 2]) +} - pub fn zip_test() { - iterator.from_list(["a", "b", "c"]) - |> iterator.zip(iterator.range(20, 30)) - |> iterator.to_list - |> should.equal([#("a", 20), #("b", 21), #("c", 22)]) - } +pub fn drop_while_test() { + iterator.from_list([1, 2, 3, 4, 2, 5]) + |> iterator.drop_while(satisfying: fn(x) { x < 4 }) + |> iterator.to_list + |> should.equal([4, 2, 5]) +} - pub fn chunk_test() { - iterator.from_list([1, 2, 2, 3, 4, 4, 6, 7, 7]) - |> iterator.chunk(by: fn(n) { n % 2 }) - |> iterator.to_list - |> should.equal([[1], [2, 2], [3], [4, 4, 6], [7, 7]]) - } +pub fn scan_test() { + iterator.from_list([1, 2, 3, 4, 5]) + |> iterator.scan(from: 0, with: fn(el, acc) { acc + el }) + |> iterator.to_list + |> should.equal([1, 3, 6, 10, 15]) +} - pub fn sized_chunk_test() { - iterator.from_list([1, 2, 3, 4, 5, 6]) - |> iterator.sized_chunk(into: 2) - |> iterator.to_list - |> should.equal([[1, 2], [3, 4], [5, 6]]) +pub fn zip_test() { + iterator.from_list(["a", "b", "c"]) + |> iterator.zip(iterator.range(20, 30)) + |> iterator.to_list + |> should.equal([#("a", 20), #("b", 21), #("c", 22)]) +} - iterator.from_list([1, 2, 3, 4, 5, 6, 7, 8]) - |> iterator.sized_chunk(into: 3) - |> iterator.to_list - |> should.equal([[1, 2, 3], [4, 5, 6], [7, 8]]) - } +pub fn chunk_test() { + iterator.from_list([1, 2, 2, 3, 4, 4, 6, 7, 7]) + |> iterator.chunk(by: fn(n) { n % 2 }) + |> iterator.to_list + |> should.equal([[1], [2, 2], [3], [4, 4, 6], [7, 7]]) +} - pub fn intersperse_test() { - iterator.empty() - |> iterator.intersperse(with: 0) - |> iterator.to_list - |> should.equal([]) +pub fn sized_chunk_test() { + iterator.from_list([1, 2, 3, 4, 5, 6]) + |> iterator.sized_chunk(into: 2) + |> iterator.to_list + |> should.equal([[1, 2], [3, 4], [5, 6]]) - iterator.from_list([1]) - |> iterator.intersperse(with: 0) - |> iterator.to_list - |> should.equal([1]) + iterator.from_list([1, 2, 3, 4, 5, 6, 7, 8]) + |> iterator.sized_chunk(into: 3) + |> iterator.to_list + |> should.equal([[1, 2, 3], [4, 5, 6], [7, 8]]) +} - iterator.from_list([1, 2, 3, 4, 5]) - |> iterator.intersperse(with: 0) - |> iterator.to_list - |> should.equal([1, 0, 2, 0, 3, 0, 4, 0, 5]) - } +pub fn intersperse_test() { + iterator.empty() + |> iterator.intersperse(with: 0) + |> iterator.to_list + |> should.equal([]) + + iterator.from_list([1]) + |> iterator.intersperse(with: 0) + |> iterator.to_list + |> should.equal([1]) + + iterator.from_list([1, 2, 3, 4, 5]) + |> iterator.intersperse(with: 0) + |> iterator.to_list + |> should.equal([1, 0, 2, 0, 3, 0, 4, 0, 5]) +} - pub fn any_test() { - iterator.empty() - |> iterator.any(satisfying: fn(n) { n % 2 == 0 }) - |> should.be_false +pub fn any_test() { + iterator.empty() + |> iterator.any(satisfying: fn(n) { n % 2 == 0 }) + |> should.be_false - iterator.from_list([1, 2, 5, 7, 9]) - |> iterator.any(satisfying: fn(n) { n % 2 == 0 }) - |> should.be_true + iterator.from_list([1, 2, 5, 7, 9]) + |> iterator.any(satisfying: fn(n) { n % 2 == 0 }) + |> should.be_true - iterator.from_list([1, 3, 5, 7, 9]) - |> iterator.any(satisfying: fn(n) { n % 2 == 0 }) - |> should.be_false - } + iterator.from_list([1, 3, 5, 7, 9]) + |> iterator.any(satisfying: fn(n) { n % 2 == 0 }) + |> should.be_false +} - pub fn all_test() { - iterator.empty() - |> iterator.all(satisfying: fn(n) { n % 2 == 0 }) - |> should.be_true +pub fn all_test() { + iterator.empty() + |> iterator.all(satisfying: fn(n) { n % 2 == 0 }) + |> should.be_true - iterator.from_list([2, 4, 6, 8]) - |> iterator.all(satisfying: fn(n) { n % 2 == 0 }) - |> should.be_true + iterator.from_list([2, 4, 6, 8]) + |> iterator.all(satisfying: fn(n) { n % 2 == 0 }) + |> should.be_true - iterator.from_list([2, 4, 5, 8]) - |> iterator.all(satisfying: fn(n) { n % 2 == 0 }) - |> should.be_false - } + iterator.from_list([2, 4, 5, 8]) + |> iterator.all(satisfying: fn(n) { n % 2 == 0 }) + |> should.be_false +} +if erlang { pub fn group_test() { iterator.from_list([1, 2, 3, 4, 5, 6]) |> iterator.group(by: fn(n) { n % 3 }) @@ -380,70 +388,70 @@ if erlang { |> iterator.reduce(with: fn(x, y) { x + y }) |> should.equal(Ok(15)) } +} - pub fn last_test() { - iterator.empty() - |> iterator.last - |> should.equal(Error(Nil)) +pub fn last_test() { + iterator.empty() + |> iterator.last + |> should.equal(Error(Nil)) - iterator.range(1, 10) - |> iterator.last - |> should.equal(Ok(9)) - } + iterator.range(1, 10) + |> iterator.last + |> should.equal(Ok(9)) +} - pub fn empty_test() { - iterator.empty() - |> iterator.to_list - |> should.equal([]) - } +pub fn empty_test() { + iterator.empty() + |> iterator.to_list + |> should.equal([]) +} - pub fn once_test() { - iterator.once(fn() { 1 }) - |> iterator.to_list - |> should.equal([1]) - } +pub fn once_test() { + iterator.once(fn() { 1 }) + |> iterator.to_list + |> should.equal([1]) +} - pub fn single_test() { - iterator.single(1) - |> iterator.to_list - |> should.equal([1]) - } +pub fn single_test() { + iterator.single(1) + |> iterator.to_list + |> should.equal([1]) +} - pub fn interleave_test() { - iterator.from_list([1, 2, 3, 4]) - |> iterator.interleave(with: iterator.from_list([11, 12, 13, 14])) - |> iterator.to_list - |> should.equal([1, 11, 2, 12, 3, 13, 4, 14]) +pub fn interleave_test() { + iterator.from_list([1, 2, 3, 4]) + |> iterator.interleave(with: iterator.from_list([11, 12, 13, 14])) + |> iterator.to_list + |> should.equal([1, 11, 2, 12, 3, 13, 4, 14]) - iterator.from_list([1, 2, 3, 4]) - |> iterator.interleave(with: iterator.from_list([100])) - |> iterator.to_list - |> should.equal([1, 100, 2, 3, 4]) - } + iterator.from_list([1, 2, 3, 4]) + |> iterator.interleave(with: iterator.from_list([100])) + |> iterator.to_list + |> should.equal([1, 100, 2, 3, 4]) +} - // a |> from_list |> fold_until(a, f) == a |> list.fold_until(_, a, f) - pub fn fold_until_test() { - let test = fn(subject, acc, f) { - subject - |> iterator.from_list() - |> iterator.fold_until(acc, f) - |> should.equal(list.fold_until(subject, acc, f)) - } +// a |> from_list |> fold_until(a, f) == a |> list.fold_until(_, a, f) +pub fn fold_until_test() { + let test = fn(subject, acc, f) { + subject + |> iterator.from_list() + |> iterator.fold_until(acc, f) + |> should.equal(list.fold_until(subject, acc, f)) + } - let f = fn(e, acc) { - case e { - _ if e < 6 -> list.Continue([e, ..acc]) - _ -> list.Stop(acc) - } + let f = fn(e, acc) { + case e { + _ if e < 6 -> list.Continue([e, ..acc]) + _ -> list.Stop(acc) } - test([], [], f) - test([1], [], f) - test([1, 2, 3], [], f) - test([1, 2, 3, 4, 5, 6, 7, 8], [], f) - - [1, 2, 3, 4, 5, 6, 7, 8] - |> iterator.from_list() - |> iterator.fold_until([], f) - |> should.equal([5, 4, 3, 2, 1]) } + test([], [], f) + test([1], [], f) + test([1, 2, 3], [], f) + test([1, 2, 3, 4, 5, 6, 7, 8], [], f) + + [1, 2, 3, 4, 5, 6, 7, 8] + |> iterator.from_list() + |> iterator.fold_until([], f) + |> should.equal([5, 4, 3, 2, 1]) } diff --git a/test/gleam/string_test.gleam b/test/gleam/string_test.gleam index 734d369..8ac6d9c 100644 --- a/test/gleam/string_test.gleam +++ b/test/gleam/string_test.gleam @@ -272,8 +272,16 @@ pub fn pad_left_test() { |> should.equal("121") "121" + |> string.pad_left(to: 4, with: "XY") + |> should.equal("X121") + + "121" |> string.pad_left(to: 5, with: "XY") - |> should.equal("XYXY121") + |> should.equal("XY121") + + "121" + |> string.pad_left(to: 6, with: "XY") + |> should.equal("XYX121") } pub fn pad_right_test() { @@ -290,8 +298,16 @@ pub fn pad_right_test() { |> should.equal("121") "121" + |> string.pad_right(to: 4, with: "XY") + |> should.equal("121X") + + "121" |> string.pad_right(to: 5, with: "XY") - |> should.equal("121XYXY") + |> should.equal("121XY") + + "121" + |> string.pad_right(to: 6, with: "XY") + |> should.equal("121XYX") } pub fn pop_grapheme_test() { |