stdlib: Split out tests

12 files changed, 483 insertions, 0 deletions

diff --git a/gen/test/any_test.erl b/gen/test/any_test.erl
new file mode 100644
index 0000000..6e5bd73
--- /dev/null
+++ b/gen/test/any_test.erl
@@ -0,0 +1,97 @@
+-module(any_test).
+-compile(no_auto_import).
+
+-export([string_test/0, int_test/0, float_test/0, thunk_test/0, bool_test/0, atom_test/0, list_test/0, tuple_test/0, field_test/0]).
+
+string_test() ->
+    expect:equal(any:string(any:from(<<"">>)), {ok, <<"">>}),
+    expect:equal(any:string(any:from(<<"Hello">>)), {ok, <<"Hello">>}),
+    expect:equal(any:string(any:from(1)),
+                 {error, <<"Expected a String, got `1`">>}),
+    expect:equal(any:string(any:from([])),
+                 {error, <<"Expected a String, got `[]`">>}).
+
+int_test() ->
+    expect:equal(any:int(any:from(1)), {ok, 1}),
+    expect:equal(any:int(any:from(2)), {ok, 2}),
+    expect:equal(any:int(any:from(1.0)),
+                 {error, <<"Expected an Int, got `1.0`">>}),
+    expect:equal(any:int(any:from([])),
+                 {error, <<"Expected an Int, got `[]`">>}).
+
+float_test() ->
+    expect:equal(any:float(any:from(1.0)), {ok, 1.0}),
+    expect:equal(any:float(any:from(2.2)), {ok, 2.2}),
+    expect:equal(any:float(any:from(1)),
+                 {error, <<"Expected a Float, got `1`">>}),
+    expect:equal(any:float(any:from([])),
+                 {error, <<"Expected a Float, got `[]`">>}).
+
+thunk_test() ->
+    expect:is_ok(any:thunk(any:from(fun() -> 1 end))),
+    expect:equal(result:map(any:thunk(any:from(fun() -> 1 end)),
+                            fun(F) -> F() end),
+                 {ok, any:from(1)}),
+    expect:is_error(any:thunk(any:from(fun(X) -> X end))),
+    expect:is_error(any:thunk(any:from(1))),
+    expect:is_error(any:thunk(any:from([]))).
+
+bool_test() ->
+    expect:equal(any:bool(any:from(true)), {ok, true}),
+    expect:equal(any:bool(any:from(false)), {ok, false}),
+    expect:equal(any:bool(any:from(1)),
+                 {error, <<"Expected a Bool, got `1`">>}),
+    expect:equal(any:bool(any:from([])),
+                 {error, <<"Expected a Bool, got `[]`">>}).
+
+atom_test() ->
+    expect:equal(any:atom(any:from(atom:create_from_string(<<"">>))),
+                 {ok, atom:create_from_string(<<"">>)}),
+    expect:equal(any:atom(any:from(atom:create_from_string(<<"ok">>))),
+                 {ok, atom:create_from_string(<<"ok">>)}),
+    expect:is_error(any:atom(any:from(1))),
+    expect:is_error(any:atom(any:from([]))).
+
+list_test() ->
+    expect:equal(any:list(any:from([]), fun any:string/1), {ok, []}),
+    expect:equal(any:list(any:from([]), fun any:int/1), {ok, []}),
+    expect:equal(any:list(any:from([1, 2, 3]), fun any:int/1), {ok, [1, 2, 3]}),
+    expect:equal(any:list(any:from([[1], [2], [3]]),
+                          fun(Capture1) ->
+                              any:list(Capture1, fun any:int/1)
+                          end),
+                 {ok, [[1], [2], [3]]}),
+    expect:is_error(any:list(any:from(1), fun any:string/1)),
+    expect:is_error(any:list(any:from(1.0), fun any:int/1)),
+    expect:is_error(any:list(any:from([<<"">>]), fun any:int/1)),
+    expect:is_error(any:list(any:from([any:from(1), any:from(<<"not an int">>)]),
+                             fun any:int/1)).
+
+tuple_test() ->
+    expect:equal(any:tuple(any:from({1, []})),
+                 {ok, {any:from(1), any:from([])}}),
+    expect:equal(any:tuple(any:from({<<"ok">>, <<"ok">>})),
+                 {ok, {any:from(<<"ok">>), any:from(<<"ok">>)}}),
+    expect:is_error(any:tuple(any:from({1}))),
+    expect:is_error(any:tuple(any:from({1, 2, 3}))),
+    expect:equal(result:then(result:then(any:tuple(any:from({1, 2.0})),
+                                         fun(X) ->
+                                             result:map(any:int(tuple:first(X)),
+                                                        fun(F) ->
+                                                            {F, tuple:second(X)}
+                                                        end)
+                                         end),
+                             fun(X) ->
+                                 result:map(any:float(tuple:second(X)),
+                                            fun(F) -> {tuple:first(X), F} end)
+                             end),
+                 {ok, {1, 2.0}}).
+
+field_test() ->
+    {ok, OkAtom} = atom:from_string(<<"ok">>),
+    expect:equal(any:field(any:from(#{}#{ok => 1}), OkAtom), {ok, any:from(1)}),
+    expect:equal(any:field(any:from(#{}#{ok => 3}#{earlier => 2}), OkAtom),
+                 {ok, any:from(3)}),
+    expect:is_error(any:field(any:from(#{}), OkAtom)),
+    expect:is_error(any:field(any:from(1), OkAtom)),
+    expect:is_error(any:field(any:from([]), [])).
diff --git a/gen/test/atom_test.erl b/gen/test/atom_test.erl
new file mode 100644
index 0000000..ae9f76b
--- /dev/null
+++ b/gen/test/atom_test.erl
@@ -0,0 +1,23 @@
+-module(atom_test).
+-compile(no_auto_import).
+
+-export([from_string_test/0, create_from_string_test/0, to_string_test/0]).
+
+from_string_test() ->
+    expect:is_ok(atom:from_string(<<"ok">>)),
+    expect:is_ok(atom:from_string(<<"expect">>)),
+    expect:is_error(atom:from_string(<<"this is not an atom we have seen before">>)).
+
+create_from_string_test() ->
+    expect:equal({ok, atom:create_from_string(<<"ok">>)},
+                 atom:from_string(<<"ok">>)),
+    expect:equal({ok, atom:create_from_string(<<"expect">>)},
+                 atom:from_string(<<"expect">>)),
+    expect:equal({ok,
+                  atom:create_from_string(<<"this is another atom we have not seen before">>)},
+                 atom:from_string(<<"this is another atom we have not seen before">>)).
+
+to_string_test() ->
+    expect:equal(atom:to_string(atom:create_from_string(<<"ok">>)), <<"ok">>),
+    expect:equal(atom:to_string(atom:create_from_string(<<"expect">>)),
+                 <<"expect">>).
diff --git a/gen/test/bool_test.erl b/gen/test/bool_test.erl
new file mode 100644
index 0000000..c38f780
--- /dev/null
+++ b/gen/test/bool_test.erl
@@ -0,0 +1,24 @@
+-module(bool_test).
+-compile(no_auto_import).
+
+-export([negate_test/0, max_test/0, min_test/0, to_int_test/0]).
+
+negate_test() ->
+    expect:false(bool:negate(true)),
+    expect:true(bool:negate(false)).
+
+max_test() ->
+    expect:equal(bool:max(true, true), true),
+    expect:equal(bool:max(true, false), true),
+    expect:equal(bool:max(false, false), false),
+    expect:equal(bool:max(false, true), true).
+
+min_test() ->
+    expect:equal(bool:min(true, true), true),
+    expect:equal(bool:min(true, false), false),
+    expect:equal(bool:min(false, false), false),
+    expect:equal(bool:min(false, true), false).
+
+to_int_test() ->
+    expect:equal(bool:to_int(true), 1),
+    expect:equal(bool:to_int(false), 0).
diff --git a/gen/test/http_test.erl b/gen/test/http_test.erl
new file mode 100644
index 0000000..306f916
--- /dev/null
+++ b/gen/test/http_test.erl
@@ -0,0 +1,6 @@
+-module(http_test).
+-compile(no_auto_import).
+
+-export([]).
+
+
diff --git a/gen/test/iodata_test.erl b/gen/test/iodata_test.erl
new file mode 100644
index 0000000..b996bec
--- /dev/null
+++ b/gen/test/iodata_test.erl
@@ -0,0 +1,52 @@
+-module(iodata_test).
+-compile(no_auto_import).
+
+-export([iodata_test/0, lowercase_test/0, uppercase_test/0, split_test/0, is_equal_test/0, is_empty_test/0]).
+
+iodata_test() ->
+    Data = iodata:prepend(iodata:append(iodata:append(iodata:new(<<"ello">>),
+                                                      <<",">>),
+                                        <<" world!">>),
+                          <<"H">>),
+    expect:equal(iodata:to_string(Data), <<"Hello, world!">>),
+    expect:equal(iodata:byte_size(Data), 13),
+    Data1 = iodata:prepend_iodata(iodata:append_iodata(iodata:append_iodata(iodata:new(<<"ello">>),
+                                                                            iodata:new(<<",">>)),
+                                                       iodata:concat([iodata:new(<<" wo">>),
+                                                                      iodata:new(<<"rld!">>)])),
+                                  iodata:new(<<"H">>)),
+    expect:equal(iodata:to_string(Data1), <<"Hello, world!">>),
+    expect:equal(iodata:byte_size(Data1), 13).
+
+lowercase_test() ->
+    expect:equal(iodata:to_string(iodata:lowercase(iodata:from_strings([<<"Gleam">>,
+                                                                        <<"Gleam">>]))),
+                 <<"gleamgleam">>).
+
+uppercase_test() ->
+    expect:equal(iodata:to_string(iodata:uppercase(iodata:from_strings([<<"Gleam">>,
+                                                                        <<"Gleam">>]))),
+                 <<"GLEAMGLEAM">>).
+
+split_test() ->
+    expect:equal(iodata:split(iodata:new(<<"Gleam,Erlang,Elixir">>), <<",">>),
+                 [iodata:new(<<"Gleam">>),
+                  iodata:new(<<"Erlang">>),
+                  iodata:new(<<"Elixir">>)]),
+    expect:equal(iodata:split(iodata:from_strings([<<"Gleam, Erl">>,
+                                                   <<"ang,Elixir">>]),
+                              <<", ">>),
+                 [iodata:new(<<"Gleam">>),
+                  iodata:from_strings([<<"Erl">>, <<"ang,Elixir">>])]).
+
+is_equal_test() ->
+    expect:true(iodata:is_equal(iodata:new(<<"12">>),
+                                iodata:from_strings([<<"1">>, <<"2">>]))),
+    expect:true(iodata:is_equal(iodata:new(<<"12">>), iodata:new(<<"12">>))),
+    expect:false(iodata:is_equal(iodata:new(<<"12">>), iodata:new(<<"2">>))).
+
+is_empty_test() ->
+    expect:true(iodata:is_empty(iodata:new(<<"">>))),
+    expect:false(iodata:is_empty(iodata:new(<<"12">>))),
+    expect:true(iodata:is_empty(iodata:from_strings([]))),
+    expect:true(iodata:is_empty(iodata:from_strings([<<"">>, <<"">>]))).
diff --git a/gen/test/list_test.erl b/gen/test/list_test.erl
new file mode 100644
index 0000000..2505a6e
--- /dev/null
+++ b/gen/test/list_test.erl
@@ -0,0 +1,95 @@
+-module(list_test).
+-compile(no_auto_import).
+
+-export([length_test/0, reverse_test/0, is_empty_test/0, contains_test/0, head_test/0, tail_test/0, filter_test/0, map_test/0, traverse_test/0, drop_test/0, take_test/0, new_test/0, append_test/0, flatten_test/0, fold_test/0, fold_right_test/0, find_test/0]).
+
+length_test() ->
+    expect:equal(list:length([]), 0),
+    expect:equal(list:length([1]), 1),
+    expect:equal(list:length([1, 1]), 2),
+    expect:equal(list:length([1, 1, 1]), 3).
+
+reverse_test() ->
+    expect:equal(list:reverse([]), []),
+    expect:equal(list:reverse([1, 2, 3, 4, 5]), [5, 4, 3, 2, 1]).
+
+is_empty_test() ->
+    expect:true(list:is_empty([])),
+    expect:false(list:is_empty([1])).
+
+contains_test() ->
+    expect:true(list:contains([0, 4, 5, 1], 1)),
+    expect:false(list:contains([0, 4, 5, 7], 1)),
+    expect:false(list:contains([], 1)).
+
+head_test() ->
+    expect:equal(list:head([0, 4, 5, 7]), {ok, 0}),
+    expect:is_error(list:head([])).
+
+tail_test() ->
+    expect:equal(list:tail([0, 4, 5, 7]), {ok, [4, 5, 7]}),
+    expect:equal(list:tail([0]), {ok, []}),
+    expect:is_error(list:tail([])).
+
+filter_test() ->
+    expect:equal(list:filter([], fun(_) -> true end), []),
+    expect:equal(list:filter([0, 4, 5, 7, 3], fun(_) -> true end),
+                 [0, 4, 5, 7, 3]),
+    expect:equal(list:filter([0, 4, 5, 7, 3], fun(X) -> X > 4 end), [5, 7]),
+    expect:equal(list:filter([0, 4, 5, 7, 3], fun(X) -> X < 4 end), [0, 3]).
+
+map_test() ->
+    expect:equal(list:map([], fun(X) -> X * 2 end), []),
+    expect:equal(list:map([0, 4, 5, 7, 3], fun(X) -> X * 2 end),
+                 [0, 8, 10, 14, 6]).
+
+traverse_test() ->
+    Fun = fun(X) -> case X =:= 6 orelse X =:= 5 orelse X =:= 4 of
+            true ->
+                {ok, X * 2};
+
+            false ->
+                {error, X}
+        end end,
+    expect:equal(list:traverse([5, 6, 5, 6], Fun), {ok, [10, 12, 10, 12]}),
+    expect:equal(list:traverse([4, 6, 5, 7, 3], Fun), {error, 7}).
+
+drop_test() ->
+    expect:equal(list:drop([], 5), []),
+    expect:equal(list:drop([1, 2, 3, 4, 5, 6, 7, 8], 5), [6, 7, 8]).
+
+take_test() ->
+    expect:equal(list:take([], 5), []),
+    expect:equal(list:take([1, 2, 3, 4, 5, 6, 7, 8], 5), [1, 2, 3, 4, 5]).
+
+new_test() ->
+    expect:equal(list:new(), []).
+
+append_test() ->
+    expect:equal(list:append([1], [2, 3]), [1, 2, 3]).
+
+flatten_test() ->
+    expect:equal(list:flatten([]), []),
+    expect:equal(list:flatten([[]]), []),
+    expect:equal(list:flatten([[], [], []]), []),
+    expect:equal(list:flatten([[1, 2], [], [3, 4]]), [1, 2, 3, 4]).
+
+fold_test() ->
+    expect:equal(list:fold([1, 2, 3], [], fun(X, Acc) -> [X | Acc] end),
+                 [3, 2, 1]).
+
+fold_right_test() ->
+    expect:equal(list:fold_right([1, 2, 3], [], fun(X, Acc) -> [X | Acc] end),
+                 [1, 2, 3]).
+
+find_test() ->
+    F = fun(X) -> case X of
+            2 ->
+                {ok, 4};
+
+            _ ->
+                {error, 0}
+        end end,
+    expect:equal(list:find([1, 2, 3], F), {ok, 4}),
+    expect:equal(list:find([1, 3, 2], F), {ok, 4}),
+    expect:is_error(list:find([1, 3], F)).
diff --git a/gen/test/map_dict_test.erl b/gen/test/map_dict_test.erl
new file mode 100644
index 0000000..e4560d9
--- /dev/null
+++ b/gen/test/map_dict_test.erl
@@ -0,0 +1,55 @@
+-module(map_dict_test).
+-compile(no_auto_import).
+
+-export([from_list_test/0, has_key_test/0, new_test/0, fetch_test/0, put_test/0, map_values_test/0, keys_test/0, values_test/0]).
+
+from_list_test() ->
+    expect:equal(map_dict:size(map_dict:from_list([{4, 0}, {1, 0}])), 2).
+
+has_key_test() ->
+    expect:false(map_dict:has_key(map_dict:from_list([]), 1)),
+    expect:true(map_dict:has_key(map_dict:from_list([{1, 0}]), 1)),
+    expect:true(map_dict:has_key(map_dict:from_list([{4, 0}, {1, 0}]), 1)),
+    expect:false(map_dict:has_key(map_dict:from_list([{4, 0}, {1, 0}]), 0)).
+
+new_test() ->
+    expect:equal(map_dict:size(map_dict:new()), 0),
+    expect:equal(map_dict:to_list(map_dict:new()), []).
+
+fetch_test() ->
+    Proplist = [{4, 0}, {1, 1}],
+    M = map_dict:from_list(Proplist),
+    expect:equal(map_dict:fetch(M, 4), {ok, 0}),
+    expect:equal(map_dict:fetch(M, 1), {ok, 1}),
+    expect:is_error(map_dict:fetch(M, 2)).
+
+put_test() ->
+    expect:equal(map_dict:put(map_dict:put(map_dict:put(map_dict:new(),
+                                                        <<"a">>,
+                                                        0),
+                                           <<"b">>,
+                                           1),
+                              <<"c">>,
+                              2),
+                 map_dict:from_list([{<<"a">>, 0},
+                                     {<<"b">>, 1},
+                                     {<<"c">>, 2}])).
+
+map_values_test() ->
+    expect:equal(map_dict:map_values(map_dict:from_list([{1, 0},
+                                                         {2, 1},
+                                                         {3, 2}]),
+                                     fun(K, V) -> K + V end),
+                 map_dict:from_list([{1, 1}, {2, 3}, {3, 5}])).
+
+keys_test() ->
+    expect:equal(map_dict:keys(map_dict:from_list([{<<"a">>, 0},
+                                                   {<<"b">>, 1},
+                                                   {<<"c">>, 2}])),
+                 [<<"a">>, <<"b">>, <<"c">>]).
+
+values_test() ->
+    expect:equal(map_dict:values(map_dict:from_list([{<<"a">>, 0},
+                                                     {<<"b">>, 1},
+                                                     {<<"c">>, 2}])),
+                 [0, 1, 2]).
diff --git a/gen/test/order_test.erl b/gen/test/order_test.erl
new file mode 100644
index 0000000..bd30c4d
--- /dev/null
+++ b/gen/test/order_test.erl
@@ -0,0 +1,6 @@
+-module(order_test).
+-compile(no_auto_import).
+
+-export([]).
+
+
diff --git a/gen/test/result_test.erl b/gen/test/result_test.erl
new file mode 100644
index 0000000..090a744
--- /dev/null
+++ b/gen/test/result_test.erl
@@ -0,0 +1,39 @@
+-module(result_test).
+-compile(no_auto_import).
+
+-export([is_ok_test/0, is_error_test/0, map_test/0, map_error_test/0, flatten_test/0, then_test/0, unwrap_test/0]).
+
+is_ok_test() ->
+    expect:true(result:is_ok({ok, 1})),
+    expect:false(result:is_ok({error, 1})).
+
+is_error_test() ->
+    expect:false(result:is_error({ok, 1})),
+    expect:true(result:is_error({error, 1})).
+
+map_test() ->
+    expect:equal(result:map({ok, 1}, fun(X) -> X + 1 end), {ok, 2}),
+    expect:equal(result:map({ok, 1}, fun(_) -> <<"2">> end), {ok, <<"2">>}),
+    expect:equal(result:map({error, 1}, fun(X) -> X + 1 end), {error, 1}).
+
+map_error_test() ->
+    expect:equal(result:map_error({ok, 1}, fun(X) -> X + 1 end), {ok, 1}),
+    expect:equal(result:map_error({error, 1}, fun(X) -> X + 1 end), {error, 2}).
+
+flatten_test() ->
+    expect:equal(result:flatten({ok, {ok, 1}}), {ok, 1}),
+    expect:equal(result:flatten({ok, {error, 1}}), {error, 1}),
+    expect:equal(result:flatten({error, 1}), {error, 1}),
+    expect:equal(result:flatten({error, {error, 1}}), {error, {error, 1}}).
+
+then_test() ->
+    expect:equal(result:then({error, 1}, fun(X) -> {ok, X + 1} end),
+                 {error, 1}),
+    expect:equal(result:then({ok, 1}, fun(X) -> {ok, X + 1} end), {ok, 2}),
+    expect:equal(result:then({ok, 1}, fun(_) -> {ok, <<"type change">>} end),
+                 {ok, <<"type change">>}),
+    expect:equal(result:then({ok, 1}, fun(_) -> {error, 1} end), {error, 1}).
+
+unwrap_test() ->
+    expect:equal(result:unwrap({ok, 1}, 50), 1),
+    expect:equal(result:unwrap({error, <<"nope">>}, 50), 50).
diff --git a/gen/test/set_test.erl b/gen/test/set_test.erl
new file mode 100644
index 0000000..cdff846
--- /dev/null
+++ b/gen/test/set_test.erl
@@ -0,0 +1,6 @@
+-module(set_test).
+-compile(no_auto_import).
+
+-export([]).
+
+
diff --git a/gen/test/str_test.erl b/gen/test/str_test.erl
new file mode 100644
index 0000000..0048ce8
--- /dev/null
+++ b/gen/test/str_test.erl
@@ -0,0 +1,57 @@
+-module(str_test).
+-compile(no_auto_import).
+
+-export([length_test/0, lowercase_test/0, uppercase_test/0, reverse_test/0, split_test/0, replace_test/0, from_int_test/0, parse_int_test/0, parse_float_test/0, base_from_int_test/0, from_float_test/0]).
+
+length_test() ->
+    expect:equal(str:length(<<"ß↑e̊">>), 3),
+    expect:equal(str:length(<<"Gleam">>), 5),
+    expect:equal(str:length(<<"">>), 0).
+
+lowercase_test() ->
+    expect:equal(str:lowercase(<<"Gleam">>), <<"gleam">>).
+
+uppercase_test() ->
+    expect:equal(str:uppercase(<<"Gleam">>), <<"GLEAM">>).
+
+reverse_test() ->
+    expect:equal(str:reverse(<<"Gleam">>), <<"maelG">>).
+
+split_test() ->
+    expect:equal(str:split(<<"Gleam,Erlang,Elixir">>, <<",">>),
+                 [<<"Gleam">>, <<"Erlang">>, <<"Elixir">>]),
+    expect:equal(str:split(<<"Gleam, Erlang,Elixir">>, <<", ">>),
+                 [<<"Gleam">>, <<"Erlang,Elixir">>]).
+
+replace_test() ->
+    expect:equal(str:replace(<<"Gleam,Erlang,Elixir">>, <<",">>, <<"++">>),
+                 <<"Gleam++Erlang++Elixir">>).
+
+from_int_test() ->
+    expect:equal(str:from_int(123), <<"123">>),
+    expect:equal(str:from_int(-123), <<"-123">>),
+    expect:equal(str:from_int(123), <<"123">>).
+
+parse_int_test() ->
+    expect:equal(str:parse_int(<<"123">>), {ok, 123}),
+    expect:equal(str:parse_int(<<"-123">>), {ok, -123}),
+    expect:equal(str:parse_int(<<"0123">>), {ok, 123}),
+    expect:is_error(str:parse_int(<<"">>)),
+    expect:is_error(str:parse_int(<<"what">>)),
+    expect:is_error(str:parse_int(<<"1.23">>)).
+
+parse_float_test() ->
+    expect:equal(str:parse_float(<<"1.23">>), {ok, 1.23}),
+    expect:equal(str:parse_float(<<"5.0">>), {ok, 5.0}),
+    expect:equal(str:parse_float(<<"0.123456789">>), {ok, 0.123456789}),
+    expect:is_error(str:parse_float(<<"">>)),
+    expect:is_error(str:parse_float(<<"what">>)),
+    expect:is_error(str:parse_float(<<"1">>)).
+
+base_from_int_test() ->
+    expect:equal(str:base_from_int(100, 16), <<"64">>),
+    expect:equal(str:base_from_int(-100, 16), <<"-64">>).
+
+from_float_test() ->
+    expect:equal(str:from_float(123.0), <<"123.0">>),
+    expect:equal(str:from_float(-8.1), <<"-8.1">>).
diff --git a/gen/test/tuple_test.erl b/gen/test/tuple_test.erl
new file mode 100644
index 0000000..2f6a1ce
--- /dev/null
+++ b/gen/test/tuple_test.erl
@@ -0,0 +1,23 @@
+-module(tuple_test).
+-compile(no_auto_import).
+
+-export([new_test/0, first_test/0, second_test/0, swap_test/0, fetch_test/0]).
+
+new_test() ->
+    expect:equal(tuple:new(1, 2), {1, 2}),
+    expect:equal(tuple:new(2, <<"3">>), {2, <<"3">>}).
+
+first_test() ->
+    expect:equal(tuple:first({1, 2}), 1).
+
+second_test() ->
+    expect:equal(tuple:second({1, 2}), 2).
+
+swap_test() ->
+    expect:equal(tuple:swap({1, <<"2">>}), {<<"2">>, 1}).
+
+fetch_test() ->
+    Proplist = [{0, <<"1">>}, {1, <<"2">>}],
+    expect:equal(tuple:fetch(Proplist, 0), {ok, <<"1">>}),
+    expect:equal(tuple:fetch(Proplist, 1), {ok, <<"2">>}),
+    expect:is_error(tuple:fetch(Proplist, 2)).