 
     capture_io(":erl. mof*,,l", fn ->
       assert :io.scan_erl_form('>') == {:ok, [{:":", 1}, {:atom, 1, :erl}, {:dot, 1}], 1}
-      assert :io.scan_erl_form('>') == {:ok, [{:atom, 1, :mof}, {:*, 1}, {:",", 1}, {:",", 1}, {:atom, 1, :l}], 1}
+
+      expected_tokens = [{:atom, 1, :mof}, {:*, 1}, {:",", 1}, {:",", 1}, {:atom, 1, :l}]
+      assert :io.scan_erl_form('>') == {:ok, expected_tokens, 1}
+
       assert :io.scan_erl_form('>') == {:eof, 1}
     end)
 
     capture_io("a\nb\nc", fn ->
-      assert GetUntil.get_line == "a\n"
-      assert GetUntil.get_line == "b\n"
-      assert GetUntil.get_line == :eof
+      assert GetUntil.get_line() == "a\n"
+      assert GetUntil.get_line() == "b\n"
+      assert GetUntil.get_line() == :eof
     end)
   end
 
   test "with setopts" do
     assert capture_io(fn ->
-      assert :io.setopts({:encoding, :latin1}) == {:error, :enotsup}
-    end) == ""
+             assert :io.setopts({:encoding, :latin1}) == {:error, :enotsup}
+           end) == ""
   end
 
   test "with getopts" do
     assert capture_io(fn ->
-      assert :io.getopts == {:ok, [binary: true, encoding: :unicode]}
-    end) == ""
+             assert :io.getopts() == {:ok, [binary: true, encoding: :unicode]}
+           end) == ""
   end
 
   test "with columns" do
     assert capture_io(fn ->
-      :io.columns
-    end) == ""
-
-    capture_io(fn ->
-      assert :io.columns == {:error, :enotsup}
+             :io.columns()
+           end) == ""
+
+    capture_io(fn ->
+      assert :io.columns() == {:error, :enotsup}
     end)
   end
 
   test "with rows" do
     assert capture_io(fn ->
-      :io.rows
-    end) == ""
-
-    capture_io(fn ->
-      assert :io.rows == {:error, :enotsup}
+             :io.rows()
+           end) == ""
+
+    capture_io(fn ->
+      assert :io.rows() == {:error, :enotsup}
     end)
   end
 
   test "with multiple IO requests" do
-    assert capture_io(fn ->
-      send_and_receive_io({:requests, [{:put_chars, :unicode, "a"},
-                                        {:put_chars, :unicode, "b"}]})
-    end) == "ab"
-
-    capture_io(fn ->
-      assert send_and_receive_io({:requests, [{:put_chars, :unicode, "a"},
-                                               {:put_chars, :unicode, "b"}]}) == :ok
+    requests = [{:put_chars, :unicode, "a"}, {:put_chars, :unicode, "b"}]
+
+    assert capture_io(fn ->
+             send_and_receive_io({:requests, requests})
+           end) == "ab"
+
+    capture_io(fn ->
+      assert send_and_receive_io({:requests, requests}) == :ok
     end)
   end
 
   test "with unknown IO request" do
     assert capture_io(fn ->
-      send_and_receive_io(:unknown)
-    end) == ""
+             send_and_receive_io(:unknown)
+           end) == ""
 
     capture_io(fn ->
       assert send_and_receive_io(:unknown) == {:error, :request}


  test "with get until" do
    assert capture_io(fn ->
      :io.scan_erl_form('>')
    end) == ">"

    assert capture_io("1.\n", fn ->
      :io.scan_erl_form('>')
    end) == ">"

    assert capture_io("1\n.\n", fn ->
       :io.scan_erl_form('>')
    end) == ">>"

    assert capture_io([capture_prompt: false], fn ->
      :io.scan_erl_form('>')
    end) == ""

    capture_io(fn ->
      assert :io.scan_erl_form('>') == {:eof, 1}
    end)

   capture_io("1", fn ->
     assert :io.scan_erl_form('>') == {:ok, [{:integer, 1, 1}], 1}
     assert :io.scan_erl_form('>') == {:eof, 1}
   end)

    capture_io("1\n.", fn ->
      assert :io.scan_erl_form('>') == {:ok, [{:integer, 1, 1}, {:dot, 2}], 2}


  test "with get line" do
    assert capture_io(fn ->
             :io.get_line(">")
           end) == ">"

    assert capture_io([capture_prompt: false], fn ->
             :io.get_line(">")
           end) == ""

    capture_io(fn ->
      assert :io.get_line(">") == :eof
