diff --git a/test/build_test.gleam b/test/build_test.gleam
index f9d2f57..59144b0 100644
--- a/test/build_test.gleam
+++ b/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)
 }
diff --git a/test/convert_test.gleam b/test/convert_test.gleam
index f14dd93..7e2181f 100644
--- a/test/convert_test.gleam
+++ b/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
 }
diff --git a/test/helpers_test.gleam b/test/helpers_test.gleam
index 88a6c02..72eaa6c 100644
--- a/test/helpers_test.gleam
+++ b/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
       }),
   )
 }
diff --git a/test/limit_tests/float_limit_test.gleam b/test/limit_tests/float_limit_test.gleam
index fc72fe3..227753a 100644
--- a/test/limit_tests/float_limit_test.gleam
+++ b/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))
 }
diff --git a/test/limit_tests/int_limit_test.gleam b/test/limit_tests/int_limit_test.gleam
index 5eb8339..cf37970 100644
--- a/test/limit_tests/int_limit_test.gleam
+++ b/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()))
 }
diff --git a/test/python_parse_test.gleam b/test/python_parse_test.gleam
index 20b6f75..09f380f 100644
--- a/test/python_parse_test.gleam
+++ b/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
         }),
     ),
   ])
diff --git a/test/scale_test.gleam b/test/scale_test.gleam
index 144876b..54e9d07 100644
--- a/test/scale_test.gleam
+++ b/test/scale_test.gleam
@@ -1,6 +1,5 @@
 import gleam/deque
 import lenient_parse/internal/scale
-import startest/expect
 
 pub fn scale_deques_test() {
   let a = deque.from_list([1, 2, 3])
@@ -8,36 +7,36 @@ pub fn scale_deques_test() {
 
   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]
 }
diff --git a/test/to_float_parse_test.gleam b/test/to_float_parse_test.gleam
index d398288..d64954c 100644
--- a/test/to_float_parse_test.gleam
+++ b/test/to_float_parse_test.gleam
@@ -4,7 +4,6 @@ import gleam/list
 import helpers
 import lenient_parse
 import startest.{describe, it}
-import startest/expect
 
 pub fn to_float_tests() {
   describe(
@@ -33,10 +32,7 @@ pub fn to_float_tests() {
         }
 
         use <- it(message)
-
-        input
-        |> lenient_parse.to_float
-        |> expect.to_equal(expected_program_output)
+        assert lenient_parse.to_float(input) == expected_program_output
       }),
   )
 }
diff --git a/test/to_int_parse_test.gleam b/test/to_int_parse_test.gleam
index 9f41e37..1b7a311 100644
--- a/test/to_int_parse_test.gleam
+++ b/test/to_int_parse_test.gleam
@@ -4,7 +4,6 @@ import gleam/list
 import helpers
 import lenient_parse
 import startest.{describe, it}
-import startest/expect
 
 pub fn to_int_tests() {
   describe(
@@ -41,10 +40,8 @@ pub fn to_int_tests() {
         }
 
         use <- it(message)
-
-        input
-        |> lenient_parse.to_int_with_base(base)
-        |> expect.to_equal(expected_program_output)
+        assert lenient_parse.to_int_with_base(input, base)
+          == expected_program_output
       }),
   )
 }
diff --git a/test/tokenizer_test.gleam b/test/tokenizer_test.gleam
index 138508d..4204dd9 100644
--- a/test/tokenizer_test.gleam
+++ b/test/tokenizer_test.gleam
@@ -9,111 +9,110 @@ import lenient_parse/internal/token.{
   DecimalPoint, Digit, ExponentSymbol, Sign, Underscore, Unknown, Whitespace,
 }
 import lenient_parse/internal/tokenizer
