aboutsummaryrefslogtreecommitdiff
path: root/test
diff options
context:
space:
mode:
Diffstat (limited to 'test')
-rw-r--r--test/gleam/any_test.gleam45
-rw-r--r--test/gleam/list_test.gleam36
-rw-r--r--test/gleam/map_test.gleam136
-rw-r--r--test/gleam/pair_test.gleam36
-rw-r--r--test/gleam/result_test.gleam6
-rw-r--r--test/gleam/tuple_test.gleam46
6 files changed, 142 insertions, 163 deletions
diff --git a/test/gleam/any_test.gleam b/test/gleam/any_test.gleam
index fc9640d..5fe0476 100644
--- a/test/gleam/any_test.gleam
+++ b/test/gleam/any_test.gleam
@@ -1,7 +1,7 @@
import gleam/any
import gleam/atom
import gleam/list
-import gleam/tuple
+import gleam/pair
import gleam/expect
import gleam/result
import gleam/map
@@ -210,49 +210,38 @@ pub fn list_test() {
|> expect.is_error
}
-// TODO: replace struct with Pair
-pub fn struct2_test() {
- struct(1, [])
+pub fn pair_test() {
+ pair.Pair(1, [])
|> any.from
- |> any.struct2
- |> expect.equal(_, Ok(struct(any.from(1), any.from([]))))
+ |> any.pair
+ |> expect.equal(_, Ok(pair.Pair(any.from(1), any.from([]))))
- struct("ok", "ok")
+ pair.Pair("ok", "ok")
|> any.from
- |> any.struct2
- |> expect.equal(_, Ok(struct(any.from("ok"), any.from("ok"))))
+ |> any.pair
+ |> expect.equal(_, Ok(pair.Pair(any.from("ok"), any.from("ok"))))
- struct(1)
+ pair.Pair(1, 2.0)
|> any.from
- |> any.struct2
- |> expect.is_error
-
- struct(1, 2, 3)
- |> any.from
- |> any.struct2
- |> expect.is_error
-
- struct(1, 2.0)
- |> any.from
- |> any.struct2
+ |> any.pair
|> result.then(_, fn(x) {
x
- |> tuple.first
+ |> pair.first
|> any.int
- |> result.map(_, fn(f) { struct(f, tuple.second(x)) })
+ |> result.map(_, fn(f) { pair.Pair(f, pair.second(x)) })
})
|> result.then(_, fn(x) {
x
- |> tuple.second
+ |> pair.second
|> any.float
- |> result.map(_, fn(f) { struct(tuple.first(x), f) })
+ |> result.map(_, fn(f) { pair.Pair(pair.first(x), f) })
})
- |> expect.equal(_, Ok(struct(1, 2.0)))
+ |> expect.equal(_, Ok(pair.Pair(1, 2.0)))
}
pub fn field_test() {
let Ok(ok_atom) = atom.from_string("ok")
- let Ok(earlier_atom) = atom.from_string("earlier")
+ let Ok(error_atom) = atom.from_string("error")
map.new()
|> map.put(_, ok_atom, 1)
@@ -262,7 +251,7 @@ pub fn field_test() {
map.new()
|> map.put(_, ok_atom, 3)
- |> map.put(_, earlier_atom, 1)
+ |> map.put(_, error_atom, 1)
|> any.from
|> any.field(_, ok_atom)
|> expect.equal(_, Ok(any.from(3)))
diff --git a/test/gleam/list_test.gleam b/test/gleam/list_test.gleam
index 1270ff3..e211947 100644
--- a/test/gleam/list_test.gleam
+++ b/test/gleam/list_test.gleam
@@ -3,6 +3,7 @@ import gleam/list
import gleam/int
import gleam/float
import gleam/string
+import gleam/pair
pub fn length_test() {
list.length([]) |> expect.equal(_, 0)
@@ -195,15 +196,14 @@ pub fn zip_test() {
list.zip([1, 2], [])
|> expect.equal(_, [])
- // TODO: replace struct with Pair
list.zip([1, 2, 3], [4, 5, 6])
- |> expect.equal(_, [struct(1, 4), struct(2, 5), struct(3, 6)])
+ |> expect.equal(_, [pair.Pair(1, 4), pair.Pair(2, 5), pair.Pair(3, 6)])
list.zip([5, 6], [1, 2, 3])
- |> expect.equal(_, [struct(5, 1), struct(6, 2)])
+ |> expect.equal(_, [pair.Pair(5, 1), pair.Pair(6, 2)])
list.zip([5, 6, 7], [1, 2])
- |> expect.equal(_, [struct(5, 1), struct(6, 2)])
+ |> expect.equal(_, [pair.Pair(5, 1), pair.Pair(6, 2)])
}
pub fn strict_zip_test() {
@@ -214,7 +214,7 @@ pub fn strict_zip_test() {
|> expect.is_error
list.strict_zip([1, 2, 3], [4, 5, 6])
- |> expect.equal(_, Ok([struct(1, 4), struct(2, 5), struct(3, 6)]))
+ |> expect.equal(_, Ok([pair.Pair(1, 4), pair.Pair(2, 5), pair.Pair(3, 6)]))
list.strict_zip([5, 6], [1, 2, 3])
|> expect.is_error
@@ -278,8 +278,8 @@ pub fn sort_test() {
}
pub fn index_map_test() {
- list.index_map([3, 4, 5], fn(i, x) { struct(i, x) })
- |> expect.equal(_, [struct(0, 3), struct(1, 4), struct(2, 5)])
+ list.index_map([3, 4, 5], fn(i, x) { pair.Pair(i, x) })
+ |> expect.equal(_, [pair.Pair(0, 3), pair.Pair(1, 4), pair.Pair(2, 5)])
let f = fn(i, x) {
string.append(x, int.to_string(i))
@@ -324,37 +324,37 @@ pub fn repeat_test() {
pub fn split_test() {
list.split([], 0)
- |> expect.equal(_, struct([], []))
+ |> expect.equal(_, pair.Pair([], []))
list.split([0, 1, 2, 3, 4], 0)
- |> expect.equal(_, struct([], [0, 1, 2, 3, 4]))
+ |> expect.equal(_, pair.Pair([], [0, 1, 2, 3, 4]))
list.split([0, 1, 2, 3, 4], -2)
- |> expect.equal(_, struct([], [0, 1, 2, 3, 4]))
+ |> expect.equal(_, pair.Pair([], [0, 1, 2, 3, 4]))
list.split([0, 1, 2, 3, 4], 1)
- |> expect.equal(_, struct([0], [1, 2, 3, 4]))
+ |> expect.equal(_, pair.Pair([0], [1, 2, 3, 4]))
list.split([0, 1, 2, 3, 4], 3)
- |> expect.equal(_, struct([0, 1, 2], [3, 4]))
+ |> expect.equal(_, pair.Pair([0, 1, 2], [3, 4]))
list.split([0, 1, 2, 3, 4], 9)
- |> expect.equal(_, struct([0, 1, 2, 3, 4], []))
+ |> expect.equal(_, pair.Pair([0, 1, 2, 3, 4], []))
}
pub fn split_while_test() {
list.split_while([], fn(x) { x <= 5 })
- |> expect.equal(_, struct([], []))
+ |> expect.equal(_, pair.Pair([], []))
list.split_while([1, 2, 3, 4, 5], fn(x) { x <= 5 })
- |> expect.equal(_, struct([1, 2, 3, 4, 5], []))
+ |> expect.equal(_, pair.Pair([1, 2, 3, 4, 5], []))
list.split_while([1, 2, 3, 4, 5], fn(x) { x == 2 })
- |> expect.equal(_, struct([], [1, 2, 3, 4, 5]))
+ |> expect.equal(_, pair.Pair([], [1, 2, 3, 4, 5]))
list.split_while([1, 2, 3, 4, 5], fn(x) { x <= 3 })
- |> expect.equal(_, struct([1, 2, 3], [4, 5]))
+ |> expect.equal(_, pair.Pair([1, 2, 3], [4, 5]))
list.split_while([1, 2, 3, 4, 5], fn(x) { x <= -3 })
- |> expect.equal(_, struct([], [1, 2, 3, 4, 5]))
+ |> expect.equal(_, pair.Pair([], [1, 2, 3, 4, 5]))
}
diff --git a/test/gleam/map_test.gleam b/test/gleam/map_test.gleam
index bef0e76..96d648f 100644
--- a/test/gleam/map_test.gleam
+++ b/test/gleam/map_test.gleam
@@ -1,12 +1,12 @@
import gleam/string
import gleam/expect
import gleam/map
+import gleam/pair
-// TODO: replace struct with Pair
pub fn from_list_test() {
[
- struct(4, 0),
- struct(1, 0),
+ pair.Pair(4, 0),
+ pair.Pair(1, 0),
]
|> map.from_list
|> map.size
@@ -20,23 +20,23 @@ pub fn has_key_test() {
|> expect.false
[
- struct(1, 0),
+ pair.Pair(1, 0),
]
|> map.from_list
|> map.has_key(_, 1)
|> expect.true
[
- struct(4, 0),
- struct(1, 0),
+ pair.Pair(4, 0),
+ pair.Pair(1, 0),
]
|> map.from_list
|> map.has_key(_, 1)
|> expect.true
[
- struct(4, 0),
- struct(1, 0),
+ pair.Pair(4, 0),
+ pair.Pair(1, 0),
]
|> map.from_list
|> map.has_key(_, 0)
@@ -55,8 +55,8 @@ pub fn new_test() {
pub fn fetch_test() {
let proplist = [
- struct(4, 0),
- struct(1, 1),
+ pair.Pair(4, 0),
+ pair.Pair(1, 1),
]
let m = map.from_list(proplist)
@@ -79,32 +79,32 @@ pub fn put_test() {
|> map.put(_, "b", 1)
|> map.put(_, "c", 2)
|> expect.equal(_, map.from_list([
- struct("a", 0),
- struct("b", 1),
- struct("c", 2),
+ pair.Pair("a", 0),
+ pair.Pair("b", 1),
+ pair.Pair("c", 2),
]))
}
pub fn map_values_test() {
[
- struct(1, 0),
- struct(2, 1),
- struct(3, 2),
+ pair.Pair(1, 0),
+ pair.Pair(2, 1),
+ pair.Pair(3, 2),
]
|> map.from_list
|> map.map_values(_, fn(k, v) { k + v })
|> expect.equal(_, map.from_list([
- struct(1, 1),
- struct(2, 3),
- struct(3, 5),
+ pair.Pair(1, 1),
+ pair.Pair(2, 3),
+ pair.Pair(3, 5),
]))
}
pub fn keys_test() {
[
- struct("a", 0),
- struct("b", 1),
- struct("c", 2),
+ pair.Pair("a", 0),
+ pair.Pair("b", 1),
+ pair.Pair("c", 2),
]
|> map.from_list
|> map.keys
@@ -113,9 +113,9 @@ pub fn keys_test() {
pub fn values_test() {
[
- struct("a", 0),
- struct("b", 1),
- struct("c", 2),
+ pair.Pair("a", 0),
+ pair.Pair("b", 1),
+ pair.Pair("c", 2),
]
|> map.from_list
|> map.values
@@ -124,72 +124,72 @@ pub fn values_test() {
pub fn take_test() {
[
- struct("a", 0),
- struct("b", 1),
- struct("c", 2),
+ pair.Pair("a", 0),
+ pair.Pair("b", 1),
+ pair.Pair("c", 2),
]
|> map.from_list
|> map.take(_, ["a", "b", "d"])
- |> expect.equal(_, map.from_list([struct("a", 0), struct("b", 1)]))
+ |> expect.equal(_, map.from_list([pair.Pair("a", 0), pair.Pair("b", 1)]))
}
pub fn drop_test() {
[
- struct("a", 0),
- struct("b", 1),
- struct("c", 2),
+ pair.Pair("a", 0),
+ pair.Pair("b", 1),
+ pair.Pair("c", 2),
]
|> map.from_list
|> map.drop(_, ["a", "b", "d"])
- |> expect.equal(_, map.from_list([struct("c", 2)]))
+ |> expect.equal(_, map.from_list([pair.Pair("c", 2)]))
}
pub fn merge_test() {
let a = map.from_list([
- struct("a", 2),
- struct("c", 4),
- struct("d", 3),
+ pair.Pair("a", 2),
+ pair.Pair("c", 4),
+ pair.Pair("d", 3),
])
let b = map.from_list([
- struct("a", 0),
- struct("b", 1),
- struct("c", 2),
+ pair.Pair("a", 0),
+ pair.Pair("b", 1),
+ pair.Pair("c", 2),
])
map.merge(a, b)
|> expect.equal(_, map.from_list([
- struct("a", 0),
- struct("b", 1),
- struct("c", 2),
- struct("d", 3),
+ pair.Pair("a", 0),
+ pair.Pair("b", 1),
+ pair.Pair("c", 2),
+ pair.Pair("d", 3),
]))
map.merge(b, a)
|> expect.equal(_, map.from_list([
- struct("a", 2),
- struct("b", 1),
- struct("c", 4),
- struct("d", 3),
+ pair.Pair("a", 2),
+ pair.Pair("b", 1),
+ pair.Pair("c", 4),
+ pair.Pair("d", 3),
]))
}
pub fn delete_test() {
[
- struct("a", 0),
- struct("b", 1),
- struct("c", 2),
+ pair.Pair("a", 0),
+ pair.Pair("b", 1),
+ pair.Pair("c", 2),
]
|> map.from_list
|> map.delete(_, "a")
|> map.delete(_, "d")
- |> expect.equal(_, map.from_list([struct("b", 1), struct("c", 2)]))
+ |> expect.equal(_, map.from_list([pair.Pair("b", 1), pair.Pair("c", 2)]))
}
pub fn update_test() {
let dict = map.from_list([
- struct("a", 0),
- struct("b", 1),
- struct("c", 2),
+ pair.Pair("a", 0),
+ pair.Pair("b", 1),
+ pair.Pair("c", 2),
])
let inc_or_zero = fn(x) {
@@ -202,35 +202,35 @@ pub fn update_test() {
dict
|> map.update(_, "a", inc_or_zero)
|> expect.equal(_, map.from_list([
- struct("a", 1),
- struct("b", 1),
- struct("c", 2),
+ pair.Pair("a", 1),
+ pair.Pair("b", 1),
+ pair.Pair("c", 2),
]))
dict
|> map.update(_, "b", inc_or_zero)
|> expect.equal(_, map.from_list([
- struct("a", 0),
- struct("b", 2),
- struct("c", 2),
+ pair.Pair("a", 0),
+ pair.Pair("b", 2),
+ pair.Pair("c", 2),
]))
dict
|> map.update(_, "z", inc_or_zero)
|> expect.equal(_, map.from_list([
- struct("a", 0),
- struct("b", 1),
- struct("c", 2),
- struct("z", 0),
+ pair.Pair("a", 0),
+ pair.Pair("b", 1),
+ pair.Pair("c", 2),
+ pair.Pair("z", 0),
]))
}
pub fn fold_test() {
let dict = map.from_list([
- struct("a", 0),
- struct("b", 1),
- struct("c", 2),
- struct("d", 3),
+ pair.Pair("a", 0),
+ pair.Pair("b", 1),
+ pair.Pair("c", 2),
+ pair.Pair("d", 3),
])
let add = fn(_, v, acc) {
diff --git a/test/gleam/pair_test.gleam b/test/gleam/pair_test.gleam
new file mode 100644
index 0000000..86a9e1e
--- /dev/null
+++ b/test/gleam/pair_test.gleam
@@ -0,0 +1,36 @@
+import gleam/expect
+import gleam/pair
+
+pub fn first_test() {
+ pair.Pair(1, 2)
+ |> pair.first
+ |> expect.equal(_, 1)
+}
+
+pub fn second_test() {
+ pair.Pair(1, 2)
+ |> pair.second
+ |> expect.equal(_, 2)
+}
+
+pub fn swap_test() {
+ pair.Pair(1, "2")
+ |> pair.swap
+ |> expect.equal(_, pair.Pair("2", 1))
+}
+
+// pub fn fetch_test() {
+// let proplist = [pair.Pair(0, "1"), pair.Pair(1, "2")]
+
+// proplist
+// |> pair.fetch(_, 0)
+// |> expect.equal(_, Ok("1"))
+
+// proplist
+// |> pair.fetch(_, 1)
+// |> expect.equal(_, Ok("2"))
+
+// proplist
+// |> pair.fetch(_, 2)
+// |> expect.is_error
+// }
diff --git a/test/gleam/result_test.gleam b/test/gleam/result_test.gleam
index 9113e6c..644a5fc 100644
--- a/test/gleam/result_test.gleam
+++ b/test/gleam/result_test.gleam
@@ -1,5 +1,6 @@
import gleam/expect
import gleam/result
+import gleam/pair
pub fn is_ok_test() {
result.is_ok(Ok(1))
@@ -36,10 +37,9 @@ pub fn map_error_test() {
|> result.map_error(_, fn(x) { x + 1 })
|> expect.equal(_, Ok(1))
- // TODO: replace struct with Pair
Error(1)
- |> result.map_error(_, fn(x) { struct("ok", x + 1) })
- |> expect.equal(_, Error(struct("ok", 2)))
+ |> result.map_error(_, fn(x) { pair.Pair("ok", x + 1) })
+ |> expect.equal(_, Error(pair.Pair("ok", 2)))
}
pub fn flatten_test() {
diff --git a/test/gleam/tuple_test.gleam b/test/gleam/tuple_test.gleam
deleted file mode 100644
index a1693b0..0000000
--- a/test/gleam/tuple_test.gleam
+++ /dev/null
@@ -1,46 +0,0 @@
-import gleam/expect
-import gleam/tuple
-
-// TODO: replace struct with Pair
-
-pub fn new_test() {
- tuple.new(1, 2)
- |> expect.equal(_, struct(1, 2))
-
- tuple.new(2, "3")
- |> expect.equal(_, struct(2, "3"))
-}
-
-pub fn first_test() {
- struct(1, 2)
- |> tuple.first
- |> expect.equal(_, 1)
-}
-
-pub fn second_test() {
- struct(1, 2)
- |> tuple.second
- |> expect.equal(_, 2)
-}
-
-pub fn swap_test() {
- struct(1, "2")
- |> tuple.swap
- |> expect.equal(_, struct("2", 1))
-}
-
-pub fn fetch_test() {
- let proplist = [struct(0, "1"), struct(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-27 20:34:20 +0000