Use assert

test/build_test.gleam

@@ -1,90 +1,89 @@
 import gleam/deque
 import lenient_parse/internal/build
-import startest/expect
 
 // ------------------ float
 
 pub fn build_float_empty_test() {
-  build.float_value(
-    is_positive: True,
-    whole_digits: deque.from_list([]),
-    fractional_digits: deque.from_list([]),
-    scale_factor: 0,
-  )
-  |> expect.to_equal(Ok(0.0))
+  assert build.float_value(
+      is_positive: True,
+      whole_digits: deque.from_list([]),
+      fractional_digits: deque.from_list([]),
+      scale_factor: 0,
+    )
+    == Ok(0.0)
 }
 
 pub fn build_float_explicit_0_both_test() {
-  build.float_value(
-    is_positive: True,
-    whole_digits: deque.from_list([0]),
-    fractional_digits: deque.from_list([0]),
-    scale_factor: 0,
-  )
-  |> expect.to_equal(Ok(0.0))
+  assert build.float_value(
+      is_positive: True,
+      whole_digits: deque.from_list([0]),
+      fractional_digits: deque.from_list([0]),
+      scale_factor: 0,
+    )
+    == Ok(0.0)
 }
 
 pub fn build_float_empty_fractional_test() {
-  build.float_value(
-    is_positive: True,
-    whole_digits: deque.from_list([1]),
-    fractional_digits: deque.from_list([]),
-    scale_factor: 0,
-  )
-  |> expect.to_equal(Ok(1.0))
+  assert build.float_value(
+      is_positive: True,
+      whole_digits: deque.from_list([1]),
+      fractional_digits: deque.from_list([]),
+      scale_factor: 0,
+    )
+    == Ok(1.0)
 }
 
 pub fn build_float_explicit_0_fractional_test() {
-  build.float_value(
-    is_positive: True,
-    whole_digits: deque.from_list([1]),
-    fractional_digits: deque.from_list([0]),
-    scale_factor: 0,
-  )
-  |> expect.to_equal(Ok(1.0))
+  assert build.float_value(
+      is_positive: True,
+      whole_digits: deque.from_list([1]),
+      fractional_digits: deque.from_list([0]),
+      scale_factor: 0,
+    )
+    == Ok(1.0)
 }
 
 pub fn build_float_empty_whole_test() {
-  build.float_value(
-    is_positive: True,
-    whole_digits: deque.from_list([]),
-    fractional_digits: deque.from_list([1]),
-    scale_factor: 0,
-  )
-  |> expect.to_equal(Ok(0.1))
+  assert build.float_value(
+      is_positive: True,
+      whole_digits: deque.from_list([]),
+      fractional_digits: deque.from_list([1]),
+      scale_factor: 0,
+    )
+    == Ok(0.1)
 }
 
 pub fn build_float_explicit_0_whole_test() {
-  build.float_value(
-    is_positive: True,
-    whole_digits: deque.from_list([0]),
-    fractional_digits: deque.from_list([1]),
-    scale_factor: 0,
-  )
-  |> expect.to_equal(Ok(0.1))
+  assert build.float_value(
+      is_positive: True,
+      whole_digits: deque.from_list([0]),
+      fractional_digits: deque.from_list([1]),
+      scale_factor: 0,
+    )
+    == Ok(0.1)
 }
 
 // ------------------ int
 
 pub fn build_int_empty_test() {
-  []
-  |> deque.from_list
-  |> build.integer_value(base: 10, is_positive: True)
-  |> expect.to_equal(Ok(0))
+  assert []
+    |> deque.from_list
+    |> build.integer_value(base: 10, is_positive: True)
+    == Ok(0)
 }
 
 pub fn build_int_explicit_0_test() {
-  [0]
-  |> deque.from_list()
-  |> build.integer_value(base: 10, is_positive: True)
-  |> expect.to_equal(Ok(0))
+  assert [0]
+    |> deque.from_list()
+    |> build.integer_value(base: 10, is_positive: True)
+    == Ok(0)
 }
 
 pub fn build_int_test() {
-  build.integer_value(
-    digits: deque.from_list([1, 2, 3]),
-    base: 10,
-    is_positive: True,
-  )
-  |> expect.to_equal(Ok(123))
+  assert build.integer_value(
+      digits: deque.from_list([1, 2, 3]),
+      base: 10,
+      is_positive: True,
+    )
+    == Ok(123)
 }

test/convert_test.gleam

@@ -1,21 +1,10 @@
 import lenient_parse/internal/base_constants.{base_10, base_16, base_2, base_8}
 import lenient_parse/internal/convert.{digits_to_int_from_list}
