From 1991d8669c879bcfee445ca5794183235cb6aacd Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Rafael=20Mendon=C3=A7a=20Fran=C3=A7a?=
 <rafaelmfranca@gmail.com>
Date: Sun, 12 Feb 2012 00:22:52 -0200
Subject: [PATCH] Use new assertions on tests

---
 test/elixir/code_test.exs                     |   6 +-
 test/elixir/elixir/cli_test.exs               |  26 ++---
 test/elixir/elixir/errors_test.exs            |  64 +++++------
 test/elixir/enum_test.exs                     |  92 +++++++--------
 test/elixir/exception_test.exs                |  56 ++++-----
 test/elixir/exunit/escaper_test.exs           |   6 +-
 test/elixir/file_test.exs                     |  26 ++---
 test/elixir/kernel/comprehension_test.exs     |  42 ++++---
 test/elixir/kernel/import_test.exs            |  24 ++--
 test/elixir/kernel/loop_test.exs              |  10 +-
 .../kernel/partial_application_test.exs       |  32 +++---
 test/elixir/kernel/quote_test.exs             |   6 +-
 test/elixir/kernel/require_test.exs           |  14 ++-
 test/elixir/kernel/rescue_test.exs            |  82 +++++++++----
 test/elixir/list/inspect_test.exs             |   8 +-
 test/elixir/list_test.exs                     |  38 +++---
 test/elixir/module_test.exs                   |  20 ++--
 test/elixir/orddict_test.exs                  |  38 +++---
 test/elixir/protocol_test.exs                 |   4 +-
 test/elixir/record_test.exs                   |  16 +--
 test/elixir/string/inspect_test.exs           | 108 +++++++++---------
 test/elixir/string_test.exs                   |   4 +-
 test/elixir/tuple_test.exs                    |   6 +-
 23 files changed, 387 insertions(+), 341 deletions(-)

diff --git a/test/elixir/code_test.exs b/test/elixir/code_test.exs
index a667912246..cbf3064c6a 100644
--- a/test/elixir/code_test.exs
+++ b/test/elixir/code_test.exs
@@ -12,14 +12,14 @@ defmodule CodeTest do
   Code.eval_quoted contents, [], "sample.ex", 13
 
   def test_eval_quoted do
-    { ::CodeTest::Sample, "sample.ex", 13 } = CodeTest::Sample.eval_quoted_info()
+    assert_equal { ::CodeTest::Sample, "sample.ex", 13 }, CodeTest::Sample.eval_quoted_info()
   end
 
   def test_require do
     Code.require_file "../fixtures/code_sample", __FILE__
 
     expanded = File.expand_path("test/elixir/fixtures/code_sample.exs")
-    true = Erlang.lists.member(expanded, Code.loaded_files)
+    assert Erlang.lists.member(expanded, Code.loaded_files)
   end
 
   def test_require_on_failure do
@@ -31,4 +31,4 @@ defmodule CodeTest do
     catch: :error, { :enoent, ^expanded }
     end
   end
-end
\ No newline at end of file
+end
diff --git a/test/elixir/elixir/cli_test.exs b/test/elixir/elixir/cli_test.exs
index d4e8e1bf1c..7ce1835eca 100644
--- a/test/elixir/elixir/cli_test.exs
+++ b/test/elixir/elixir/cli_test.exs
@@ -6,10 +6,10 @@ defmodule Elixir::CLI::InitTest do
   use ExUnit::Case
 
   def test_code_init do
-    '3\n' = OS.cmd('bin/elixir -e "IO.puts 1 + 2"')
+    assert_equal '3\n', OS.cmd('bin/elixir -e "IO.puts 1 + 2"')
 
-    expected  = '#{inspect ['-o', '1', '2', '3']}\n3\n'
-    ^expected = OS.cmd('bin/elixir -e "IO.puts inspect(Code.argv)" test/elixir/fixtures/init_sample.exs -o 1 2 3')
+    expected = '#{inspect ['-o', '1', '2', '3']}\n3\n'
+    assert_equal expected, OS.cmd('bin/elixir -e "IO.puts inspect(Code.argv)" test/elixir/fixtures/init_sample.exs -o 1 2 3')
   end
 end
 
@@ -17,7 +17,7 @@ defmodule Elixir::CLI::AtExitTest do
   use ExUnit::Case
 
   def test_at_exit do
-    'goodbye cruel world with status 0\n' = OS.cmd('bin/elixir test/elixir/fixtures/at_exit.exs')
+    assert_equal 'goodbye cruel world with status 0\n', OS.cmd('bin/elixir test/elixir/fixtures/at_exit.exs')
   end
 end
 
@@ -29,7 +29,7 @@ defmodule Elixir::CLI::ErrorTest do
     assert_included '** (::ErlangError) erlang error: 1',  OS.cmd('bin/elixir -e "error 1"')
 
     # It does not catch exits with integers nor strings...
-    '' = OS.cmd('bin/elixir -e "exit 1"')
+    assert_equal '', OS.cmd('bin/elixir -e "exit 1"')
   end
 end
 
@@ -46,13 +46,11 @@ defmodule Elixir::CLI::CompileTest do
   use ExUnit::Case
 
   def test_compile_code do
-    try do
-      'Compiling test/elixir/fixtures/compile_sample.exs\n' =
-        OS.cmd('bin/elixirc test/elixir/fixtures/compile_sample.exs -o test/tmp/')
-      true = File.regular?("test/tmp/::CompileSample.beam")
-    catch: :invalid, _
-    after:
-      Erlang.file.del_dir("test/tmp/")
-    end
+    assert_equal 'Compiling test/elixir/fixtures/compile_sample.exs\n',
+      OS.cmd('bin/elixirc test/elixir/fixtures/compile_sample.exs -o test/tmp/')
+    assert File.regular?("test/tmp/::CompileSample.beam")
+  catch: :invalid, _
+  after:
+    Erlang.file.del_dir("test/tmp/")
   end
-end
\ No newline at end of file
+end
diff --git a/test/elixir/elixir/errors_test.exs b/test/elixir/elixir/errors_test.exs
index a18745e025..c261d1bc97 100644
--- a/test/elixir/elixir/errors_test.exs
+++ b/test/elixir/elixir/errors_test.exs
@@ -9,139 +9,139 @@ defmodule Elixir::ErrorsTest do
   end
 
   def test_invalid_token do
-    "invalid token: \end" = format_rescue '\end'
+    assert_equal "invalid token: \end", format_rescue '\end'
   end
 
   def test_syntax_error do
-    "syntax error before: '}'" = format_rescue 'case 1 do }'
+    assert_equal "syntax error before: '}'", format_rescue 'case 1 do }'
   end
 
   def test_syntax_error_with_no_token do
-    "syntax error: expression is incomplete" = format_rescue 'case 1 do'
+    assert_equal "syntax error: expression is incomplete", format_rescue 'case 1 do'
   end
 
   def test_bad_form do
-    "function bar/0 undefined" = format_rescue 'defmodule Foo do\ndef foo, do: bar\nend'
+    assert_equal "function bar/0 undefined", format_rescue 'defmodule Foo do\ndef foo, do: bar\nend'
   end
 
   def test_unbound_var do
-    "unbound variable ^x" = format_rescue('^x = 1')
+    assert_equal "unbound variable ^x", format_rescue('^x = 1')
   end
 
   def test_unbound_not_assignment do
-    "cannot access variable ^x outside of assignment" = format_rescue('^x')
+    assert_equal "cannot access variable ^x outside of assignment", format_rescue('^x')
   end
 
   def test_unbound_expr do
-    "cannot use ^ with expression at ^x, ^ must be used only with variables" = format_rescue('^x(1)')
+    assert_equal "cannot use ^ with expression at ^x, ^ must be used only with variables", format_rescue('^x(1)')
   end
 
   def test_name_for_defmodule do
-    "invalid module name: 3" = format_rescue 'defmodule 1 + 2, do: 3'
+    assert_equal "invalid module name: 3", format_rescue 'defmodule 1 + 2, do: 3'
   end
 
   def test_invalid_scope_for_function do
-    "cannot invoke def outside module" = format_rescue 'def Foo, do: 2'
-    "cannot invoke defmacro outside module" = format_rescue '\n\ndefmacro Foo, do: 2'
+    assert_equal "cannot invoke def outside module", format_rescue 'def Foo, do: 2'
+    assert_equal "cannot invoke defmacro outside module", format_rescue '\n\ndefmacro Foo, do: 2'
   end
 
   def test_invalid_quote_args do
-    "invalid args for quote" = format_rescue 'quote 1'
+    assert_equal "invalid args for quote", format_rescue 'quote 1'
   end
 
   def test_invalid_fn_args do
-    "no block given to fn" = format_rescue 'fn 1'
+    assert_equal "no block given to fn", format_rescue 'fn 1'
   end
 
   def test_unproper_macro do
-    "key value blocks not supported by ::Elixir::ErrorsTest::UnproperMacro.unproper/1" =
+    assert_equal "key value blocks not supported by ::Elixir::ErrorsTest::UnproperMacro.unproper/1",
       format_rescue 'defmodule Foo do\nrequire Elixir::ErrorsTest::UnproperMacro\nElixir::ErrorsTest::UnproperMacro.unproper do\nmatch: 1\nmatch: 2\nend\nend'
   end
 
   def test_macro_conflict do
