Improve Class tests

1 files changed, 36 insertions, 44 deletions

diff --git a/test/t/class.rb b/test/t/class.rb
index eb470e416..3654b28b8 100644
--- a/test/t/class.rb
+++ b/test/t/class.rb
@@ -2,11 +2,11 @@
 # Class ISO Test
 
 assert('Class', '15.2.3') do
-  Class.class == Class
+  assert_equal(Class.class, Class)
 end
 
 assert('Class superclass', '15.2.3.2') do
-  Class.superclass == Module
+  assert_equal(Class.superclass, Module)
 end
 
 # Class#initialize '15.2.3.3.1' is tested in Class#new
@@ -26,7 +26,8 @@ assert('Class#initialize_copy', '15.2.3.3.2') do
   c2 = c1.dup
   c3 = TestClass.new('Bar')
 
-  c1.n == c2.n and c1.n != c3.n
+  assert_equal(c1.n, c2.n)
+  assert_not_equal(c1.n, c3.n)
 end
 
 assert('Class#new', '15.2.3.3.3') do
@@ -55,48 +56,48 @@ assert('Class#new', '15.2.3.3.3') do
     def result; @result; end
   end
 
-  TestClass.new(:arg).result == :only_args
+  assert_equal(TestClass.new(:arg).result, :only_args)
   # with block doesn't work yet
 end
 
 assert('Class#superclass', '15.2.3.3.4') do
   class SubClass < String; end
-  SubClass.superclass == String
+  assert_equal(SubClass.superclass, String)
 end
 
 # Not ISO specified
 
 assert('Class 1') do
   class C1; end
-  C1.class == Class
+  assert_equal(C1.class, Class)
 end
 
 assert('Class 2') do
   class C2; end
-  C2.new.class == C2
+  assert_equal(C2.new.class, C2)
 end
 
 assert('Class 3') do
   class C3; end
-  C3.new.class.class == Class
+  assert_equal(C3.new.class.class, Class)
 end
 
 assert('Class 4') do
   class C4_A; end
   class C4 < C4_A; end
-  C4.class == Class
+  assert_equal(C4.class, Class)
 end
 
 assert('Class 5') do
   class C5_A; end
   class C5 < C5_A; end
-  C5.new.class == C5
+  assert_equal(C5.new.class, C5)
 end
 
 assert('Class 6') do
   class C6_A; end
   class C6 < C6_A; end
-  C6.new.class.class == Class
+  assert_equal(C6.new.class.class, Class)
 end
 
 assert('Class 7') do
@@ -105,15 +106,10 @@ assert('Class 7') do
 
   class C7 < C7_A; end
 
-  error = false
-  begin
+  assert_raise(TypeError) do
     # Different superclass.
     class C7 < C7_B; end
-  rescue TypeError
-    error = true
   end
-
-  error
 end
 
 assert('Class 8') do
@@ -121,111 +117,107 @@ assert('Class 8') do
 
   class C8; end  # superclass is Object
 
-  error = false
-  begin
+  assert_raise(TypeError) do
     # Different superclass.
     class C8 < C8_A; end
-  rescue TypeError
-    error = true
   end
-
-  error
 end
 
 assert('Class 9') do
   Class9Const = "a"
 
-  error = false
-  begin
+  assert_raise(TypeError) do
     class Class9Const; end
-  rescue TypeError
-    error = true
   end
-
-  error
 end
 
 assert('Class Module 1') do
   module M; end
-  M.class == Module
+  assert_equal(M.class, Module)
 end
 
 assert('Class Module 2') do
   module M; end
   class C; include M; end
-  C.new.class == C
+  assert_equal(C.new.class, C)
 end
 
 # nested class
 assert('Class Nested 1') do
   class A; end
   class A::B; end
-  A::B == A::B
+  assert_equal(A::B, A::B)
 end
 
 assert('Class Nested 2') do
   class A; end
   class A::B; end
-  A::B.new.class == A::B
+  assert_equal(A::B.new.class, A::B)
 end
 
 assert('Class Nested 3') do
   class A; end
   class A::B; end
-  A::B.new.class.class == Class
+  assert_equal(A::B.new.class.class, Class)
 end
 
 assert('Class Nested 4') do
   class A; end
   class A::B; end
   class A::B::C; end
-  A::B::C == A::B::C
+  assert_equal(A::B::C, A::B::C)
 end
 
 assert('Class Nested 5') do
   class A; end
   class A::B; end
   class A::B::C; end
-  A::B::C.class == Class
+  assert_equal(A::B::C.class, Class)
 end
 
 assert('Class Nested 6') do
   class A; end
   class A::B; end
   class A::B::C; end
-  A::B::C.new.class == A::B::C
+  assert_equal(A::B::C.new.class, A::B::C)
 end
 
 assert('Class Nested 7') do
   class A; end
   class A::B; end
   class A::B2 < A::B; end
-  A::B2 == A::B2
+  assert_equal(A::B2, A::B2)
 end
 
 assert('Class Nested 8') do
   class A; end
   class A::B; end
   class A::B2 < A::B; end
-  A::B2.class == Class
+  assert_equal(A::B2.class, Class)
 end
 
 assert('Class Colon 1') do
-  class A; end; A::C = 1; A::C == 1
+  class A; end
+  A::C = 1
+  assert_equal(A::C, 1)
 end
 
 assert('Class Colon 2') do
-  class A; class ::C; end end; C == C
+  class A; class ::C; end end
+  assert_equal(C, C)
 end
 
 assert('Class Colon 3') do
-  class A; class ::C; end end; C.class == Class
+  class A; class ::C; end end
+  assert_equal(C.class, Class)
 end
 
 assert('Class Dup 1') do
-  class C; end;  C.dup.class == Class
+  class C; end
+  assert_equal(C.dup.class, Class)
 end
 
 assert('Class Dup 2') do
-  module M; end;  M.dup.class == Module
+  module M; end
+  assert_equal(M.dup.class, Module)
 end