aboutsummaryrefslogtreecommitdiff
path: root/test
diff options
context:
space:
mode:
Diffstat (limited to 'test')
-rw-r--r--test/any_test.gleam278
-rw-r--r--test/atom_test.gleam46
-rw-r--r--test/bool_test.gleam61
-rw-r--r--test/http_test.gleam1
-rw-r--r--test/iodata_test.gleam90
-rw-r--r--test/list_test.gleam164
-rw-r--r--test/map_dict_test.gleam113
-rw-r--r--test/order_test.gleam52
-rw-r--r--test/result_test.gleam85
-rw-r--r--test/set_test.gleam0
-rw-r--r--test/str_test.gleam130
-rw-r--r--test/tuple_test.gleam44
12 files changed, 1064 insertions, 0 deletions
diff --git a/test/any_test.gleam b/test/any_test.gleam
new file mode 100644
index 0000000..9c9d236
--- /dev/null
+++ b/test/any_test.gleam
@@ -0,0 +1,278 @@
+import any
+import atom
+import list
+import tuple
+import expect
+import result
+
+pub fn string_test() {
+ ""
+ |> any:from
+ |> any:string
+ |> expect:equal(_, Ok(""))
+
+ "Hello"
+ |> any:from
+ |> any:string
+ |> expect:equal(_, Ok("Hello"))
+
+ 1
+ |> any:from
+ |> any:string
+ |> expect:equal(_, Error("Expected a String, got `1`"))
+
+ []
+ |> any:from
+ |> any:string
+ |> expect:equal(_, Error("Expected a String, got `[]`"))
+}
+
+pub fn int_test() {
+ 1
+ |> any:from
+ |> any:int
+ |> expect:equal(_, Ok(1))
+
+ 2
+ |> any:from
+ |> any:int
+ |> expect:equal(_, Ok(2))
+
+ 1.0
+ |> any:from
+ |> any:int
+ |> expect:equal(_, Error("Expected an Int, got `1.0`"))
+
+ []
+ |> any:from
+ |> any:int
+ |> expect:equal(_, Error("Expected an Int, got `[]`"))
+}
+
+pub fn float_test() {
+ 1.0
+ |> any:from
+ |> any:float
+ |> expect:equal(_, Ok(1.0))
+
+ 2.2
+ |> any:from
+ |> any:float
+ |> expect:equal(_, Ok(2.2))
+
+ 1
+ |> any:from
+ |> any:float
+ |> expect:equal(_, Error("Expected a Float, got `1`"))
+
+ []
+ |> any:from
+ |> any:float
+ |> expect:equal(_, Error("Expected a Float, got `[]`"))
+}
+
+// pub fn atom_test() {
+// make an atom here
+// |> any:from
+// |> atom
+// |> expect:equal(_, Ok(""))
+
+// make an atom here
+// |> any:from
+// |> atom
+// |> expect:equal(_, Ok("ok"))
+
+// 1
+// |> any:from
+// |> atom
+// |> expect:is_error
+
+// []
+// |> any:from
+// |> atom
+// |> expect:is_error
+// }
+
+pub fn thunk_test() {
+ fn() { 1 }
+ |> any:from
+ |> any:thunk
+ |> expect:is_ok
+
+ fn() { 1 }
+ |> any:from
+ |> any:thunk
+ |> result:map(_, fn(f) { f() })
+ |> expect:equal(_, Ok(any:from(1)))
+
+ fn(x) { x }
+ |> any:from
+ |> any:thunk
+ |> expect:is_error
+
+ 1
+ |> any:from
+ |> any:thunk
+ |> expect:is_error
+
+ []
+ |> any:from
+ |> any:thunk
+ |> expect:is_error
+}
+
+pub fn bool_test() {
+ True
+ |> any:from
+ |> any:bool
+ |> expect:equal(_, Ok(True))
+
+ False
+ |> any:from
+ |> any:bool
+ |> expect:equal(_, Ok(False))
+
+ 1
+ |> any:from
+ |> any:bool
+ |> expect:equal(_, Error("Expected a Bool, got `1`"))
+
+ []
+ |> any:from
+ |> any:bool
+ |> expect:equal(_, Error("Expected a Bool, got `[]`"))
+}
+
+pub fn atom_test() {
+ ""
+ |> atom:create_from_string
+ |> any:from
+ |> any:atom
+ |> expect:equal(_, Ok(atom:create_from_string("")))
+
+ "ok"
+ |> atom:create_from_string
+ |> any:from
+ |> any:atom
+ |> expect:equal(_, Ok(atom:create_from_string("ok")))
+
+ 1
+ |> any:from
+ |> any:atom
+ |> expect:is_error
+
+ []
+ |> any:from
+ |> any:atom
+ |> expect:is_error
+}
+
+pub fn list_test() {
+ []
+ |> any:from
+ |> any:list(_, any:string)
+ |> expect:equal(_, Ok([]))
+
+ []
+ |> any:from
+ |> any:list(_, any:int)
+ |> expect:equal(_, Ok([]))
+
+ [1, 2, 3]
+ |> any:from
+ |> any:list(_, any:int)
+ |> expect:equal(_, Ok([1, 2, 3]))
+
+ [[1], [2], [3]]
+ |> any:from
+ |> any:list(_, any:list(_, any:int))
+ |> expect:equal(_, Ok([[1], [2], [3]]))
+
+ 1
+ |> any:from
+ |> any:list(_, any:string)
+ |> expect:is_error
+
+ 1.0
+ |> any:from
+ |> any:list(_, any:int)
+ |> expect:is_error
+
+ [""]
+ |> any:from
+ |> any:list(_, any:int)
+ |> expect:is_error
+
+ [any:from(1), any:from("not an int")]
+ |> any:from
+ |> any:list(_, any:int)
+ |> expect:is_error
+}
+
+pub fn tuple_test() {
+ {1, []}
+ |> any:from
+ |> any:tuple
+ |> expect:equal(_, Ok({any:from(1), any:from([])}))
+
+ {"ok", "ok"}
+ |> any:from
+ |> any:tuple
+ |> expect:equal(_, Ok({any:from("ok"), any:from("ok")}))
+
+ {1}
+ |> any:from
+ |> any:tuple
+ |> expect:is_error
+
+ {1, 2, 3}
+ |> any:from
+ |> any:tuple
+ |> expect:is_error
+
+ {1, 2.0}
+ |> any:from
+ |> any:tuple
+ |> result:then(_, fn(x) {
+ x
+ |> tuple:first
+ |> any:int
+ |> result:map(_, fn(f) { {f, tuple:second(x)} })
+ })
+ |> result:then(_, fn(x) {
+ x
+ |> tuple:second
+ |> any:float
+ |> result:map(_, fn(f) { {tuple:first(x), f} })
+ })
+ |> expect:equal(_, Ok({1, 2.0}))
+}
+
+pub fn field_test() {
+ let Ok(ok_atom) = atom:from_string("ok")
+
+ {ok = 1}
+ |> any:from
+ |> any:field(_, ok_atom)
+ |> expect:equal(_, Ok(any:from(1)))
+
+ {earlier = 2, ok = 3}
+ |> any:from
+ |> any:field(_, ok_atom)
+ |> expect:equal(_, Ok(any:from(3)))
+
+ {}
+ |> any:from
+ |> any:field(_, ok_atom)
+ |> expect:is_error
+
+ 1
+ |> any:from
+ |> any:field(_, ok_atom)
+ |> expect:is_error
+
+ []
+ |> any:from
+ |> any:field(_, [])
+ |> expect:is_error
+}
diff --git a/test/atom_test.gleam b/test/atom_test.gleam
new file mode 100644
index 0000000..60686ab
--- /dev/null
+++ b/test/atom_test.gleam
@@ -0,0 +1,46 @@
+import atom
+import expect
+
+pub fn from_string_test() {
+ "ok"
+ |> atom:from_string
+ |> expect:is_ok
+
+ "expect"
+ |> atom:from_string
+ |> expect:is_ok
+
+ "this is not an atom we have seen before"
+ |> atom:from_string
+ // |> expect:equal(_, Error(AtomNotLoaded))
+ |> expect:is_error
+}
+
+pub fn create_from_string_test() {
+ "ok"
+ |> atom:create_from_string
+ |> Ok
+ |> expect:equal(_, atom:from_string("ok"))
+
+ "expect"
+ |> atom:create_from_string
+ |> Ok
+ |> expect:equal(_, atom:from_string("expect"))
+
+ "this is another atom we have not seen before"
+ |> atom:create_from_string
+ |> Ok
+ |> expect:equal(_, atom:from_string("this is another atom we have not seen before"))
+}
+
+pub fn to_string_test() {
+ "ok"
+ |> atom:create_from_string
+ |> atom:to_string
+ |> expect:equal(_, "ok")
+
+ "expect"
+ |> atom:create_from_string
+ |> atom:to_string
+ |> expect:equal(_, "expect")
+}
diff --git a/test/bool_test.gleam b/test/bool_test.gleam
new file mode 100644
index 0000000..78c711b
--- /dev/null
+++ b/test/bool_test.gleam
@@ -0,0 +1,61 @@
+import bool
+// import order
+import expect
+
+pub fn negate_test() {
+ bool:negate(True)
+ |> expect:false
+
+ bool:negate(False)
+ |> expect:true
+}
+
+// pub fn compare_test() {
+// bool:compare(True, True)
+// |> expect:equal(_, order:Eq)
+
+// bool:compare(True, False)
+// |> expect:equal(_, order:Gt)
+
+// bool:compare(False, False)
+// |> expect:equal(_, order:Lt)
+
+// bool:compare(False, True)
+// |> expect:equal(_, order:Gt)
+// }
+
+pub fn max_test() {
+ bool:max(True, True)
+ |> expect:equal(_, True)
+
+ bool:max(True, False)
+ |> expect:equal(_, True)
+
+ bool:max(False, False)
+ |> expect:equal(_, False)
+
+ bool:max(False, True)
+ |> expect:equal(_, True)
+}
+
+pub fn min_test() {
+ bool:min(True, True)
+ |> expect:equal(_, True)
+
+ bool:min(True, False)
+ |> expect:equal(_, False)
+
+ bool:min(False, False)
+ |> expect:equal(_, False)
+
+ bool:min(False, True)
+ |> expect:equal(_, False)
+}
+
+pub fn to_int_test() {
+ bool:to_int(True)
+ |> expect:equal(_, 1)
+
+ bool:to_int(False)
+ |> expect:equal(_, 0)
+}
diff --git a/test/http_test.gleam b/test/http_test.gleam
new file mode 100644
index 0000000..9941d56
--- /dev/null
+++ b/test/http_test.gleam
@@ -0,0 +1 @@
+// Nothing here yet...
diff --git a/test/iodata_test.gleam b/test/iodata_test.gleam
new file mode 100644
index 0000000..e57c8cc
--- /dev/null
+++ b/test/iodata_test.gleam
@@ -0,0 +1,90 @@
+import expect
+import iodata
+
+pub fn iodata_test() {
+ let data = iodata:new("ello")
+ |> iodata:append(_, ",")
+ |> iodata:append(_, " world!")
+ |> iodata:prepend(_, "H")
+
+ data
+ |> iodata:to_string
+ |> expect:equal(_, "Hello, world!")
+
+ data
+ |> iodata:byte_size
+ |> expect:equal(_, 13)
+
+ let data = iodata:new("ello")
+ |> iodata:append_iodata(_, iodata:new(","))
+ |> iodata:append_iodata(_, iodata:concat([iodata:new(" wo"), iodata:new("rld!")]))
+ |> iodata:prepend_iodata(_, iodata:new("H"))
+
+ data
+ |> iodata:to_string
+ |> expect:equal(_, "Hello, world!")
+
+ data
+ |> iodata:byte_size
+ |> expect:equal(_, 13)
+}
+
+pub fn lowercase_test() {
+ ["Gleam", "Gleam"]
+ |> iodata:from_strings
+ |> iodata:lowercase
+ |> iodata:to_string
+ |> expect:equal(_, "gleamgleam")
+}
+
+pub fn uppercase_test() {
+ ["Gleam", "Gleam"]
+ |> iodata:from_strings
+ |> iodata:uppercase
+ |> iodata:to_string
+ |> expect:equal(_, "GLEAMGLEAM")
+}
+
+pub fn split_test() {
+ "Gleam,Erlang,Elixir"
+ |> iodata:new
+ |> iodata:split(_, ",")
+ |> expect:equal(_, [iodata:new("Gleam"), iodata:new("Erlang"), iodata:new("Elixir")])
+
+ ["Gleam, Erl", "ang,Elixir"]
+ |> iodata:from_strings
+ |> iodata:split(_, ", ")
+ |> expect:equal(_, [iodata:new("Gleam"), iodata:from_strings(["Erl", "ang,Elixir"])])
+}
+
+pub fn is_equal_test() {
+ iodata:new("12")
+ |> iodata:is_equal(_, iodata:from_strings(["1", "2"]))
+ |> expect:true
+
+ iodata:new("12")
+ |> iodata:is_equal(_, iodata:new("12"))
+ |> expect:true
+
+ iodata:new("12")
+ |> iodata:is_equal(_, iodata:new("2"))
+ |> expect:false
+}
+
+pub fn is_empty_test() {
+ iodata:new("")
+ |> iodata:is_empty
+ |> expect:true
+
+ iodata:new("12")
+ |> iodata:is_empty
+ |> expect:false
+
+ iodata:from_strings([])
+ |> iodata:is_empty
+ |> expect:true
+
+ iodata:from_strings(["", ""])
+ |> iodata:is_empty
+ |> expect:true
+}
diff --git a/test/list_test.gleam b/test/list_test.gleam
new file mode 100644
index 0000000..c0a16ae
--- /dev/null
+++ b/test/list_test.gleam
@@ -0,0 +1,164 @@
+import expect
+import list
+
+pub fn length_test() {
+ list:length([]) |> expect:equal(_, 0)
+ list:length([1]) |> expect:equal(_, 1)
+ list:length([1, 1]) |> expect:equal(_, 2)
+ list:length([1, 1, 1]) |> expect:equal(_, 3)
+}
+
+pub fn reverse_test() {
+ list:reverse([]) |> expect:equal(_, [])
+ list:reverse([1, 2, 3, 4, 5]) |> expect:equal(_, [5, 4, 3, 2, 1])
+}
+
+pub fn is_empty_test() {
+ list:is_empty([]) |> expect:true
+ list:is_empty([1]) |> expect:false
+}
+
+pub fn contains_test() {
+ list:contains([0, 4, 5, 1], 1) |> expect:true
+ list:contains([0, 4, 5, 7], 1) |> expect:false
+ list:contains([], 1) |> expect:false
+}
+
+pub fn head_test() {
+ list:head([0, 4, 5, 7])
+ |> expect:equal(_, Ok(0))
+
+ list:head([])
+ |> expect:is_error
+}
+
+pub fn tail_test() {
+ list:tail([0, 4, 5, 7])
+ |> expect:equal(_, Ok([4, 5, 7]))
+
+ list:tail([0])
+ |> expect:equal(_, Ok([]))
+
+ list:tail([])
+ |> expect:is_error
+}
+
+pub fn filter_test() {
+ []
+ |> list:filter(_, fn(_) { True })
+ |> expect:equal(_, [])
+
+ [0, 4, 5, 7, 3]
+ |> list:filter(_, fn(_) { True })
+ |> expect:equal(_, [0, 4, 5, 7, 3])
+
+ [0, 4, 5, 7, 3]
+ |> list:filter(_, fn(x) { x > 4 })
+ |> expect:equal(_, [5, 7])
+
+ [0, 4, 5, 7, 3]
+ |> list:filter(_, fn(x) { x < 4 })
+ |> expect:equal(_, [0, 3])
+}
+
+pub fn map_test() {
+ []
+ |> list:map(_, fn(x) { x * 2 })
+ |> expect:equal(_, [])
+
+ [0, 4, 5, 7, 3]
+ |> list:map(_, fn(x) { x * 2 })
+ |> expect:equal(_, [0, 8, 10, 14, 6])
+}
+
+pub fn traverse_test() {
+ let fun = fn(x) {
+ case x == 6 || x == 5 || x == 4 {
+ | True -> Ok(x * 2)
+ | False -> Error(x)
+ }
+ }
+
+ [5, 6, 5, 6]
+ |> list:traverse(_, fun)
+ |> expect:equal(_, Ok([10, 12, 10, 12]))
+
+ [4, 6, 5, 7, 3]
+ |> list:traverse(_, fun)
+ |> expect:equal(_, Error(7))
+}
+
+pub fn drop_test() {
+ []
+ |> list:drop(_, 5)
+ |> expect:equal(_, [])
+
+ [1, 2, 3, 4, 5, 6, 7, 8]
+ |> list:drop(_, 5)
+ |> expect:equal(_, [6, 7, 8])
+}
+
+pub fn take_test() {
+ []
+ |> list:take(_, 5)
+ |> expect:equal(_, [])
+ [1, 2, 3, 4, 5, 6, 7, 8]
+ |> list:take(_, 5)
+ |> expect:equal(_, [1, 2, 3, 4, 5])
+}
+
+pub fn new_test() {
+ list:new() |> expect:equal(_, [])
+}
+
+pub fn append_test() {
+ list:append([1], [2, 3])
+ |> expect:equal(_, [1, 2, 3])
+}
+
+pub fn flatten_test() {
+ list:flatten([])
+ |> expect:equal(_, [])
+
+ list:flatten([[]])
+ |> expect:equal(_, [])
+
+ list:flatten([[], [], []])
+ |> expect:equal(_, [])
+
+ list:flatten([[1, 2], [], [3, 4]])
+ |> expect:equal(_, [1, 2, 3, 4])
+}
+
+pub fn fold_test() {
+ [1, 2, 3]
+ |> list:fold(_, [], fn(x, acc) { [x | acc] })
+ |> expect:equal(_, [3, 2, 1])
+}
+
+pub fn fold_right_test() {
+ [1, 2, 3]
+ |> list:fold_right(_, [], fn(x, acc) { [x | acc] })
+ |> expect:equal(_, [1, 2, 3])
+}
+
+pub fn find_test() {
+ let f = fn(x) {
+ case x {
+ | 2 -> Ok(4)
+ | _ -> Error(0)
+ }
+ }
+
+ [1, 2, 3]
+ |> list:find(_, f)
+ |> expect:equal(_, Ok(4))
+
+ [1, 3, 2]
+ |> list:find(_, f)
+ |> expect:equal(_, Ok(4))
+
+ [1, 3]
+ |> list:find(_, f)
+ |> expect:is_error
+}
diff --git a/test/map_dict_test.gleam b/test/map_dict_test.gleam
new file mode 100644
index 0000000..02b7072
--- /dev/null
+++ b/test/map_dict_test.gleam
@@ -0,0 +1,113 @@
+import expect
+import map_dict
+
+pub fn from_list_test() {
+ [
+ {4, 0},
+ {1, 0},
+ ]
+ |> map_dict:from_list
+ |> map_dict:size
+ |> expect:equal(_, 2)
+}
+
+pub fn has_key_test() {
+ []
+ |> map_dict:from_list
+ |> map_dict:has_key(_, 1)
+ |> expect:false
+
+ [
+ {1, 0},
+ ]
+ |> map_dict:from_list
+ |> map_dict:has_key(_, 1)
+ |> expect:true
+
+ [
+ {4, 0},
+ {1, 0},
+ ]
+ |> map_dict:from_list
+ |> map_dict:has_key(_, 1)
+ |> expect:true
+
+ [
+ {4, 0},
+ {1, 0},
+ ]
+ |> map_dict:from_list
+ |> map_dict:has_key(_, 0)
+ |> expect:false
+}
+
+pub fn new_test() {
+ map_dict:new()
+ |> map_dict:size
+ |> expect:equal(_, 0)
+
+ map_dict:new()
+ |> map_dict:to_list
+ |> expect:equal(_, [])
+}
+
+pub fn fetch_test() {
+ let proplist = [
+ {4, 0},
+ {1, 1},
+ ]
+ let m = map_dict:from_list(proplist)
+
+ m
+ |> map_dict:fetch(_, 4)
+ |> expect:equal(_, Ok(0))
+
+ m
+ |> map_dict:fetch(_, 1)
+ |> expect:equal(_, Ok(1))
+
+ m
+ |> map_dict:fetch(_, 2)
+ |> expect:is_error
+}
+
+pub fn put_test() {
+ map_dict:new()
+ |> map_dict:put(_, "a", 0)
+ |> map_dict:put(_, "b", 1)
+ |> map_dict:put(_, "c", 2)
+ |> expect:equal(_, map_dict:from_list([{"a", 0}, {"b", 1}, {"c", 2}]))
+}
+
+pub fn map_values_test() {
+ [
+ {1, 0},
+ {2, 1},
+ {3, 2},
+ ]
+ |> map_dict:from_list
+ |> map_dict:map_values(_, fn(k, v) { k + v })
+ |> expect:equal(_, map_dict:from_list([{1, 1}, {2, 3}, {3, 5}]))
+}
+
+pub fn keys_test() {
+ [
+ {"a", 0},
+ {"b", 1},
+ {"c", 2},
+ ]
+ |> map_dict:from_list
+ |> map_dict:keys
+ |> expect:equal(_, ["a", "b", "c"])
+}
+
+pub fn values_test() {
+ [
+ {"a", 0},
+ {"b", 1},
+ {"c", 2},
+ ]
+ |> map_dict:from_list
+ |> map_dict:values
+ |> expect:equal(_, [0, 1, 2])
+}
diff --git a/test/order_test.gleam b/test/order_test.gleam
new file mode 100644
index 0000000..07b527c
--- /dev/null
+++ b/test/order_test.gleam
@@ -0,0 +1,52 @@
+import expect
+import order
+
+// TODO: https://github.com/lpil/gleam/issues/141
+
+// pub fn reverse_test() {
+// order:reverse(Lt) |> expect:equal(_, Gt)
+// order:reverse(Eq) |> expect:equal(_, Eq)
+// order:reverse(Gt) |> expect:equal(_, Lt)
+// }
+
+// pub fn to_int_test() {
+// order:to_int(Lt) |> expect:equal(_, -1)
+// order:to_int(Eq) |> expect:equal(_, 0)
+// order:to_int(Gt) |> expect:equal(_, 1)
+// }
+
+// pub fn compare_test() {
+// order:compare(Lt, Lt) |> expect:equal(_, Eq)
+// order:compare(Lt, Eq) |> expect:equal(_, Lt)
+// order:compare(Lt, Gt) |> expect:equal(_, Lt)
+// order:compare(Eq, Lt) |> expect:equal(_, Gt)
+// order:compare(Eq, Eq) |> expect:equal(_, Eq)
+// order:compare(Eq, Gt) |> expect:equal(_, Lt)
+// order:compare(Gt, Lt) |> expect:equal(_, Gt)
+// order:compare(Gt, Eq) |> expect:equal(_, Gt)
+// order:compare(Gt, Gt) |> expect:equal(_, Eq)
+// }
+
+// pub fn max_test() {
+// order:max(Lt, Lt) |> expect:equal(_, Lt)
+// order:max(Lt, Eq) |> expect:equal(_, Eq)
+// order:max(Lt, Gt) |> expect:equal(_, Gt)
+// order:max(Eq, Lt) |> expect:equal(_, Eq)
+// order:max(Eq, Eq) |> expect:equal(_, Eq)
+// order:max(Eq, Gt) |> expect:equal(_, Gt)
+// order:max(Gt, Lt) |> expect:equal(_, Gt)
+// order:max(Gt, Eq) |> expect:equal(_, Gt)
+// order:max(Gt, Gt) |> expect:equal(_, Gt)
+// }
+
+// pub fn min_test() {
+// order:min(Lt, Lt) |> expect:equal(_, Lt)
+// order:min(Lt, Eq) |> expect:equal(_, Lt)
+// order:min(Lt, Gt) |> expect:equal(_, Lt)
+// order:min(Eq, Lt) |> expect:equal(_, Lt)
+// order:min(Eq, Eq) |> expect:equal(_, Eq)
+// order:min(Eq, Gt) |> expect:equal(_, Eq)
+// order:min(Gt, Lt) |> expect:equal(_, Lt)
+// order:min(Gt, Eq) |> expect:equal(_, Eq)
+// order:min(Gt, Gt) |> expect:equal(_, Gt)
+// }
diff --git a/test/result_test.gleam b/test/result_test.gleam
new file mode 100644
index 0000000..36d208e
--- /dev/null
+++ b/test/result_test.gleam
@@ -0,0 +1,85 @@
+import expect
+import result
+
+pub fn is_ok_test() {
+ result:is_ok(Ok(1)) |> expect:true
+ result:is_ok(Error(1)) |> expect:false
+}
+
+pub fn is_error_test() {
+ result:is_error(Ok(1))
+ |> expect:false
+
+ result:is_error(Error(1))
+ |> expect:true
+}
+
+pub fn map_test() {
+ Ok(1)
+ |> result:map(_, fn(x) { x + 1 })
+ |> expect:equal(_, Ok(2))
+
+ Ok(1)
+ |> result:map(_, fn(_) { "2" })
+ |> expect:equal(_, Ok("2"))
+
+ Error(1)
+ |> result:map(_, fn(x) { x + 1 })
+ |> expect:equal(_, Error(1))
+}
+
+pub fn map_error_test() {
+ Ok(1)
+ |> result:map_error(_, fn(x) { x + 1 })
+ |> expect:equal(_, Ok(1))
+
+ Error(1)
+ |> result:map_error(_, fn(x) { x + 1 })
+ |> expect:equal(_, Error(2))
+}
+
+pub fn flatten_test() {
+ Ok(Ok(1))
+ |> result:flatten
+ |> expect:equal(_, Ok(1))
+
+ Ok(Error(1))
+ |> result:flatten
+ |> expect:equal(_, Error(1))
+
+ Error(1)
+ |> result:flatten
+ |> expect:equal(_, Error(1))
+
+ Error(Error(1))
+ |> result:flatten
+ |> expect:equal(_, Error(Error(1)))
+}
+
+pub fn then_test() {
+ Error(1)
+ |> result:then(_, fn(x) { Ok(x + 1) })
+ |> expect:equal(_, Error(1))
+
+ Ok(1)
+ |> result:then(_, fn(x) { Ok(x + 1) })
+ |> expect:equal(_, Ok(2))
+
+ Ok(1)
+ |> result:then(_, fn(_) { Ok("type change") })
+ |> expect:equal(_, Ok("type change"))
+
+ Ok(1)
+ |> result:then(_, fn(_) { Error(1) })
+ |> expect:equal(_, Error(1))
+}
+
+pub fn unwrap_test() {
+ Ok(1)
+ |> result:unwrap(_, 50)
+ |> expect:equal(_, 1)
+
+ Error("nope")
+ |> result:unwrap(_, 50)
+ |> expect:equal(_, 50)
+}
diff --git a/test/set_test.gleam b/test/set_test.gleam
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/test/set_test.gleam
diff --git a/test/str_test.gleam b/test/str_test.gleam
new file mode 100644
index 0000000..13d781c
--- /dev/null
+++ b/test/str_test.gleam
@@ -0,0 +1,130 @@
+import str
+import expect
+
+pub fn length_test() {
+ str:length("ß↑e̊")
+ |> expect:equal(_, 3)
+
+ str:length("Gleam")
+ |> expect:equal(_, 5)
+
+ str:length("")
+ |> expect:equal(_, 0)
+}
+
+pub fn lowercase_test() {
+ str:lowercase("Gleam")
+ |> expect:equal(_, "gleam")
+}
+
+pub fn uppercase_test() {
+ str:uppercase("Gleam")
+ |> expect:equal(_, "GLEAM")
+}
+
+pub fn reverse_test() {
+ str:reverse("Gleam")
+ |> expect:equal(_, "maelG")
+}
+
+pub fn split_test() {
+ "Gleam,Erlang,Elixir"
+ |> str:split(_, ",")
+ |> expect:equal(_, ["Gleam", "Erlang", "Elixir"])
+
+ "Gleam, Erlang,Elixir"
+ |> str:split(_, ", ")
+ |> expect:equal(_, ["Gleam", "Erlang,Elixir"])
+}
+
+pub fn replace_test() {
+ "Gleam,Erlang,Elixir"
+ |> str:replace(_, ",", "++")
+ |> expect:equal(_, "Gleam++Erlang++Elixir")
+}
+
+pub fn from_int_test() {
+ 123
+ |> str:from_int
+ |> expect:equal(_, "123")
+
+ -123
+ |> str:from_int
+ |> expect:equal(_, "-123")
+
+ 0123
+ |> str:from_int
+ |> expect:equal(_, "123")
+}
+
+pub fn parse_int_test() {
+ "123"
+ |> str:parse_int
+ |> expect:equal(_, Ok(123))
+
+ "-123"
+ |> str:parse_int
+ |> expect:equal(_, Ok(-123))
+
+ "0123"
+ |> str:parse_int
+ |> expect:equal(_, Ok(123))
+
+ ""
+ |> str:parse_int
+ |> expect:is_error
+
+ "what"
+ |> str:parse_int
+ |> expect:is_error
+
+ "1.23"
+ |> str:parse_int
+ |> expect:is_error
+}
+
+pub fn parse_float_test() {
+ "1.23"
+ |> str:parse_float
+ |> expect:equal(_, Ok(1.23))
+
+ "5.0"
+ |> str:parse_float
+ |> expect:equal(_, Ok(5.0))
+
+ "0.123456789"
+ |> str:parse_float
+ |> expect:equal(_, Ok(0.123456789))
+
+ ""
+ |> str:parse_float
+ |> expect:is_error
+
+ "what"
+ |> str:parse_float
+ |> expect:is_error
+
+ "1"
+ |> str:parse_float
+ |> expect:is_error
+}
+
+pub fn base_from_int_test() {
+ 100
+ |> str:base_from_int(_, 16)
+ |> expect:equal(_, "64")
+
+ -100
+ |> str:base_from_int(_, 16)
+ |> expect:equal(_, "-64")
+}
+
+pub fn from_float_test() {
+ 123.0
+ |> str:from_float
+ |> expect:equal(_, "123.0")
+
+ -8.1
+ |> str:from_float
+ |> expect:equal(_, "-8.1")
+}
diff --git a/test/tuple_test.gleam b/test/tuple_test.gleam
new file mode 100644
index 0000000..1c0463a
--- /dev/null
+++ b/test/tuple_test.gleam
@@ -0,0 +1,44 @@
+import expect
+import tuple
+
+pub fn new_test() {
+ tuple:new(1, 2)
+ |> expect:equal(_, {1, 2})
+
+ tuple:new(2, "3")
+ |> expect:equal(_, {2, "3"})
+}
+
+pub fn first_test() {
+ {1, 2}
+ |> tuple:first
+ |> expect:equal(_, 1)
+}
+
+pub fn second_test() {
+ {1, 2}
+ |> tuple:second
+ |> expect:equal(_, 2)
+}
+
+pub fn swap_test() {
+ {1, "2"}
+ |> tuple:swap
+ |> expect:equal(_, {"2", 1})
+}
+
+pub fn fetch_test() {
+ let proplist = [{0, "1"}, {1, "2"}]
+
+ proplist
+ |> tuple:fetch(_, 0)
+ |> expect:equal(_, Ok("1"))
+
+ proplist
+ |> tuple:fetch(_, 1)
+ |> expect:equal(_, Ok("2"))
+
+ proplist
+ |> tuple:fetch(_, 2)
+ |> expect:is_error
+}
generated by cgit v1.2.3 (git 2.25.1) at 2025-07-26 23:47:17 +0000