-    "imported ::Elixir::Builtin.defrecord/2 conflicts with local function" =
+    assert_equal "imported ::Elixir::Builtin.defrecord/2 conflicts with local function",
       format_rescue 'defmodule Foo do\ndefrecord(::Elixir::ErrorsTest::MacroConflict, a: 1)\ndef defrecord(_, _), do: OMG\nend'
   end
 
   def test_erlang_function_conflict do
-    "function exit/1 already imported from erlang" =
+    assert_equal "function exit/1 already imported from erlang",
       format_rescue 'defmodule Foo do import Elixir::ErrorsTest::UnproperMacro, only: [exit: 1]\nend'
   end
 
   def test_import_invalid_macro do
-    "cannot import ::Elixir::Builtin.invalid/1 because it doesn't exist" =
+    assert_equal "cannot import ::Elixir::Builtin.invalid/1 because it doesn't exist",
       format_rescue 'defmodule Foo do\nimport Elixir::Builtin, only: [invalid: 1]\nend'
   end
 
   def test_unrequired_macro do
-    "tried to invoke macro ::Elixir::ErrorsTest::UnproperMacro.unproper/1 but module was not required. Required: ['::Elixir::Builtin']" =
+    assert_equal "tried to invoke macro ::Elixir::ErrorsTest::UnproperMacro.unproper/1 but module was not required. Required: ['::Elixir::Builtin']",
       format_rescue 'defmodule Foo do\nElixir::ErrorsTest::UnproperMacro.unproper([])\nend'
   end
 
   def test_def_defmacro_clause_change do
-    "defmacro foo/1 already defined as def" =
+    assert_equal "defmacro foo/1 already defined as def",
       format_rescue 'defmodule Foo do\ndef foo(1), do: 1\ndefmacro foo(x), do: x\nend'
   end
 
   def test_visibility_clause_change do
-    "function foo/1 already defined with visibility public" =
+    assert_equal "function foo/1 already defined with visibility public",
       format_rescue 'defmodule Foo do\ndef foo(1), do: 1\ndefp foo(x), do: x\nend'
   end
 
   def test_clause_change do
-    "function foo/1 does not match previous clause" =
+    assert_equal "function foo/1 does not match previous clause",
       format_rescue 'defmodule Foo do\ndef foo(1), do: 1\ndef bar(x), do: x\ndef foo(x), do: x\nend'
   end
 
   def test_internal_function_overriden do
-    "function __info__/1 is internal and should not be overriden" =
+    assert_equal "function __info__/1 is internal and should not be overriden",
       format_rescue 'defmodule Foo do\ndef __info__(_), do: []\nend'
   end
 
   def test_no_macros do
-    "could not load macros from module lists" =
+    assert_equal "could not load macros from module lists",
       format_rescue 'defmodule Foo do\nimport :macros, Erlang.lists\nend'
   end
 
   def test_unloaded_module do
-    "module ::Certainly::Doesnt::Exist is not loaded, reason: nofile" =
+    assert_equal "module ::Certainly::Doesnt::Exist is not loaded, reason: nofile",
       format_rescue 'import Certainly::Doesnt::Exist'
   end
 
   def test_scheduled_module do
-    "module ::Hygiene is not loaded but was defined. This may happen because the module is nested inside another module. Try defining the module outside the context that requires it." =
+    assert_equal "module ::Hygiene is not loaded but was defined. This may happen because the module is nested inside another module. Try defining the module outside the context that requires it.",
       format_rescue 'defmodule Foo do; defmodule Hygiene do; end; import Hygiene; end'
   end
 
   def test_already_compiled_module do
-    "could not call eval_quoted on module ::Record because it was already compiled" =
+    assert_equal "could not call eval_quoted on module ::Record because it was already compiled",
       format_rescue 'Module.eval_quoted ::Record, quote(do: 1), [], __FILE__, __LINE__'
   end
 
   def test_interpolation_error do
-    "syntax error before: ')'" = format_rescue '"foo\#{case 1 do )}bar"'
+    assert_equal "syntax error before: ')'", format_rescue '"foo\#{case 1 do )}bar"'
   end
 
   def test_invalid_kv_for_match do
-    "invalid key invalid" =
+    assert_equal "invalid key invalid",
       format_rescue 'case true do\ninvalid: 2\nafter: 3\nend'
   end
 
   def test_cant_define_local_due_to_in_erlang_macros_conflict do
-    "cannot define local quote/1 because it conflicts with Elixir internal macros" =
+    assert_equal "cannot define local quote/1 because it conflicts with Elixir internal macros",
       format_rescue 'defmodule Foo do\ndef quote(x), do: x\ndef bar(x), do: quote(do: x)\nend'
   end
 
   def test_already_defined_module do
-    "module ::Record already defined" = format_rescue 'defmodule Record, do: true'
+    assert_equal "module ::Record already defined", format_rescue 'defmodule Record, do: true'
   end
 
   def test_duplicated_bitstring_size do
-    "duplicated size specifier 12 in <<>>" = format_rescue '<<1|12-12>>'
+    assert_equal "duplicated size specifier 12 in <<>>", format_rescue '<<1|12-12>>'
   end
 
   def test_invalid_bitstring_specified do
-    "invalid specifier for <<>>" = format_rescue '<<1|12-binary()>>'
+    assert_equal "invalid specifier for <<>>", format_rescue '<<1|12-binary()>>'
   end
 
   ## Helpers
@@ -156,4 +156,4 @@ defmodule Elixir::ErrorsTest do
 
     result || raise(ExUnit::AssertionError, message: "Expected function given to format_rescue to fail")
   end
-end
\ No newline at end of file
+end
diff --git a/test/elixir/enum_test.exs b/test/elixir/enum_test.exs
index 1d12c940ce..12b0f14b74 100644
--- a/test/elixir/enum_test.exs
+++ b/test/elixir/enum_test.exs
@@ -4,113 +4,113 @@ defmodule EnumTest do
   use ExUnit::Case
 
   def test_all? do
-    true  = Enum.all? [2,4,6], fn(x, do: rem(x, 2) == 0)
-    false = Enum.all? [2,3,4], fn(x, do: rem(x, 2) == 0)
+    assert Enum.all?([2,4,6], fn(x, do: rem(x, 2) == 0))
+    refute Enum.all?([2,3,4], fn(x, do: rem(x, 2) == 0))
 
-    true  = Enum.all? [2,4,6]
-    false = Enum.all? [2,nil,4]
+    assert Enum.all?([2,4,6])
+    refute Enum.all?([2,nil,4])
 
-    true  = Enum.all? []
+    assert Enum.all?([])
   end
 
   def test_any? do
-    false = Enum.any? [2,4,6], fn(x, do: rem(x, 2) == 1)
-    true  = Enum.any? [2,3,4], fn(x, do: rem(x, 2) == 1)
+    refute Enum.any?([2,4,6], fn(x, do: rem(x, 2) == 1))
+    assert Enum.any?([2,3,4], fn(x, do: rem(x, 2) == 1))
 
-    false = Enum.any? [false,false,false]
-    true  = Enum.any? [false,true,false]
+    refute Enum.any?([false,false,false])
+    assert Enum.any?([false,true,false])
 
-    false = Enum.any? []
+    refute Enum.any?([])
   end
 
   def test_detect do
-    nil = Enum.detect [2,4,6], fn(x, do: rem(x, 2) == 1)
-    0   = Enum.detect [2,4,6], 0, fn(x, do: rem(x, 2) == 1)
-    3   = Enum.detect [2,3,4], fn(x, do: rem(x, 2) == 1)
+    assert_equal nil, Enum.detect([2,4,6], fn(x, do: rem(x, 2) == 1))
+    assert_equal 0, Enum.detect([2,4,6], 0, fn(x, do: rem(x, 2) == 1))
+    assert_equal 3, Enum.detect([2,3,4], fn(x, do: rem(x, 2) == 1))
   end
 
   def test_detect_value do
-    nil  = Enum.detect_value [2,4,6], fn(x, do: rem(x, 2) == 1)
-    0    = Enum.detect_value [2,4,6], 0, fn(x, do: rem(x, 2) == 1)
-    true = Enum.detect_value [2,3,4], fn(x, do: rem(x, 2) == 1)
+    assert_equal nil, Enum.detect_value([2,4,6], fn(x, do: rem(x, 2) == 1))
+    assert_equal 0, Enum.detect_value([2,4,6], 0, fn(x, do: rem(x, 2) == 1))
+    assert Enum.detect_value([2,3,4], fn(x, do: rem(x, 2) == 1))
   end
 
   def test_empty? do
-    true  = Enum.empty? []
-    false = Enum.empty? [1,2,3]
+    assert Enum.empty?([])
+    refute Enum.empty?([1,2,3])
   end
 
   def test_each do
-    [] = Enum.each [], fn(x, do: x)
+    assert_equal [], Enum.each([], fn(x, do: x))
 
-    [1,2,3] = Enum.each [1,2,3], fn(x, do: Process.put(:enum_test_each, x * 2))
-    6 = Process.get(:enum_test_each)
+    assert_equal [1,2,3], Enum.each([1,2,3], fn(x, do: Process.put(:enum_test_each, x * 2)))
+    assert_equal 6, Process.get(:enum_test_each)
   after:
     Process.erase(:enum_test_each)
   end
 
   def test_filter do