-import startest/expect
 
 // With floats, only base 10 is supported. Any letter character (a-z/A-Z),
 // outside of an exponent character, should be considered an Unknown.
 pub fn tokenize_float_test() {
-  " \t\n\r\f\r\n+-0123456789eE._abc"
-  |> tokenizer.tokenize_float
-  |> expect.to_equal([
-    Whitespace(0, space),
-    Whitespace(1, horizontal_tab),
-    Whitespace(2, line_feed),
-    Whitespace(3, carriage_return),
-    Whitespace(4, form_feed),
-    Whitespace(5, windows_newline),
-    Sign(6, "+", True),
-    Sign(7, "-", False),
-    Digit(8, "0", 0),
-    Digit(9, "1", 1),
-    Digit(10, "2", 2),
-    Digit(11, "3", 3),
-    Digit(12, "4", 4),
-    Digit(13, "5", 5),
-    Digit(14, "6", 6),
-    Digit(15, "7", 7),
-    Digit(16, "8", 8),
-    Digit(17, "9", 9),
-    ExponentSymbol(18, "e"),
-    ExponentSymbol(19, "E"),
-    DecimalPoint(20),
-    Underscore(21),
-    Unknown(22, "a"),
-    Unknown(23, "b"),
-    Unknown(24, "c"),
-  ])
+  assert tokenizer.tokenize_float(" \t\n\r\f\r\n+-0123456789eE._abc")
+    == [
+      Whitespace(0, space),
+      Whitespace(1, horizontal_tab),
+      Whitespace(2, line_feed),
+      Whitespace(3, carriage_return),
+      Whitespace(4, form_feed),
+      Whitespace(5, windows_newline),
+      Sign(6, "+", True),
+      Sign(7, "-", False),
+      Digit(8, "0", 0),
+      Digit(9, "1", 1),
+      Digit(10, "2", 2),
+      Digit(11, "3", 3),
+      Digit(12, "4", 4),
+      Digit(13, "5", 5),
+      Digit(14, "6", 6),
+      Digit(15, "7", 7),
+      Digit(16, "8", 8),
+      Digit(17, "9", 9),
+      ExponentSymbol(18, "e"),
+      ExponentSymbol(19, "E"),
+      DecimalPoint(20),
+      Underscore(21),
+      Unknown(22, "a"),
+      Unknown(23, "b"),
+      Unknown(24, "c"),
+    ]
 }
 
 // With integers, Letter characters (a-z/A-Z) are all supported given the right
 // base, so we mark these as Digits.
 pub fn tokenize_int_test() {
-  " \t\n\r\f\r\n+-abcdefghijklmnopqrstuvwxyz._ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-  |> tokenizer.tokenize_int
-  |> expect.to_equal([
-    Whitespace(0, space),
-    Whitespace(1, horizontal_tab),
-    Whitespace(2, line_feed),
-    Whitespace(3, carriage_return),
-    Whitespace(4, form_feed),
-    Whitespace(5, windows_newline),
-    Sign(6, "+", True),
-    Sign(7, "-", False),
-    Digit(8, "a", 10),
-    Digit(9, "b", 11),
-    Digit(10, "c", 12),
-    Digit(11, "d", 13),
-    Digit(12, "e", 14),
-    Digit(13, "f", 15),
-    Digit(14, "g", 16),
-    Digit(15, "h", 17),
-    Digit(16, "i", 18),
-    Digit(17, "j", 19),
-    Digit(18, "k", 20),
-    Digit(19, "l", 21),
-    Digit(20, "m", 22),
-    Digit(21, "n", 23),
-    Digit(22, "o", 24),
-    Digit(23, "p", 25),
-    Digit(24, "q", 26),
-    Digit(25, "r", 27),
-    Digit(26, "s", 28),
-    Digit(27, "t", 29),
-    Digit(28, "u", 30),
-    Digit(29, "v", 31),
-    Digit(30, "w", 32),
-    Digit(31, "x", 33),
-    Digit(32, "y", 34),
-    Digit(33, "z", 35),
-    Unknown(34, "."),
-    Underscore(35),
-    Digit(36, "A", 10),
-    Digit(37, "B", 11),
-    Digit(38, "C", 12),
-    Digit(39, "D", 13),
-    Digit(40, "E", 14),
-    Digit(41, "F", 15),
-    Digit(42, "G", 16),
-    Digit(43, "H", 17),
-    Digit(44, "I", 18),
-    Digit(45, "J", 19),
-    Digit(46, "K", 20),
-    Digit(47, "L", 21),
-    Digit(48, "M", 22),
-    Digit(49, "N", 23),
-    Digit(50, "O", 24),
-    Digit(51, "P", 25),
-    Digit(52, "Q", 26),
-    Digit(53, "R", 27),
-    Digit(54, "S", 28),
-    Digit(55, "T", 29),
-    Digit(56, "U", 30),
-    Digit(57, "V", 31),
-    Digit(58, "W", 32),
-    Digit(59, "X", 33),
-    Digit(60, "Y", 34),
-    Digit(61, "Z", 35),
-  ])
+  assert tokenizer.tokenize_int(
+      " \t\n\r\f\r\n+-abcdefghijklmnopqrstuvwxyz._ABCDEFGHIJKLMNOPQRSTUVWXYZ",
+    )
+    == [
+      Whitespace(0, space),
+      Whitespace(1, horizontal_tab),
+      Whitespace(2, line_feed),
+      Whitespace(3, carriage_return),
+      Whitespace(4, form_feed),
+      Whitespace(5, windows_newline),
+      Sign(6, "+", True),
+      Sign(7, "-", False),
+      Digit(8, "a", 10),
+      Digit(9, "b", 11),
+      Digit(10, "c", 12),
+      Digit(11, "d", 13),
+      Digit(12, "e", 14),
+      Digit(13, "f", 15),
+      Digit(14, "g", 16),
+      Digit(15, "h", 17),
+      Digit(16, "i", 18),
+      Digit(17, "j", 19),
+      Digit(18, "k", 20),
+      Digit(19, "l", 21),
+      Digit(20, "m", 22),
+      Digit(21, "n", 23),
+      Digit(22, "o", 24),
+      Digit(23, "p", 25),
+      Digit(24, "q", 26),
+      Digit(25, "r", 27),
+      Digit(26, "s", 28),
+      Digit(27, "t", 29),
+      Digit(28, "u", 30),
+      Digit(29, "v", 31),
+      Digit(30, "w", 32),
+      Digit(31, "x", 33),
+      Digit(32, "y", 34),
+      Digit(33, "z", 35),
+      Unknown(34, "."),
+      Underscore(35),
+      Digit(36, "A", 10),
+      Digit(37, "B", 11),
+      Digit(38, "C", 12),
+      Digit(39, "D", 13),
+      Digit(40, "E", 14),
+      Digit(41, "F", 15),
+      Digit(42, "G", 16),
+      Digit(43, "H", 17),
+      Digit(44, "I", 18),
+      Digit(45, "J", 19),
+      Digit(46, "K", 20),
+      Digit(47, "L", 21),
+      Digit(48, "M", 22),
+      Digit(49, "N", 23),
+      Digit(50, "O", 24),
+      Digit(51, "P", 25),
+      Digit(52, "Q", 26),
+      Digit(53, "R", 27),
+      Digit(54, "S", 28),
+      Digit(55, "T", 29),
+      Digit(56, "U", 30),
+      Digit(57, "V", 31),
+      Digit(58, "W", 32),
+      Digit(59, "X", 33),
+      Digit(60, "Y", 34),
+      Digit(61, "Z", 35),
+    ]
 }
 
 pub fn tokenize_int_with_all_whitespace_characters_test() {
@@ -127,8 +126,8 @@ pub fn tokenize_int_with_all_whitespace_characters_test() {
 
   let whitespace_character_strings = dict.keys(whitespace.character_dict())
 
-  whitespace_character_strings
-  |> string.join("")
-  |> tokenizer.tokenize_int
-  |> expect.to_equal(expected_tokens)
+  assert whitespace_character_strings
+    |> string.join("")
+    |> tokenizer.tokenize_int
+    == expected_tokens
 }