diff --git a/test/parser/test_sax2.rb b/test/parser/test_sax2.rb
index 91d135f5..9cc76ffb 100644
--- a/test/parser/test_sax2.rb
+++ b/test/parser/test_sax2.rb
@@ -4,200 +4,200 @@
 require "rexml/sax2listener"
 
 module REXMLTests
-class TestSAX2Parser < Test::Unit::TestCase
-  class TestDocumentTypeDeclaration < self
-    private
-    def xml(internal_subset)
-      <<-XML
+  class TestSAX2Parser < Test::Unit::TestCase
+    class TestDocumentTypeDeclaration < self
+      private
+      def xml(internal_subset)
+        <<-XML
 <!DOCTYPE r SYSTEM "urn:x-henrikmartensson:test" [
 #{internal_subset}
 ]>
 <r/>
-      XML
-    end
+        XML
+      end
 
-    class TestEntityDeclaration < self
-      class Listener
-        include REXML::SAX2Listener
-        attr_reader :entity_declarations
-        def initialize
-          @entity_declarations = []
-        end
+      class TestEntityDeclaration < self
+        class Listener
+          include REXML::SAX2Listener
+          attr_reader :entity_declarations
+          def initialize
+            @entity_declarations = []
+          end
 
-        def entitydecl(declaration)
-          super
-          @entity_declarations << declaration
+          def entitydecl(declaration)
+            super
+            @entity_declarations << declaration
+          end
         end
-      end
 
-      private
-      def parse(internal_subset)
-        listener = Listener.new
-        parser = REXML::Parsers::SAX2Parser.new(xml(internal_subset))
-        parser.listen(listener)
-        parser.parse
-        listener.entity_declarations
-      end
+        private
+        def parse(internal_subset)
+          listener = Listener.new
+          parser = REXML::Parsers::SAX2Parser.new(xml(internal_subset))
+          parser.listen(listener)
+          parser.parse
+          listener.entity_declarations
+        end
 
-      class TestGeneralEntity < self
-        class TestValue < self
-          def test_double_quote
-            assert_equal([["name", "value"]], parse(<<-INTERNAL_SUBSET))
+        class TestGeneralEntity < self
+          class TestValue < self
+            def test_double_quote
+              assert_equal([["name", "value"]], parse(<<-INTERNAL_SUBSET))
 <!ENTITY name "value">
-            INTERNAL_SUBSET
-          end
+              INTERNAL_SUBSET
+            end
 
-          def test_single_quote
-            assert_equal([["name", "value"]], parse(<<-INTERNAL_SUBSET))
+            def test_single_quote
+              assert_equal([["name", "value"]], parse(<<-INTERNAL_SUBSET))
 <!ENTITY name 'value'>
-            INTERNAL_SUBSET
+              INTERNAL_SUBSET
+            end
           end
-        end
 
-        class TestExternlID < self
-          class TestSystem < self
-            def test_with_ndata
-              declaration = [
-                "name",
-                "SYSTEM", "system-literal",
-                "NDATA", "ndata-name",
-              ]
-              assert_equal([declaration],
-                           parse(<<-INTERNAL_SUBSET))
+          class TestExternlID < self
+            class TestSystem < self
+              def test_with_ndata
+                declaration = [
+                  "name",
+                  "SYSTEM", "system-literal",
+                  "NDATA", "ndata-name",
+                ]
+                assert_equal([declaration],
+                             parse(<<-INTERNAL_SUBSET))
 <!ENTITY name SYSTEM "system-literal" NDATA ndata-name>