-    [2]     = Enum.filter [1,2,3], fn(x, do: rem(x, 2) == 0)
-    [2,4,6] = Enum.filter [2,4,6], fn(x, do: rem(x, 2) == 0)
+    assert_equal [2], Enum.filter([1,2,3], fn(x, do: rem(x, 2) == 0))
+    assert_equal [2,4,6], Enum.filter([2,4,6], fn(x, do: rem(x, 2) == 0))
   end
 
   def test_foldl do
-    1 = Enum.foldl [], 1, fn(x, acc, do: x + acc)
-    7 = Enum.foldl [1,2,3], 1, fn(x, acc, do: x + acc)
+    assert_equal 1, Enum.foldl([], 1, fn(x, acc, do: x + acc))
+    assert_equal 7, Enum.foldl([1,2,3], 1, fn(x, acc, do: x + acc))
   end
 
   def test_join_with_bin do
-    ""            = Enum.join [], " = "
-    "1 = 2 = 3"   = Enum.join [1,2,3], " = "
-    "1 = {2} = 3" = Enum.join [1,{ 2 },3], " = "
+    assert_equal "", Enum.join([], " = ")
+    assert_equal "1 = 2 = 3", Enum.join([1,2,3], " = ")
+    assert_equal "1 = {2} = 3", Enum.join([1,{ 2 },3], " = ")
   end
 
   def test_join_with_list do
-    ''            = Enum.join [], ' = '
-    '1 = 2 = 3'   = Enum.join [1,2,3], ' = '
-    '1 = {2} = 3' = Enum.join [1,{ 2 },3], ' = '
+    assert_equal '', Enum.join([], ' = ')
+    assert_equal '1 = 2 = 3', Enum.join([1,2,3], ' = ')
+    assert_equal '1 = {2} = 3', Enum.join([1,{ 2 },3], ' = ')
   end
 
   def test_map do
-    [] = Enum.map [], fn(x) -> x * 2 end
-    [2,4,6] = Enum.map [1,2,3], fn(x) -> x * 2 end
+    assert_equal [], Enum.map([], fn(x) -> x * 2 end)
+    assert_equal [2,4,6], Enum.map([1,2,3], fn(x) -> x * 2 end)
   end
 
   def test_mapfoldl do
-    { [], 1 } = Enum.mapfoldl [], 1, fn(x, acc, do: { x * 2, x + acc })
-    { [2,4,6], 7 } = Enum.mapfoldl [1,2,3], 1, fn(x, acc, do: { x * 2, x + acc })
+    assert_equal { [], 1 }, Enum.mapfoldl([], 1, fn(x, acc, do: { x * 2, x + acc }))
+    assert_equal { [2,4,6], 7 }, Enum.mapfoldl([1,2,3], 1, fn(x, acc, do: { x * 2, x + acc }))
   end
 
   def test_times_with_arity_0 do
     put(:times_with_arity, nil)
-    0 = Enum.times 0, fn do: Process.put(:times_with_arity, :ok)
-    nil = Process.get(:times_with_arity)
-    3 = Enum.times 3, fn do: Process.put(:times_with_arity, :ok)
-    :ok = Process.get(:times_with_arity)
+    assert_equal 0, Enum.times(0, fn do: Process.put(:times_with_arity, :ok))
+    assert_equal nil, Process.get(:times_with_arity)
+    assert_equal 3, Enum.times(3, fn do: Process.put(:times_with_arity, :ok))
+    assert_equal :ok, Process.get(:times_with_arity)
   after:
     Process.erase(:times_with_arity)
   end
 
   def test_times_with_arity_1 do
-    5 = Enum.times 5, fn(x, do: Process.put(:times_with_arity, x))
-    5 = Process.get(:times_with_arity)
+    assert_equal 5, Enum.times(5, fn(x, do: Process.put(:times_with_arity, x)))
+    assert_equal 5, Process.get(:times_with_arity)
   after:
     Process.erase(:times_with_arity)
   end
 
   def test_times_with_arity_2 do
-    15 = Enum.times 5, 0, fn(acc, x) -> acc + x end
+    assert_equal 15, Enum.times(5, 0, fn(acc, x) -> acc + x end)
   end
 
   def test_enum_for do
-    [{1, 3}, {1, 4}, {2, 3}, {2, 4}] = Enum.__for__ [[1,2],[3,4]], fn(acc, y, x) -> [{x,y}|acc] end
+    assert_equal [{1, 3}, {1, 4}, {2, 3}, {2, 4}], Enum.__for__([[1,2],[3,4]], fn(acc, y, x) -> [{x,y}|acc] end)
   end
 
   def test_for do
-    [{1, 3}, {1, 4}, {2, 3}, {2, 4}] = for x in [1,2], y in [3,4], do: {x,y}
+    assert_equal [{1, 3}, {1, 4}, {2, 3}, {2, 4}], for x in [1,2], y in [3,4], do: {x,y}
 
     lists = [1,{1,2},2,{2,1}]
-    [{1, 3}, {1, 4}, {2, 3}, {2, 4}] = for {x,_} in lists, y in [3,4], do: {x,y}
-    [{1, 3}, {1, 4}] = for {x,_} in lists, y in [3,4], x == 1, do: {x,y}
+    assert_equal [{1, 3}, {1, 4}, {2, 3}, {2, 4}], for {x,_} in lists, y in [3,4], do: {x,y}
+    assert_equal [{1, 3}, {1, 4}], for {x,_} in lists, y in [3,4], x == 1, do: {x,y}
   end
 end
diff --git a/test/elixir/exception_test.exs b/test/elixir/exception_test.exs
index a245cbe7a6..7459df471e 100644
--- a/test/elixir/exception_test.exs
+++ b/test/elixir/exception_test.exs
@@ -4,59 +4,59 @@ defmodule Kernel::ExceptionTest do
   use ExUnit::Case
 
   def test_is_exception do
-    true  = is_exception(RuntimeError.new)
-    false = is_exception({ :foo, :bar })
+    assert is_exception(RuntimeError.new)
+    refute is_exception({ :foo, :bar })
   end
 
   def test_format_stacktrace_with_no_file_or_line do
-    "::Foo.bar(1, 2, 3)" = Exception.format_stacktrace({::Foo, :bar, [1, 2, 3], []})
-    "::Foo.bar()" = Exception.format_stacktrace({::Foo, :bar, [], []})
-    "::Foo.bar/1" = Exception.format_stacktrace({::Foo, :bar, 1, []})
+    assert_equal "::Foo.bar(1, 2, 3)", Exception.format_stacktrace({::Foo, :bar, [1, 2, 3], []})
+    assert_equal "::Foo.bar()", Exception.format_stacktrace({::Foo, :bar, [], []})
+    assert_equal "::Foo.bar/1", Exception.format_stacktrace({::Foo, :bar, 1, []})
   end
 
   def test_format_stacktrace_with_file_and_line do
-    "file.ex:10: ::Foo.bar()" = Exception.format_stacktrace({::Foo, :bar, [], [file: 'file.ex', line: 10]})
-    "file.ex:10: ::Foo.bar(1, 2, 3)" = Exception.format_stacktrace({::Foo, :bar, [1, 2, 3], [file: 'file.ex', line: 10]})
-    "file.ex:10: ::Foo.bar/1" = Exception.format_stacktrace({::Foo, :bar, 1, [file: 'file.ex', line: 10]})
+    assert_equal "file.ex:10: ::Foo.bar()", Exception.format_stacktrace({::Foo, :bar, [], [file: 'file.ex', line: 10]})
+    assert_equal "file.ex:10: ::Foo.bar(1, 2, 3)", Exception.format_stacktrace({::Foo, :bar, [1, 2, 3], [file: 'file.ex', line: 10]})
+    assert_equal "file.ex:10: ::Foo.bar/1", Exception.format_stacktrace({::Foo, :bar, 1, [file: 'file.ex', line: 10]})
   end
 
   def test_format_stacktrace_with_file_no_line do
-    "file.ex: ::Foo.bar()" = Exception.format_stacktrace({::Foo, :bar, [], [file: 'file.ex']})
-    "file.ex: ::Foo.bar(1, 2, 3)" = Exception.format_stacktrace({::Foo, :bar, [1, 2, 3], [file: 'file.ex']})
-    "file.ex: ::Foo.bar/1" = Exception.format_stacktrace({::Foo, :bar, 1, [file: 'file.ex']})
+    assert_equal "file.ex: ::Foo.bar()", Exception.format_stacktrace({::Foo, :bar, [], [file: 'file.ex']})
+    assert_equal "file.ex: ::Foo.bar(1, 2, 3)", Exception.format_stacktrace({::Foo, :bar, [1, 2, 3], [file: 'file.ex']})
+    assert_equal "file.ex: ::Foo.bar/1", Exception.format_stacktrace({::Foo, :bar, 1, [file: 'file.ex']})
   end
 
   def test_format_module_function_arity do
-    "::Foo.bar/1"   = Exception.format_module_fun_arity ::Foo, :bar, 1
-    "::Foo.bar()"   = Exception.format_module_fun_arity ::Foo, :bar, []
-    "foo:bar(1, 2)" = Exception.format_module_fun_arity :foo,  :bar, [1,2]
+    assert_equal "::Foo.bar/1", Exception.format_module_fun_arity ::Foo, :bar, 1
+    assert_equal "::Foo.bar()", Exception.format_module_fun_arity ::Foo, :bar, []
+    assert_equal "foo:bar(1, 2)", Exception.format_module_fun_arity :foo,  :bar, [1,2]
   end
 
   def test_runtime_error_message do