-import startest/expect
 
 pub fn digits_to_int_test() {
-  [1, 2, 3]
-  |> digits_to_int_from_list(base_10)
-  |> expect.to_equal(123)
-
-  [1, 0, 1]
-  |> digits_to_int_from_list(base_2)
-  |> expect.to_equal(0b101)
-
-  [0o1, 0o2, 0o7]
-  |> digits_to_int_from_list(base_8)
-  |> expect.to_equal(0o127)
-
-  [0xa, 0xb, 0xc, 0xd, 0xe, 0xf]
-  |> digits_to_int_from_list(base_16)
-  |> expect.to_equal(0xabcdef)
+  assert digits_to_int_from_list([1, 2, 3], base_10) == 123
+  assert digits_to_int_from_list([1, 0, 1], base_2) == 0b101
+  assert digits_to_int_from_list([0o1, 0o2, 0o7], base_8) == 0o127
+  assert digits_to_int_from_list([0xa, 0xb, 0xc, 0xd, 0xe, 0xf], base_16)
+    == 0xabcdef
 }

test/helpers_test.gleam

@@ -3,7 +3,6 @@ import gleam/list
 import helpers
 import lenient_parse/internal/whitespace
 import startest.{describe, it}
-import startest/expect
 
 pub fn to_printable_text_tests() {
   let whitespace_tuples =
@@ -26,7 +25,7 @@ pub fn to_printable_text_tests() {
       |> list.map(fn(tuple) {
         let #(input, output) = tuple
         use <- it("\"" <> output <> "\"")
-        input |> helpers.to_printable_text |> expect.to_equal(output)
+        assert helpers.to_printable_text(input) == output
       }),
   )
 }

test/limit_tests/float_limit_test.gleam

@@ -1,7 +1,6 @@
 import gleam/string
 import lenient_parse
 import lenient_parse/parse_error.{OutOfFloatRange}
-import startest/expect
 
 // In the future, we should try to test closer to the actual limit. I had a hard
 // time finding the exact limit here, so I may be overshooting. Once we find the
@@ -12,34 +11,30 @@ pub fn large_positive_float_limit_test() {
   let float_string = "34028235e301"
   let expected = "34028235" <> string.repeat("0", 301) <> ".0"
 
-  float_string
-  |> lenient_parse.to_float
-  |> expect.to_equal(Error(OutOfFloatRange(expected)))
+  assert lenient_parse.to_float(float_string)
+    == Error(OutOfFloatRange(expected))
 }
 
 pub fn large_negative_float_limit_test() {
   let float_string = "-34028235e301"
   let expected = "-34028235" <> string.repeat("0", 301) <> ".0"
 
-  float_string
-  |> lenient_parse.to_float
-  |> expect.to_equal(Error(OutOfFloatRange(expected)))
+  assert lenient_parse.to_float(float_string)
+    == Error(OutOfFloatRange(expected))
 }
 
 pub fn small_positive_float_limit_test() {
   let float_string = "0.34028235e-308"
   let expected = "0." <> string.repeat("0", 308) <> "34028235"
 
-  float_string
-  |> lenient_parse.to_float
-  |> expect.to_equal(Error(OutOfFloatRange(expected)))
+  assert lenient_parse.to_float(float_string)
+    == Error(OutOfFloatRange(expected))
 }
 
 pub fn small_negative_float_limit_test() {
   let float_string = "-0.34028235e-308"
   let expected = "-0." <> string.repeat("0", 308) <> "34028235"
 
-  float_string
-  |> lenient_parse.to_float
-  |> expect.to_equal(Error(OutOfFloatRange(expected)))
+  assert lenient_parse.to_float(float_string)
+    == Error(OutOfFloatRange(expected))
 }

test/limit_tests/int_limit_test.gleam