+                INTERNAL_SUBSET
+              end
+
+              def test_without_ndata
+                declaration = [
+                  "name",
+                  "SYSTEM", "system-literal",
+                ]
+                assert_equal([declaration],
+                             parse(<<-INTERNAL_SUBSET))
+<!ENTITY name SYSTEM "system-literal">
+                INTERNAL_SUBSET
+              end
+            end
+
+            class TestPublic < self
+              def test_with_ndata
+                declaration = [
+                  "name",
+                  "PUBLIC", "public-literal", "system-literal",
+                  "NDATA", "ndata-name",
+                ]
+                assert_equal([declaration],
+                             parse(<<-INTERNAL_SUBSET))
+<!ENTITY name PUBLIC "public-literal" "system-literal" NDATA ndata-name>
+                INTERNAL_SUBSET
+              end
+
+              def test_without_ndata
+                declaration = [
+                  "name",
+                  "PUBLIC", "public-literal", "system-literal",
+                ]
+                assert_equal([declaration], parse(<<-INTERNAL_SUBSET))
+<!ENTITY name PUBLIC "public-literal" "system-literal">
+                INTERNAL_SUBSET
+              end
+            end
+          end
+        end
+
+        class TestParameterEntity < self
+          class TestValue < self
+            def test_double_quote
+              assert_equal([["%", "name", "value"]], parse(<<-INTERNAL_SUBSET))
+<!ENTITY % name "value">
               INTERNAL_SUBSET
             end
 
-            def test_without_ndata
-              declaration = [
-                "name",
-                "SYSTEM", "system-literal",
-              ]
-              assert_equal([declaration],
-                           parse(<<-INTERNAL_SUBSET))
-<!ENTITY name SYSTEM "system-literal">
+            def test_single_quote
+              assert_equal([["%", "name", "value"]], parse(<<-INTERNAL_SUBSET))
+<!ENTITY % name 'value'>
               INTERNAL_SUBSET
             end
           end
 
-          class TestPublic < self
-            def test_with_ndata
+          class TestExternlID < self
+            def test_system
               declaration = [
+                "%",
                 "name",
-                "PUBLIC", "public-literal", "system-literal",
-                "NDATA", "ndata-name",
+                "SYSTEM", "system-literal",
               ]
               assert_equal([declaration],
-                           parse(<<-INTERNAL_SUBSET))
-<!ENTITY name PUBLIC "public-literal" "system-literal" NDATA ndata-name>
+                             parse(<<-INTERNAL_SUBSET))
+<!ENTITY % name SYSTEM "system-literal">
               INTERNAL_SUBSET
             end
 
-            def test_without_ndata
+            def test_public
               declaration = [
+                "%",
                 "name",
                 "PUBLIC", "public-literal", "system-literal",
               ]
               assert_equal([declaration], parse(<<-INTERNAL_SUBSET))
-<!ENTITY name PUBLIC "public-literal" "system-literal">
+<!ENTITY % name PUBLIC "public-literal" "system-literal">
               INTERNAL_SUBSET
             end
           end
         end
       end
 
-      class TestParameterEntity < self
-        class TestValue < self
-          def test_double_quote
-            assert_equal([["%", "name", "value"]], parse(<<-INTERNAL_SUBSET))
-<!ENTITY % name "value">
-            INTERNAL_SUBSET
+      class TestNotationDeclaration < self
+        class Listener
+          include REXML::SAX2Listener
+          attr_reader :notation_declarations
+          def initialize
+            @notation_declarations = []
           end
 
-          def test_single_quote
-            assert_equal([["%", "name", "value"]], parse(<<-INTERNAL_SUBSET))
-<!ENTITY % name 'value'>
-            INTERNAL_SUBSET
+          def notationdecl(*declaration)
+            super
+            @notation_declarations << declaration
           end
         end
 
+        private
+        def parse(internal_subset)
+          listener = Listener.new
+          parser = REXML::Parsers::SAX2Parser.new(xml(internal_subset))
+          parser.listen(listener)
+          parser.parse
+          listener.notation_declarations
+        end
+
         class TestExternlID < self
           def test_system