-    "runtime error" = RuntimeError.new.message
-    "exception"     = RuntimeError.new(message: "exception").message
+    assert_equal "runtime error", RuntimeError.new.message
+    assert_equal "exception", RuntimeError.new(message: "exception").message
   end
 
   def test_argument_error_message do
-    "argument error" = ArgumentError.new.message
-    "exception"      = ArgumentError.new(message: "exception").message
+    assert_equal "argument error", ArgumentError.new.message
+    assert_equal "exception", ArgumentError.new(message: "exception").message
   end
 
   def test_undefined_function_message do
-    "undefined function" = UndefinedFunctionError.new.message
-    "undefined function: ::Foo.bar/1" = UndefinedFunctionError.new(module: ::Foo, function: :bar, arity: 1).message
-    "undefined function: ::Foo.bar/0" = UndefinedFunctionError.new(module: ::Foo, function: :bar, arity: []).message
-    "undefined function: foo:bar/0"   = UndefinedFunctionError.new(module: :foo,  function: :bar, arity: []).message
+    assert_equal "undefined function", UndefinedFunctionError.new.message
+    assert_equal "undefined function: ::Foo.bar/1", UndefinedFunctionError.new(module: ::Foo, function: :bar, arity: 1).message
+    assert_equal "undefined function: ::Foo.bar/0", UndefinedFunctionError.new(module: ::Foo, function: :bar, arity: []).message
+    assert_equal "undefined function: foo:bar/0", UndefinedFunctionError.new(module: :foo,  function: :bar, arity: []).message
   end
 
   def test_function_clause_message do
-    "no function clause matches" = FunctionClauseError.new.message
-    "no function clause matching: ::Foo.bar/1" = FunctionClauseError.new(module: ::Foo, function: :bar, arity: 1).message
-    "no function clause matching: ::Foo.bar()" = FunctionClauseError.new(module: ::Foo, function: :bar, arity: []).message
-    "no function clause matching: foo:bar()"   = FunctionClauseError.new(module: :foo,  function: :bar, arity: []).message
+    assert_equal "no function clause matches", FunctionClauseError.new.message
+    assert_equal "no function clause matching: ::Foo.bar/1", FunctionClauseError.new(module: ::Foo, function: :bar, arity: 1).message
+    assert_equal "no function clause matching: ::Foo.bar()", FunctionClauseError.new(module: ::Foo, function: :bar, arity: []).message
+    assert_equal "no function clause matching: foo:bar()", FunctionClauseError.new(module: :foo,  function: :bar, arity: []).message
   end
 
   def test_erlang_error_message do
-    "erlang error: :sample" = ErlangError.new(original: :sample).message
+    assert_equal "erlang error: :sample", ErlangError.new(original: :sample).message
   end
-end
\ No newline at end of file
+end
diff --git a/test/elixir/exunit/escaper_test.exs b/test/elixir/exunit/escaper_test.exs
index 8a1a6cb861..4b1db4c14b 100644
--- a/test/elixir/exunit/escaper_test.exs
+++ b/test/elixir/exunit/escaper_test.exs
@@ -4,7 +4,7 @@ defmodule ExUnit::EscaperTest do
   use ExUnit::Case
 
   def test_escape do
-    escaped  = ExUnit::Escaper.escape({ :{}, 1, [2, { :_, 2, false }] })
-    "{2,_}" = inspect elem Code.eval_quoted(escaped, [], __FILE__, __LINE__), 1
+    escaped = ExUnit::Escaper.escape({ :{}, 1, [2, { :_, 2, false }] })
+    assert_equal "{2,_}", inspect elem Code.eval_quoted(escaped, [], __FILE__, __LINE__), 1
   end
-end
\ No newline at end of file
+end
diff --git a/test/elixir/file_test.exs b/test/elixir/file_test.exs
index e2942b96f2..c0c80ca1f0 100644
--- a/test/elixir/file_test.exs
+++ b/test/elixir/file_test.exs
@@ -4,19 +4,19 @@ defmodule FileTest do
   use ExUnit::Case
 
   def expand_path_test do
-    "/foo/bar" = File.expand_path("/foo/bar")
-    "/foo/bar" = File.expand_path("/foo/bar/")
-    "/foo/bar" = File.expand_path("/foo/bar/.")
-    "/foo/bar" = File.expand_path("/foo/bar/../bar")
+    assert_equal "/foo/bar", File.expand_path("/foo/bar")
+    assert_equal "/foo/bar", File.expand_path("/foo/bar/")
+    assert_equal "/foo/bar", File.expand_path("/foo/bar/.")
+    assert_equal "/foo/bar", File.expand_path("/foo/bar/../bar")
 
-    "/foo/bar" = File.expand_path("bar", "/foo")
-    "/foo/bar" = File.expand_path("bar/", "/foo")
-    "/foo/bar" = File.expand_path("bar/.", "/foo")
-    "/foo/bar" = File.expand_path("bar/../bar", "/foo")
-    "/bar" = File.expand_path("../bar/../bar", "/foo/../foo/../foo")
+    assert_equal "/foo/bar", File.expand_path("bar", "/foo")
+    assert_equal "/foo/bar", File.expand_path("bar/", "/foo")
+    assert_equal "/foo/bar", File.expand_path("bar/.", "/foo")
+    assert_equal "/foo/bar", File.expand_path("bar/../bar", "/foo")
+    assert_equal "/bar", File.expand_path("../bar/../bar", "/foo/../foo/../foo")
 
     full  = File.expand_path("foo/bar")
-    ^full = File.expand_path("bar/../bar", "foo")
+    assert_equal full, File.expand_path("bar/../bar", "foo")
   end
 
   # def join_test
@@ -31,7 +31,7 @@ defmodule FileTest do
   # end
 
   def regular_test do
-    true  = File.regular?(__FILE__)
-    false = File.regular?("#{__FILE__}.unknown")
+    assert File.regular?(__FILE__)
+    refute File.regular?("#{__FILE__}.unknown")
   end
-end
\ No newline at end of file
+end
diff --git a/test/elixir/kernel/comprehension_test.exs b/test/elixir/kernel/comprehension_test.exs
index 47891cf76f..8e3fcc48fe 100644
--- a/test/elixir/kernel/comprehension_test.exs
+++ b/test/elixir/kernel/comprehension_test.exs
@@ -4,80 +4,84 @@ defmodule Kernel::ComprehensionTest do
   use ExUnit::Case
 
   def test_list_comprehensions do
-    [4] = lc x in [1,2,3], rem(x, 2) == 0, do: x * 2
+    assert_equal [4], lc x in [1,2,3], rem(x, 2) == 0, do: x * 2
   end
 
   def test_list_comprehensions_with_nil do
-    [] = lc x in [1,2,3], nilly, do: x * 2
+    assert_equal [], lc x in [1,2,3], nilly, do: x * 2
   end
 
   def test_list_comprehensions_with_truthy_object do
-    [2,4,6] = lc x in [1,2,3], 1, do: x * 2
+    assert_equal [2,4,6], lc x in [1,2,3], 1, do: x * 2
   end
 
   def test_list_comprehensions_with_inlist do
-    [2,4,6] = lc inlist(x, [1,2,3]), do: x * 2
+    assert_equal [2,4,6], lc inlist(x, [1,2,3]), do: x * 2
   end
 
   def test_list_comprehensions_with_inlist_of_bins do
-    [2,4,6] = lc inlist(<<x>>, [<<1>>,<<2>>,<<3>>]), do: x * 2
+    assert_equal [2,4,6], lc inlist(<<x>>, [<<1>>,<<2>>,<<3>>]), do: x * 2
   end
 
   def test_list_comprehensions_with_implicit_inbin do
-    [2,4,6] = lc <<x>> in <<1,2,3>>, do: x * 2
+    assert_equal [2,4,6], lc <<x>> in <<1,2,3>>, do: x * 2
   end
 
   def test_list_comprehensions_with_explicit_inbin do
-    [2,4,6] = lc inbin(<<x>>, <<1,2,3>>), do: x * 2
+    assert_equal [2,4,6], lc inbin(<<x>>, <<1,2,3>>), do: x * 2
   end
 
   def test_list_comprehensions_with_two_generators do
-    [4, 5, 6, 8, 10, 12, 12, 15, 18] = lc x in [1,2,3], y in [4,5,6], do: x * y
+    assert_equal [4, 5, 6, 8, 10, 12, 12, 15, 18], lc x in [1,2,3], y in [4,5,6], do: x * y
   end
 
   def test_list_comprehension_multiline do
-    [2,4,6] = lc x in [1,2,3] do
+    result = lc x in [1,2,3] do
       x * 2
     end
+
+    assert_equal [2,4,6], result
   end
 
   def test_bin_comprehensions do
-    <<4>> = bc x in [1,2,3], rem(x, 2) == 0, do: <<x * 2>>
+    assert_equal <<4>>, bc x in [1,2,3], rem(x, 2) == 0, do: <<x * 2>>
   end
 
   def test_bin_comprehensions_with_nil do
-    <<>> = bc x in [1,2,3], nilly, do: <<x * 2>>
+    assert_equal <<>>, bc x in [1,2,3], nilly, do: <<x * 2>>
   end
 
   def test_bin_comprehensions_with_truthy_object do
