# File lib/module_extensions/hierarchy.rb, line 326
        def test_remove_class
          r = RemoveClass.remove_class(HierarchyTest::RemoveClass::B)
          assert_equal(4, r.size)
          ['B', 'D', 'E', 'C'].each { |x| assert(r.include?(x)) }
          assert_equal(5, RemoveClass.constants.size)
          ['A', 'F', 'Z', 'M', 'BAR'].each do |x|
            assert(RemoveClass.constants.include?(x))
          end
        end

# File lib/module_extensions/hierarchy.rb, line 165
        def test_sub_classes
          sub_classes = M.sub_classes(HierarchyTest::M::A)
          assert_equal(2, sub_classes.size)
          [HierarchyTest::M::B, HierarchyTest::M::A].each do |x|
            assert(sub_classes.include?(x))
          end
          assert_equal([HierarchyTest::M::C], M.sub_classes(M::C))
        end

# File lib/module_extensions/hierarchy.rb, line 298
        def test_sub_classes_error
          assert_raise(TypeError) do
            Error.sub_classes_tree(HierarchyTest::Error::M)
          end
          assert_raise(TypeError) do
            Error.sub_classes(HierarchyTest::Error::M)
          end
          assert_raise(TypeError) do
            Error.remove_class(HierarchyTest::Error::M)
          end
        end

# File lib/module_extensions/hierarchy.rb, line 183
        def test_sub_classes_force_autoload
          sub_classes = Mautoload.sub_classes(Mautoload::A)
          assert_equal(2, sub_classes.size)
          [Mautoload::B, Mautoload::A].each do |x|
            assert(sub_classes.include?(x))
          end
          assert_equal(4, Mautoload.constants.size)
          assert_not_nil(Mautoload.autoload?(:C))
          assert_raise(MissingSourceFile, LoadError) { Mautoload.sub_classes(Mautoload::A, true) }
          assert_equal(3, Mautoload.constants.size)
          assert_nil(Mautoload.autoload?(:C))
        end

# File lib/module_extensions/hierarchy.rb, line 209
        def test_sub_classes_recursive
          sub_classes = Mrec.sub_classes(Mrec::A)
          assert_equal(2, sub_classes.size)
          [Mrec::B, Mrec::A].each do |x|
            assert(sub_classes.include?(x))
          end
          sub_classes = Mrec.sub_classes(Mrec::A, false, true)
          assert_equal(5, sub_classes.size)
          [Mrec::B, Mrec::A, Mrec::M::C, Mrec::M::D, Mrec::M::E].each do |x|
            assert(sub_classes.include?(x))
          end
          r = Mrec.remove_class(Mrec::A, true)
          assert_equal(5, r.size)
          ['B', 'A', 'M::E', 'M::C', 'M::D'].each do |x|
            assert(r.include?(x))
          end
          assert_equal(3, Mrec.constants.size)
          ['FOO', 'M', 'Z'].each { |x| assert(Mrec.constants.include?(x)) }
          assert_equal(1, Mrec::M.constants.size)
          ['Y'].each { |x| assert(Mrec::M.constants.include?(x)) }
        end

# File lib/module_extensions/hierarchy.rb, line 277
        def test_sub_classes_tree
          r = Tree.sub_classes_tree(HierarchyTest::Tree::A)
          ref = {
            HierarchyTest::Tree::A => {
              HierarchyTest::Tree::B => {
                HierarchyTest::Tree::D => {},
                HierarchyTest::Tree::C => {}
              },
              HierarchyTest::Tree::E => {}
            }
          }
          d = r.diff(ref)
          assert_equal({}, d[:different])
          assert_equal({}, d[:additional])
          assert_equal({}, d[:missing])
        end

# File lib/module_extensions/hierarchy.rb, line 251
        def test_sub_classes_tree_rec
          r = Tree.sub_classes_tree(HierarchyTest::Tree::A, false, true)
          ref = {
            HierarchyTest::Tree::A => {
              HierarchyTest::Tree::M::F => {
                HierarchyTest::Tree::M::G => {}
              },
              HierarchyTest::Tree::B => {
                HierarchyTest::Tree::C => {},
                HierarchyTest::Tree::D => {
                  HierarchyTest::Tree::M::H => {
                    HierarchyTest::Tree::M::I=>{}
                  }
                }
              },
              HierarchyTest::Tree::E=> {
                HierarchyTest::Tree::M::J=>{}
              }
            }
          }
          d = r.diff(ref)
          assert_equal({}, d[:different])
          assert_equal({}, d[:additional])
          assert_equal({}, d[:missing])
        end