use should.be_true()/.be_false() instead of should.equal() (#339)

4 files changed, 38 insertions, 38 deletions

diff --git a/test/gleam/bool_test.gleam b/test/gleam/bool_test.gleam
index 17d8b12..24607fb 100644
--- a/test/gleam/bool_test.gleam
+++ b/test/gleam/bool_test.gleam
@@ -82,30 +82,30 @@ pub fn compare_test() {
 
 pub fn max_test() {
   bool.max(True, True)
-  |> should.equal(True)
+  |> should.be_true
 
   bool.max(True, False)
-  |> should.equal(True)
+  |> should.be_true
 
   bool.max(False, False)
-  |> should.equal(False)
+  |> should.be_false
 
   bool.max(False, True)
-  |> should.equal(True)
+  |> should.be_true
 }
 
 pub fn min_test() {
   bool.min(True, True)
-  |> should.equal(True)
+  |> should.be_true
 
   bool.min(True, False)
-  |> should.equal(False)
+  |> should.be_false
 
   bool.min(False, False)
-  |> should.equal(False)
+  |> should.be_false
 
   bool.min(False, True)
-  |> should.equal(False)
+  |> should.be_false
 }
 
 pub fn to_int_test() {
diff --git a/test/gleam/list_test.gleam b/test/gleam/list_test.gleam
index f9a7f44..e02ef87 100644
--- a/test/gleam/list_test.gleam
+++ b/test/gleam/list_test.gleam
@@ -59,7 +59,7 @@ pub fn contains_test() {
 
   list.repeat(0, recursion_test_cycles)
   |> list.contains(1)
-  |> should.equal(False)
+  |> should.be_false
 }
 
 pub fn first_test() {
@@ -309,21 +309,21 @@ pub fn find_test() {
 
 pub fn all_test() {
   list.all([1, 2, 3, 4, 5], fn(x) { x > 0 })
-  |> should.equal(True)
+  |> should.be_true
 
   list.all([1, 2, 3, 4, 5], fn(x) { x < 0 })
-  |> should.equal(False)
+  |> should.be_false
 
   list.all([], fn(_) { False })
-  |> should.equal(True)
+  |> should.be_true
 
   list.repeat(False, recursion_test_cycles)
   |> list.all(fn(item) { item })
-  |> should.equal(False)
+  |> should.be_false
 
   list.repeat(True, recursion_test_cycles)
   |> list.all(fn(item) { item })
-  |> should.equal(True)
+  |> should.be_true
 
   [1, 2, 3]
   |> list.all(fn(x) {
@@ -340,21 +340,21 @@ pub fn all_test() {
 
 pub fn any_test() {
   list.any([1, 2, 3, 4, 5], fn(x) { x == 2 })
-  |> should.equal(True)
+  |> should.be_true
 
   list.any([1, 2, 3, 4, 5], fn(x) { x < 0 })
-  |> should.equal(False)
+  |> should.be_false
 
   list.any([], fn(_) { False })
-  |> should.equal(False)
+  |> should.be_false
 
   list.repeat(True, recursion_test_cycles)
   |> list.any(fn(item) { item })
-  |> should.equal(True)
+  |> should.be_true
 
   list.repeat(False, recursion_test_cycles)
   |> list.any(fn(item) { item })
-  |> should.equal(False)
+  |> should.be_false
 
   [1, 2, 3]
   |> list.any(fn(x) {
diff --git a/test/gleam/regex_test.gleam b/test/gleam/regex_test.gleam
index d311b99..cdd6e68 100644
--- a/test/gleam/regex_test.gleam
+++ b/test/gleam/regex_test.gleam
@@ -6,10 +6,10 @@ pub fn from_string_test() {
   assert Ok(re) = regex.from_string("[0-9]")
 
   regex.check(re, "abc123")
-  |> should.equal(True)
+  |> should.be_true
 
   regex.check(re, "abcxyz")
-  |> should.equal(False)
+  |> should.be_false
 
   assert Error(_) = regex.from_string("[0-9")
 }
@@ -19,23 +19,23 @@ pub fn compile_test() {
   assert Ok(re) = regex.compile("[A-B]", options)
 
   regex.check(re, "abc123")
-  |> should.equal(True)
+  |> should.be_true
 
   let options = Options(case_insensitive: False, multi_line: True)
   assert Ok(re) = regex.compile("^[0-9]", options)
 
   regex.check(re, "abc\n123")
-  |> should.equal(True)
+  |> should.be_true
 }
 
 pub fn check_test() {
   assert Ok(re) = regex.from_string("^f.o.?")
 
   regex.check(re, "foo")
-  |> should.equal(True)
+  |> should.be_true
 
   regex.check(re, "boo")
-  |> should.equal(False)
+  |> should.be_false
 }
 
 pub fn split_test() {
diff --git a/test/gleam/string_test.gleam b/test/gleam/string_test.gleam
index 7155ea6..e1c4799 100644
--- a/test/gleam/string_test.gleam
+++ b/test/gleam/string_test.gleam
@@ -125,14 +125,14 @@ pub fn compare_test() {
 pub fn contains_test() {
   "gleam"
   |> string.contains("ea")
-  |> should.equal(True)
+  |> should.be_true
 
   "gleam"
   |> string.contains("x")
-  |> should.equal(False)
+  |> should.be_false
 
   string.contains(does: "bellwether", contain: "bell")
-  |> should.equal(True)
+  |> should.be_true
 }
 
 pub fn concat_test() {
@@ -186,37 +186,37 @@ pub fn trim_right_test() {
 pub fn starts_with_test() {
   "theory"
   |> string.starts_with("")
-  |> should.equal(True)
+  |> should.be_true
 
   "theory"
   |> string.starts_with("the")
-  |> should.equal(True)
+  |> should.be_true
 
   "theory"
   |> string.starts_with("ory")
-  |> should.equal(False)
+  |> should.be_false
 
   "theory"
   |> string.starts_with("theory2")
-  |> should.equal(False)
+  |> should.be_false
 }
 
 pub fn ends_with_test() {
   "theory"
   |> string.ends_with("")
-  |> should.equal(True)
+  |> should.be_true
 
   "theory"
   |> string.ends_with("ory")
-  |> should.equal(True)
+  |> should.be_true
 
   "theory"
   |> string.ends_with("the")
-  |> should.equal(False)
+  |> should.be_false
 
   "theory"
   |> string.ends_with("theory2")
-  |> should.equal(False)
+  |> should.be_false
 }
 
 pub fn slice_test() {
@@ -795,7 +795,7 @@ if erlang {
       regex.from_string("^\\/\\/erl\\(<[0-9]+\\.[0-9]+\\.[0-9]+>\\)$")
     string.inspect(create_erlang_pid())
     |> regex.check(regular_expression, _)
-    |> should.equal(True)
+    |> should.be_true
 
     // Looks like: `//erl(#Ref<0.1809744150.4035444737.100468>)`.
     assert Ok(regular_expression) =
@@ -804,7 +804,7 @@ if erlang {
       )
     string.inspect(create_erlang_reference())
     |> regex.check(regular_expression, _)
-    |> should.equal(True)
+    |> should.be_true
 
     // On Erlang the runtime representation for `String` and `BitString` is indistinguishable.
     <<"abc":utf8>>