-    <<2,4,6>> = bc x in [1,2,3], 1, do: <<x * 2>>
+    assert_equal <<2,4,6>>, bc x in [1,2,3], 1, do: <<x * 2>>
   end
 
   def test_bin_comprehensions_with_inlist do
-    <<2,4,6>> = bc inlist(x, [1,2,3]), do: <<x * 2>>
+    assert_equal <<2,4,6>>, bc inlist(x, [1,2,3]), do: <<x * 2>>
   end
 
   def test_bin_comprehensions_with_inlist_of_bins do
-    <<2,4,6>> = bc inlist(<<x>>, [<<1>>,<<2>>,<<3>>]), do: <<x * 2>>
+    assert_equal <<2,4,6>>, bc inlist(<<x>>, [<<1>>,<<2>>,<<3>>]), do: <<x * 2>>
   end
 
   def test_bin_comprehensions_with_implicit_inbin do
-    <<2,4,6>> = bc <<x>> in <<1,2,3>>, do: <<x * 2>>
+    assert_equal <<2,4,6>>, bc <<x>> in <<1,2,3>>, do: <<x * 2>>
   end
 
   def test_bin_comprehensions_with_explicit_inbin do
-    <<2,4,6>> = bc inbin(<<x>>, <<1,2,3>>), do: <<x * 2>>
+    assert_equal <<2,4,6>>, bc inbin(<<x>>, <<1,2,3>>), do: <<x * 2>>
   end
 
   def test_bin_comprehensions_with_two_generators do
-    <<4, 5, 6, 8, 10, 12, 12, 15, 18>> = bc x in [1,2,3], y in [4,5,6], do: <<x*y>>
+    assert_equal <<4, 5, 6, 8, 10, 12, 12, 15, 18>>, bc x in [1,2,3], y in [4,5,6], do: <<x*y>>
   end
 
   def test_bin_comprehension_multiline do
-    <<2,4,6>> = bc x in [1,2,3] do
+    result = bc x in [1,2,3] do
       <<x * 2>>
     end
+
+    assert_equal <<2,4,6>>, result
   end
 
   defp nilly, do: nil
-end
\ No newline at end of file
+end
diff --git a/test/elixir/kernel/import_test.exs b/test/elixir/kernel/import_test.exs
index cc05dfb92d..fa15444b7c 100644
--- a/test/elixir/kernel/import_test.exs
+++ b/test/elixir/kernel/import_test.exs
@@ -6,7 +6,7 @@ defmodule Kernel::ImportOnlyTest do
   import Erlang.lists, only: [flatten: 1]
 
   def test_import_erlang do
-    [1,2,3] = flatten [1,[2],3]
+    assert_equal [1,2,3], flatten [1,[2],3]
   end
 end
 
@@ -16,7 +16,7 @@ defmodule Kernel::ImportAllTest do
   import Erlang.lists
 
   def test_import_erlang do
-    [1,2,3] = flatten [1,[2],3]
+    assert_equal [1,2,3], flatten [1,[2],3]
   end
 end
 
@@ -26,7 +26,7 @@ defmodule Kernel::ImportExceptTest do
   import Erlang.lists, except: [each: 1]
 
   def test_import_erlang do
-    [1,2,3] = flatten [1,[2],3]
+    assert_equal [1,2,3], flatten [1,[2],3]
   end
 end
 
@@ -41,23 +41,23 @@ defmodule Kernel::ImportMacrosTest do
   import :macros, Bitwise
 
   def test_import_true do
-    1  = band(1, 1)
-    1  = bor(0, 1)
-    -1 = bnot(0)
+    assert_equal 1, band(1, 1)
+    assert_equal 1, bor(0, 1)
+    assert_equal -1, bnot(0)
   end
 
   def test_function_import_with_only do
     import :macros, Bitwise, except: [bnot: 1]
     import :macros, Kernel::MessedBitwise, only: [bnot: 1]
-    0 = bnot(0)
-    1 = bor(0, 1)
+    assert_equal 0, bnot(0)
+    assert_equal 1, bor(0, 1)
   end
 
   # This test is asserting that the requires done
   # inside the function do not affect outer ones.
   def test_import_true_not_affected do
-    1  = band(1, 1)
-    1  = bor(0, 1)
-    -1 = bnot(0)
+    assert_equal 1 , band(1, 1)
+    assert_equal 1 , bor(0, 1)
+    assert_equal -1, bnot(0)
   end
-end
\ No newline at end of file
+end
diff --git a/test/elixir/kernel/loop_test.exs b/test/elixir/kernel/loop_test.exs
index 72ad0e195d..294fd8f62f 100644
--- a/test/elixir/kernel/loop_test.exs
+++ b/test/elixir/kernel/loop_test.exs
@@ -6,12 +6,14 @@ defmodule Kernel::LoopTest do
   def test_do_loop do
     list = [1,2,3]
 
-    [6,4,2] = loop list, [] do
+    result = loop list, [] do
     match: [h|t], acc
       recur t, [h*2|acc]
     match: [], acc
       acc
     end
+
+    assert_equal [6,4,2], result
   end
 
   def test_do_loop_base do
@@ -22,7 +24,7 @@ defmodule Kernel::LoopTest do
       2
     end
 
-    1 = fun.({ 1, 2 }, [])
-    2 = fun.([], [])
+    assert_equal 1, fun.({ 1, 2 }, [])
+    assert_equal 2, fun.([], [])
   end
-end
\ No newline at end of file
+end
diff --git a/test/elixir/kernel/partial_application_test.exs b/test/elixir/kernel/partial_application_test.exs
index 2f4ed3e54c..e094b1119e 100644
--- a/test/elixir/kernel/partial_application_test.exs
+++ b/test/elixir/kernel/partial_application_test.exs
@@ -5,57 +5,57 @@ defmodule Kernel::PartialApplicationTest do
 
   def test_partial_with_simple_call_and_one_item do
     fun = minus(10, _)
-    5 = fun.(5)
-    7 = fun.(3)
+    assert_equal 5, fun.(5)
+    assert_equal 7, fun.(3)
   end
 
   def test_partial_with_simple_call_and_all_items do
     fun = minus(_, _)
-    5 = fun.(10, 5)
-    7 = fun.(13, 6)
+    assert_equal 5, fun.(10, 5)
+    assert_equal 7, fun.(13, 6)
   end
 
   def test_partial_with_atom_call_and_one_item do
     fun = :minus.(10, _)
-    5 = fun.(5)
-    7 = fun.(3)
+    assert_equal 5, fun.(5)
+    assert_equal 7, fun.(3)
   end
 
   def test_partial_with_funcall_and_one_item do
     fun = minus(_, _)
     fun = fun.(10, _)
-    5 = fun.(5)
-    7 = fun.(3)
+    assert_equal 5, fun.(5)
+    assert_equal 7, fun.(3)
   end
 
   def test_partial_with_funcall_and_all_items do
     fun = minus(_, _)
     fun = fun.(_, _)
-    5 = fun.(10, 5)
-    7 = fun.(13, 6)
+    assert_equal 5, fun.(10, 5)
+    assert_equal 7, fun.(13, 6)
   end
 
   def test_partial_with_internal_macro do
     fun = if(_, do: 1, else: 2)
-    1 = fun.(20)
-    2 = fun.(nil)
+    assert_equal 1, fun.(20)
+    assert_equal 2, fun.(nil)
   end
 
   def test_partial_application_for_module_calls do
     fun = List.reverse(_)
-    [3,2,1] = fun.([1,2,3])
+    assert_equal [3,2,1], fun.([1,2,3])
   end
 
   def test_partial_application_for_operator do
-    [2,4,6] = Enum.map [1,2,3], _ * 2
+    assert_equal [2,4,6], Enum.map [1,2,3], _ * 2
   end
 
   def test_partial_application_for_const_op do
     fun = Foo::_
-    ::Foo::Bar = fun.(Bar)
+    assert_equal ::Foo::Bar, fun.(Bar)
   end
 
   defp minus(x, y) do
     x - y
   end
-end
\ No newline at end of file
+end
diff --git a/test/elixir/kernel/quote_test.exs b/test/elixir/kernel/quote_test.exs
index ad0ec6520b..0f64d9467e 100644
--- a/test/elixir/kernel/quote_test.exs
+++ b/test/elixir/kernel/quote_test.exs
@@ -21,16 +21,16 @@ defmodule Kernel::QuoteTest do
   def test_no_interference do
     a = 10
     no_interference
-    10 = a
+    assert_equal 10, a
   end
 
   def test_write_interference do
     write_interference
-    1 = a
+    assert_equal 1, a
   end
 
   def test_read_interference do
     a = 10
     read_interference
   end
-end
\ No newline at end of file
+end
diff --git a/test/elixir/kernel/require_test.exs b/test/elixir/kernel/require_test.exs
index b2aec36700..c69a05d3f2 100644
--- a/test/elixir/kernel/require_test.exs
+++ b/test/elixir/kernel/require_test.exs
@@ -9,22 +9,24 @@ defmodule Kernel::RequireTest do
 
   def test_require_erlang do
     require Erlang.lists, as: MyList
-    [1,2,3] = MyList.flatten([1,[2],3])
-    :"::MyList::Bar" = ::MyList::Bar
-    :"::lists::Bar" = MyList::Bar
+    assert_equal [1,2,3], MyList.flatten([1,[2],3])
+    assert_equal :"::MyList::Bar", ::MyList::Bar
+    assert_equal :"::lists::Bar", MyList::Bar
   end
 
   def test_require_with_one_arg do
     require Kernel::RequireTest::Nested