@@ -12,48 +12,39 @@ import javascript_constants.{
 import lenient_parse
 @target(javascript)
 import lenient_parse/parse_error.{OutOfIntRange}
-import startest/expect
 
 @target(erlang)
 pub fn erlang_javascript_min_safe_integer_test() {
-  min_safe_integer_string()
-  |> lenient_parse.to_int
-  |> expect.to_equal(Ok(min_safe_integer()))
+  assert lenient_parse.to_int(min_safe_integer_string())
+    == Ok(min_safe_integer())
 
-  min_safe_integer_minus_1_string()
-  |> lenient_parse.to_int
-  |> expect.to_equal(Ok(min_safe_integer_minus_1()))
+  assert lenient_parse.to_int(min_safe_integer_minus_1_string())
+    == Ok(min_safe_integer_minus_1())
 }
 
 @target(erlang)
 pub fn erlang_javascript_max_safe_integer_test() {
-  max_safe_integer_string()
-  |> lenient_parse.to_int
-  |> expect.to_equal(Ok(max_safe_integer()))
+  assert lenient_parse.to_int(max_safe_integer_string())
+    == Ok(max_safe_integer())
 
-  max_safe_integer_plus_1_string()
-  |> lenient_parse.to_int
-  |> expect.to_equal(Ok(max_safe_integer_plus_1()))
+  assert lenient_parse.to_int(max_safe_integer_plus_1_string())
+    == Ok(max_safe_integer_plus_1())
 }
 
 @target(javascript)
 pub fn javascript_javascript_min_safe_integer_test() {
-  min_safe_integer_string()
-  |> lenient_parse.to_int
-  |> expect.to_equal(Ok(min_safe_integer()))
+  assert lenient_parse.to_int(min_safe_integer_string())
+    == Ok(min_safe_integer())
 
-  min_safe_integer_minus_1_string()
-  |> lenient_parse.to_int
-  |> expect.to_equal(Error(OutOfIntRange(min_safe_integer_minus_1_string())))
+  assert lenient_parse.to_int(min_safe_integer_minus_1_string())
+    == Error(OutOfIntRange(min_safe_integer_minus_1_string()))
 }
 
 @target(javascript)
 pub fn javascript_javascript_max_safe_integer_test() {
-  max_safe_integer_string()
-  |> lenient_parse.to_int
-  |> expect.to_equal(Ok(max_safe_integer()))
+  assert lenient_parse.to_int(max_safe_integer_string())
+    == Ok(max_safe_integer())
 
-  max_safe_integer_plus_1_string()
-  |> lenient_parse.to_int
-  |> expect.to_equal(Error(OutOfIntRange(max_safe_integer_plus_1_string())))
+  assert lenient_parse.to_int(max_safe_integer_plus_1_string())
+    == Error(OutOfIntRange(max_safe_integer_plus_1_string()))
 }

test/python_parse_test.gleam

@@ -4,7 +4,6 @@ import gleam/int
 import gleam/list
 import helpers
 import startest.{describe, it}
-import startest/expect
 
 pub fn check_against_python_tests() {
   describe("check_against_python_tests", [
@@ -51,8 +50,7 @@ pub fn check_against_python_tests() {
           }
 
           use <- it(message)
-
-          expect.to_equal(expected_python_output, actual_python_output)
+          assert expected_python_output == actual_python_output
         }),
     ),
     describe(
@@ -108,8 +106,7 @@ pub fn check_against_python_tests() {
           }
 
           use <- it(message)
-
-          expect.to_equal(expected_python_output, actual_python_output)
+          assert expected_python_output == actual_python_output
         }),
     ),
   ])

test/scale_test.gleam

@@ -1,43 +1,42 @@
 import gleam/deque
 import lenient_parse/internal/scale
-import startest/expect
 
 pub fn scale_deques_test() {
   let a = deque.from_list([1, 2, 3])
   let b = deque.from_list([4, 5, 6])
 
   let #(a, b) = scale.deques(a, b, 1)
 
-  a |> deque.to_list |> expect.to_equal([1, 2, 3, 4])
-  b |> deque.to_list |> expect.to_equal([5, 6])
+  assert deque.to_list(a) == [1, 2, 3, 4]
+  assert deque.to_list(b) == [5, 6]
 
   let #(a, b) = scale.deques(a, b, 1)
 
-  a |> deque.to_list |> expect.to_equal([1, 2, 3, 4, 5])
-  b |> deque.to_list |> expect.to_equal([6])
+  assert deque.to_list(a) == [1, 2, 3, 4, 5]
+  assert deque.to_list(b) == [6]
 
   let #(a, b) = scale.deques(a, b, 1)
 
-  a |> deque.to_list |> expect.to_equal([1, 2, 3, 4, 5, 6])
-  b |> deque.to_list |> expect.to_equal([])
+  assert deque.to_list(a) == [1, 2, 3, 4, 5, 6]
+  assert deque.to_list(b) == []
 
   let #(a, b) = scale.deques(a, b, 1)
 
-  a |> deque.to_list |> expect.to_equal([1, 2, 3, 4, 5, 6, 0])
-  b |> deque.to_list |> expect.to_equal([])
+  assert deque.to_list(a) == [1, 2, 3, 4, 5, 6, 0]
+  assert deque.to_list(b) == []
 
   let #(a, b) = scale.deques(a, b, -3)
 
-  a |> deque.to_list |> expect.to_equal([1, 2, 3, 4])
-  b |> deque.to_list |> expect.to_equal([5, 6, 0])
+  assert deque.to_list(a) == [1, 2, 3, 4]
+  assert deque.to_list(b) == [5, 6, 0]
 
   let #(a, b) = scale.deques(a, b, -4)
 
-  a |> deque.to_list |> expect.to_equal([])
-  b |> deque.to_list |> expect.to_equal([1, 2, 3, 4, 5, 6, 0])
+  assert deque.to_list(a) == []
+  assert deque.to_list(b) == [1, 2, 3, 4, 5, 6, 0]
 
   let #(a, b) = scale.deques(a, b, -3)
 
-  a |> deque.to_list |> expect.to_equal([])
-  b |> deque.to_list |> expect.to_equal([0, 0, 0, 1, 2, 3, 4, 5, 6, 0])
+  assert deque.to_list(a) == []
+  assert deque.to_list(b) == [0, 0, 0, 1, 2, 3, 4, 5, 6, 0]
 }