-            declaration = [
-              "%",
-              "name",
-              "SYSTEM", "system-literal",
-            ]
+            declaration = ["name", "SYSTEM", nil, "system-literal"]
             assert_equal([declaration],
-                           parse(<<-INTERNAL_SUBSET))
-<!ENTITY % name SYSTEM "system-literal">
-            INTERNAL_SUBSET
-          end
-
-          def test_public
-            declaration = [
-              "%",
-              "name",
-              "PUBLIC", "public-literal", "system-literal",
-            ]
-            assert_equal([declaration], parse(<<-INTERNAL_SUBSET))
-<!ENTITY % name PUBLIC "public-literal" "system-literal">
-            INTERNAL_SUBSET
-          end
-        end
-      end
-    end
-
-    class TestNotationDeclaration < self
-      class Listener
-        include REXML::SAX2Listener
-        attr_reader :notation_declarations
-        def initialize
-          @notation_declarations = []
-        end
-
-        def notationdecl(*declaration)
-          super
-          @notation_declarations << declaration
-        end
-      end
-
-      private
-      def parse(internal_subset)
-        listener = Listener.new
-        parser = REXML::Parsers::SAX2Parser.new(xml(internal_subset))
-        parser.listen(listener)
-        parser.parse
-        listener.notation_declarations
-      end
-
-      class TestExternlID < self
-        def test_system
-          declaration = ["name", "SYSTEM", nil, "system-literal"]
-          assert_equal([declaration],
-                       parse(<<-INTERNAL_SUBSET))
+                         parse(<<-INTERNAL_SUBSET))
 <!NOTATION name SYSTEM "system-literal">
-          INTERNAL_SUBSET
-        end
+           INTERNAL_SUBSET
+         end
 
-        def test_public
-          declaration = ["name", "PUBLIC", "public-literal", "system-literal"]
-          assert_equal([declaration], parse(<<-INTERNAL_SUBSET))
+         def test_public
+           declaration = ["name", "PUBLIC", "public-literal", "system-literal"]
+           assert_equal([declaration], parse(<<-INTERNAL_SUBSET))
 <!NOTATION name PUBLIC "public-literal" "system-literal">
-          INTERNAL_SUBSET
+            INTERNAL_SUBSET
+          end
         end
-      end
 
-      class TestPublicID < self
-        def test_literal
-          declaration = ["name", "PUBLIC", "public-literal", nil]
-          assert_equal([declaration],
-                       parse(<<-INTERNAL_SUBSET))
+        class TestPublicID < self
+          def test_literal
+            declaration = ["name", "PUBLIC", "public-literal", nil]
+            assert_equal([declaration],
+                         parse(<<-INTERNAL_SUBSET))
 <!NOTATION name PUBLIC "public-literal">
-          INTERNAL_SUBSET
+            INTERNAL_SUBSET
+          end
         end
       end
     end
   end
 end
-end
diff --git a/test/parser/test_tree.rb b/test/parser/test_tree.rb
index 8a5d9d12..88bc075c 100644
--- a/test/parser/test_tree.rb
+++ b/test/parser/test_tree.rb
@@ -4,40 +4,40 @@
 require "rexml/parsers/treeparser"
 
 module REXMLTests
-class TestTreeParser < Test::Unit::TestCase
-  class TestInvalid < self
-    def test_unmatched_close_tag
-      xml = "<root></not-root>"
-      exception = assert_raise(REXML::ParseException) do
-        parse(xml)
-      end
-      assert_equal(<<-MESSAGE, exception.to_s)
+  class TestTreeParser < Test::Unit::TestCase
+    class TestInvalid < self
+      def test_unmatched_close_tag
+        xml = "<root></not-root>"
+        exception = assert_raise(REXML::ParseException) do
+          parse(xml)
+        end
+        assert_equal(<<-MESSAGE, exception.to_s)
 Missing end tag for 'root' (got 'not-root')
 Line: 1
 Position: #{xml.bytesize}
 Last 80 unconsumed characters:
-      MESSAGE
-    end
-
-    def test_no_close_tag
-      xml = "<root>"
-      exception = assert_raise(REXML::ParseException) do
-        parse(xml)
+        MESSAGE
       end
-      assert_equal(<<-MESSAGE, exception.to_s)
+
+      def test_no_close_tag
+        xml = "<root>"
+        exception = assert_raise(REXML::ParseException) do
+          parse(xml)
+        end
+        assert_equal(<<-MESSAGE, exception.to_s)
 No close tag for /root
 Line: 1
 Position: #{xml.bytesize}
 Last 80 unconsumed characters:
-      MESSAGE
-    end
+        MESSAGE
+      end
 
-    private
-    def parse(xml)
-      document = REXML::Document.new
-      parser = REXML::Parsers::TreeParser.new(xml, document)
-      parser.parse
+      private
+      def parse(xml)
+        document = REXML::Document.new
+        parser = REXML::Parsers::TreeParser.new(xml, document)
+        parser.parse
+      end
     end
   end
 end
-end
diff --git a/test/parser/test_ultra_light.rb b/test/parser/test_ultra_light.rb
index b3f576ff..d1364d6a 100644
--- a/test/parser/test_ultra_light.rb
+++ b/test/parser/test_ultra_light.rb
@@ -3,66 +3,66 @@
 require "rexml/parsers/ultralightparser"
 
 module REXMLTests
-class TestUltraLightParser < Test::Unit::TestCase
-  class TestDocumentTypeDeclaration < self
-    def test_entity_declaration
-      assert_equal([
-                     [
-                       :start_doctype,
-                       :parent,
-                       "root",
-                       "SYSTEM",
-                       "urn:x-test",
-                       nil,
-                       [:entitydecl, "name", "value"]
+  class TestUltraLightParser < Test::Unit::TestCase
+    class TestDocumentTypeDeclaration < self
+      def test_entity_declaration
+        assert_equal([
+                       [
+                         :start_doctype,
+                         :parent,
+                         "root",
+                         "SYSTEM",
+                         "urn:x-test",
+                         nil,
+                         [:entitydecl, "name", "value"]
+                       ],
+                       [:start_element, :parent, "root", {}],
                      ],
-                     [:start_element, :parent, "root", {}],
-                   ],
-                   parse(<<-INTERNAL_SUBSET))
+                     parse(<<-INTERNAL_SUBSET))
 <!ENTITY name "value">
-      INTERNAL_SUBSET
-    end
+        INTERNAL_SUBSET
+      end
 
-    private
-    def xml(internal_subset)
-      <<-XML
+      private
+      def xml(internal_subset)
+        <<-XML
 <!DOCTYPE root SYSTEM "urn:x-test" [
 #{internal_subset}
 ]>
 <root/>
-      XML
-    end
+        XML
+      end
 
-    def parse(internal_subset)
-      parser = REXML::Parsers::UltraLightParser.new(xml(internal_subset))
-      normalize(parser.parse)
-    end
+      def parse(internal_subset)
+        parser = REXML::Parsers::UltraLightParser.new(xml(internal_subset))
+        normalize(parser.parse)
+      end
 
-    def normalize(root)
-      root.collect do |child|
-        normalize_child(child)
+      def normalize(root)
+        root.collect do |child|
+          normalize_child(child)
+        end
       end
-    end
 
-    def normalize_child(child)
-      tag = child.first
-      case tag
-      when :start_doctype
-        normalized_parent = :parent
-        normalized_doctype = child.dup
-        normalized_doctype[1] = normalized_parent
-        normalized_doctype
-      when :start_element
-        tag, _parent, name, attributes, *children = child
-        normalized_parent = :parent
-        normalized_children = children.collect do |sub_child|
-          normalize_child(sub_child)
+      def normalize_child(child)
+        tag = child.first
+        case tag
+        when :start_doctype
+          normalized_parent = :parent
+          normalized_doctype = child.dup
+          normalized_doctype[1] = normalized_parent
+          normalized_doctype
+        when :start_element
+          tag, _parent, name, attributes, *children = child
+          normalized_parent = :parent
+          normalized_children = children.collect do |sub_child|
+            normalize_child(sub_child)
+          end
+          [tag, normalized_parent, name, attributes, *normalized_children]
+        else
+          child
         end
-        [tag, normalized_parent, name, attributes, *normalized_children]
-      else
-        child
       end
     end
   end
 end
-end