-    1 = Nested.value
+    assert_equal 1, Nested.value
   end
 
   def test_default_required do
-    true = Elixir::Builtin.case 1 do
+    result = Elixir::Builtin.case 1 do
     match: 1
       true
     else:
       false
     end
+
+    assert result
   end
-end
\ No newline at end of file
+end
diff --git a/test/elixir/kernel/rescue_test.exs b/test/elixir/kernel/rescue_test.exs
index 9eb8c80bd1..de939f5a55 100644
--- a/test/elixir/kernel/rescue_test.exs
+++ b/test/elixir/kernel/rescue_test.exs
@@ -4,25 +4,29 @@ defmodule Kernel::RescueTest do
   use ExUnit::Case
 
   def test_rescue_with_underscore_no_exception do
-    true = try do
+    result = try do
       RescueUndefinedModule.go
     rescue: _
       true
     end
+
+    assert result
   end
 
   def test_rescue_with_higher_precedence_than_catch do
-    true = try do
+    result = try do
       RescueUndefinedModule.go
     catch: _, _
       false
     rescue: _
       true
     end
+
+    assert result
   end
 
   def test_rescue_runtime_error do
-    true = try do
+    result = try do
       raise "an exception"
     rescue: RuntimeError
       true
@@ -30,161 +34,197 @@ defmodule Kernel::RescueTest do
       false
     end
 
-    false = try do
+    assert result
+
+    result = try do
       raise "an exception"
     rescue: AnotherError
       true
     catch: :error, _
       false
     end
+
+    refute result
   end
 
   def test_rescue_named_runtime_error do
-    "an exception" = try do
+    result = try do
       raise "an exception"
     rescue: x in [RuntimeError]
       x.message
     catch: :error, _
       false
     end
+
+    assert_equal "an exception", result
   end
 
   def test_rescue_named_with_underscore do
-    "an exception" = try do
+    result = try do
       raise "an exception"
     rescue: x in _
       x.message
     end
+
+    assert_equal "an exception", result
   end
 
   def test_rescue_defined_variable do
     expected = RuntimeError
 
-    true = try do
+    result = try do
       raise "an exception"
     rescue: ^expected
       true
     catch: :error, _
       false
     end
+
+    assert result
   end
 
   def test_rescue_named_defined_variable do
     expected = RuntimeError
 
-    "an exception" = try do
+    result = try do
       raise RuntimeError, message: "an exception"
     rescue: x in [expected, AnotherError]
       x.message
     catch: :error, _
       false
     end
+
+    assert_equal "an exception", result
   end
 
   def test_wrap_custom_erlang_error do
-    "erlang error: :sample" = try do
+    result = try do
       error(:sample)
     rescue: x in [RuntimeError, ErlangError]
       x.message
     end
+
+    assert_equal "erlang error: :sample", result
   end
 
   def test_undefined_function_error do
-    "undefined function: ::DoNotExist.for_sure/0" = try do
+    result = try do
       DoNotExist.for_sure()
     rescue: x in [UndefinedFunctionError]
       x.message
     end
+
+    assert_equal "undefined function: ::DoNotExist.for_sure/0", result
   end
 
   def test_function_clause_error do
-    "no function clause matching: ::Kernel::RescueTest.zero(1)" = try do
+    result = try do
       zero(1)
     rescue: x in [FunctionClauseError]
       x.message
     end
+
+    assert_equal "no function clause matching: ::Kernel::RescueTest.zero(1)", result
   end
 
   def test_badarg_error do
-    "argument error" = try do
+    result = try do
       error(:badarg)
     rescue: x in [ArgumentError]
       x.message
     end
+
+    assert_equal "argument error", result
   end
 
   def test_tuple_badarg_error do
-    "argument error: [1,2,3]" = try do
+    result = try do
       error({ :badarg, [1,2,3] })
     rescue: x in [ArgumentError]
       x.message
     end
+
+    assert_equal "argument error: [1,2,3]", result
   end
 
   def test_badarith_error do
-    "bad argument in arithmetic expression" = try do
+    result = try do
       error(:badarith)
     rescue: x in [ArithmeticError]
       x.message
     end
+
+    assert_equal "bad argument in arithmetic expression", result
   end
 
   def test_badarity_error do
     fun    = fn(x, do: x)
     string = "bad arity error: #{inspect(fun)} called with [1,2]"
 
-    ^string = try do
+    result = try do
       fun.(1,2)
     rescue: x in [BadArityError]
       x.message
     end
+
+    assert_equal string, result
   end
 
   def test_badfun_error do
     x = :example
-    "bad function: :example" = try do
+    result = try do
       x.(2)
     rescue: x in [BadFunctionError]
       x.message
     end
+
+    assert_equal "bad function: :example", result
   end
 
   def test_badmatch_error do
     x = :example
-    "no match of right hand side value: :other" = try do
+    result = try do
       ^x = :other
     rescue: x in [MatchError]
       x.message
     end
+
+    assert_equal "no match of right hand side value: :other", result
   end
 
   def test_case_clause_error do
     x = :example
-    "no case clause matching: :other" = try do
+    result = try do
       case :other do
       match: ^x
       end
     rescue: x in [CaseClauseError]
       x.message
     end
+
+    assert_equal "no case clause matching: :other", result
   end
 
   def test_undefined_function_error_from_expected_variable do
     expected = UndefinedFunctionError
-    "undefined function: ::DoNotExist.for_sure/0" = try do
+    result = try do
       DoNotExist.for_sure()
     rescue: x in [expected]
       x.message
     end
+
+    assert_equal "undefined function: ::DoNotExist.for_sure/0", result
   end
 
   def test_undefined_function_error_as_erlang_error do
-    "undefined function: ::DoNotExist.for_sure/0" = try do
+    result = try do
       DoNotExist.for_sure()
     rescue: x in [ErlangError]
       x.message
     end
+
+    assert_equal "undefined function: ::DoNotExist.for_sure/0", result
   end
 
   defp zero(0), do: 0
-end
\ No newline at end of file
+end
diff --git a/test/elixir/list/inspect_test.exs b/test/elixir/list/inspect_test.exs
index 027db0d327..56ca3b70b5 100644
--- a/test/elixir/list/inspect_test.exs
+++ b/test/elixir/list/inspect_test.exs
@@ -4,7 +4,7 @@ defmodule List::Inspect::AtomTest do
   use ExUnit::Case
 
   def test_basic do
-    'foo' = to_char_list(:foo)
+    assert_equal 'foo', to_char_list(:foo)
   end
 end
 
@@ -12,7 +12,7 @@ defmodule List::Inspect::BitStringTest do
   use ExUnit::Case
 
   def test_basic do
-    'foo' = to_char_list("foo")
+    assert_equal 'foo', to_char_list("foo")
   end
 end
 
@@ -20,7 +20,7 @@ defmodule List::Inspect::TupleTest do
   use ExUnit::Case
 
   def test_basic do
-    [1, "b", 3] = to_char_list({ 1, "b", 3 })
+    assert_equal [1, "b", 3], to_char_list({ 1, "b", 3 })
   end
 end
 
@@ -28,6 +28,6 @@ defmodule List::Inspect::ListTest do
   use ExUnit::Case
 
   def test_basic do
-    [1, "b", 3] = to_char_list([ 1, "b", 3 ])
+    assert_equal [1, "b", 3], to_char_list([ 1, "b", 3 ])
   end
 end
diff --git a/test/elixir/list_test.exs b/test/elixir/list_test.exs
index 71c0adf3ca..21fda14407 100644
--- a/test/elixir/list_test.exs
+++ b/test/elixir/list_test.exs
@@ -4,48 +4,48 @@ defmodule ListTest do
   use ExUnit::Case
 
   def test_brackets_function do
-    [1,2,3] = :[].(1,2,3)
+    assert_equal [1,2,3], :[].(1,2,3)
   end
 
   def test_flatten do
-    [1,2,3] = List.flatten([1,2,3])
-    [1,2,3] = List.flatten([1,[2],3])
-    [1,2,3] = List.flatten([[1,[2],3]])
+    assert_equal [1,2,3], List.flatten([1,2,3])
+    assert_equal [1,2,3], List.flatten([1,[2],3])
+    assert_equal [1,2,3], List.flatten([[1,[2],3]])
 
-    [] = List.flatten([])
-    [] = List.flatten([[]])
+    assert_equal [], List.flatten([])
+    assert_equal [], List.flatten([[]])
   end
 
   def test_flatten_with_tail do
-    [1,2,3,4,5] = List.flatten([1,2,3], [4,5])
-    [1,2,3,4,5] = List.flatten([1,[2],3], [4,5])
-    [1,2,3,4,5] = List.flatten([[1,[2],3]], [4,5])
+    assert_equal [1,2,3,4,5], List.flatten([1,2,3], [4,5])
+    assert_equal [1,2,3,4,5], List.flatten([1,[2],3], [4,5])
+    assert_equal [1,2,3,4,5], List.flatten([[1,[2],3]], [4,5])
   end
 
   def test_member? do
-    true  = List.member? [1,2,3], 1
-    false = List.member? [1,2,3], 0
-    false = List.member? [], 0
+    assert List.member? [1,2,3], 1
+    refute List.member? [1,2,3], 0
+    refute List.member? [], 0
   end
 
   def test_seq do
-    [1,2,3] = List.seq(1,3)
-    [1]     = List.seq(1,1)
+    assert_equal [1,2,3], List.seq(1,3)
+    assert_equal [1], List.seq(1,1)
   end
 
   def test_append_1 do
-    [1,[2],3,4,5,6] = List.append [[1,[2],3], [4], [5,6]]
+    assert_equal [1,[2],3,4,5,6], List.append [[1,[2],3], [4], [5,6]]
   end
 
   def test_append_2 do
-    [1,[2],3,4,5] = List.append [1,[2],3], [4,5]
+    assert_equal [1,[2],3,4,5], List.append [1,[2],3], [4,5]
   end
 
   def test_reverse do
-    [3,2,1] = List.reverse [1,2,3]
+    assert_equal [3,2,1], List.reverse [1,2,3]
   end
 
   def test_uniq do
-    [1,2,3] = List.uniq [1,2,3,2,1]
+    assert_equal [1,2,3], List.uniq [1,2,3,2,1]
   end
-end
\ No newline at end of file
+end
diff --git a/test/elixir/module_test.exs b/test/elixir/module_test.exs
index 88dc4daad0..a0fb110c12 100644
--- a/test/elixir/module_test.exs
+++ b/test/elixir/module_test.exs
@@ -60,16 +60,16 @@ defmodule ModuleTest do
   Module.merge_data __MODULE__, other_value: 2
 
   def test_eval_quoted do
-    { ::ModuleTest, "sample.ex", 13 } = eval_quoted_info()
+    assert_equal { ::ModuleTest, "sample.ex", 13 }, eval_quoted_info()
   end
 
   def test_line_from_macro do
-    30 = ModuleTest::ToUse.line
+    assert_equal 30, ModuleTest::ToUse.line
   end
 
   def test___MODULE__ do
     __MODULE__ = :"::ModuleTest"
-    :"::ModuleTest" = __MODULE__
+    assert_equal :"::ModuleTest", __MODULE__
   end
 
   def test_merge_data do
@@ -77,24 +77,24 @@ defmodule ModuleTest do
   end
 
   def test_compile_callback_hook do
-    1     = ModuleTest::ToUse.value(1)
-    false = ModuleTest::ToUse.original_value
-    true  = Orddict.get ModuleTest::ToUse.__info__(:data), :has_callback, false
+    assert ModuleTest::ToUse.value(1)
+    refute ModuleTest::ToUse.original_value
+    assert Orddict.get ModuleTest::ToUse.__info__(:data), :has_callback, false
   end
 
   def test_default_compile_callback_hook do
-    true  = Orddict.get ModuleTest::ToUse.__info__(:data), :compiling, false
+    assert Orddict.get ModuleTest::ToUse.__info__(:data), :compiling, false
   end
 
   def test_reserved_attributes do
-    {:behavior,[:gen_server]} = :lists.keyfind(:behavior, 1, Elixir::Server.__info__(:attributes))
+    assert_equal {:behavior,[:gen_server]}, :lists.keyfind(:behavior, 1, Elixir::Server.__info__(:attributes))
   end
 
   def test_registered_attributes do
-    {:register_example,[:it_works]} = :lists.keyfind(:register_example, 1, __MODULE__.__info__(:attributes))
+    assert_equal {:register_example,[:it_works]}, :lists.keyfind(:register_example, 1, __MODULE__.__info__(:attributes))
   end
 
   def test_duplicated_attributes do
     [{:vsn,_},{:foo,[1]},{:foo,[2]},{:foo,[3]}] = ModuleTest::DuplicateAttribute.__info__(:attributes)
   end
-end
\ No newline at end of file
+end
diff --git a/test/elixir/orddict_test.exs b/test/elixir/orddict_test.exs
index 442dfa3f94..6f82c9899c 100644
--- a/test/elixir/orddict_test.exs
+++ b/test/elixir/orddict_test.exs
@@ -4,44 +4,44 @@ defmodule OrddictTest do
   use ExUnit::Case
 
   def test_from_enum do
-    [first_key: 1, second_key: 2] = Orddict.from_enum([{:second_key, 2}, {:first_key, 1}])
+    assert_equal [first_key: 1, second_key: 2], Orddict.from_enum([{:second_key, 2}, {:first_key, 1}])
   end
 
   def test_fetch do
-    1         = Orddict.get(create_dict, :first_key)
-    2         = Orddict.get(create_dict, :second_key)
-    nil       = Orddict.get(create_dict, :other_key)
-    "default" = Orddict.get(create_empty_dict, :first_key, "default")
+    assert_equal 1, Orddict.get(create_dict, :first_key)
+    assert_equal 2, Orddict.get(create_dict, :second_key)
+    assert_equal nil, Orddict.get(create_dict, :other_key)
+    assert_equal "default", Orddict.get(create_empty_dict, :first_key, "default")
   end
 
   def test_keys do
-    [:first_key, :second_key] = Orddict.keys(create_dict)
-    []                        = Orddict.keys(create_empty_dict)
+    assert_equal [:first_key, :second_key], Orddict.keys(create_dict)
+    assert_equal [], Orddict.keys(create_empty_dict)
   end
 
   def test_values do
-    [1, 2] = Orddict.values(create_dict)
-    []     = Orddict.values(create_empty_dict)
+    assert_equal [1, 2], Orddict.values(create_dict)
+    assert_equal [], Orddict.values(create_empty_dict)
   end
 
   def test_delete do
-    [first_key: 1]                = Orddict.delete(create_dict, :second_key)
-    [first_key: 1, second_key: 2] = Orddict.delete(create_dict, :other_key)
-    [] = Orddict.delete(create_empty_dict, :other_key)
+    assert_equal [first_key: 1], Orddict.delete(create_dict, :second_key)
+    assert_equal [first_key: 1, second_key: 2], Orddict.delete(create_dict, :other_key)
+    assert_equal [], Orddict.delete(create_empty_dict, :other_key)
   end
 
   def test_store do
-    [first_key: 1]                = Orddict.set(create_empty_dict, :first_key, 1)
-    [first_key: 1, second_key: 2] = Orddict.set(create_dict, :first_key, 1)
+    assert_equal [first_key: 1], Orddict.set(create_empty_dict, :first_key, 1)
+    assert_equal [first_key: 1, second_key: 2], Orddict.set(create_dict, :first_key, 1)
   end
 
   def test_merge do
-    [first_key: 1, second_key: 2] = Orddict.merge(create_empty_dict, create_dict)
-    [first_key: 1, second_key: 2] = Orddict.merge(create_dict, create_empty_dict)
-    [first_key: 1, second_key: 2] = Orddict.merge(create_dict, create_dict)
-    [] = Orddict.merge(create_empty_dict, create_empty_dict)
+    assert_equal [first_key: 1, second_key: 2], Orddict.merge(create_empty_dict, create_dict)
+    assert_equal [first_key: 1, second_key: 2], Orddict.merge(create_dict, create_empty_dict)
+    assert_equal [first_key: 1, second_key: 2], Orddict.merge(create_dict, create_dict)
+    assert_equal [], Orddict.merge(create_empty_dict, create_empty_dict)
   end
 
   defp create_empty_dict, do: create_dict([])
   defp create_dict(list // [first_key: 1, second_key: 2]), do: Orddict.from_enum(list)
-end
\ No newline at end of file
+end
diff --git a/test/elixir/protocol_test.exs b/test/elixir/protocol_test.exs
index e609c097f3..7d3db98563 100644
--- a/test/elixir/protocol_test.exs
+++ b/test/elixir/protocol_test.exs
@@ -73,7 +73,7 @@ defmodule ProtocolTest do
   # Assert that the given protocol is going to be dispatched.
   defp assert_protocol_for(target, impl, thing) do
     joined  = target::impl
-    ^joined = target.__protocol_for__ thing
+    assert_equal joined, target.__protocol_for__ thing
   end
 
   # Dispatch `blank(thing)` to the given `target`
@@ -95,4 +95,4 @@ defmodule ProtocolTest do
       end
     end
   end
-end
\ No newline at end of file
+end
diff --git a/test/elixir/record_test.exs b/test/elixir/record_test.exs
index fc046a2d51..ae33837506 100644
--- a/test/elixir/record_test.exs
+++ b/test/elixir/record_test.exs
@@ -11,27 +11,27 @@ defmodule RecordTest do
 
   def test_record_constructor_with_dict do
     record   = RecordTest::FileInfo.new(type: :regular)
-    :regular = record.type
-    nil      = record.access
+    assert_equal :regular, record.type
+    assert_equal nil, record.access
   end
 
   def test_record_accessors do
     record = RecordTest::FileInfo.new(file_info)
-    :regular    = record.type
-    :read_write = record.access
+    assert_equal :regular, record.type
+    assert_equal :read_write, record.access
 
     new_record = record.access :read
-    :read = new_record.access
+    assert_equal :read, new_record.access
   end
 
   def test_dynamic_record_name do
     record = RecordTest::DynamicName.new
-    0 = record.a
-    1 = record.b
+    assert_equal 0, record.a
+    assert_equal 1, record.b
   end
 
   defp file_info do
     { :ok, file_info } = Erlang.file.read_file_info(__FILE__)
     file_info
   end
-end
\ No newline at end of file
+end
diff --git a/test/elixir/string/inspect_test.exs b/test/elixir/string/inspect_test.exs
index 5a5e880d27..6b7340cc4d 100644
--- a/test/elixir/string/inspect_test.exs
+++ b/test/elixir/string/inspect_test.exs
@@ -4,39 +4,39 @@ defmodule String::Inspect::AtomTest do
   use ExUnit::Case
 
   def test_basic do
-    ":foo" = inspect(:foo)
-    "foo"  = to_binary(:foo)
+    assert_equal ":foo", inspect(:foo)
+    assert_equal "foo", to_binary(:foo)
   end
 
   def test_empty do
-    ":\"\"" = inspect(:"")
-    ""     = to_binary(:"")
+    assert_equal ":\"\"", inspect(:"")
+    assert_equal "", to_binary(:"")
   end
 
   def test_true_false_nil do
-    "false" = inspect(false)
-    "true"  = inspect(true)
-    "nil"   = inspect(nil)
+    assert_equal "false", inspect(false)
+    assert_equal "true", inspect(true)
+    assert_equal "nil", inspect(nil)
 
-    "false" = to_binary(false)
-    "true"  = to_binary(true)
-    ""      = to_binary(nil)
+    assert_equal "false", to_binary(false)
+    assert_equal "true", to_binary(true)
+    assert_equal "", to_binary(nil)
   end
 
   def test_with_uppercase do
-    ":fOO" = inspect(:fOO)
-    "fOO"  = to_binary(:fOO)
-    ":FOO" = inspect(:FOO)
-    "FOO"  = to_binary(:FOO)
+    assert_equal ":fOO", inspect(:fOO)
+    assert_equal "fOO", to_binary(:fOO)
+    assert_equal ":FOO", inspect(:FOO)
+    assert_equal "FOO", to_binary(:FOO)
   end
 
   def test_reference_atom do
-    "::Foo::Bar" = inspect(::Foo::Bar)
-    "::Foo::Bar" = to_binary(::Foo::Bar)
+    assert_equal "::Foo::Bar", inspect(::Foo::Bar)
+    assert_equal "::Foo::Bar", to_binary(::Foo::Bar)
   end
 
   def test_impl do
-    String::Inspect = String::Inspect::Atom.__impl__
+    assert_equal String::Inspect, String::Inspect::Atom.__impl__
   end
 end
 
@@ -44,27 +44,27 @@ defmodule String::Inspect::BitStringTest do
   use ExUnit::Case
 
   def test_bitstring do
-    "<<0,1|4>>" = inspect(<<1|12-integer-signed>>)
-    "<<0,1|4>>" = to_binary(<<1|12-integer-signed>>)
+    assert_equal "<<0,1|4>>", inspect(<<1|12-integer-signed>>)
+    assert_equal "<<0,1|4>>", to_binary(<<1|12-integer-signed>>)
   end
 
   def test_binary do
-    "\"foo\"" = inspect("foo")
-    "foo"     = to_binary("foo")
+    assert_equal "\"foo\"", inspect("foo")
+    assert_equal "foo", to_binary("foo")
 
-    "\"abc\"" = inspect(<<?a, ?b, ?c>>)
-    "abc"     = to_binary(<<?a, ?b, ?c>>)
+    assert_equal "\"abc\"", inspect(<<?a, ?b, ?c>>)
+    assert_equal "abc", to_binary(<<?a, ?b, ?c>>)
 
-    "我今天要学习." = to_binary("我今天要学习.")
+    assert_equal "我今天要学习.", to_binary("我今天要学习.")
   end
 
   def test_escape do
-    "\"f\\no\""  = inspect("f\no")
-    "\"f\\\\o\"" = inspect("f\\o")
+    assert_equal "\"f\\no\"" , inspect("f\no")
+    assert_equal "\"f\\\\o\"", inspect("f\\o")
   end
 
   def test_unprintable do
-    "<<1>>" = inspect(<<1>>)
+    assert_equal "<<1>>", inspect(<<1>>)
   end
 end
 
@@ -72,19 +72,19 @@ defmodule String::Inspect::NumberTest do
   use ExUnit::Case
 
   def test_integer do
-    "100" = inspect(100)
-    "100" = to_binary(100)
+    assert_equal "100", inspect(100)
+    assert_equal "100", to_binary(100)
   end
 
   def test_float do
-    "1.00000000000000000000e+00" = inspect(1.0)
-    "1.00000000000000000000e+00" = to_binary(1.0)
+    assert_equal "1.00000000000000000000e+00", inspect(1.0)
+    assert_equal "1.00000000000000000000e+00", to_binary(1.0)
 
-    "1.00000000000000000000e+10" = inspect(1.0e10)
-    "1.00000000000000000000e+10" = to_binary(1.0e10)
+    assert_equal "1.00000000000000000000e+10", inspect(1.0e10)
+    assert_equal "1.00000000000000000000e+10", to_binary(1.0e10)
 
-    "1.00000000000000000000e+10" = inspect(1.0e+10)
-    "1.00000000000000000000e+10" = to_binary(1.0e+10)
+    assert_equal "1.00000000000000000000e+10", inspect(1.0e+10)
+    assert_equal "1.00000000000000000000e+10", to_binary(1.0e+10)
   end
 end
 
@@ -92,23 +92,23 @@ defmodule String::Inspect::TupleTest do
   use ExUnit::Case
 
   def test_basic do
-    "{1,\"b\",3}" = inspect({ 1, "b", 3 })
-    "{1,\"b\",3}" = to_binary({ 1, "b", 3 })
+    assert_equal "{1,\"b\",3}", inspect({ 1, "b", 3 })
+    assert_equal "{1,\"b\",3}", to_binary({ 1, "b", 3 })
   end
 
   def test_record_like do
-    "{:foo,:bar}" = inspect({ :foo, :bar })
-    "{:foo,:bar}" = to_binary({ :foo, :bar })
+    assert_equal "{:foo,:bar}", inspect({ :foo, :bar })
+    assert_equal "{:foo,:bar}", to_binary({ :foo, :bar })
   end
 
   def test_exception do
-    "::RuntimeError{\"runtime error\"}" = inspect(RuntimeError.new)
-    "::RuntimeError{\"runtime error\"}" = to_binary(RuntimeError.new)
+    assert_equal "::RuntimeError{\"runtime error\"}", inspect(RuntimeError.new)
+    assert_equal "::RuntimeError{\"runtime error\"}", to_binary(RuntimeError.new)
   end
 
   def test_empty do
-    "{}" = inspect({})
-    "{}" = to_binary({})
+    assert_equal "{}", inspect({})
+    assert_equal "{}", to_binary({})
   end
 end
 
@@ -116,28 +116,28 @@ defmodule String::Inspect::ListTest do
   use ExUnit::Case
 
   def test_basic do
-    "[1,\"b\",3]" = inspect([ 1, "b", 3 ])
-    <<1,98,3>> = to_binary([ 1, "b", 3 ])
+    assert_equal "[1,\"b\",3]", inspect([ 1, "b", 3 ])
+    assert_equal <<1,98,3>>, to_binary([ 1, "b", 3 ])
   end
 
   def test_printable do
-    "'abc'" = inspect('abc')
-    "abc"   = to_binary('abc')
+    assert_equal "'abc'", inspect('abc')
+    assert_equal "abc"  , to_binary('abc')
   end
 
   def test_non_printable do
-    "[{:a,1}]" = inspect([{:a,1}])
-    "[{:a,1}]" = to_binary([{:a,1}])
+    assert_equal "[{:a,1}]", inspect([{:a,1}])
+    assert_equal "[{:a,1}]", to_binary([{:a,1}])
   end
 
   def test_unproper do
-    "[:foo|:bar]" = inspect([:foo | :bar])
-    "[:foo|:bar]" = to_binary([:foo | :bar])
+    assert_equal "[:foo|:bar]", inspect([:foo | :bar])
+    assert_equal "[:foo|:bar]", to_binary([:foo | :bar])
   end
 
   def test_empty do
-    "[]" = inspect([])
-    ""   = to_binary([])
+    assert_equal "[]", inspect([])
+    assert_equal "", to_binary([])
   end
 end
 
@@ -151,4 +151,4 @@ defmodule String::Inspect::AnyTest do
     bin = to_binary(fn(x, do: x + 1))
     '#Fun<' ++ _ = binary_to_list(bin)
   end
-end
\ No newline at end of file
+end
diff --git a/test/elixir/string_test.exs b/test/elixir/string_test.exs
index 535cb660e4..c96b8d04da 100644
--- a/test/elixir/string_test.exs
+++ b/test/elixir/string_test.exs
@@ -5,6 +5,6 @@ defmodule StringTest do
 
   def test_string_concatenation_as_match do
     "foo" <> x = "foobar"
-    "bar" = x
+    assert_equal "bar", x
   end
-end
\ No newline at end of file
+end
diff --git a/test/elixir/tuple_test.exs b/test/elixir/tuple_test.exs
index c05242c40f..46b3d9586b 100644
--- a/test/elixir/tuple_test.exs
+++ b/test/elixir/tuple_test.exs
@@ -4,10 +4,10 @@ defmodule TupleTest do
   use ExUnit::Case
 
   def test_elem do
-    :b = elem({ :a, :b, :c }, 2)
+    assert_equal :b, elem({ :a, :b, :c }, 2)
   end
 
   def test_setelem do
-    { :a, :d, :c } = setelem({ :a, :b, :c }, 2, :d)
+    assert_equal { :a, :d, :c }, setelem({ :a, :b, :c }, 2, :d)
   end
-end
\ No newline at end of file
+end